libstdc++
regex.h
Go to the documentation of this file.
1// class template regex -*- C++ -*-
2
3// Copyright (C) 2010-2024 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library. This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.
10
11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14// GNU General Public License for more details.
15
16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.
19
20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23// <http://www.gnu.org/licenses/>.
24
25/**
26 * @file bits/regex.h
27 * This is an internal header file, included by other library headers.
28 * Do not attempt to use it directly. @headername{regex}
29 */
30
31#if __cplusplus >= 202002L
32# include <bits/iterator_concepts.h> // std::default_sentinel_t
33#endif
34
35namespace std _GLIBCXX_VISIBILITY(default)
36{
37_GLIBCXX_BEGIN_NAMESPACE_VERSION
38_GLIBCXX_BEGIN_NAMESPACE_CXX11
39 template<typename, typename>
40 class basic_regex;
41
42 template<typename _Bi_iter, typename _Alloc>
43 class match_results;
44
45_GLIBCXX_END_NAMESPACE_CXX11
46
47namespace __detail
48{
49 enum class _RegexExecutorPolicy : int { _S_auto, _S_alternate };
50
51 template<typename _BiIter, typename _Alloc,
52 typename _CharT, typename _TraitsT>
53 bool
54 __regex_algo_impl(_BiIter __s, _BiIter __e,
55 match_results<_BiIter, _Alloc>& __m,
56 const basic_regex<_CharT, _TraitsT>& __re,
58 _RegexExecutorPolicy __policy,
59 bool __match_mode);
60
61 template<typename, typename, typename, bool>
62 class _Executor;
63
64 template<typename _Tp>
65 struct __is_contiguous_iter : false_type { };
66
67 template<typename _Tp>
68 struct __is_contiguous_iter<_Tp*> : true_type { };
69
70 template<typename _Tp, typename _Cont>
71 struct __is_contiguous_iter<__gnu_cxx::__normal_iterator<_Tp*, _Cont>>
72 : true_type { };
73}
74
75_GLIBCXX_BEGIN_NAMESPACE_CXX11
76
77 /**
78 * @addtogroup regex
79 * @{
80 */
81
82 /**
83 * @brief Describes aspects of a regular expression.
84 *
85 * A regular expression traits class that satisfies the requirements of
86 * section [28.7].
87 *
88 * The class %regex is parameterized around a set of related types and
89 * functions used to complete the definition of its semantics. This class
90 * satisfies the requirements of such a traits class.
91 *
92 * @headerfile regex
93 * @since C++11
94 */
95 template<typename _Ch_type>
97 {
98 public:
99 typedef _Ch_type char_type;
100 typedef std::basic_string<char_type> string_type;
101 typedef std::locale locale_type;
102
103 private:
104 struct _RegexMask
105 {
106 typedef std::ctype_base::mask _BaseType;
107 _BaseType _M_base;
108 unsigned char _M_extended;
109 static constexpr unsigned char _S_under = 1 << 0;
110 static constexpr unsigned char _S_valid_mask = 0x1;
111
112 constexpr _RegexMask(_BaseType __base = 0,
113 unsigned char __extended = 0)
114 : _M_base(__base), _M_extended(__extended)
115 { }
116
117 constexpr _RegexMask
118 operator&(_RegexMask __other) const
119 {
120 return _RegexMask(_M_base & __other._M_base,
121 _M_extended & __other._M_extended);
122 }
123
124 constexpr _RegexMask
125 operator|(_RegexMask __other) const
126 {
127 return _RegexMask(_M_base | __other._M_base,
128 _M_extended | __other._M_extended);
129 }
130
131 constexpr _RegexMask
132 operator^(_RegexMask __other) const
133 {
134 return _RegexMask(_M_base ^ __other._M_base,
135 _M_extended ^ __other._M_extended);
136 }
137
138 constexpr _RegexMask
139 operator~() const
140 { return _RegexMask(~_M_base, ~_M_extended); }
141
142 _RegexMask&
143 operator&=(_RegexMask __other)
144 { return *this = (*this) & __other; }
145
146 _RegexMask&
147 operator|=(_RegexMask __other)
148 { return *this = (*this) | __other; }
149
150 _RegexMask&
151 operator^=(_RegexMask __other)
152 { return *this = (*this) ^ __other; }
153
154 constexpr bool
155 operator==(_RegexMask __other) const
156 {
157 return (_M_extended & _S_valid_mask)
158 == (__other._M_extended & _S_valid_mask)
159 && _M_base == __other._M_base;
160 }
161
162#if __cpp_impl_three_way_comparison < 201907L
163 constexpr bool
164 operator!=(_RegexMask __other) const
165 { return !((*this) == __other); }
166#endif
167 };
168
169 public:
170 typedef _RegexMask char_class_type;
171
172 public:
173 /**
174 * @brief Constructs a default traits object.
175 */
177
178 /**
179 * @brief Gives the length of a C-style string starting at @p __p.
180 *
181 * @param __p a pointer to the start of a character sequence.
182 *
183 * @returns the number of characters between @p *__p and the first
184 * default-initialized value of type @p char_type. In other words, uses
185 * the C-string algorithm for determining the length of a sequence of
186 * characters.
187 */
188 static std::size_t
189 length(const char_type* __p)
190 { return string_type::traits_type::length(__p); }
191
192 /**
193 * @brief Performs the identity translation.
194 *
195 * @param __c A character to the locale-specific character set.
196 *
197 * @returns __c.
198 */
199 char_type
200 translate(char_type __c) const
201 { return __c; }
202
203 /**
204 * @brief Translates a character into a case-insensitive equivalent.
205 *
206 * @param __c A character to the locale-specific character set.
207 *
208 * @returns the locale-specific lower-case equivalent of __c.
209 * @throws std::bad_cast if the imbued locale does not support the ctype
210 * facet.
211 */
212 char_type
213 translate_nocase(char_type __c) const
214 {
215 typedef std::ctype<char_type> __ctype_type;
216 const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale));
217 return __fctyp.tolower(__c);
218 }
219
220 /**
221 * @brief Gets a sort key for a character sequence.
222 *
223 * @param __first beginning of the character sequence.
224 * @param __last one-past-the-end of the character sequence.
225 *
226 * Returns a sort key for the character sequence designated by the
227 * iterator range [F1, F2) such that if the character sequence [G1, G2)
228 * sorts before the character sequence [H1, H2) then
229 * v.transform(G1, G2) < v.transform(H1, H2).
230 *
231 * What this really does is provide a more efficient way to compare a
232 * string to multiple other strings in locales with fancy collation
233 * rules and equivalence classes.
234 *
235 * @returns a locale-specific sort key equivalent to the input range.
236 *
237 * @throws std::bad_cast if the current locale does not have a collate
238 * facet.
239 */
240 template<typename _Fwd_iter>
241 string_type
242 transform(_Fwd_iter __first, _Fwd_iter __last) const
243 {
244 typedef std::collate<char_type> __collate_type;
245 const __collate_type& __fclt(use_facet<__collate_type>(_M_locale));
246 string_type __s(__first, __last);
247 return __fclt.transform(__s.data(), __s.data() + __s.size());
248 }
249
250 /**
251 * @brief Gets a sort key for a character sequence, independent of case.
252 *
253 * @param __first beginning of the character sequence.
254 * @param __last one-past-the-end of the character sequence.
255 *
256 * Effects: if typeid(use_facet<collate<_Ch_type> >) ==
257 * typeid(collate_byname<_Ch_type>) and the form of the sort key
258 * returned by collate_byname<_Ch_type>::transform(__first, __last)
259 * is known and can be converted into a primary sort key
260 * then returns that key, otherwise returns an empty string.
261 *
262 * @todo Implement this function correctly.
263 */
264 template<typename _Fwd_iter>
265 string_type
266 transform_primary(_Fwd_iter __first, _Fwd_iter __last) const
267 {
268 // TODO : this is not entirely correct.
269 // This function requires extra support from the platform.
270 //
271 // Read http://gcc.gnu.org/ml/libstdc++/2013-09/msg00117.html and
272 // http://www.open-std.org/Jtc1/sc22/wg21/docs/papers/2003/n1429.htm
273 // for details.
274 typedef std::ctype<char_type> __ctype_type;
275 const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale));
276 _GLIBCXX_STD_C::vector<char_type> __s(__first, __last);
277 __fctyp.tolower(__s.data(), __s.data() + __s.size());
278 return this->transform(__s.data(), __s.data() + __s.size());
279 }
280
281 /**
282 * @brief Gets a collation element by name.
283 *
284 * @param __first beginning of the collation element name.
285 * @param __last one-past-the-end of the collation element name.
286 *
287 * @returns a sequence of one or more characters that represents the
288 * collating element consisting of the character sequence designated by
289 * the iterator range [__first, __last). Returns an empty string if the
290 * character sequence is not a valid collating element.
291 */
292 template<typename _Fwd_iter>
293 string_type
294 lookup_collatename(_Fwd_iter __first, _Fwd_iter __last) const;
295
296 /**
297 * @brief Maps one or more characters to a named character
298 * classification.
299 *
300 * @param __first beginning of the character sequence.
301 * @param __last one-past-the-end of the character sequence.
302 * @param __icase ignores the case of the classification name.
303 *
304 * @returns an unspecified value that represents the character
305 * classification named by the character sequence designated by
306 * the iterator range [__first, __last). If @p icase is true,
307 * the returned mask identifies the classification regardless of
308 * the case of the characters to be matched (for example,
309 * [[:lower:]] is the same as [[:alpha:]]), otherwise a
310 * case-dependent classification is returned. The value
311 * returned shall be independent of the case of the characters
312 * in the character sequence. If the name is not recognized then
313 * returns a value that compares equal to 0.
314 *
315 * At least the following names (or their wide-character equivalent) are
316 * supported.
317 * - d
318 * - w
319 * - s
320 * - alnum
321 * - alpha
322 * - blank
323 * - cntrl
324 * - digit
325 * - graph
326 * - lower
327 * - print
328 * - punct
329 * - space
330 * - upper
331 * - xdigit
332 */
333 template<typename _Fwd_iter>
334 char_class_type
335 lookup_classname(_Fwd_iter __first, _Fwd_iter __last,
336 bool __icase = false) const;
337
338 /**
339 * @brief Determines if @p c is a member of an identified class.
340 *
341 * @param __c a character.
342 * @param __f a class type (as returned from lookup_classname).
343 *
344 * @returns true if the character @p __c is a member of the classification
345 * represented by @p __f, false otherwise.
346 *
347 * @throws std::bad_cast if the current locale does not have a ctype
348 * facet.
349 */
350 bool
351 isctype(_Ch_type __c, char_class_type __f) const;
352
353 /**
354 * @brief Converts a digit to an int.
355 *
356 * @param __ch a character representing a digit.
357 * @param __radix the radix if the numeric conversion (limited to 8, 10,
358 * or 16).
359 *
360 * @returns the value represented by the digit __ch in base radix if the
361 * character __ch is a valid digit in base radix; otherwise returns -1.
362 */
363 int
364 value(_Ch_type __ch, int __radix) const;
365
366 /**
367 * @brief Imbues the regex_traits object with a copy of a new locale.
368 *
369 * @param __loc A locale.
370 *
371 * @returns a copy of the previous locale in use by the regex_traits
372 * object.
373 *
374 * @note Calling imbue with a different locale than the one currently in
375 * use invalidates all cached data held by *this.
376 */
377 locale_type
378 imbue(locale_type __loc)
379 {
380 std::swap(_M_locale, __loc);
381 return __loc;
382 }
383
384 /**
385 * @brief Gets a copy of the current locale in use by the regex_traits
386 * object.
387 */
388 locale_type
389 getloc() const
390 { return _M_locale; }
391
392 protected:
393 locale_type _M_locale;
394 };
395
396 // [7.8] Class basic_regex
397 /**
398 * @brief A regular expression
399 *
400 * Specializations of this class template represent regular expressions
401 * constructed from sequences of character type `_Ch_type`.
402 * Use the `std::regex` typedef for `std::basic_regex<char>`.
403 *
404 * A character sequence passed to the constructor will be parsed according
405 * to the chosen grammar, and used to create a state machine representing
406 * the regular expression. The regex object can then be passed to algorithms
407 * such as `std::regex_match` to match sequences of characters.
408 *
409 * The `syntax_option_type` flag passed to the constructor selects from
410 * one of the supported regular expression grammars. The default is
411 * `ECMAScript` and the others are `basic`, `extended`, `awk`, `grep`, and
412 * `egrep`, which are variations on POSIX regular expressions.
413 *
414 * @headerfile regex
415 * @since C++11
416 */
417 template<typename _Ch_type, typename _Rx_traits = regex_traits<_Ch_type>>
419 {
420 public:
422 "regex traits class must have the same char_type");
423
424 // types:
425 typedef _Ch_type value_type;
426 typedef _Rx_traits traits_type;
427 typedef typename traits_type::string_type string_type;
428 typedef regex_constants::syntax_option_type flag_type;
429 typedef typename traits_type::locale_type locale_type;
430
431 /**
432 * @name Constants
433 * std [28.8.1](1)
434 */
435 ///@{
436 static constexpr flag_type icase = regex_constants::icase;
437 static constexpr flag_type nosubs = regex_constants::nosubs;
438 static constexpr flag_type optimize = regex_constants::optimize;
439 static constexpr flag_type collate = regex_constants::collate;
440 static constexpr flag_type ECMAScript = regex_constants::ECMAScript;
441 static constexpr flag_type basic = regex_constants::basic;
442 static constexpr flag_type extended = regex_constants::extended;
443 static constexpr flag_type awk = regex_constants::awk;
444 static constexpr flag_type grep = regex_constants::grep;
445 static constexpr flag_type egrep = regex_constants::egrep;
446#if __cplusplus >= 201703L || !defined __STRICT_ANSI__
447 static constexpr flag_type multiline = regex_constants::multiline;
448#endif
449 ///@}
450
451 // [7.8.2] construct/copy/destroy
452 /**
453 * Constructs a basic regular expression that does not match any
454 * character sequence.
455 */
456 basic_regex() noexcept
457 : _M_flags(ECMAScript), _M_loc(), _M_automaton(nullptr)
458 { }
459
460 /**
461 * @brief Constructs a basic regular expression from the
462 * sequence [__p, __p + char_traits<_Ch_type>::length(__p))
463 * interpreted according to the flags in @p __f.
464 *
465 * @param __p A pointer to the start of a C-style null-terminated string
466 * containing a regular expression.
467 * @param __f Flags indicating the syntax rules and options.
468 *
469 * @throws regex_error if @p __p is not a valid regular expression.
470 */
471 explicit
472 basic_regex(const _Ch_type* __p, flag_type __f = ECMAScript)
473 { _M_compile(__p, __p + _Rx_traits::length(__p), __f); }
474
475 /**
476 * @brief Constructs a basic regular expression from the sequence
477 * [p, p + len) interpreted according to the flags in @p f.
478 *
479 * @param __p A pointer to the start of a string containing a regular
480 * expression.
481 * @param __len The length of the string containing the regular
482 * expression.
483 * @param __f Flags indicating the syntax rules and options.
484 *
485 * @throws regex_error if @p __p is not a valid regular expression.
486 */
487 basic_regex(const _Ch_type* __p, std::size_t __len,
488 flag_type __f = ECMAScript)
489 {
490 __glibcxx_requires_string_len(__p, __len);
491 _M_compile(__p, __p + __len, __f);
492 }
493
494 /**
495 * @brief Copy-constructs a basic regular expression.
496 *
497 * @param __rhs A @p regex object.
498 */
499 basic_regex(const basic_regex& __rhs) = default;
500
501 /**
502 * @brief Move-constructs a basic regular expression.
503 *
504 * @param __rhs A @p regex object.
505 */
506 basic_regex(basic_regex&& __rhs) noexcept = default;
507
508 /**
509 * @brief Constructs a basic regular expression from the string
510 * @p s interpreted according to the flags in @p f.
511 *
512 * @param __s A string containing a regular expression.
513 * @param __f Flags indicating the syntax rules and options.
514 *
515 * @throws regex_error if @p __s is not a valid regular expression.
516 */
517 template<typename _Ch_traits, typename _Ch_alloc>
518 explicit
519 basic_regex(const std::basic_string<_Ch_type, _Ch_traits,
520 _Ch_alloc>& __s,
521 flag_type __f = ECMAScript)
522 { _M_compile(__s.data(), __s.data() + __s.size(), __f); }
523
524 /**
525 * @brief Constructs a basic regular expression from the range
526 * [first, last) interpreted according to the flags in @p f.
527 *
528 * @param __first The start of a range containing a valid regular
529 * expression.
530 * @param __last The end of a range containing a valid regular
531 * expression.
532 * @param __f The format flags of the regular expression.
533 *
534 * @throws regex_error if @p [__first, __last) is not a valid regular
535 * expression.
536 */
537 template<typename _FwdIter>
538 basic_regex(_FwdIter __first, _FwdIter __last,
539 flag_type __f = ECMAScript)
540 { this->assign(__first, __last, __f); }
541
542 /**
543 * @brief Constructs a basic regular expression from an initializer list.
544 *
545 * @param __l The initializer list.
546 * @param __f The format flags of the regular expression.
547 *
548 * @throws regex_error if @p __l is not a valid regular expression.
549 */
550 basic_regex(initializer_list<_Ch_type> __l, flag_type __f = ECMAScript)
551 { _M_compile(__l.begin(), __l.end(), __f); }
552
553 /**
554 * @brief Destroys a basic regular expression.
555 */
557 { }
558
559 /**
560 * @brief Assigns one regular expression to another.
561 */
563 operator=(const basic_regex&) = default;
564
565 /**
566 * @brief Move-assigns one regular expression to another.
567 */
569 operator=(basic_regex&&) = default;
570
571 /**
572 * @brief Replaces a regular expression with a new one constructed from
573 * a C-style null-terminated string.
574 *
575 * @param __p A pointer to the start of a null-terminated C-style string
576 * containing a regular expression.
577 */
579 operator=(const _Ch_type* __p)
580 { return this->assign(__p); }
581
582 /**
583 * @brief Replaces a regular expression with a new one constructed from
584 * an initializer list.
585 *
586 * @param __l The initializer list.
587 *
588 * @throws regex_error if @p __l is not a valid regular expression.
589 */
592 { return this->assign(__l); }
593
594 /**
595 * @brief Replaces a regular expression with a new one constructed from
596 * a string.
597 *
598 * @param __s A pointer to a string containing a regular expression.
599 */
600 template<typename _Ch_traits, typename _Alloc>
603 { return this->assign(__s); }
604
605 // [7.8.3] assign
606 /**
607 * @brief Assigns one regular expression to another.
608 *
609 * @param __rhs Another regular expression object.
610 */
612 assign(const basic_regex& __rhs) noexcept
613 { return *this = __rhs; }
614
615 /**
616 * @brief Move-assigns one regular expression to another.
617 *
618 * @param __rhs Another regular expression object.
619 */
621 assign(basic_regex&& __rhs) noexcept
622 { return *this = std::move(__rhs); }
623
624 /**
625 * @brief Assigns a new regular expression to a regex object from a
626 * C-style null-terminated string containing a regular expression
627 * pattern.
628 *
629 * @param __p A pointer to a C-style null-terminated string containing
630 * a regular expression pattern.
631 * @param __flags Syntax option flags.
632 *
633 * @throws regex_error if __p does not contain a valid regular
634 * expression pattern interpreted according to @p __flags. If
635 * regex_error is thrown, *this remains unchanged.
636 */
638 assign(const _Ch_type* __p, flag_type __flags = ECMAScript)
639 {
640 _M_compile(__p, __p + _Rx_traits::length(__p), __flags);
641 return *this;
642 }
643
644 /**
645 * @brief Assigns a new regular expression to a regex object from a
646 * C-style string containing a regular expression pattern.
647 *
648 * @param __p A pointer to a C-style string containing a
649 * regular expression pattern.
650 * @param __len The length of the regular expression pattern string.
651 * @param __flags Syntax option flags.
652 *
653 * @throws regex_error if p does not contain a valid regular
654 * expression pattern interpreted according to @p __flags. If
655 * regex_error is thrown, *this remains unchanged.
656 */
657 // _GLIBCXX_RESOLVE_LIB_DEFECTS
658 // 3296. Inconsistent default argument for basic_regex<>::assign
660 assign(const _Ch_type* __p, size_t __len, flag_type __flags = ECMAScript)
661 {
662 _M_compile(__p, __p + __len, __flags);
663 return *this;
664 }
665
666 /**
667 * @brief Assigns a new regular expression to a regex object from a
668 * string containing a regular expression pattern.
669 *
670 * @param __s A string containing a regular expression pattern.
671 * @param __flags Syntax option flags.
672 *
673 * @throws regex_error if __s does not contain a valid regular
674 * expression pattern interpreted according to @p __flags. If
675 * regex_error is thrown, *this remains unchanged.
676 */
677 template<typename _Ch_traits, typename _Alloc>
680 flag_type __flags = ECMAScript)
681 {
682 _M_compile(__s.data(), __s.data() + __s.size(), __flags);
683 return *this;
684 }
685
686 /**
687 * @brief Assigns a new regular expression to a regex object.
688 *
689 * @param __first The start of a range containing a valid regular
690 * expression.
691 * @param __last The end of a range containing a valid regular
692 * expression.
693 * @param __flags Syntax option flags.
694 *
695 * @throws regex_error if p does not contain a valid regular
696 * expression pattern interpreted according to @p __flags. If
697 * regex_error is thrown, the object remains unchanged.
698 */
699 template<typename _InputIterator>
701 assign(_InputIterator __first, _InputIterator __last,
702 flag_type __flags = ECMAScript)
703 {
704#if __cpp_if_constexpr >= 201606L
705 using _ValT = typename iterator_traits<_InputIterator>::value_type;
706 if constexpr (__detail::__is_contiguous_iter<_InputIterator>::value
707 && is_same_v<_ValT, value_type>)
708 {
709 __glibcxx_requires_valid_range(__first, __last);
710 if constexpr (is_pointer_v<_InputIterator>)
711 _M_compile(__first, __last, __flags);
712 else // __normal_iterator<_T*, C>
713 _M_compile(__first.base(), __last.base(), __flags);
714 }
715 else
716#endif
717 this->assign(string_type(__first, __last), __flags);
718 return *this;
719 }
720
721 /**
722 * @brief Assigns a new regular expression to a regex object.
723 *
724 * @param __l An initializer list representing a regular expression.
725 * @param __flags Syntax option flags.
726 *
727 * @throws regex_error if @p __l does not contain a valid
728 * regular expression pattern interpreted according to @p
729 * __flags. If regex_error is thrown, the object remains
730 * unchanged.
731 */
733 assign(initializer_list<_Ch_type> __l, flag_type __flags = ECMAScript)
734 {
735 _M_compile(__l.begin(), __l.end(), __flags);
736 return *this;
737 }
738
739 // [7.8.4] const operations
740 /**
741 * @brief Gets the number of marked subexpressions within the regular
742 * expression.
743 */
744 unsigned int
745 mark_count() const noexcept
746 {
747 if (_M_automaton)
748 return _M_automaton->_M_sub_count() - 1;
749 return 0;
750 }
751
752 /**
753 * @brief Gets the flags used to construct the regular expression
754 * or in the last call to assign().
755 */
756 flag_type
757 flags() const noexcept
758 { return _M_flags; }
759
760 // [7.8.5] locale
761 /**
762 * @brief Imbues the regular expression object with the given locale.
763 *
764 * @param __loc A locale.
765 */
766 locale_type
767 imbue(locale_type __loc)
768 {
769 std::swap(__loc, _M_loc);
770 _M_automaton.reset();
771 return __loc;
772 }
773
774 /**
775 * @brief Gets the locale currently imbued in the regular expression
776 * object.
777 */
778 locale_type
779 getloc() const noexcept
780 { return _M_loc; }
781
782 // [7.8.6] swap
783 /**
784 * @brief Swaps the contents of two regular expression objects.
785 *
786 * @param __rhs Another regular expression object.
787 */
788 void
789 swap(basic_regex& __rhs) noexcept
790 {
791 std::swap(_M_flags, __rhs._M_flags);
792 std::swap(_M_loc, __rhs._M_loc);
793 std::swap(_M_automaton, __rhs._M_automaton);
794 }
795
796#ifdef _GLIBCXX_DEBUG
797 void
798 _M_dot(std::ostream& __ostr)
799 { _M_automaton->_M_dot(__ostr); }
800#endif
801
802 private:
804
805 void
806 _M_compile(const _Ch_type* __first, const _Ch_type* __last,
807 flag_type __f)
808 {
809 __detail::_Compiler<_Rx_traits> __c(__first, __last, _M_loc, __f);
810 _M_automaton = __c._M_get_nfa();
811 _M_flags = __f;
812 }
813
814 template<typename _Bp, typename _Ap, typename _Cp, typename _Rp>
815 friend bool
816 __detail::__regex_algo_impl(_Bp, _Bp, match_results<_Bp, _Ap>&,
819 __detail::_RegexExecutorPolicy, bool);
820
821 template<typename, typename, typename, bool>
822 friend class __detail::_Executor;
823
824 flag_type _M_flags;
825 locale_type _M_loc;
826 _AutomatonPtr _M_automaton;
827 };
828
829#if ! __cpp_inline_variables
830 template<typename _Ch, typename _Tr>
832 basic_regex<_Ch, _Tr>::icase;
833
834 template<typename _Ch, typename _Tr>
836 basic_regex<_Ch, _Tr>::nosubs;
837
838 template<typename _Ch, typename _Tr>
840 basic_regex<_Ch, _Tr>::optimize;
841
842 template<typename _Ch, typename _Tr>
844 basic_regex<_Ch, _Tr>::collate;
845
846 template<typename _Ch, typename _Tr>
848 basic_regex<_Ch, _Tr>::ECMAScript;
849
850 template<typename _Ch, typename _Tr>
852 basic_regex<_Ch, _Tr>::basic;
853
854 template<typename _Ch, typename _Tr>
856 basic_regex<_Ch, _Tr>::extended;
857
858 template<typename _Ch, typename _Tr>
860 basic_regex<_Ch, _Tr>::awk;
861
862 template<typename _Ch, typename _Tr>
864 basic_regex<_Ch, _Tr>::grep;
865
866 template<typename _Ch, typename _Tr>
868 basic_regex<_Ch, _Tr>::egrep;
869#endif // ! C++17
870
871#if __cpp_deduction_guides >= 201606
872 template<typename _ForwardIterator>
873 basic_regex(_ForwardIterator, _ForwardIterator,
876#endif
877
878 /** @brief Standard regular expressions. */
880
881#ifdef _GLIBCXX_USE_WCHAR_T
882 /** @brief Standard wide-character regular expressions. */
884#endif
885
886
887 // [7.8.6] basic_regex swap
888 /**
889 * @brief Swaps the contents of two regular expression objects.
890 * @param __lhs First regular expression.
891 * @param __rhs Second regular expression.
892 * @relates basic_regex
893 */
894 template<typename _Ch_type, typename _Rx_traits>
895 inline void
897 basic_regex<_Ch_type, _Rx_traits>& __rhs) noexcept
898 { __lhs.swap(__rhs); }
899
900
901 // C++11 28.9 [re.submatch] Class template sub_match
902 /**
903 * A sequence of characters matched by a particular marked sub-expression.
904 *
905 * An object of this class is essentially a pair of iterators marking a
906 * matched subexpression within a regular expression pattern match. Such
907 * objects can be converted to and compared with std::basic_string objects
908 * of the same character type as the pattern matched by the regular
909 * expression.
910 *
911 * A `sub_match<Iter>` has a public base class of type `pair<Iter, Iter>`,
912 * so inherits pair's data members named `first` and `second`.
913 * The iterators that make up the pair are the usual half-open interval
914 * referencing the actual original pattern matched.
915 *
916 * @headerfile regex
917 * @since C++11
918 */
919 template<typename _BiIter>
920 class sub_match
921 /// @cond undocumented
922 : public std::pair<_BiIter, _BiIter>
923 /// @endcond
924 {
925 typedef iterator_traits<_BiIter> __iter_traits;
926
927 public:
928 typedef typename __iter_traits::value_type value_type;
929 typedef typename __iter_traits::difference_type difference_type;
930 typedef _BiIter iterator;
931 typedef basic_string<value_type> string_type;
932
933 _GLIBCXX_DOXYGEN_ONLY(iterator first; iterator second;)
934
935 bool matched;
936
937 constexpr sub_match() noexcept : matched() { }
938
939 /// Gets the length of the matching sequence.
940 difference_type
941 length() const noexcept
942 { return this->matched ? std::distance(this->first, this->second) : 0; }
943
944 /**
945 * @brief Gets the matching sequence as a string.
946 *
947 * @returns the matching sequence as a string.
948 *
949 * This is the implicit conversion operator. It is identical to the
950 * str() member function except that it will want to pop up in
951 * unexpected places and cause a great deal of confusion and cursing
952 * from the unwary.
953 */
954 operator string_type() const
955 { return str(); }
956
957 /**
958 * @brief Gets the matching sequence as a string.
959 *
960 * @returns the matching sequence as a string.
961 */
962 string_type
963 str() const
964 {
965 return this->matched
966 ? string_type(this->first, this->second)
967 : string_type();
968 }
969
970 /**
971 * @brief Compares this and another matched sequence.
972 *
973 * @param __s Another matched sequence to compare to this one.
974 *
975 * @retval negative This matched sequence will collate before `__s`.
976 * @retval zero This matched sequence is equivalent to `__s`.
977 * @retval positive This matched sequence will collate after `__s`.
978 */
979 int
980 compare(const sub_match& __s) const
981 { return this->_M_str().compare(__s._M_str()); }
982
983 /**
984 * @{
985 * @brief Compares this `sub_match` to a string.
986 *
987 * @param __s A string to compare to this `sub_match`.
988 *
989 * @retval negative This matched sequence will collate before `__s`.
990 * @retval zero This matched sequence is equivalent to `__s`.
991 * @retval positive This matched sequence will collate after `__s`.
992 */
993 int
994 compare(const string_type& __s) const
995 { return this->_M_str().compare(__s); }
996
997 int
998 compare(const value_type* __s) const
999 { return this->_M_str().compare(__s); }
1000 /// @}
1001
1002 /// @cond undocumented
1003 // Non-standard, used by comparison operators
1004 int
1005 _M_compare(const value_type* __s, size_t __n) const
1006 { return this->_M_str().compare({__s, __n}); }
1007 /// @endcond
1008
1009 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1010 // 3204. sub_match::swap only swaps the base class
1011 /// Swap the values of two sub_match objects.
1012 void
1013 swap(sub_match& __s) noexcept(__is_nothrow_swappable<_BiIter>::value)
1014 {
1016 std::swap(matched, __s.matched);
1017 }
1018
1019 private:
1020 // Simplified basic_string_view for C++11
1021 struct __string_view
1022 {
1023 using traits_type = typename string_type::traits_type;
1024
1025 __string_view() = default;
1026
1027 __string_view(const value_type* __s, size_t __n) noexcept
1028 : _M_data(__s), _M_len(__n) { }
1029
1030 __string_view(const value_type* __s) noexcept
1031 : _M_data(__s), _M_len(traits_type::length(__s)) { }
1032
1033 __string_view(const string_type& __s) noexcept
1034 : _M_data(__s.data()), _M_len(__s.length()) { }
1035
1036 int
1037 compare(__string_view __s) const noexcept
1038 {
1039 if (const size_t __n = std::min(_M_len, __s._M_len))
1040 if (int __ret = traits_type::compare(_M_data, __s._M_data, __n))
1041 return __ret;
1042 using __limits = __gnu_cxx::__int_traits<int>;
1043 const difference_type __diff = _M_len - __s._M_len;
1044 if (__diff > __limits::__max)
1045 return __limits::__max;
1046 if (__diff < __limits::__min)
1047 return __limits::__min;
1048 return static_cast<int>(__diff);
1049 }
1050
1051 private:
1052 const value_type* _M_data = nullptr;
1053 size_t _M_len = 0;
1054 };
1055
1056 // Create a __string_view over the iterator range.
1057 template<typename _Iter = _BiIter>
1058 __enable_if_t<__detail::__is_contiguous_iter<_Iter>::value,
1059 __string_view>
1060 _M_str() const noexcept
1061 {
1062 if (this->matched)
1063 if (size_t __len = this->second - this->first)
1064 return { std::__addressof(*this->first), __len };
1065 return {};
1066 }
1067
1068 // Create a temporary string that can be converted to __string_view.
1069 template<typename _Iter = _BiIter>
1070 __enable_if_t<!__detail::__is_contiguous_iter<_Iter>::value,
1071 string_type>
1072 _M_str() const
1073 { return str(); }
1074 };
1075
1076
1077 /** @brief Standard regex submatch over a C-style null-terminated string. */
1079
1080 /** @brief Standard regex submatch over a standard string. */
1082
1083#ifdef _GLIBCXX_USE_WCHAR_T
1084 /** @brief Regex submatch over a C-style null-terminated wide string. */
1086
1087 /** @brief Regex submatch over a standard wide string. */
1089#endif
1090
1091 // [7.9.2] sub_match non-member operators
1092
1093 /// @relates sub_match @{
1094
1095 /**
1096 * @brief Tests the equivalence of two regular expression submatches.
1097 * @param __lhs First regular expression submatch.
1098 * @param __rhs Second regular expression submatch.
1099 * @returns true if @a __lhs is equivalent to @a __rhs, false otherwise.
1100 */
1101 template<typename _BiIter>
1102 inline bool
1103 operator==(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs)
1104 { return __lhs.compare(__rhs) == 0; }
1105
1106#if __cpp_lib_three_way_comparison
1107 /**
1108 * @brief Three-way comparison of two regular expression submatches.
1109 * @param __lhs First regular expression submatch.
1110 * @param __rhs Second regular expression submatch.
1111 * @returns A value indicating whether `__lhs` is less than, equal to,
1112 * greater than, or incomparable with `__rhs`.
1113 */
1114 template<typename _BiIter>
1115 inline auto
1116 operator<=>(const sub_match<_BiIter>& __lhs,
1117 const sub_match<_BiIter>& __rhs)
1118 noexcept(__detail::__is_contiguous_iter<_BiIter>::value)
1119 {
1121 return __detail::__char_traits_cmp_cat<_Tr>(__lhs.compare(__rhs));
1122 }
1123#else
1124 /**
1125 * @brief Tests the inequivalence of two regular expression submatches.
1126 * @param __lhs First regular expression submatch.
1127 * @param __rhs Second regular expression submatch.
1128 * @returns true if @a __lhs is not equivalent to @a __rhs, false otherwise.
1129 */
1130 template<typename _BiIter>
1131 inline bool
1132 operator!=(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs)
1133 { return __lhs.compare(__rhs) != 0; }
1134
1135 /**
1136 * @brief Tests the ordering of two regular expression submatches.
1137 * @param __lhs First regular expression submatch.
1138 * @param __rhs Second regular expression submatch.
1139 * @returns true if @a __lhs precedes @a __rhs, false otherwise.
1140 */
1141 template<typename _BiIter>
1142 inline bool
1143 operator<(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs)
1144 { return __lhs.compare(__rhs) < 0; }
1145
1146 /**
1147 * @brief Tests the ordering of two regular expression submatches.
1148 * @param __lhs First regular expression submatch.
1149 * @param __rhs Second regular expression submatch.
1150 * @returns true if @a __lhs does not succeed @a __rhs, false otherwise.
1151 */
1152 template<typename _BiIter>
1153 inline bool
1154 operator<=(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs)
1155 { return __lhs.compare(__rhs) <= 0; }
1156
1157 /**
1158 * @brief Tests the ordering of two regular expression submatches.
1159 * @param __lhs First regular expression submatch.
1160 * @param __rhs Second regular expression submatch.
1161 * @returns true if @a __lhs does not precede @a __rhs, false otherwise.
1162 */
1163 template<typename _BiIter>
1164 inline bool
1165 operator>=(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs)
1166 { return __lhs.compare(__rhs) >= 0; }
1167
1168 /**
1169 * @brief Tests the ordering of two regular expression submatches.
1170 * @param __lhs First regular expression submatch.
1171 * @param __rhs Second regular expression submatch.
1172 * @returns true if @a __lhs succeeds @a __rhs, false otherwise.
1173 */
1174 template<typename _BiIter>
1175 inline bool
1176 operator>(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs)
1177 { return __lhs.compare(__rhs) > 0; }
1178#endif // three-way comparison
1179
1180 /// @cond undocumented
1181
1182 // Alias for a basic_string that can be compared to a sub_match.
1183 template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1184 using __sub_match_string = basic_string<
1186 _Ch_traits, _Ch_alloc>;
1187 /// @endcond
1188
1189#if ! __cpp_lib_three_way_comparison
1190 /**
1191 * @brief Tests the equivalence of a string and a regular expression
1192 * submatch.
1193 * @param __lhs A string.
1194 * @param __rhs A regular expression submatch.
1195 * @returns true if @a __lhs is equivalent to @a __rhs, false otherwise.
1196 */
1197 template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1198 inline bool
1199 operator==(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1200 const sub_match<_Bi_iter>& __rhs)
1201 { return __rhs._M_compare(__lhs.data(), __lhs.size()) == 0; }
1202
1203 /**
1204 * @brief Tests the inequivalence of a string and a regular expression
1205 * submatch.
1206 * @param __lhs A string.
1207 * @param __rhs A regular expression submatch.
1208 * @returns true if @a __lhs is not equivalent to @a __rhs, false otherwise.
1209 */
1210 template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1211 inline bool
1212 operator!=(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1213 const sub_match<_Bi_iter>& __rhs)
1214 { return !(__lhs == __rhs); }
1215
1216 /**
1217 * @brief Tests the ordering of a string and a regular expression submatch.
1218 * @param __lhs A string.
1219 * @param __rhs A regular expression submatch.
1220 * @returns true if @a __lhs precedes @a __rhs, false otherwise.
1221 */
1222 template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1223 inline bool
1224 operator<(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1225 const sub_match<_Bi_iter>& __rhs)
1226 { return __rhs._M_compare(__lhs.data(), __lhs.size()) > 0; }
1227
1228 /**
1229 * @brief Tests the ordering of a string and a regular expression submatch.
1230 * @param __lhs A string.
1231 * @param __rhs A regular expression submatch.
1232 * @returns true if @a __lhs succeeds @a __rhs, false otherwise.
1233 */
1234 template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1235 inline bool
1236 operator>(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1237 const sub_match<_Bi_iter>& __rhs)
1238 { return __rhs < __lhs; }
1239
1240 /**
1241 * @brief Tests the ordering of a string and a regular expression submatch.
1242 * @param __lhs A string.
1243 * @param __rhs A regular expression submatch.
1244 * @returns true if @a __lhs does not precede @a __rhs, false otherwise.
1245 */
1246 template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1247 inline bool
1248 operator>=(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1249 const sub_match<_Bi_iter>& __rhs)
1250 { return !(__lhs < __rhs); }
1251
1252 /**
1253 * @brief Tests the ordering of a string and a regular expression submatch.
1254 * @param __lhs A string.
1255 * @param __rhs A regular expression submatch.
1256 * @returns true if @a __lhs does not succeed @a __rhs, false otherwise.
1257 */
1258 template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1259 inline bool
1260 operator<=(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1261 const sub_match<_Bi_iter>& __rhs)
1262 { return !(__rhs < __lhs); }
1263#endif // three-way comparison
1264
1265 /**
1266 * @brief Tests the equivalence of a regular expression submatch and a
1267 * string.
1268 * @param __lhs A regular expression submatch.
1269 * @param __rhs A string.
1270 * @returns true if @a __lhs is equivalent to @a __rhs, false otherwise.
1271 */
1272 template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1273 inline bool
1274 operator==(const sub_match<_Bi_iter>& __lhs,
1275 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1276 { return __lhs._M_compare(__rhs.data(), __rhs.size()) == 0; }
1277
1278#if __cpp_lib_three_way_comparison
1279 /**
1280 * @brief Three-way comparison of a regular expression submatch and a string.
1281 * @param __lhs A regular expression submatch.
1282 * @param __rhs A string.
1283 * @returns A value indicating whether `__lhs` is less than, equal to,
1284 * greater than, or incomparable with `__rhs`.
1285 */
1286 template<typename _Bi_iter, typename _Ch_traits, typename _Alloc>
1287 inline auto
1288 operator<=>(const sub_match<_Bi_iter>& __lhs,
1289 const __sub_match_string<_Bi_iter, _Ch_traits, _Alloc>& __rhs)
1290 noexcept(__detail::__is_contiguous_iter<_Bi_iter>::value)
1291 {
1292 return __detail::__char_traits_cmp_cat<_Ch_traits>(
1293 __lhs._M_compare(__rhs.data(), __rhs.size()));
1294 }
1295#else
1296 /**
1297 * @brief Tests the inequivalence of a regular expression submatch and a
1298 * string.
1299 * @param __lhs A regular expression submatch.
1300 * @param __rhs A string.
1301 * @returns true if @a __lhs is not equivalent to @a __rhs, false otherwise.
1302 */
1303 template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1304 inline bool
1305 operator!=(const sub_match<_Bi_iter>& __lhs,
1306 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1307 { return !(__lhs == __rhs); }
1308
1309 /**
1310 * @brief Tests the ordering of a regular expression submatch and a string.
1311 * @param __lhs A regular expression submatch.
1312 * @param __rhs A string.
1313 * @returns true if @a __lhs precedes @a __rhs, false otherwise.
1314 */
1315 template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1316 inline bool
1317 operator<(const sub_match<_Bi_iter>& __lhs,
1318 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1319 { return __lhs._M_compare(__rhs.data(), __rhs.size()) < 0; }
1320
1321 /**
1322 * @brief Tests the ordering of a regular expression submatch and a string.
1323 * @param __lhs A regular expression submatch.
1324 * @param __rhs A string.
1325 * @returns true if @a __lhs succeeds @a __rhs, false otherwise.
1326 */
1327 template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1328 inline bool
1329 operator>(const sub_match<_Bi_iter>& __lhs,
1330 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1331 { return __rhs < __lhs; }
1332
1333 /**
1334 * @brief Tests the ordering of a regular expression submatch and a string.
1335 * @param __lhs A regular expression submatch.
1336 * @param __rhs A string.
1337 * @returns true if @a __lhs does not precede @a __rhs, false otherwise.
1338 */
1339 template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1340 inline bool
1341 operator>=(const sub_match<_Bi_iter>& __lhs,
1342 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1343 { return !(__lhs < __rhs); }
1344
1345 /**
1346 * @brief Tests the ordering of a regular expression submatch and a string.
1347 * @param __lhs A regular expression submatch.
1348 * @param __rhs A string.
1349 * @returns true if @a __lhs does not succeed @a __rhs, false otherwise.
1350 */
1351 template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc>
1352 inline bool
1353 operator<=(const sub_match<_Bi_iter>& __lhs,
1354 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1355 { return !(__rhs < __lhs); }
1356
1357 /**
1358 * @brief Tests the equivalence of a C string and a regular expression
1359 * submatch.
1360 * @param __lhs A null-terminated string.
1361 * @param __rhs A regular expression submatch.
1362 * @returns true if @a __lhs is equivalent to @a __rhs, false otherwise.
1363 */
1364 template<typename _Bi_iter>
1365 inline bool
1366 operator==(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
1367 const sub_match<_Bi_iter>& __rhs)
1368 { return __rhs.compare(__lhs) == 0; }
1369
1370 /**
1371 * @brief Tests the inequivalence of a C string and a regular
1372 * expression submatch.
1373 * @param __lhs A null-terminated string.
1374 * @param __rhs A regular expression submatch.
1375 * @returns true if @a __lhs is not equivalent to @a __rhs, false otherwise.
1376 */
1377 template<typename _Bi_iter>
1378 inline bool
1379 operator!=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
1380 const sub_match<_Bi_iter>& __rhs)
1381 { return !(__lhs == __rhs); }
1382
1383 /**
1384 * @brief Tests the ordering of a C string and a regular expression submatch.
1385 * @param __lhs A null-terminated string.
1386 * @param __rhs A regular expression submatch.
1387 * @returns true if @a __lhs precedes @a __rhs, false otherwise.
1388 */
1389 template<typename _Bi_iter>
1390 inline bool
1391 operator<(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
1392 const sub_match<_Bi_iter>& __rhs)
1393 { return __rhs.compare(__lhs) > 0; }
1394
1395 /**
1396 * @brief Tests the ordering of a C string and a regular expression submatch.
1397 * @param __lhs A null-terminated string.
1398 * @param __rhs A regular expression submatch.
1399 * @returns true if @a __lhs succeeds @a __rhs, false otherwise.
1400 */
1401 template<typename _Bi_iter>
1402 inline bool
1403 operator>(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
1404 const sub_match<_Bi_iter>& __rhs)
1405 { return __rhs < __lhs; }
1406
1407 /**
1408 * @brief Tests the ordering of a C string and a regular expression submatch.
1409 * @param __lhs A null-terminated string.
1410 * @param __rhs A regular expression submatch.
1411 * @returns true if @a __lhs does not precede @a __rhs, false otherwise.
1412 */
1413 template<typename _Bi_iter>
1414 inline bool
1415 operator>=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
1416 const sub_match<_Bi_iter>& __rhs)
1417 { return !(__lhs < __rhs); }
1418
1419 /**
1420 * @brief Tests the ordering of a C string and a regular expression submatch.
1421 * @param __lhs A null-terminated string.
1422 * @param __rhs A regular expression submatch.
1423 * @returns true if @a __lhs does not succeed @a __rhs, false otherwise.
1424 */
1425 template<typename _Bi_iter>
1426 inline bool
1427 operator<=(typename iterator_traits<_Bi_iter>::value_type const* __lhs,
1428 const sub_match<_Bi_iter>& __rhs)
1429 { return !(__rhs < __lhs); }
1430#endif // three-way comparison
1431
1432 /**
1433 * @brief Tests the equivalence of a regular expression submatch and a C
1434 * string.
1435 * @param __lhs A regular expression submatch.
1436 * @param __rhs A null-terminated string.
1437 * @returns true if @a __lhs is equivalent to @a __rhs, false otherwise.
1438 */
1439 template<typename _Bi_iter>
1440 inline bool
1441 operator==(const sub_match<_Bi_iter>& __lhs,
1442 typename iterator_traits<_Bi_iter>::value_type const* __rhs)
1443 { return __lhs.compare(__rhs) == 0; }
1444
1445#if __cpp_lib_three_way_comparison
1446 /**
1447 * @brief Three-way comparison of a regular expression submatch and a C
1448 * string.
1449 * @param __lhs A regular expression submatch.
1450 * @param __rhs A null-terminated string.
1451 * @returns A value indicating whether `__lhs` is less than, equal to,
1452 * greater than, or incomparable with `__rhs`.
1453 */
1454 template<typename _Bi_iter>
1455 inline auto
1456 operator<=>(const sub_match<_Bi_iter>& __lhs,
1457 typename iterator_traits<_Bi_iter>::value_type const* __rhs)
1458 noexcept(__detail::__is_contiguous_iter<_Bi_iter>::value)
1459 {
1461 return __detail::__char_traits_cmp_cat<_Tr>(__lhs.compare(__rhs));
1462 }
1463#else
1464 /**
1465 * @brief Tests the inequivalence of a regular expression submatch and a
1466 * string.
1467 * @param __lhs A regular expression submatch.
1468 * @param __rhs A null-terminated string.
1469 * @returns true if @a __lhs is not equivalent to @a __rhs, false otherwise.
1470 */
1471 template<typename _Bi_iter>
1472 inline bool
1473 operator!=(const sub_match<_Bi_iter>& __lhs,
1474 typename iterator_traits<_Bi_iter>::value_type const* __rhs)
1475 { return !(__lhs == __rhs); }
1476
1477 /**
1478 * @brief Tests the ordering of a regular expression submatch and a C string.
1479 * @param __lhs A regular expression submatch.
1480 * @param __rhs A null-terminated string.
1481 * @returns true if @a __lhs precedes @a __rhs, false otherwise.
1482 */
1483 template<typename _Bi_iter>
1484 inline bool
1485 operator<(const sub_match<_Bi_iter>& __lhs,
1486 typename iterator_traits<_Bi_iter>::value_type const* __rhs)
1487 { return __lhs.compare(__rhs) < 0; }
1488
1489 /**
1490 * @brief Tests the ordering of a regular expression submatch and a C string.
1491 * @param __lhs A regular expression submatch.
1492 * @param __rhs A null-terminated string.
1493 * @returns true if @a __lhs succeeds @a __rhs, false otherwise.
1494 */
1495 template<typename _Bi_iter>
1496 inline bool
1497 operator>(const sub_match<_Bi_iter>& __lhs,
1498 typename iterator_traits<_Bi_iter>::value_type const* __rhs)
1499 { return __rhs < __lhs; }
1500
1501 /**
1502 * @brief Tests the ordering of a regular expression submatch and a C string.
1503 * @param __lhs A regular expression submatch.
1504 * @param __rhs A null-terminated string.
1505 * @returns true if @a __lhs does not precede @a __rhs, false otherwise.
1506 */
1507 template<typename _Bi_iter>
1508 inline bool
1509 operator>=(const sub_match<_Bi_iter>& __lhs,
1510 typename iterator_traits<_Bi_iter>::value_type const* __rhs)
1511 { return !(__lhs < __rhs); }
1512
1513 /**
1514 * @brief Tests the ordering of a regular expression submatch and a C string.
1515 * @param __lhs A regular expression submatch.
1516 * @param __rhs A null-terminated string.
1517 * @returns true if @a __lhs does not succeed @a __rhs, false otherwise.
1518 */
1519 template<typename _Bi_iter>
1520 inline bool
1521 operator<=(const sub_match<_Bi_iter>& __lhs,
1522 typename iterator_traits<_Bi_iter>::value_type const* __rhs)
1523 { return !(__rhs < __lhs); }
1524
1525 /**
1526 * @brief Tests the equivalence of a character and a regular expression
1527 * submatch.
1528 * @param __lhs A character.
1529 * @param __rhs A regular expression submatch.
1530 * @returns true if @a __lhs is equivalent to @a __rhs, false otherwise.
1531 */
1532 template<typename _Bi_iter>
1533 inline bool
1534 operator==(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
1535 const sub_match<_Bi_iter>& __rhs)
1536 { return __rhs._M_compare(std::__addressof(__lhs), 1) == 0; }
1537
1538 /**
1539 * @brief Tests the inequivalence of a character and a regular expression
1540 * submatch.
1541 * @param __lhs A character.
1542 * @param __rhs A regular expression submatch.
1543 * @returns true if @a __lhs is not equivalent to @a __rhs, false otherwise.
1544 */
1545 template<typename _Bi_iter>
1546 inline bool
1547 operator!=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
1548 const sub_match<_Bi_iter>& __rhs)
1549 { return !(__lhs == __rhs); }
1550
1551 /**
1552 * @brief Tests the ordering of a character and a regular expression
1553 * submatch.
1554 * @param __lhs A character.
1555 * @param __rhs A regular expression submatch.
1556 * @returns true if @a __lhs precedes @a __rhs, false otherwise.
1557 */
1558 template<typename _Bi_iter>
1559 inline bool
1560 operator<(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
1561 const sub_match<_Bi_iter>& __rhs)
1562 { return __rhs._M_compare(std::__addressof(__lhs), 1) > 0; }
1563
1564 /**
1565 * @brief Tests the ordering of a character and a regular expression
1566 * submatch.
1567 * @param __lhs A character.
1568 * @param __rhs A regular expression submatch.
1569 * @returns true if @a __lhs succeeds @a __rhs, false otherwise.
1570 */
1571 template<typename _Bi_iter>
1572 inline bool
1573 operator>(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
1574 const sub_match<_Bi_iter>& __rhs)
1575 { return __rhs < __lhs; }
1576
1577 /**
1578 * @brief Tests the ordering of a character and a regular expression
1579 * submatch.
1580 * @param __lhs A character.
1581 * @param __rhs A regular expression submatch.
1582 * @returns true if @a __lhs does not precede @a __rhs, false otherwise.
1583 */
1584 template<typename _Bi_iter>
1585 inline bool
1586 operator>=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
1587 const sub_match<_Bi_iter>& __rhs)
1588 { return !(__lhs < __rhs); }
1589
1590 /**
1591 * @brief Tests the ordering of a character and a regular expression
1592 * submatch.
1593 * @param __lhs A character.
1594 * @param __rhs A regular expression submatch.
1595 * @returns true if @a __lhs does not succeed @a __rhs, false otherwise.
1596 */
1597 template<typename _Bi_iter>
1598 inline bool
1599 operator<=(typename iterator_traits<_Bi_iter>::value_type const& __lhs,
1600 const sub_match<_Bi_iter>& __rhs)
1601 { return !(__rhs < __lhs); }
1602#endif // three-way comparison
1603
1604 /**
1605 * @brief Tests the equivalence of a regular expression submatch and a
1606 * character.
1607 * @param __lhs A regular expression submatch.
1608 * @param __rhs A character.
1609 * @returns true if @a __lhs is equivalent to @a __rhs, false otherwise.
1610 */
1611 template<typename _Bi_iter>
1612 inline bool
1613 operator==(const sub_match<_Bi_iter>& __lhs,
1614 typename iterator_traits<_Bi_iter>::value_type const& __rhs)
1615 { return __lhs._M_compare(std::__addressof(__rhs), 1) == 0; }
1616
1617#if __cpp_lib_three_way_comparison
1618 /**
1619 * @brief Three-way comparison of a regular expression submatch and a
1620 * character.
1621 * @param __lhs A regular expression submatch.
1622 * @param __rhs A character.
1623 * @returns A value indicating whether `__lhs` is less than, equal to,
1624 * greater than, or incomparable with `__rhs`.
1625 */
1626
1627 template<typename _Bi_iter>
1628 inline auto
1629 operator<=>(const sub_match<_Bi_iter>& __lhs,
1630 typename iterator_traits<_Bi_iter>::value_type const& __rhs)
1631 noexcept(__detail::__is_contiguous_iter<_Bi_iter>::value)
1632 {
1634 return __detail::__char_traits_cmp_cat<_Tr>(
1635 __lhs._M_compare(std::__addressof(__rhs), 1));
1636 }
1637#else
1638 /**
1639 * @brief Tests the inequivalence of a regular expression submatch and a
1640 * character.
1641 * @param __lhs A regular expression submatch.
1642 * @param __rhs A character.
1643 * @returns true if @a __lhs is not equivalent to @a __rhs, false otherwise.
1644 */
1645 template<typename _Bi_iter>
1646 inline bool
1647 operator!=(const sub_match<_Bi_iter>& __lhs,
1648 typename iterator_traits<_Bi_iter>::value_type const& __rhs)
1649 { return !(__lhs == __rhs); }
1650
1651 /**
1652 * @brief Tests the ordering of a regular expression submatch and a
1653 * character.
1654 * @param __lhs A regular expression submatch.
1655 * @param __rhs A character.
1656 * @returns true if @a __lhs precedes @a __rhs, false otherwise.
1657 */
1658 template<typename _Bi_iter>
1659 inline bool
1660 operator<(const sub_match<_Bi_iter>& __lhs,
1661 typename iterator_traits<_Bi_iter>::value_type const& __rhs)
1662 { return __lhs._M_compare(std::__addressof(__rhs), 1) < 0; }
1663
1664 /**
1665 * @brief Tests the ordering of a regular expression submatch and a
1666 * character.
1667 * @param __lhs A regular expression submatch.
1668 * @param __rhs A character.
1669 * @returns true if @a __lhs succeeds @a __rhs, false otherwise.
1670 */
1671 template<typename _Bi_iter>
1672 inline bool
1673 operator>(const sub_match<_Bi_iter>& __lhs,
1674 typename iterator_traits<_Bi_iter>::value_type const& __rhs)
1675 { return __rhs < __lhs; }
1676
1677 /**
1678 * @brief Tests the ordering of a regular expression submatch and a
1679 * character.
1680 * @param __lhs A regular expression submatch.
1681 * @param __rhs A character.
1682 * @returns true if @a __lhs does not precede @a __rhs, false otherwise.
1683 */
1684 template<typename _Bi_iter>
1685 inline bool
1686 operator>=(const sub_match<_Bi_iter>& __lhs,
1687 typename iterator_traits<_Bi_iter>::value_type const& __rhs)
1688 { return !(__lhs < __rhs); }
1689
1690 /**
1691 * @brief Tests the ordering of a regular expression submatch and a
1692 * character.
1693 * @param __lhs A regular expression submatch.
1694 * @param __rhs A character.
1695 * @returns true if @a __lhs does not succeed @a __rhs, false otherwise.
1696 */
1697 template<typename _Bi_iter>
1698 inline bool
1699 operator<=(const sub_match<_Bi_iter>& __lhs,
1700 typename iterator_traits<_Bi_iter>::value_type const& __rhs)
1701 { return !(__rhs < __lhs); }
1702#endif // three-way comparison
1703
1704 /**
1705 * @brief Inserts a matched string into an output stream.
1706 *
1707 * @param __os The output stream.
1708 * @param __m A submatch string.
1709 *
1710 * @returns the output stream with the submatch string inserted.
1711 */
1712 template<typename _Ch_type, typename _Ch_traits, typename _Bi_iter>
1713 inline
1716 const sub_match<_Bi_iter>& __m)
1717 { return __os << __m.str(); }
1718
1719 /// @} relates sub_match
1720
1721 // [7.10] Class template match_results
1722
1723 /**
1724 * @brief The results of a match or search operation.
1725 *
1726 * A collection of character sequences representing the result of a regular
1727 * expression match. Storage for the collection is allocated and freed as
1728 * necessary by the member functions of class template match_results.
1729 *
1730 * This class satisfies the Sequence requirements, with the exception that
1731 * only the operations defined for a const-qualified Sequence are supported.
1732 *
1733 * The sub_match object stored at index 0 represents sub-expression 0, i.e.
1734 * the whole match. In this case the %sub_match member matched is always true.
1735 * The sub_match object stored at index n denotes what matched the marked
1736 * sub-expression n within the matched expression. If the sub-expression n
1737 * participated in a regular expression match then the %sub_match member
1738 * matched evaluates to true, and members first and second denote the range
1739 * of characters [first, second) which formed that match. Otherwise matched
1740 * is false, and members first and second point to the end of the sequence
1741 * that was searched.
1742 *
1743 * @headerfile regex
1744 * @since C++11
1745 */
1746 template<typename _Bi_iter,
1747 typename _Alloc = allocator<sub_match<_Bi_iter> > >
1749 : private std::vector<sub_match<_Bi_iter>, _Alloc>
1750 {
1751 private:
1752 /*
1753 * The vector base is empty if this does not represent a match (!ready());
1754 * Otherwise if it's a match failure, it contains 3 elements:
1755 * [0] unmatched
1756 * [1] prefix
1757 * [2] suffix
1758 * Otherwise it contains n+4 elements where n is the number of marked
1759 * sub-expressions:
1760 * [0] entire match
1761 * [1] 1st marked subexpression
1762 * ...
1763 * [n] nth marked subexpression
1764 * [n+1] unmatched
1765 * [n+2] prefix
1766 * [n+3] suffix
1767 */
1768 typedef std::vector<sub_match<_Bi_iter>, _Alloc> _Base_type;
1769 // In debug mode _Base_type is the debug vector, this is the unsafe one:
1770 typedef _GLIBCXX_STD_C::vector<sub_match<_Bi_iter>, _Alloc> _Unchecked;
1771 typedef std::iterator_traits<_Bi_iter> __iter_traits;
1772 typedef regex_constants::match_flag_type match_flag_type;
1773
1774 public:
1775 /**
1776 * @name 28.10 Public Types
1777 */
1778 ///@{
1779 typedef sub_match<_Bi_iter> value_type;
1780 typedef const value_type& const_reference;
1781 typedef value_type& reference;
1782 typedef typename _Base_type::const_iterator const_iterator;
1783 typedef const_iterator iterator;
1784 typedef typename __iter_traits::difference_type difference_type;
1785 typedef typename allocator_traits<_Alloc>::size_type size_type;
1786 typedef _Alloc allocator_type;
1787 typedef typename __iter_traits::value_type char_type;
1788 typedef std::basic_string<char_type> string_type;
1789 ///@}
1790
1791 public:
1792 /**
1793 * @name 28.10.1 Construction, Copying, and Destruction
1794 */
1795 ///@{
1796
1797 /**
1798 * @brief Constructs a default %match_results container.
1799 * @post size() returns 0 and str() returns an empty string.
1800 */
1802
1803 /**
1804 * @brief Constructs a default %match_results container.
1805 * @post size() returns 0 and str() returns an empty string.
1806 */
1807 explicit
1808 match_results(const _Alloc& __a) noexcept
1809 : _Base_type(__a)
1810 { }
1811
1812 /**
1813 * @brief Copy constructs a %match_results.
1814 */
1815 match_results(const match_results&) = default;
1816
1817 /**
1818 * @brief Move constructs a %match_results.
1819 */
1820 match_results(match_results&&) noexcept = default;
1821
1822 /**
1823 * @brief Assigns rhs to *this.
1824 */
1826 operator=(const match_results&) = default;
1827
1828 /**
1829 * @brief Move-assigns rhs to *this.
1830 */
1832 operator=(match_results&&) = default;
1833
1834 /**
1835 * @brief Destroys a %match_results object.
1836 */
1837 ~match_results() = default;
1838
1839 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1840 // 2195. Missing constructors for match_results
1841
1842 match_results(const match_results& __m, const _Alloc& __a)
1843 : _Base_type(__m, __a) { }
1844
1845 match_results(match_results&& __m, const _Alloc& __a)
1846 noexcept(noexcept(_Base_type(std::move(__m), __a)))
1847 : _Base_type(std::move(__m), __a) { }
1848
1849 ///@}
1850
1851 // 28.10.2, state:
1852 /**
1853 * @brief Indicates if the %match_results is ready.
1854 * @retval true The object has a fully-established result state.
1855 * @retval false The object is not ready.
1856 */
1857 bool ready() const noexcept { return !_Unchecked::empty(); }
1858
1859 /**
1860 * @name 28.10.2 Size
1861 */
1862 ///@{
1863
1864 /**
1865 * @brief Gets the number of matches and submatches.
1866 *
1867 * The number of matches for a given regular expression will be either 0
1868 * if there was no match or mark_count() + 1 if a match was successful.
1869 * Some matches may be empty.
1870 *
1871 * @returns the number of matches found.
1872 */
1873 size_type
1874 size() const noexcept
1875 { return _Unchecked::empty() ? 0 : _Unchecked::size() - 3; }
1876
1877 size_type
1878 max_size() const noexcept
1879 { return _Unchecked::max_size() - 3; }
1880
1881 /**
1882 * @brief Indicates if the %match_results contains no results.
1883 * @retval true The %match_results object is empty.
1884 * @retval false The %match_results object is not empty.
1885 */
1886 _GLIBCXX_NODISCARD bool
1887 empty() const noexcept
1888 { return _Unchecked::size() <= 3; }
1889
1890 ///@}
1891
1892 /**
1893 * @name 28.10.4 Element Access
1894 */
1895 ///@{
1896
1897 /**
1898 * @brief Gets the length of the indicated submatch.
1899 * @param __sub indicates the submatch.
1900 * @pre ready() == true
1901 *
1902 * This function returns the length of the indicated submatch, or the
1903 * length of the entire match if @p __sub is zero (the default).
1904 */
1906 length(size_type __sub = 0) const
1907 { return (*this)[__sub].length(); }
1908
1909 /**
1910 * @brief Gets the offset of the beginning of the indicated submatch.
1911 * @param __sub indicates the submatch.
1912 * @pre ready() == true
1913 *
1914 * This function returns the offset from the beginning of the target
1915 * sequence to the beginning of the submatch, unless the value of @p __sub
1916 * is zero (the default), in which case this function returns the offset
1917 * from the beginning of the target sequence to the beginning of the
1918 * match.
1919 */
1921 position(size_type __sub = 0) const
1922 { return std::distance(_M_begin, (*this)[__sub].first); }
1923
1924 /**
1925 * @brief Gets the match or submatch converted to a string type.
1926 * @param __sub indicates the submatch.
1927 * @pre ready() == true
1928 *
1929 * This function gets the submatch (or match, if @p __sub is
1930 * zero) extracted from the target range and converted to the
1931 * associated string type.
1932 */
1933 string_type
1934 str(size_type __sub = 0) const
1935 { return string_type((*this)[__sub]); }
1936
1937 /**
1938 * @brief Gets a %sub_match reference for the match or submatch.
1939 * @param __sub indicates the submatch.
1940 * @pre ready() == true
1941 *
1942 * This function gets a reference to the indicated submatch, or
1943 * the entire match if @p __sub is zero.
1944 *
1945 * If @p __sub >= size() then this function returns a %sub_match with a
1946 * special value indicating no submatch.
1947 */
1948 const_reference
1949 operator[](size_type __sub) const
1950 {
1951 __glibcxx_assert( ready() );
1952 return __sub < size()
1953 ? _Unchecked::operator[](__sub)
1954 : _M_unmatched_sub();
1955 }
1956
1957 /**
1958 * @brief Gets a %sub_match representing the match prefix.
1959 * @pre ready() == true
1960 *
1961 * This function gets a reference to a %sub_match object representing the
1962 * part of the target range between the start of the target range and the
1963 * start of the match.
1964 */
1965 const_reference
1966 prefix() const
1967 {
1968 __glibcxx_assert( ready() );
1969 return !empty() ? _M_prefix() : _M_unmatched_sub();
1970 }
1971
1972 /**
1973 * @brief Gets a %sub_match representing the match suffix.
1974 * @pre ready() == true
1975 *
1976 * This function gets a reference to a %sub_match object representing the
1977 * part of the target range between the end of the match and the end of
1978 * the target range.
1979 */
1980 const_reference
1981 suffix() const
1982 {
1983 __glibcxx_assert( ready() );
1984 return !empty() ? _M_suffix() : _M_unmatched_sub();
1985 }
1986
1987 /**
1988 * @brief Gets an iterator to the start of the %sub_match collection.
1989 */
1990 const_iterator
1991 begin() const noexcept
1992 { return _Base_type::begin(); }
1993
1994 /**
1995 * @brief Gets an iterator to the start of the %sub_match collection.
1996 */
1997 const_iterator
1998 cbegin() const noexcept
1999 { return this->begin(); }
2000
2001 /**
2002 * @brief Gets an iterator to one-past-the-end of the collection.
2003 */
2004 const_iterator
2005 end() const noexcept
2006 { return _Base_type::end() - (_Base_type::empty() ? 0 : 3); }
2007
2008 /**
2009 * @brief Gets an iterator to one-past-the-end of the collection.
2010 */
2011 const_iterator
2012 cend() const noexcept
2013 { return this->end(); }
2014
2015 ///@}
2016
2017 /**
2018 * @name 28.10.5 Formatting
2019 *
2020 * These functions perform formatted substitution of the matched
2021 * character sequences into their target. The format specifiers and
2022 * escape sequences accepted by these functions are determined by
2023 * their @p flags parameter as documented above.
2024 */
2025 ///@{
2026
2027 /**
2028 * @pre ready() == true
2029 */
2030 template<typename _Out_iter>
2031 _Out_iter
2032 format(_Out_iter __out, const char_type* __fmt_first,
2033 const char_type* __fmt_last,
2034 match_flag_type __flags = regex_constants::format_default) const;
2035
2036 /**
2037 * @pre ready() == true
2038 */
2039 template<typename _Out_iter, typename _St, typename _Sa>
2040 _Out_iter
2041 format(_Out_iter __out, const basic_string<char_type, _St, _Sa>& __fmt,
2042 match_flag_type __flags = regex_constants::format_default) const
2043 {
2044 return format(__out, __fmt.data(), __fmt.data() + __fmt.size(),
2045 __flags);
2046 }
2047
2048 /**
2049 * @pre ready() == true
2050 */
2051 template<typename _St, typename _Sa>
2054 match_flag_type __flags = regex_constants::format_default) const
2055 {
2057 format(std::back_inserter(__result), __fmt, __flags);
2058 return __result;
2059 }
2060
2061 /**
2062 * @pre ready() == true
2063 */
2064 string_type
2065 format(const char_type* __fmt,
2066 match_flag_type __flags = regex_constants::format_default) const
2067 {
2068 string_type __result;
2069 format(std::back_inserter(__result),
2070 __fmt,
2071 __fmt + char_traits<char_type>::length(__fmt),
2072 __flags);
2073 return __result;
2074 }
2075
2076 ///@}
2077
2078 /**
2079 * @name 28.10.6 Allocator
2080 */
2081 ///@{
2082
2083 /**
2084 * @brief Gets a copy of the allocator.
2085 */
2086 allocator_type
2087 get_allocator() const noexcept
2088 { return _Base_type::get_allocator(); }
2089
2090 ///@}
2091
2092 /**
2093 * @name 28.10.7 Swap
2094 */
2095 ///@{
2096
2097 /**
2098 * @brief Swaps the contents of two match_results.
2099 */
2100 void
2101 swap(match_results& __that) noexcept
2102 {
2103 using std::swap;
2104 _Base_type::swap(__that);
2105 swap(_M_begin, __that._M_begin);
2106 }
2107 ///@}
2108
2109 private:
2110 template<typename, typename, typename>
2111 friend class regex_iterator;
2112
2113 /// @cond undocumented
2114
2115 template<typename, typename, typename, bool>
2116 friend class __detail::_Executor;
2117
2118 template<typename _Bp, typename _Ap, typename _Cp, typename _Rp>
2119 friend bool
2120 __detail::__regex_algo_impl(_Bp, _Bp, match_results<_Bp, _Ap>&,
2121 const basic_regex<_Cp, _Rp>&,
2123 __detail::_RegexExecutorPolicy, bool);
2124
2125 // Reset contents to __size unmatched sub_match objects
2126 // (plus additional objects for prefix, suffix and unmatched sub).
2127 void
2128 _M_resize(unsigned int __size)
2129 { _Unchecked::assign(__size + 3, sub_match<_Bi_iter>{}); }
2130
2131 // Set state to a failed match for the given past-the-end iterator.
2132 void
2133 _M_establish_failed_match(_Bi_iter __end)
2134 {
2135 sub_match<_Bi_iter> __sm;
2136 __sm.first = __sm.second = __end;
2137 _Unchecked::assign(3, __sm);
2138 }
2139
2140 const_reference
2141 _M_unmatched_sub() const
2142 { return _Unchecked::operator[](_Unchecked::size() - 3); }
2143
2144 sub_match<_Bi_iter>&
2145 _M_unmatched_sub()
2146 { return _Unchecked::operator[](_Unchecked::size() - 3); }
2147
2148 const_reference
2149 _M_prefix() const
2150 { return _Unchecked::operator[](_Unchecked::size() - 2); }
2151
2152 sub_match<_Bi_iter>&
2153 _M_prefix()
2154 { return _Unchecked::operator[](_Unchecked::size() - 2); }
2155
2156 const_reference
2157 _M_suffix() const
2158 { return _Unchecked::operator[](_Unchecked::size() - 1); }
2159
2160 sub_match<_Bi_iter>&
2161 _M_suffix()
2162 { return _Unchecked::operator[](_Unchecked::size() - 1); }
2163
2164 _Bi_iter _M_begin {};
2165 /// @endcond
2166 };
2167
2168 typedef match_results<const char*> cmatch;
2170#ifdef _GLIBCXX_USE_WCHAR_T
2171 typedef match_results<const wchar_t*> wcmatch;
2173#endif
2174
2175 // match_results comparisons
2176
2177 /**
2178 * @brief Compares two match_results for equality.
2179 * @returns true if the two objects refer to the same match,
2180 * false otherwise.
2181 *
2182 * @relates match_results
2183 */
2184 template<typename _Bi_iter, typename _Alloc>
2185 inline bool
2188 {
2189 if (__m1.ready() != __m2.ready())
2190 return false;
2191 if (!__m1.ready()) // both are not ready
2192 return true;
2193 if (__m1.empty() != __m2.empty())
2194 return false;
2195 if (__m1.empty()) // both are empty
2196 return true;
2197 return __m1.prefix() == __m2.prefix()
2198 && __m1.size() == __m2.size()
2199 && std::equal(__m1.begin(), __m1.end(), __m2.begin())
2200 && __m1.suffix() == __m2.suffix();
2201 }
2202
2203#if ! __cpp_lib_three_way_comparison
2204 /**
2205 * @brief Compares two match_results for inequality.
2206 * @returns true if the two objects do not refer to the same match,
2207 * false otherwise.
2208 *
2209 * @relates match_results
2210 */
2211 template<typename _Bi_iter, class _Alloc>
2212 inline bool
2213 operator!=(const match_results<_Bi_iter, _Alloc>& __m1,
2215 { return !(__m1 == __m2); }
2216#endif
2217
2218 // [7.10.6] match_results swap
2219 /**
2220 * @brief Swaps two match results.
2221 * @param __lhs A match result.
2222 * @param __rhs A match result.
2223 *
2224 * The contents of the two match_results objects are swapped.
2225 *
2226 * @relates match_results
2227 */
2228 template<typename _Bi_iter, typename _Alloc>
2229 inline void
2231 match_results<_Bi_iter, _Alloc>& __rhs) noexcept
2232 { __lhs.swap(__rhs); }
2233
2234_GLIBCXX_END_NAMESPACE_CXX11
2235
2236 // [28.11.2] Function template regex_match
2237 /**
2238 * @name Matching, Searching, and Replacing
2239 *
2240 * @{
2241 */
2242
2243 /**
2244 * @brief Determines if there is a match between the regular expression @p e
2245 * and all of the character sequence [first, last).
2246 *
2247 * @param __s Start of the character sequence to match.
2248 * @param __e One-past-the-end of the character sequence to match.
2249 * @param __m The match results.
2250 * @param __re The regular expression.
2251 * @param __flags Controls how the regular expression is matched.
2252 *
2253 * @retval true A match exists.
2254 * @retval false Otherwise.
2255 *
2256 * @throws an exception of type regex_error.
2257 */
2258 template<typename _Bi_iter, typename _Alloc,
2259 typename _Ch_type, typename _Rx_traits>
2260 inline bool
2261 regex_match(_Bi_iter __s,
2262 _Bi_iter __e,
2267 {
2268 return __detail::__regex_algo_impl(__s, __e, __m, __re, __flags,
2269 __detail::_RegexExecutorPolicy::_S_auto, true);
2270 }
2271
2272 /**
2273 * @brief Indicates if there is a match between the regular expression @p e
2274 * and all of the character sequence [first, last).
2275 *
2276 * @param __first Beginning of the character sequence to match.
2277 * @param __last One-past-the-end of the character sequence to match.
2278 * @param __re The regular expression.
2279 * @param __flags Controls how the regular expression is matched.
2280 *
2281 * @retval true A match exists.
2282 * @retval false Otherwise.
2283 *
2284 * @throws an exception of type regex_error.
2285 */
2286 template<typename _Bi_iter, typename _Ch_type, typename _Rx_traits>
2287 inline bool
2288 regex_match(_Bi_iter __first, _Bi_iter __last,
2292 {
2294 return regex_match(__first, __last, __what, __re, __flags);
2295 }
2296
2297 /**
2298 * @brief Determines if there is a match between the regular expression @p e
2299 * and a C-style null-terminated string.
2300 *
2301 * @param __s The C-style null-terminated string to match.
2302 * @param __m The match results.
2303 * @param __re The regular expression.
2304 * @param __f Controls how the regular expression is matched.
2305 *
2306 * @retval true A match exists.
2307 * @retval false Otherwise.
2308 *
2309 * @throws an exception of type regex_error.
2310 */
2311 template<typename _Ch_type, typename _Alloc, typename _Rx_traits>
2312 inline bool
2313 regex_match(const _Ch_type* __s,
2318 { return regex_match(__s, __s + _Rx_traits::length(__s), __m, __re, __f); }
2319
2320 /**
2321 * @brief Determines if there is a match between the regular expression @p e
2322 * and a string.
2323 *
2324 * @param __s The string to match.
2325 * @param __m The match results.
2326 * @param __re The regular expression.
2327 * @param __flags Controls how the regular expression is matched.
2328 *
2329 * @retval true A match exists.
2330 * @retval false Otherwise.
2331 *
2332 * @throws an exception of type regex_error.
2333 */
2334 template<typename _Ch_traits, typename _Ch_alloc,
2335 typename _Alloc, typename _Ch_type, typename _Rx_traits>
2336 inline bool
2338 match_results<typename basic_string<_Ch_type,
2339 _Ch_traits, _Ch_alloc>::const_iterator, _Alloc>& __m,
2343 { return regex_match(__s.begin(), __s.end(), __m, __re, __flags); }
2344
2345 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2346 // 2329. regex_match() with match_results should forbid temporary strings
2347 /// Prevent unsafe attempts to get match_results from a temporary string.
2348 template<typename _Ch_traits, typename _Ch_alloc,
2349 typename _Alloc, typename _Ch_type, typename _Rx_traits>
2350 bool
2352 match_results<typename basic_string<_Ch_type,
2353 _Ch_traits, _Ch_alloc>::const_iterator, _Alloc>&,
2357
2358 /**
2359 * @brief Indicates if there is a match between the regular expression @p e
2360 * and a C-style null-terminated string.
2361 *
2362 * @param __s The C-style null-terminated string to match.
2363 * @param __re The regular expression.
2364 * @param __f Controls how the regular expression is matched.
2365 *
2366 * @retval true A match exists.
2367 * @retval false Otherwise.
2368 *
2369 * @throws an exception of type regex_error.
2370 */
2371 template<typename _Ch_type, class _Rx_traits>
2372 inline bool
2373 regex_match(const _Ch_type* __s,
2377 { return regex_match(__s, __s + _Rx_traits::length(__s), __re, __f); }
2378
2379 /**
2380 * @brief Indicates if there is a match between the regular expression @p e
2381 * and a string.
2382 *
2383 * @param __s [IN] The string to match.
2384 * @param __re [IN] The regular expression.
2385 * @param __flags [IN] Controls how the regular expression is matched.
2386 *
2387 * @retval true A match exists.
2388 * @retval false Otherwise.
2389 *
2390 * @throws an exception of type regex_error.
2391 */
2392 template<typename _Ch_traits, typename _Str_allocator,
2393 typename _Ch_type, typename _Rx_traits>
2394 inline bool
2400
2401 // [7.11.3] Function template regex_search
2402 /**
2403 * Searches for a regular expression within a range.
2404 * @param __s [IN] The start of the string to search.
2405 * @param __e [IN] One-past-the-end of the string to search.
2406 * @param __m [OUT] The match results.
2407 * @param __re [IN] The regular expression to search for.
2408 * @param __flags [IN] Search policy flags.
2409 * @retval true A match was found within the string.
2410 * @retval false No match was found within the string, the content of %m is
2411 * undefined.
2412 *
2413 * @throws an exception of type regex_error.
2414 */
2415 template<typename _Bi_iter, typename _Alloc,
2416 typename _Ch_type, typename _Rx_traits>
2417 inline bool
2418 regex_search(_Bi_iter __s, _Bi_iter __e,
2423 {
2424 return __detail::__regex_algo_impl(__s, __e, __m, __re, __flags,
2425 __detail::_RegexExecutorPolicy::_S_auto, false);
2426 }
2427
2428 /**
2429 * Searches for a regular expression within a range.
2430 * @param __first [IN] The start of the string to search.
2431 * @param __last [IN] One-past-the-end of the string to search.
2432 * @param __re [IN] The regular expression to search for.
2433 * @param __flags [IN] Search policy flags.
2434 * @retval true A match was found within the string.
2435 * @retval false No match was found within the string.
2436 *
2437 * @throws an exception of type regex_error.
2438 */
2439 template<typename _Bi_iter, typename _Ch_type, typename _Rx_traits>
2440 inline bool
2441 regex_search(_Bi_iter __first, _Bi_iter __last,
2445 {
2447 return regex_search(__first, __last, __what, __re, __flags);
2448 }
2449
2450 /**
2451 * @brief Searches for a regular expression within a C-string.
2452 * @param __s [IN] A C-string to search for the regex.
2453 * @param __m [OUT] The set of regex matches.
2454 * @param __e [IN] The regex to search for in @p s.
2455 * @param __f [IN] The search flags.
2456 * @retval true A match was found within the string.
2457 * @retval false No match was found within the string, the content of %m is
2458 * undefined.
2459 *
2460 * @throws an exception of type regex_error.
2461 */
2462 template<typename _Ch_type, class _Alloc, class _Rx_traits>
2463 inline bool
2464 regex_search(const _Ch_type* __s,
2469 { return regex_search(__s, __s + _Rx_traits::length(__s), __m, __e, __f); }
2470
2471 /**
2472 * @brief Searches for a regular expression within a C-string.
2473 * @param __s [IN] The C-string to search.
2474 * @param __e [IN] The regular expression to search for.
2475 * @param __f [IN] Search policy flags.
2476 * @retval true A match was found within the string.
2477 * @retval false No match was found within the string.
2478 *
2479 * @throws an exception of type regex_error.
2480 */
2481 template<typename _Ch_type, typename _Rx_traits>
2482 inline bool
2483 regex_search(const _Ch_type* __s,
2487 { return regex_search(__s, __s + _Rx_traits::length(__s), __e, __f); }
2488
2489 /**
2490 * @brief Searches for a regular expression within a string.
2491 * @param __s [IN] The string to search.
2492 * @param __e [IN] The regular expression to search for.
2493 * @param __flags [IN] Search policy flags.
2494 * @retval true A match was found within the string.
2495 * @retval false No match was found within the string.
2496 *
2497 * @throws an exception of type regex_error.
2498 */
2499 template<typename _Ch_traits, typename _String_allocator,
2500 typename _Ch_type, typename _Rx_traits>
2501 inline bool
2502 regex_search(const basic_string<_Ch_type, _Ch_traits,
2503 _String_allocator>& __s,
2507 { return regex_search(__s.begin(), __s.end(), __e, __flags); }
2508
2509 /**
2510 * @brief Searches for a regular expression within a string.
2511 * @param __s [IN] A C++ string to search for the regex.
2512 * @param __m [OUT] The set of regex matches.
2513 * @param __e [IN] The regex to search for in @p s.
2514 * @param __f [IN] The search flags.
2515 * @retval true A match was found within the string.
2516 * @retval false No match was found within the string, the content of %m is
2517 * undefined.
2518 *
2519 * @throws an exception of type regex_error.
2520 */
2521 template<typename _Ch_traits, typename _Ch_alloc,
2522 typename _Alloc, typename _Ch_type,
2523 typename _Rx_traits>
2524 inline bool
2526 match_results<typename basic_string<_Ch_type,
2527 _Ch_traits, _Ch_alloc>::const_iterator, _Alloc>& __m,
2531 { return regex_search(__s.begin(), __s.end(), __m, __e, __f); }
2532
2533 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2534 // 2329. regex_search() with match_results should forbid temporary strings
2535 /// Prevent unsafe attempts to get match_results from a temporary string.
2536 template<typename _Ch_traits, typename _Ch_alloc,
2537 typename _Alloc, typename _Ch_type,
2538 typename _Rx_traits>
2539 bool
2541 match_results<typename basic_string<_Ch_type,
2542 _Ch_traits, _Ch_alloc>::const_iterator, _Alloc>&,
2546
2547 // std [28.11.4] Function template regex_replace
2548
2549 /// @cond undocumented
2550 template<typename _Out_iter, typename _Bi_iter,
2551 typename _Rx_traits, typename _Ch_type>
2552 _Out_iter
2553 __regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last,
2555 const _Ch_type* __fmt, size_t __len,
2557 /// @endcond
2558
2559 /**
2560 * @brief Search for a regular expression within a range for multiple times,
2561 and replace the matched parts through filling a format string.
2562 * @param __out [OUT] The output iterator.
2563 * @param __first [IN] The start of the string to search.
2564 * @param __last [IN] One-past-the-end of the string to search.
2565 * @param __e [IN] The regular expression to search for.
2566 * @param __fmt [IN] The format string.
2567 * @param __flags [IN] Search and replace policy flags.
2568 *
2569 * @returns __out
2570 * @throws an exception of type regex_error.
2571 */
2572 template<typename _Out_iter, typename _Bi_iter,
2573 typename _Rx_traits, typename _Ch_type,
2574 typename _St, typename _Sa>
2575 inline _Out_iter
2576 regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last,
2581 {
2582 return std::__regex_replace(__out, __first, __last, __e, __fmt.c_str(),
2583 __fmt.length(), __flags);
2584 }
2585
2586 /**
2587 * @brief Search for a regular expression within a range for multiple times,
2588 and replace the matched parts through filling a format C-string.
2589 * @param __out [OUT] The output iterator.
2590 * @param __first [IN] The start of the string to search.
2591 * @param __last [IN] One-past-the-end of the string to search.
2592 * @param __e [IN] The regular expression to search for.
2593 * @param __fmt [IN] The format C-string.
2594 * @param __flags [IN] Search and replace policy flags.
2595 *
2596 * @returns __out
2597 * @throws an exception of type regex_error.
2598 */
2599 template<typename _Out_iter, typename _Bi_iter,
2600 typename _Rx_traits, typename _Ch_type>
2601 _Out_iter
2602 regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last,
2604 const _Ch_type* __fmt,
2607 {
2608 return std::__regex_replace(__out, __first, __last, __e, __fmt,
2609 char_traits<_Ch_type>::length(__fmt),
2610 __flags);
2611 }
2612
2613
2614 /**
2615 * @brief Search for a regular expression within a string for multiple times,
2616 and replace the matched parts through filling a format string.
2617 * @param __s [IN] The string to search and replace.
2618 * @param __e [IN] The regular expression to search for.
2619 * @param __fmt [IN] The format string.
2620 * @param __flags [IN] Search and replace policy flags.
2621 *
2622 * @returns The string after replacing.
2623 * @throws an exception of type regex_error.
2624 */
2625 template<typename _Rx_traits, typename _Ch_type,
2626 typename _St, typename _Sa, typename _Fst, typename _Fsa>
2627 inline basic_string<_Ch_type, _St, _Sa>
2633 {
2636 __s.begin(), __s.end(), __e, __fmt, __flags);
2637 return __result;
2638 }
2639
2640 /**
2641 * @brief Search for a regular expression within a string for multiple times,
2642 and replace the matched parts through filling a format C-string.
2643 * @param __s [IN] The string to search and replace.
2644 * @param __e [IN] The regular expression to search for.
2645 * @param __fmt [IN] The format C-string.
2646 * @param __flags [IN] Search and replace policy flags.
2647 *
2648 * @returns The string after replacing.
2649 * @throws an exception of type regex_error.
2650 */
2651 template<typename _Rx_traits, typename _Ch_type,
2652 typename _St, typename _Sa>
2653 inline basic_string<_Ch_type, _St, _Sa>
2656 const _Ch_type* __fmt,
2659 {
2662 __s.begin(), __s.end(), __e, __fmt, __flags);
2663 return __result;
2664 }
2665
2666 /**
2667 * @brief Search for a regular expression within a C-string for multiple
2668 times, and replace the matched parts through filling a format string.
2669 * @param __s [IN] The C-string to search and replace.
2670 * @param __e [IN] The regular expression to search for.
2671 * @param __fmt [IN] The format string.
2672 * @param __flags [IN] Search and replace policy flags.
2673 *
2674 * @returns The string after replacing.
2675 * @throws an exception of type regex_error.
2676 */
2677 template<typename _Rx_traits, typename _Ch_type,
2678 typename _St, typename _Sa>
2679 inline basic_string<_Ch_type>
2680 regex_replace(const _Ch_type* __s,
2685 {
2686 basic_string<_Ch_type> __result;
2687 regex_replace(std::back_inserter(__result), __s,
2688 __s + char_traits<_Ch_type>::length(__s),
2689 __e, __fmt, __flags);
2690 return __result;
2691 }
2692
2693 /**
2694 * @brief Search for a regular expression within a C-string for multiple
2695 times, and replace the matched parts through filling a format C-string.
2696 * @param __s [IN] The C-string to search and replace.
2697 * @param __e [IN] The regular expression to search for.
2698 * @param __fmt [IN] The format C-string.
2699 * @param __flags [IN] Search and replace policy flags.
2700 *
2701 * @returns The string after replacing.
2702 * @throws an exception of type regex_error.
2703 */
2704 template<typename _Rx_traits, typename _Ch_type>
2705 inline basic_string<_Ch_type>
2706 regex_replace(const _Ch_type* __s,
2708 const _Ch_type* __fmt,
2711 {
2712 basic_string<_Ch_type> __result;
2713 regex_replace(std::back_inserter(__result), __s,
2714 __s + char_traits<_Ch_type>::length(__s),
2715 __e, __fmt, __flags);
2716 return __result;
2717 }
2718
2719 /// @}
2720
2721_GLIBCXX_BEGIN_NAMESPACE_CXX11
2722
2723 // std [28.12] Class template regex_iterator
2724 /**
2725 * An iterator adaptor that will provide repeated calls of regex_search over
2726 * a range until no more matches remain.
2727 *
2728 * @headerfile regex
2729 * @since C++11
2730 */
2731 template<typename _Bi_iter,
2732 typename _Ch_type = typename iterator_traits<_Bi_iter>::value_type,
2733 typename _Rx_traits = regex_traits<_Ch_type> >
2735 {
2736 public:
2737 typedef basic_regex<_Ch_type, _Rx_traits> regex_type;
2738 typedef match_results<_Bi_iter> value_type;
2739 typedef std::ptrdiff_t difference_type;
2740 typedef const value_type* pointer;
2741 typedef const value_type& reference;
2742 typedef std::forward_iterator_tag iterator_category;
2743#if __cplusplus > 201703L
2744 typedef std::input_iterator_tag iterator_concept;
2745#endif
2746
2747 /**
2748 * @brief Provides a singular iterator, useful for indicating
2749 * one-past-the-end of a range.
2750 */
2751 regex_iterator() = default;
2752
2753 /**
2754 * Constructs a %regex_iterator...
2755 * @param __a [IN] The start of a text range to search.
2756 * @param __b [IN] One-past-the-end of the text range to search.
2757 * @param __re [IN] The regular expression to match.
2758 * @param __m [IN] Policy flags for match rules.
2759 */
2760 regex_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re,
2763 : _M_begin(__a), _M_end(__b), _M_pregex(&__re), _M_flags(__m), _M_match()
2764 {
2765 if (!regex_search(_M_begin, _M_end, _M_match, *_M_pregex, _M_flags))
2766 *this = regex_iterator();
2767 }
2768
2769 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2770 // 2332. regex_iterator should forbid temporary regexes
2771 regex_iterator(_Bi_iter, _Bi_iter, const regex_type&&,
2774
2775 /// Copy constructs a %regex_iterator.
2777
2778 /// Copy assigns one %regex_iterator to another.
2780 operator=(const regex_iterator&) = default;
2781
2782 ~regex_iterator() = default;
2783
2784 /**
2785 * @brief Tests the equivalence of two regex iterators.
2786 */
2787 bool
2788 operator==(const regex_iterator&) const noexcept;
2789
2790#if __cplusplus >= 202002L
2791 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2792 // 3719. Directory iterators should be usable with default sentinel
2793 bool operator==(default_sentinel_t) const noexcept
2794 { return _M_pregex == nullptr; }
2795#endif
2796
2797#if __cpp_impl_three_way_comparison < 201907L
2798 /**
2799 * @brief Tests the inequivalence of two regex iterators.
2800 */
2801 bool
2802 operator!=(const regex_iterator& __rhs) const noexcept
2803 { return !(*this == __rhs); }
2804#endif
2805
2806 /**
2807 * @brief Dereferences a %regex_iterator.
2808 */
2809 const value_type&
2810 operator*() const noexcept
2811 { return _M_match; }
2812
2813 /**
2814 * @brief Selects a %regex_iterator member.
2815 */
2816 const value_type*
2817 operator->() const noexcept
2818 { return &_M_match; }
2819
2820 /**
2821 * @brief Increments a %regex_iterator.
2822 */
2825
2826 /**
2827 * @brief Postincrements a %regex_iterator.
2828 */
2831 {
2832 auto __tmp = *this;
2833 ++(*this);
2834 return __tmp;
2835 }
2836
2837 private:
2838 _Bi_iter _M_begin {};
2839 _Bi_iter _M_end {};
2840 const regex_type* _M_pregex = nullptr;
2842 match_results<_Bi_iter> _M_match;
2843 };
2844
2845 typedef regex_iterator<const char*> cregex_iterator;
2846 typedef regex_iterator<string::const_iterator> sregex_iterator;
2847#ifdef _GLIBCXX_USE_WCHAR_T
2848 typedef regex_iterator<const wchar_t*> wcregex_iterator;
2849 typedef regex_iterator<wstring::const_iterator> wsregex_iterator;
2850#endif
2851
2852 // [7.12.2] Class template regex_token_iterator
2853 /**
2854 * Iterates over submatches in a range (or @a splits a text string).
2855 *
2856 * The purpose of this iterator is to enumerate all, or all specified,
2857 * matches of a regular expression within a text range. The dereferenced
2858 * value of an iterator of this class is a std::sub_match object.
2859 *
2860 * @headerfile regex
2861 * @since C++11
2862 */
2863 template<typename _Bi_iter,
2864 typename _Ch_type = typename iterator_traits<_Bi_iter>::value_type,
2865 typename _Rx_traits = regex_traits<_Ch_type> >
2867 {
2868 public:
2869 typedef basic_regex<_Ch_type, _Rx_traits> regex_type;
2870 typedef sub_match<_Bi_iter> value_type;
2871 typedef std::ptrdiff_t difference_type;
2872 typedef const value_type* pointer;
2873 typedef const value_type& reference;
2874 typedef std::forward_iterator_tag iterator_category;
2875#if __cplusplus > 201703L
2876 typedef std::input_iterator_tag iterator_concept;
2877#endif
2878
2879 public:
2880 /**
2881 * @brief Default constructs a %regex_token_iterator.
2882 *
2883 * A default-constructed %regex_token_iterator is a singular iterator
2884 * that will compare equal to the one-past-the-end value for any
2885 * iterator of the same type.
2886 */
2888 : _M_position(), _M_subs(), _M_suffix(), _M_n(0), _M_result(nullptr),
2889 _M_has_m1(false)
2890 { }
2891
2892 /**
2893 * Constructs a %regex_token_iterator...
2894 * @param __a [IN] The start of the text to search.
2895 * @param __b [IN] One-past-the-end of the text to search.
2896 * @param __re [IN] The regular expression to search for.
2897 * @param __submatch [IN] Which submatch to return. There are some
2898 * special values for this parameter:
2899 * - -1 each enumerated subexpression does NOT
2900 * match the regular expression (aka field
2901 * splitting)
2902 * - 0 the entire string matching the
2903 * subexpression is returned for each match
2904 * within the text.
2905 * - >0 enumerates only the indicated
2906 * subexpression from a match within the text.
2907 * @param __m [IN] Policy flags for match rules.
2908 */
2909 regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re,
2910 int __submatch = 0,
2913 : _M_position(__a, __b, __re, __m), _M_subs(1, __submatch), _M_n(0)
2914 { _M_init(__a, __b); }
2915
2916 /**
2917 * Constructs a %regex_token_iterator...
2918 * @param __a [IN] The start of the text to search.
2919 * @param __b [IN] One-past-the-end of the text to search.
2920 * @param __re [IN] The regular expression to search for.
2921 * @param __submatches [IN] A list of subexpressions to return for each
2922 * regular expression match within the text.
2923 * @param __m [IN] Policy flags for match rules.
2924 */
2925 regex_token_iterator(_Bi_iter __a, _Bi_iter __b,
2926 const regex_type& __re,
2927 const std::vector<int>& __submatches,
2930 : _M_position(__a, __b, __re, __m), _M_subs(__submatches), _M_n(0)
2931 { _M_init(__a, __b); }
2932
2933 /**
2934 * Constructs a %regex_token_iterator...
2935 * @param __a [IN] The start of the text to search.
2936 * @param __b [IN] One-past-the-end of the text to search.
2937 * @param __re [IN] The regular expression to search for.
2938 * @param __submatches [IN] A list of subexpressions to return for each
2939 * regular expression match within the text.
2940 * @param __m [IN] Policy flags for match rules.
2941 */
2942 regex_token_iterator(_Bi_iter __a, _Bi_iter __b,
2943 const regex_type& __re,
2944 initializer_list<int> __submatches,
2947 : _M_position(__a, __b, __re, __m), _M_subs(__submatches), _M_n(0)
2948 { _M_init(__a, __b); }
2949
2950 /**
2951 * Constructs a %regex_token_iterator...
2952 * @param __a [IN] The start of the text to search.
2953 * @param __b [IN] One-past-the-end of the text to search.
2954 * @param __re [IN] The regular expression to search for.
2955 * @param __submatches [IN] A list of subexpressions to return for each
2956 * regular expression match within the text.
2957 * @param __m [IN] Policy flags for match rules.
2958 */
2959 template<std::size_t _Nm>
2960 regex_token_iterator(_Bi_iter __a, _Bi_iter __b,
2961 const regex_type& __re,
2962 const int (&__submatches)[_Nm],
2965 : _M_position(__a, __b, __re, __m),
2966 _M_subs(__submatches, __submatches + _Nm), _M_n(0)
2967 { _M_init(__a, __b); }
2968
2969 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2970 // 2332. regex_token_iterator should forbid temporary regexes
2971 regex_token_iterator(_Bi_iter, _Bi_iter, const regex_type&&, int = 0,
2974 regex_token_iterator(_Bi_iter, _Bi_iter, const regex_type&&,
2975 const std::vector<int>&,
2978 regex_token_iterator(_Bi_iter, _Bi_iter, const regex_type&&,
2982 template <std::size_t _Nm>
2983 regex_token_iterator(_Bi_iter, _Bi_iter, const regex_type&&,
2984 const int (&)[_Nm],
2987
2988 /**
2989 * @brief Copy constructs a %regex_token_iterator.
2990 * @param __rhs [IN] A %regex_token_iterator to copy.
2991 */
2993 : _M_position(__rhs._M_position), _M_subs(__rhs._M_subs),
2994 _M_suffix(__rhs._M_suffix), _M_n(__rhs._M_n), _M_has_m1(__rhs._M_has_m1)
2995 { _M_normalize_result(); }
2996
2997 /**
2998 * @brief Assigns a %regex_token_iterator to another.
2999 * @param __rhs [IN] A %regex_token_iterator to copy.
3000 */
3003
3004 /**
3005 * @brief Compares a %regex_token_iterator to another for equality.
3006 */
3007 bool
3009
3010#if __cplusplus >= 202002L
3011 // _GLIBCXX_RESOLVE_LIB_DEFECTS
3012 // 3719. Directory iterators should be usable with default sentinel
3013 bool operator==(default_sentinel_t) const noexcept
3014 { return _M_end_of_seq(); }
3015#endif
3016
3017#if __cpp_impl_three_way_comparison < 201907L
3018 /**
3019 * @brief Compares a %regex_token_iterator to another for inequality.
3020 */
3021 bool
3022 operator!=(const regex_token_iterator& __rhs) const
3023 { return !(*this == __rhs); }
3024#endif
3025
3026 /**
3027 * @brief Dereferences a %regex_token_iterator.
3028 */
3029 const value_type&
3031 { return *_M_result; }
3032
3033 /**
3034 * @brief Selects a %regex_token_iterator member.
3035 */
3036 const value_type*
3038 { return _M_result; }
3039
3040 /**
3041 * @brief Increments a %regex_token_iterator.
3042 */
3045
3046 /**
3047 * @brief Postincrements a %regex_token_iterator.
3048 */
3051 {
3052 auto __tmp = *this;
3053 ++(*this);
3054 return __tmp;
3055 }
3056
3057 private:
3059
3060 void
3061 _M_init(_Bi_iter __a, _Bi_iter __b);
3062
3063 const value_type&
3064 _M_current_match() const
3065 {
3066 if (_M_subs[_M_n] == -1)
3067 return (*_M_position).prefix();
3068 else
3069 return (*_M_position)[_M_subs[_M_n]];
3070 }
3071
3072 constexpr bool
3073 _M_end_of_seq() const noexcept
3074 { return _M_result == nullptr; }
3075
3076 // [28.12.2.2.4]
3077 void
3078 _M_normalize_result()
3079 {
3080 if (_M_position != _Position())
3081 _M_result = &_M_current_match();
3082 else if (_M_has_m1)
3083 _M_result = &_M_suffix;
3084 else
3085 _M_result = nullptr;
3086 }
3087
3088 _Position _M_position;
3089 std::vector<int> _M_subs;
3090 value_type _M_suffix;
3091 std::size_t _M_n;
3092 const value_type* _M_result;
3093
3094 // Show whether _M_subs contains -1
3095 bool _M_has_m1;
3096 };
3097
3098 /** @brief Token iterator for C-style NULL-terminated strings. */
3100
3101 /** @brief Token iterator for standard strings. */
3103
3104#ifdef _GLIBCXX_USE_WCHAR_T
3105 /** @brief Token iterator for C-style NULL-terminated wide strings. */
3107
3108 /** @brief Token iterator for standard wide-character strings. */
3110#endif
3111
3112 ///@} // group regex
3113
3114_GLIBCXX_END_NAMESPACE_CXX11
3115_GLIBCXX_END_NAMESPACE_VERSION
3116} // namespace
3117
3118#include <bits/regex.tcc>
basic_ostream< char > ostream
Base class for char output streams.
Definition iosfwd:143
__bool_constant< true > true_type
The type used as a compile-time boolean with true value.
Definition type_traits:111
__bool_constant< false > false_type
The type used as a compile-time boolean with false value.
Definition type_traits:114
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
Definition move.h:137
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
Definition move.h:51
constexpr const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
const _Facet & use_facet(const locale &__loc)
Return a facet.
sub_match< wstring::const_iterator > wssub_match
Regex submatch over a standard wide string.
Definition regex.h:1088
auto operator<=>(const sub_match< const char * > &__lhs, const sub_match< const char * > &__rhs) noexcept(__detail::__is_contiguous_iter< const char * >::value)
Definition regex.h:1116
sub_match< string::const_iterator > ssub_match
Standard regex submatch over a standard string.
Definition regex.h:1081
sub_match< const char * > csub_match
Standard regex submatch over a C-style null-terminated string.
Definition regex.h:1078
regex_token_iterator< const char * > cregex_token_iterator
Token iterator for C-style NULL-terminated strings.
Definition regex.h:3099
bool operator==(const sub_match< _Bi_iter > &__lhs, const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__rhs)
Tests the equivalence of a regular expression submatch and a string.
Definition regex.h:1274
regex_token_iterator< wstring::const_iterator > wsregex_token_iterator
Token iterator for standard wide-character strings.
Definition regex.h:3109
bool operator==(const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const &__rhs)
Tests the equivalence of a regular expression submatch and a character.
Definition regex.h:1613
bool operator==(const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const *__rhs)
Tests the equivalence of a regular expression submatch and a C string.
Definition regex.h:1441
regex_token_iterator< const wchar_t * > wcregex_token_iterator
Token iterator for C-style NULL-terminated wide strings.
Definition regex.h:3106
void swap(basic_regex< _Ch_type, _Rx_traits > &__lhs, basic_regex< _Ch_type, _Rx_traits > &__rhs) noexcept
Swaps the contents of two regular expression objects.
Definition regex.h:896
basic_regex< char > regex
Standard regular expressions.
Definition regex.h:879
_Out_iter regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last, const basic_regex< _Ch_type, _Rx_traits > &__e, const basic_string< _Ch_type, _St, _Sa > &__fmt, regex_constants::match_flag_type __flags=regex_constants::match_default)
Search for a regular expression within a range for multiple times, and replace the matched parts thro...
Definition regex.h:2576
sub_match< const wchar_t * > wcsub_match
Regex submatch over a C-style null-terminated wide string.
Definition regex.h:1085
regex_token_iterator< string::const_iterator > sregex_token_iterator
Token iterator for standard strings.
Definition regex.h:3102
bool regex_match(_Bi_iter __s, _Bi_iter __e, match_results< _Bi_iter, _Alloc > &__m, const basic_regex< _Ch_type, _Rx_traits > &__re, regex_constants::match_flag_type __flags=regex_constants::match_default)
Determines if there is a match between the regular expression e and all of the character sequence [fi...
Definition regex.h:2261
bool operator==(const match_results< _BidirectionalIterator, polymorphic_allocator< sub_match< _BidirectionalIterator > > > &__m1, const match_results< _BidirectionalIterator, polymorphic_allocator< sub_match< _BidirectionalIterator > > > &__m2)
Definition regex.h:2186
bool regex_search(_Bi_iter __s, _Bi_iter __e, match_results< _Bi_iter, _Alloc > &__m, const basic_regex< _Ch_type, _Rx_traits > &__re, regex_constants::match_flag_type __flags=regex_constants::match_default)
Definition regex.h:2418
void swap(match_results< _BidirectionalIterator, polymorphic_allocator< sub_match< _BidirectionalIterator > > > &__lhs, match_results< _BidirectionalIterator, polymorphic_allocator< sub_match< _BidirectionalIterator > > > &__rhs) noexcept
Definition regex.h:2230
basic_regex< wchar_t > wregex
Standard wide-character regular expressions.
Definition regex.h:883
bool operator==(const sub_match< _BiIter > &__lhs, const sub_match< _BiIter > &__rhs)
Tests the equivalence of two regular expression submatches.
Definition regex.h:1103
constexpr back_insert_iterator< _Container > back_inserter(_Container &__x)
ISO C++ entities toplevel namespace is std.
constexpr iterator_traits< _InputIterator >::difference_type distance(_InputIterator __first, _InputIterator __last)
A generalization of pointer arithmetic.
constexpr bitset< _Nb > operator^(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
Definition bitset:1577
std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const bitset< _Nb > &__x)
Global I/O operators for bitsets.
Definition bitset:1687
constexpr bitset< _Nb > operator|(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
Definition bitset:1567
constexpr bitset< _Nb > operator&(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
Definition bitset:1557
Implementation details not part of the namespace std interface.
__numeric_traits_integer< _Tp > __int_traits
Convenience alias for __numeric_traits<integer-type>.
constexpr syntax_option_type collate
constexpr syntax_option_type ECMAScript
constexpr syntax_option_type egrep
syntax_option_type
This is a bitmask type indicating how to interpret the regex.
constexpr syntax_option_type multiline
constexpr match_flag_type match_default
constexpr syntax_option_type awk
constexpr syntax_option_type extended
constexpr syntax_option_type basic
match_flag_type
This is a bitmask type indicating regex matching rules.
constexpr syntax_option_type icase
constexpr syntax_option_type optimize
constexpr match_flag_type format_default
constexpr syntax_option_type nosubs
constexpr syntax_option_type grep
initializer_list
Template class basic_ostream.
Definition ostream:67
typename _Size< _Alloc, difference_type >::type size_type
The allocator's size type.
The standard allocator, as per C++03 [20.4.1].
Definition allocator.h:129
Managing sequences of characters and character-like objects.
constexpr const _CharT * c_str() const noexcept
Return const pointer to null-terminated contents.
constexpr size_type size() const noexcept
Returns the number of characters in the string, not including any null-termination.
constexpr const _CharT * data() const noexcept
Return const pointer to contents.
constexpr size_type length() const noexcept
constexpr iterator end() noexcept
constexpr iterator begin() noexcept
Basis for explicit traits specializations.
Traits class for iterators.
Container class for localization functionality.
Primary class template ctype facet.
A regular expression.
Definition regex.h:419
basic_regex & assign(const _Ch_type *__p, flag_type __flags=ECMAScript)
Assigns a new regular expression to a regex object from a C-style null-terminated string containing a...
Definition regex.h:638
basic_regex & assign(const _Ch_type *__p, size_t __len, flag_type __flags=ECMAScript)
Assigns a new regular expression to a regex object from a C-style string containing a regular express...
Definition regex.h:660
locale_type getloc() const noexcept
Gets the locale currently imbued in the regular expression object.
Definition regex.h:779
unsigned int mark_count() const noexcept
Gets the number of marked subexpressions within the regular expression.
Definition regex.h:745
basic_regex & assign(_InputIterator __first, _InputIterator __last, flag_type __flags=ECMAScript)
Assigns a new regular expression to a regex object.
Definition regex.h:701
locale_type imbue(locale_type __loc)
Imbues the regular expression object with the given locale.
Definition regex.h:767
basic_regex(const basic_regex &__rhs)=default
Copy-constructs a basic regular expression.
basic_regex & assign(initializer_list< _Ch_type > __l, flag_type __flags=ECMAScript)
Assigns a new regular expression to a regex object.
Definition regex.h:733
basic_regex & assign(basic_regex &&__rhs) noexcept
Move-assigns one regular expression to another.
Definition regex.h:621
flag_type flags() const noexcept
Gets the flags used to construct the regular expression or in the last call to assign().
Definition regex.h:757
basic_regex & operator=(basic_regex &&)=default
Move-assigns one regular expression to another.
basic_regex(const _Ch_type *__p, flag_type __f=ECMAScript)
Constructs a basic regular expression from the sequence [__p, __p + char_traits<_Ch_type>::length(__p...
Definition regex.h:472
void swap(basic_regex &__rhs) noexcept
Swaps the contents of two regular expression objects.
Definition regex.h:789
basic_regex(const std::basic_string< _Ch_type, _Ch_traits, _Ch_alloc > &__s, flag_type __f=ECMAScript)
Constructs a basic regular expression from the string s interpreted according to the flags in f.
Definition regex.h:519
basic_regex(_FwdIter __first, _FwdIter __last, flag_type __f=ECMAScript)
Constructs a basic regular expression from the range [first, last) interpreted according to the flags...
Definition regex.h:538
basic_regex & operator=(const basic_regex &)=default
Assigns one regular expression to another.
basic_regex(const _Ch_type *__p, std::size_t __len, flag_type __f=ECMAScript)
Constructs a basic regular expression from the sequence [p, p + len) interpreted according to the fla...
Definition regex.h:487
basic_regex & operator=(initializer_list< _Ch_type > __l)
Replaces a regular expression with a new one constructed from an initializer list.
Definition regex.h:591
basic_regex & assign(const basic_string< _Ch_type, _Ch_traits, _Alloc > &__s, flag_type __flags=ECMAScript)
Assigns a new regular expression to a regex object from a string containing a regular expression patt...
Definition regex.h:679
basic_regex(basic_regex &&__rhs) noexcept=default
Move-constructs a basic regular expression.
basic_regex(initializer_list< _Ch_type > __l, flag_type __f=ECMAScript)
Constructs a basic regular expression from an initializer list.
Definition regex.h:550
basic_regex & operator=(const _Ch_type *__p)
Replaces a regular expression with a new one constructed from a C-style null-terminated string.
Definition regex.h:579
basic_regex & assign(const basic_regex &__rhs) noexcept
Assigns one regular expression to another.
Definition regex.h:612
basic_regex() noexcept
Definition regex.h:456
basic_regex & operator=(const basic_string< _Ch_type, _Ch_traits, _Alloc > &__s)
Replaces a regular expression with a new one constructed from a string.
Definition regex.h:602
~basic_regex()
Destroys a basic regular expression.
Definition regex.h:556
The results of a match or search operation.
Definition regex.h:1750
_Out_iter format(_Out_iter __out, const char_type *__fmt_first, const char_type *__fmt_last, match_flag_type __flags=regex_constants::format_default) const
match_results(match_results &&__m, const polymorphic_allocator< sub_match< _BidirectionalIterator > > &__a) noexcept(noexcept(_Base_type(std::move(__m), __a)))
Definition regex.h:1845
basic_string< char_type, _St, _Sa > format(const basic_string< char_type, _St, _Sa > &__fmt, match_flag_type __flags=regex_constants::format_default) const
Definition regex.h:2053
match_results(const polymorphic_allocator< sub_match< _BidirectionalIterator > > &__a) noexcept
Definition regex.h:1808
_Out_iter format(_Out_iter __out, const basic_string< char_type, _St, _Sa > &__fmt, match_flag_type __flags=regex_constants::format_default) const
Definition regex.h:2041
string_type format(const char_type *__fmt, match_flag_type __flags=regex_constants::format_default) const
Definition regex.h:2065
match_results()
Constructs a default match_results container.
Definition regex.h:1801
Takes a regex and an input string and does the matching.
Describes aspects of a regular expression.
Definition regex.h:97
char_type translate(char_type __c) const
Performs the identity translation.
Definition regex.h:200
static std::size_t length(const char_type *__p)
Gives the length of a C-style string starting at __p.
Definition regex.h:189
string_type transform_primary(_Fwd_iter __first, _Fwd_iter __last) const
Gets a sort key for a character sequence, independent of case.
Definition regex.h:266
regex_traits()
Constructs a default traits object.
Definition regex.h:176
int value(_Ch_type __ch, int __radix) const
Converts a digit to an int.
Definition regex.tcc:337
char_type translate_nocase(char_type __c) const
Translates a character into a case-insensitive equivalent.
Definition regex.h:213
string_type lookup_collatename(_Fwd_iter __first, _Fwd_iter __last) const
Gets a collation element by name.
Definition regex.tcc:123
locale_type getloc() const
Gets a copy of the current locale in use by the regex_traits object.
Definition regex.h:389
bool isctype(_Ch_type __c, char_class_type __f) const
Determines if c is a member of an identified class.
Definition regex.tcc:323
locale_type imbue(locale_type __loc)
Imbues the regex_traits object with a copy of a new locale.
Definition regex.h:378
char_class_type lookup_classname(_Fwd_iter __first, _Fwd_iter __last, bool __icase=false) const
Maps one or more characters to a named character classification.
Definition regex.tcc:279
string_type transform(_Fwd_iter __first, _Fwd_iter __last) const
Gets a sort key for a character sequence.
Definition regex.h:242
difference_type length() const noexcept
Gets the length of the matching sequence.
Definition regex.h:941
void swap(sub_match &__s) noexcept(__is_nothrow_swappable< _BiIter >::value)
Swap the values of two sub_match objects.
Definition regex.h:1013
int compare(const value_type *__s) const
Compares this sub_match to a string.
Definition regex.h:998
string_type str() const
Gets the matching sequence as a string.
Definition regex.h:963
int compare(const sub_match &__s) const
Compares this and another matched sequence.
Definition regex.h:980
int compare(const string_type &__s) const
Compares this sub_match to a string.
Definition regex.h:994
const value_type * operator->() const noexcept
Selects a regex_iterator member.
Definition regex.h:2817
regex_iterator operator++(int)
Postincrements a regex_iterator.
Definition regex.h:2830
regex_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type &__re, regex_constants::match_flag_type __m=regex_constants::match_default)
Definition regex.h:2760
regex_iterator(const regex_iterator &)=default
Copy constructs a regex_iterator.
regex_iterator & operator=(const regex_iterator &)=default
Copy assigns one regex_iterator to another.
regex_iterator()=default
Provides a singular iterator, useful for indicating one-past-the-end of a range.
const value_type & operator*() const noexcept
Dereferences a regex_iterator.
Definition regex.h:2810
bool operator==(const regex_iterator &) const noexcept
Tests the equivalence of two regex iterators.
Definition regex.tcc:499
regex_iterator & operator++()
Increments a regex_iterator.
Definition regex.tcc:515
regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type &__re, const int(&__submatches)[_Nm], regex_constants::match_flag_type __m=regex_constants::match_default)
Definition regex.h:2960
bool operator==(const regex_token_iterator &__rhs) const
Compares a regex_token_iterator to another for equality.
Definition regex.tcc:590
regex_token_iterator(const regex_token_iterator &__rhs)
Copy constructs a regex_token_iterator.
Definition regex.h:2992
regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type &__re, const std::vector< int > &__submatches, regex_constants::match_flag_type __m=regex_constants::match_default)
Definition regex.h:2925
regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type &__re, initializer_list< int > __submatches, regex_constants::match_flag_type __m=regex_constants::match_default)
Definition regex.h:2942
regex_token_iterator operator++(int)
Postincrements a regex_token_iterator.
Definition regex.h:3050
const value_type * operator->() const
Selects a regex_token_iterator member.
Definition regex.h:3037
regex_token_iterator & operator=(const regex_token_iterator &__rhs)
Assigns a regex_token_iterator to another.
Definition regex.tcc:574
regex_token_iterator & operator++()
Increments a regex_token_iterator.
Definition regex.tcc:610
regex_token_iterator()
Default constructs a regex_token_iterator.
Definition regex.h:2887
const value_type & operator*() const
Dereferences a regex_token_iterator.
Definition regex.h:3030
regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type &__re, int __submatch=0, regex_constants::match_flag_type __m=regex_constants::match_default)
Definition regex.h:2909
A smart pointer with reference-counted copy semantics.
Struct holding two objects of arbitrary type.
Definition stl_pair.h:286
constexpr void swap(pair &__p) noexcept(__and_< __is_nothrow_swappable< _T1 >, __is_nothrow_swappable< _T2 > >::value)
Swap the first members and then the second members.
Definition stl_pair.h:303
Marking input iterators.
Forward iterators support a superset of input iterator operations.
A standard container which offers fixed time access to individual elements in any order.
Definition stl_vector.h:429
constexpr iterator end() noexcept
Definition stl_vector.h:893
constexpr iterator begin() noexcept
Definition stl_vector.h:873
constexpr void assign(size_type __n, const value_type &__val)
Definition stl_vector.h:808
constexpr void swap(vector &__x) noexcept
constexpr bool empty() const noexcept
constexpr allocator_type get_allocator() const noexcept
constexpr size_type size() const noexcept
Definition stl_vector.h:992
constexpr reference operator[](size_type __n) noexcept
constexpr size_type max_size() const noexcept
Definition stl_vector.h:998