31 namespace std _GLIBCXX_VISIBILITY(default)
33 _GLIBCXX_BEGIN_NAMESPACE_VERSION
34 _GLIBCXX_BEGIN_NAMESPACE_CXX11
35 template<
typename,
typename>
38 template<
typename,
typename>
41 _GLIBCXX_END_NAMESPACE_CXX11
45 enum class _RegexExecutorPolicy : int { _S_auto, _S_alternate };
47 template<
typename _BiIter,
typename _Alloc,
48 typename _CharT,
typename _TraitsT,
49 _RegexExecutorPolicy __policy,
52 __regex_algo_impl(_BiIter __s,
54 match_results<_BiIter, _Alloc>& __m,
55 const basic_regex<_CharT, _TraitsT>& __re,
58 template<
typename,
typename,
typename,
bool>
62 _GLIBCXX_BEGIN_NAMESPACE_CXX11
79 template<
typename _Ch_type>
83 typedef _Ch_type char_type;
90 typedef std::ctype_base::mask _BaseType;
92 unsigned char _M_extended;
93 static constexpr
unsigned char _S_under = 1 << 0;
94 static constexpr
unsigned char _S_valid_mask = 0x1;
96 constexpr _RegexMask(_BaseType
__base = 0,
97 unsigned char __extended = 0)
98 : _M_base(
__base), _M_extended(__extended)
104 return _RegexMask(_M_base & __other._M_base,
105 _M_extended & __other._M_extended);
109 operator|(_RegexMask __other)
const
111 return _RegexMask(_M_base | __other._M_base,
112 _M_extended | __other._M_extended);
116 operator^(_RegexMask __other)
const
118 return _RegexMask(_M_base ^ __other._M_base,
119 _M_extended ^ __other._M_extended);
124 {
return _RegexMask(~_M_base, ~_M_extended); }
127 operator&=(_RegexMask __other)
128 {
return *
this = (*this) & __other; }
131 operator|=(_RegexMask __other)
132 {
return *
this = (*this) | __other; }
135 operator^=(_RegexMask __other)
136 {
return *
this = (*this) ^ __other; }
139 operator==(_RegexMask __other)
const
141 return (_M_extended & _S_valid_mask)
142 == (__other._M_extended & _S_valid_mask)
143 && _M_base == __other._M_base;
146 #if __cpp_impl_three_way_comparison < 201907L
148 operator!=(_RegexMask __other)
const
149 {
return !((*this) == __other); }
154 typedef _RegexMask char_class_type;
174 {
return string_type::traits_type::length(__p); }
200 const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale));
201 return __fctyp.tolower(__c);
224 template<
typename _Fwd_iter>
229 const __collate_type& __fclt(use_facet<__collate_type>(_M_locale));
231 return __fclt.transform(__s.
data(), __s.
data() + __s.
size());
248 template<
typename _Fwd_iter>
259 const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale));
276 template<
typename _Fwd_iter>
317 template<
typename _Fwd_iter>
320 bool __icase =
false)
const;
335 isctype(_Ch_type __c, char_class_type __f)
const;
348 value(_Ch_type __ch,
int __radix)
const;
374 {
return _M_locale; }
377 locale_type _M_locale;
388 template<
typename _Ch_type,
typename _Rx_traits = regex_traits<_Ch_type>>
393 "regex traits class must have the same char_type");
396 typedef _Ch_type value_type;
397 typedef _Rx_traits traits_type;
398 typedef typename traits_type::string_type string_type;
400 typedef typename traits_type::locale_type locale_type;
425 : _M_flags(
ECMAScript), _M_loc(), _M_automaton(nullptr)
484 template<
typename _Ch_traits,
typename _Ch_alloc>
505 template<
typename _FwdIter>
534 {
return this->
assign(__rhs); }
552 {
return this->
assign(__p); }
564 {
return this->
assign(__l.begin(), __l.end()); }
572 template<
typename _Ch_traits,
typename _Alloc>
575 {
return this->
assign(__s); }
619 {
return this->
assign(string_type(__p), __flags); }
638 {
return this->
assign(string_type(__p, __len), __flags); }
651 template<
typename _Ch_traits,
typename _Alloc>
673 template<
typename _InputIterator>
675 assign(_InputIterator __first, _InputIterator __last,
677 {
return this->
assign(string_type(__first, __last), __flags); }
692 {
return this->
assign(__l.begin(), __l.end(), __flags); }
703 return _M_automaton->_M_sub_count() - 1;
725 _M_automaton.reset();
748 std::swap(_M_automaton, __rhs._M_automaton);
751 #ifdef _GLIBCXX_DEBUG
754 { _M_automaton->_M_dot(__ostr); }
760 template<
typename _FwdIter>
761 basic_regex(_FwdIter __first, _FwdIter __last, locale_type __loc,
763 : _M_flags(__f), _M_loc(
std::
move(__loc)),
764 _M_automaton(__detail::__compile_nfa<_Rx_traits>(
768 template<
typename _Bp,
typename _Ap,
typename _Cp,
typename _Rp,
769 __detail::_RegexExecutorPolicy,
bool>
775 template<
typename,
typename,
typename,
bool>
783 #if __cplusplus < 201703L
784 template<
typename _Ch,
typename _Tr>
788 template<
typename _Ch,
typename _Tr>
792 template<
typename _Ch,
typename _Tr>
796 template<
typename _Ch,
typename _Tr>
800 template<
typename _Ch,
typename _Tr>
804 template<
typename _Ch,
typename _Tr>
808 template<
typename _Ch,
typename _Tr>
812 template<
typename _Ch,
typename _Tr>
816 template<
typename _Ch,
typename _Tr>
820 template<
typename _Ch,
typename _Tr>
825 #if __cpp_deduction_guides >= 201606
826 template<
typename _ForwardIterator>
829 -> basic_regex<
typename iterator_traits<_ForwardIterator>::value_type>;
835 #ifdef _GLIBCXX_USE_WCHAR_T
848 template<
typename _Ch_type,
typename _Rx_traits>
852 { __lhs.
swap(__rhs); }
868 template<
typename _BiIter>
874 typedef typename __iter_traits::value_type value_type;
875 typedef typename __iter_traits::difference_type difference_type;
876 typedef _BiIter iterator;
881 constexpr
sub_match() noexcept : matched() { }
886 {
return this->matched ? std::distance(this->
first, this->
second) : 0; }
898 operator string_type()
const
925 {
return this->_M_str().compare(__s._M_str()); }
939 {
return this->_M_str().compare(__s); }
943 {
return this->_M_str().compare(__s); }
949 _M_compare(
const value_type* __s,
size_t __n)
const
950 {
return this->_M_str().compare({__s, __n}); }
957 using traits_type =
typename string_type::traits_type;
959 __string_view() =
default;
961 __string_view(
const value_type* __s,
size_t __n) noexcept
962 : _M_data(__s), _M_len(__n) { }
964 __string_view(
const value_type* __s) noexcept
965 : _M_data(__s), _M_len(traits_type::length(__s)) { }
967 __string_view(
const string_type& __s) noexcept
968 : _M_data(__s.data()), _M_len(__s.length()) { }
971 compare(__string_view __s)
const noexcept
973 if (
const size_t __n =
std::min(_M_len, __s._M_len))
974 if (
int __ret = traits_type::compare(_M_data, __s._M_data, __n))
977 const difference_type __diff = _M_len - __s._M_len;
978 if (__diff > __limits::__max)
979 return __limits::__max;
980 if (__diff < __limits::__min)
981 return __limits::__min;
982 return static_cast<int>(__diff);
986 const value_type* _M_data =
nullptr;
991 template<
typename _Iter = _BiIter>
992 __enable_if_t<__detail::__is_contiguous_iter<_Iter>::value,
994 _M_str() const noexcept
1003 template<
typename _Iter = _BiIter>
1004 __enable_if_t<!__detail::__is_contiguous_iter<_Iter>::value,
1017 #ifdef _GLIBCXX_USE_WCHAR_T
1035 template<
typename _BiIter>
1038 {
return __lhs.
compare(__rhs) == 0; }
1040 #if __cpp_lib_three_way_comparison
1048 template<
typename _BiIter>
1052 noexcept(__detail::__is_contiguous_iter<_BiIter>::value)
1055 return __detail::__char_traits_cmp_cat<_Tr>(__lhs.compare(__rhs));
1064 template<
typename _BiIter>
1067 {
return __lhs.
compare(__rhs) != 0; }
1075 template<
typename _BiIter>
1078 {
return __lhs.
compare(__rhs) < 0; }
1086 template<
typename _BiIter>
1089 {
return __lhs.
compare(__rhs) <= 0; }
1097 template<
typename _BiIter>
1100 {
return __lhs.
compare(__rhs) >= 0; }
1108 template<
typename _BiIter>
1111 {
return __lhs.
compare(__rhs) > 0; }
1117 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1120 _Ch_traits, _Ch_alloc>;
1123 #if ! __cpp_lib_three_way_comparison
1131 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1133 operator==(
const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1135 {
return __rhs._M_compare(__lhs.data(), __lhs.size()) == 0; }
1144 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1146 operator!=(
const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1148 {
return !(__lhs == __rhs); }
1156 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1158 operator<(
const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1160 {
return __rhs._M_compare(__lhs.data(), __lhs.size()) > 0; }
1168 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1170 operator>(
const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1172 {
return __rhs < __lhs; }
1180 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1182 operator>=(
const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1184 {
return !(__lhs < __rhs); }
1192 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1194 operator<=(
const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs,
1196 {
return !(__rhs < __lhs); }
1206 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1209 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1210 {
return __lhs._M_compare(__rhs.data(), __rhs.size()) == 0; }
1212 #if __cpp_lib_three_way_comparison
1220 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Alloc>
1223 const __sub_match_string<_Bi_iter, _Ch_traits, _Alloc>& __rhs)
1224 noexcept(__detail::__is_contiguous_iter<_Bi_iter>::value)
1226 return __detail::__char_traits_cmp_cat<_Ch_traits>(
1227 __lhs._M_compare(__rhs.data(), __rhs.size()));
1237 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1240 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1241 {
return !(__lhs == __rhs); }
1249 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1252 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1253 {
return __lhs._M_compare(__rhs.data(), __rhs.size()) < 0; }
1261 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1264 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1265 {
return __rhs < __lhs; }
1273 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1276 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1277 {
return !(__lhs < __rhs); }
1285 template<
typename _Bi_iter,
typename _Ch_traits,
typename _Ch_alloc>
1288 const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs)
1289 {
return !(__rhs < __lhs); }
1298 template<
typename _Bi_iter>
1302 {
return __rhs.
compare(__lhs) == 0; }
1311 template<
typename _Bi_iter>
1315 {
return !(__lhs == __rhs); }
1323 template<
typename _Bi_iter>
1327 {
return __rhs.
compare(__lhs) > 0; }
1335 template<
typename _Bi_iter>
1339 {
return __rhs < __lhs; }
1347 template<
typename _Bi_iter>
1351 {
return !(__lhs < __rhs); }
1359 template<
typename _Bi_iter>
1363 {
return !(__rhs < __lhs); }
1373 template<
typename _Bi_iter>
1377 {
return __lhs.
compare(__rhs) == 0; }
1379 #if __cpp_lib_three_way_comparison
1388 template<
typename _Bi_iter>
1392 noexcept(__detail::__is_contiguous_iter<_Bi_iter>::value)
1395 return __detail::__char_traits_cmp_cat<_Tr>(__lhs.compare(__rhs));
1405 template<
typename _Bi_iter>
1409 {
return !(__lhs == __rhs); }
1417 template<
typename _Bi_iter>
1421 {
return __lhs.
compare(__rhs) < 0; }
1429 template<
typename _Bi_iter>
1433 {
return __rhs < __lhs; }
1441 template<
typename _Bi_iter>
1445 {
return !(__lhs < __rhs); }
1453 template<
typename _Bi_iter>
1457 {
return !(__rhs < __lhs); }
1466 template<
typename _Bi_iter>
1479 template<
typename _Bi_iter>
1483 {
return !(__lhs == __rhs); }
1492 template<
typename _Bi_iter>
1505 template<
typename _Bi_iter>
1509 {
return __rhs < __lhs; }
1518 template<
typename _Bi_iter>
1522 {
return !(__lhs < __rhs); }
1531 template<
typename _Bi_iter>
1535 {
return !(__rhs < __lhs); }
1545 template<
typename _Bi_iter>
1551 #if __cpp_lib_three_way_comparison
1561 template<
typename _Bi_iter>
1565 noexcept(__detail::__is_contiguous_iter<_Bi_iter>::value)
1568 return __detail::__char_traits_cmp_cat<_Tr>(
1579 template<
typename _Bi_iter>
1583 {
return !(__lhs == __rhs); }
1592 template<
typename _Bi_iter>
1605 template<
typename _Bi_iter>
1609 {
return __rhs < __lhs; }
1618 template<
typename _Bi_iter>
1622 {
return !(__lhs < __rhs); }
1631 template<
typename _Bi_iter>
1635 {
return !(__rhs < __lhs); }
1646 template<
typename _Ch_type,
typename _Ch_traits,
typename _Bi_iter>
1651 {
return __os << __m.
str(); }
1677 template<
typename _Bi_iter,
1678 typename _Alloc = allocator<sub_match<_Bi_iter> > >
1680 :
private std::vector<sub_match<_Bi_iter>, _Alloc>
1711 typedef typename _Base_type::const_iterator const_iterator;
1712 typedef const_iterator iterator;
1713 typedef typename __iter_traits::difference_type difference_type;
1715 typedef _Alloc allocator_type;
1716 typedef typename __iter_traits::value_type char_type;
1805 _GLIBCXX_NODISCARD
bool
1807 {
return size() == 0; }
1826 {
return (*
this)[__sub].length(); }
1841 {
return std::distance(_M_begin, (*
this)[__sub].first); }
1853 str(size_type __sub = 0)
const
1870 __glibcxx_assert(
ready() );
1871 return __sub <
size()
1873 : _M_unmatched_sub();
1887 __glibcxx_assert(
ready() );
1888 return !
empty() ? _M_prefix() : _M_unmatched_sub();
1902 __glibcxx_assert(
ready() );
1903 return !
empty() ? _M_suffix() : _M_unmatched_sub();
1918 {
return this->
begin(); }
1932 {
return this->
end(); }
1949 template<
typename _Out_iter>
1951 format(_Out_iter __out,
const char_type* __fmt_first,
1952 const char_type* __fmt_last,
1958 template<
typename _Out_iter,
typename _St,
typename _Sa>
1970 template<
typename _St,
typename _Sa>
2024 swap(_M_begin, __that._M_begin);
2029 template<
typename,
typename,
typename>
2034 template<
typename,
typename,
typename,
bool>
2037 template<
typename _Bp,
typename _Ap,
typename _Cp,
typename _Rp,
2038 __detail::_RegexExecutorPolicy,
bool>
2047 _M_resize(
unsigned int __size)
2052 _M_establish_failed_match(_Bi_iter __end)
2054 sub_match<_Bi_iter> __sm;
2055 __sm.first = __sm.second = __end;
2060 _M_unmatched_sub()
const
2063 sub_match<_Bi_iter>&
2071 sub_match<_Bi_iter>&
2079 sub_match<_Bi_iter>&
2089 #ifdef _GLIBCXX_USE_WCHAR_T
2101 template<
typename _Bi_iter,
typename _Alloc>
2120 #if ! __cpp_lib_three_way_comparison
2126 template<
typename _Bi_iter,
class _Alloc>
2130 {
return !(__m1 == __m2); }
2141 template<
typename _Bi_iter,
typename _Alloc>
2145 { __lhs.swap(__rhs); }
2147 _GLIBCXX_END_NAMESPACE_CXX11
2170 template<
typename _Bi_iter,
typename _Alloc,
2171 typename _Ch_type,
typename _Rx_traits>
2180 return __detail::__regex_algo_impl<_Bi_iter, _Alloc, _Ch_type, _Rx_traits,
2181 __detail::_RegexExecutorPolicy::_S_auto,
true>
2182 (__s, __e, __m, __re, __flags);
2199 template<
typename _Bi_iter,
typename _Ch_type,
typename _Rx_traits>
2207 return regex_match(__first, __last, __what, __re, __flags);
2224 template<
typename _Ch_type,
typename _Alloc,
typename _Rx_traits>
2231 {
return regex_match(__s, __s + _Rx_traits::length(__s), __m, __re, __f); }
2247 template<
typename _Ch_traits,
typename _Ch_alloc,
2248 typename _Alloc,
typename _Ch_type,
typename _Rx_traits>
2252 _Ch_traits, _Ch_alloc>::const_iterator, _Alloc>& __m,
2256 {
return regex_match(__s.
begin(), __s.
end(), __m, __re, __flags); }
2261 template<
typename _Ch_traits,
typename _Ch_alloc,
2262 typename _Alloc,
typename _Ch_type,
typename _Rx_traits>
2266 _Ch_traits, _Ch_alloc>::const_iterator, _Alloc>&,
2284 template<
typename _Ch_type,
class _Rx_traits>
2290 {
return regex_match(__s, __s + _Rx_traits::length(__s), __re, __f); }
2305 template<
typename _Ch_traits,
typename _Str_allocator,
2306 typename _Ch_type,
typename _Rx_traits>
2312 {
return regex_match(__s.
begin(), __s.
end(), __re, __flags); }
2328 template<
typename _Bi_iter,
typename _Alloc,
2329 typename _Ch_type,
typename _Rx_traits>
2337 return __detail::__regex_algo_impl<_Bi_iter, _Alloc, _Ch_type, _Rx_traits,
2338 __detail::_RegexExecutorPolicy::_S_auto,
false>
2339 (__s, __e, __m, __re, __flags);
2353 template<
typename _Bi_iter,
typename _Ch_type,
typename _Rx_traits>
2361 return regex_search(__first, __last, __what, __re, __flags);
2376 template<
typename _Ch_type,
class _Alloc,
class _Rx_traits>
2383 {
return regex_search(__s, __s + _Rx_traits::length(__s), __m, __e, __f); }
2395 template<
typename _Ch_type,
typename _Rx_traits>
2401 {
return regex_search(__s, __s + _Rx_traits::length(__s), __e, __f); }
2413 template<
typename _Ch_traits,
typename _String_allocator,
2414 typename _Ch_type,
typename _Rx_traits>
2417 _String_allocator>& __s,
2421 {
return regex_search(__s.begin(), __s.end(), __e, __flags); }
2435 template<
typename _Ch_traits,
typename _Ch_alloc,
2436 typename _Alloc,
typename _Ch_type,
2437 typename _Rx_traits>
2441 _Ch_traits, _Ch_alloc>::const_iterator, _Alloc>& __m,
2445 {
return regex_search(__s.
begin(), __s.
end(), __m, __e, __f); }
2450 template<
typename _Ch_traits,
typename _Ch_alloc,
2451 typename _Alloc,
typename _Ch_type,
2452 typename _Rx_traits>
2456 _Ch_traits, _Ch_alloc>::const_iterator, _Alloc>&,
2475 template<
typename _Out_iter,
typename _Bi_iter,
2476 typename _Rx_traits,
typename _Ch_type,
2477 typename _St,
typename _Sa>
2485 return regex_replace(__out, __first, __last, __e, __fmt.
c_str(), __flags);
2501 template<
typename _Out_iter,
typename _Bi_iter,
2502 typename _Rx_traits,
typename _Ch_type>
2506 const _Ch_type* __fmt,
2521 template<
typename _Rx_traits,
typename _Ch_type,
2522 typename _St,
typename _Sa,
typename _Fst,
typename _Fsa>
2532 __s.
begin(), __s.
end(), __e, __fmt, __flags);
2547 template<
typename _Rx_traits,
typename _Ch_type,
2548 typename _St,
typename _Sa>
2552 const _Ch_type* __fmt,
2558 __s.
begin(), __s.
end(), __e, __fmt, __flags);
2573 template<
typename _Rx_traits,
typename _Ch_type,
2574 typename _St,
typename _Sa>
2585 __e, __fmt, __flags);
2600 template<
typename _Rx_traits,
typename _Ch_type>
2604 const _Ch_type* __fmt,
2611 __e, __fmt, __flags);
2617 _GLIBCXX_BEGIN_NAMESPACE_CXX11
2624 template<
typename _Bi_iter,
2632 typedef std::ptrdiff_t difference_type;
2633 typedef const value_type* pointer;
2634 typedef const value_type& reference;
2653 : _M_begin(__a), _M_end(__b), _M_pregex(&__re), _M_flags(__m), _M_match()
2655 if (!regex_search(_M_begin, _M_end, _M_match, *_M_pregex, _M_flags))
2685 {
return !(*
this == __rhs); }
2692 {
return _M_match; }
2699 {
return &_M_match; }
2719 _Bi_iter _M_begin {};
2721 const regex_type* _M_pregex =
nullptr;
2723 match_results<_Bi_iter> _M_match;
2728 #ifdef _GLIBCXX_USE_WCHAR_T
2741 template<
typename _Bi_iter,
2749 typedef std::ptrdiff_t difference_type;
2763 : _M_position(), _M_subs(), _M_suffix(), _M_n(0), _M_result(nullptr),
2788 : _M_position(__a, __b, __re, __m), _M_subs(1, __submatch), _M_n(0)
2789 { _M_init(__a, __b); }
2805 : _M_position(__a, __b, __re, __m), _M_subs(__submatches), _M_n(0)
2806 { _M_init(__a, __b); }
2822 : _M_position(__a, __b, __re, __m), _M_subs(__submatches), _M_n(0)
2823 { _M_init(__a, __b); }
2834 template<std::
size_t _Nm>
2837 const int (&__submatches)[_Nm],
2840 : _M_position(__a, __b, __re, __m),
2841 _M_subs(__submatches, __submatches + _Nm), _M_n(0)
2842 { _M_init(__a, __b); }
2857 template <std::
size_t _Nm>
2868 : _M_position(__rhs._M_position), _M_subs(__rhs._M_subs),
2869 _M_suffix(__rhs._M_suffix), _M_n(__rhs._M_n), _M_has_m1(__rhs._M_has_m1)
2870 { _M_normalize_result(); }
2890 {
return !(*
this == __rhs); }
2897 {
return *_M_result; }
2904 {
return _M_result; }
2927 _M_init(_Bi_iter __a, _Bi_iter __b);
2930 _M_current_match()
const
2932 if (_M_subs[_M_n] == -1)
2933 return (*_M_position).prefix();
2935 return (*_M_position)[_M_subs[_M_n]];
2939 _M_end_of_seq()
const
2940 {
return _M_result ==
nullptr; }
2944 _M_normalize_result()
2946 if (_M_position != _Position())
2947 _M_result = &_M_current_match();
2949 _M_result = &_M_suffix;
2951 _M_result =
nullptr;
2954 _Position _M_position;
2956 value_type _M_suffix;
2958 const value_type* _M_result;
2970 #ifdef _GLIBCXX_USE_WCHAR_T
2980 _GLIBCXX_END_NAMESPACE_CXX11
2981 _GLIBCXX_END_NAMESPACE_VERSION
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
_BiIter first
The first member.
_BiIter second
The second member.
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
void swap(any &__x, any &__y) noexcept
Exchange the states of two any objects.
_Tp * begin(valarray< _Tp > &__va)
Return an iterator pointing to the first element of the valarray.
_Tp * end(valarray< _Tp > &__va)
Return an iterator pointing to one past the last element of the valarray.
constexpr const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
char_type translate(char_type __c) const
Performs the identity translation.
static constexpr flag_type extended
allocator_type get_allocator() const noexcept
Gets a copy of the allocator.
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)
basic_string< _Ch_type > regex_replace(const _Ch_type *__s, const basic_regex< _Ch_type, _Rx_traits > &__e, const _Ch_type *__fmt, regex_constants::match_flag_type __flags=regex_constants::match_default)
Search for a regular expression within a C-string for multiple times, and replace the matched parts t...
bool operator>=(typename iterator_traits< _Bi_iter >::value_type const &__lhs, const sub_match< _Bi_iter > &__rhs)
Tests the ordering of a character and a regular expression submatch.
bool operator==(const regex_token_iterator &__rhs) const
Compares a regex_token_iterator to another for equality.
regex_iterator & operator++()
Increments a regex_iterator.
sub_match< wstring::const_iterator > wssub_match
Regex submatch over a standard wide string.
const value_type & operator*() const
Dereferences a regex_token_iterator.
bool operator!=(const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const &__rhs)
Tests the inequivalence of a regular expression submatch and a character.
void swap(match_results &__that) noexcept
Swaps the contents of two match_results.
string_type lookup_collatename(_Fwd_iter __first, _Fwd_iter __last) const
Gets a collation element by name.
regex_token_iterator< const wchar_t * > wcregex_token_iterator
Token iterator for C-style NULL-terminated wide strings.
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...
static constexpr flag_type icase
sub_match< string::const_iterator > ssub_match
Standard regex submatch over a standard string.
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.
friend bool __detail::__regex_algo_impl(_Bp, _Bp, match_results< _Bp, _Ap > &, const basic_regex< _Cp, _Rp > &, regex_constants::match_flag_type)
constexpr syntax_option_type collate
static constexpr flag_type ECMAScript
bool regex_search(const _Ch_type *__s, match_results< const _Ch_type *, _Alloc > &__m, const basic_regex< _Ch_type, _Rx_traits > &__e, regex_constants::match_flag_type __f=regex_constants::match_default)
Searches for a regular expression within a C-string.
match_results< wstring::const_iterator > wsmatch
Tests the equivalence of two regular expression submatches.
basic_regex & assign(basic_regex &&__rhs) noexcept
The move-assignment operator.
bool operator==(const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__lhs, const sub_match< _Bi_iter > &__rhs)
Tests the equivalence of a string and a regular expression submatch.
basic_regex & operator=(const basic_regex &__rhs)
Assigns one regular expression to another.
regex_iterator< wstring::const_iterator > wsregex_iterator
Token iterator for C-style NULL-terminated strings.
bool operator!=(const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__lhs, const sub_match< _Bi_iter > &__rhs)
Tests the inequivalence of a string and a regular expression submatch.
difference_type position(size_type __sub=0) const
Gets the offset of the beginning of the indicated submatch.
basic_regex & assign(initializer_list< _Ch_type > __l, flag_type __flags=ECMAScript)
Assigns a new regular expression to a regex object.
sub_match< const char * > csub_match
Standard regex submatch over a C-style null-terminated string.
size_type size() const noexcept
Gets the number of matches and submatches.
static std::size_t length(const char_type *__p)
Gives the length of a C-style string starting at __p.
bool operator!=(const regex_iterator &__rhs) const noexcept
Tests the inequivalence of two regex iterators.
string_type transform_primary(_Fwd_iter __first, _Fwd_iter __last) const
Gets a sort key for a character sequence, independent of case.
regex_token_iterator(const regex_token_iterator &__rhs)
Copy constructs a regex_token_iterator.
_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...
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.
bool operator>=(const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__lhs, const sub_match< _Bi_iter > &__rhs)
Tests the ordering of a string and a regular expression submatch.
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)
bool regex_search(_Bi_iter __first, _Bi_iter __last, const basic_regex< _Ch_type, _Rx_traits > &__re, regex_constants::match_flag_type __flags=regex_constants::match_default)
constexpr syntax_option_type ECMAScript
static constexpr flag_type basic
locale_type imbue(locale_type __loc)
Imbues the regular expression object with the given locale.
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.
_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
constexpr syntax_option_type egrep
basic_regex & assign(const basic_regex &__rhs)
the real assignment operator.
bool operator>=(const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const *__rhs)
Tests the ordering of a regular expression submatch and a C string.
difference_type length(size_type __sub=0) const
Gets the length of the indicated submatch.
regex_iterator< const char * > cregex_iterator
Token iterator for C-style NULL-terminated strings.
regex_traits()
Constructs a default traits object.
const_reference prefix() const
Gets a sub_match representing the match prefix.
syntax_option_type
This is a bitmask type indicating how to interpret the regex.
basic_regex(const basic_regex &__rhs)=default
Copy-constructs a basic regular expression.
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)
difference_type length() const noexcept
Gets the length of the matching sequence.
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)
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.
bool operator!=(const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const *__rhs)
Tests the inequivalence of a regular expression submatch and a string.
size_type max_size() const noexcept
Gets the number of matches and submatches.
bool operator!=(typename iterator_traits< _Bi_iter >::value_type const *__lhs, const sub_match< _Bi_iter > &__rhs)
Tests the inequivalence of a C string and a regular expression submatch.
int value(_Ch_type __ch, int __radix) const
Converts a digit to an int.
regex_iterator operator++(int)
Postincrements a regex_iterator.
void swap(basic_regex &__rhs)
Swaps the contents of two regular expression objects.
const_reference operator[](size_type __sub) const
Gets a sub_match reference for the match or submatch.
static constexpr flag_type grep
regex_token_iterator & operator++()
Increments a regex_token_iterator.
bool operator!=(const match_results< _Bi_iter, _Alloc > &__m1, const match_results< _Bi_iter, _Alloc > &__m2)
Compares two match_results for inequality.
unsigned int mark_count() const
Gets the number of marked subexpressions within the regular expression.
bool regex_search(const basic_string< _Ch_type, _Ch_traits, _Ch_alloc > &&, match_results< typename basic_string< _Ch_type, _Ch_traits, _Ch_alloc >::const_iterator, _Alloc > &, const basic_regex< _Ch_type, _Rx_traits > &, regex_constants::match_flag_type=regex_constants::match_default)=delete
Prevent unsafe attempts to get match_results from a temporary string.
bool operator!=(const regex_token_iterator &__rhs) const
Compares a regex_token_iterator to another for inequality.
regex_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type &__re, regex_constants::match_flag_type __m=regex_constants::match_default)
match_results(match_results &&) noexcept=default
Move constructs a match_results.
basic_string< _Ch_type, _St, _Sa > regex_replace(const basic_string< _Ch_type, _St, _Sa > &__s, const basic_regex< _Ch_type, _Rx_traits > &__e, const basic_string< _Ch_type, _Fst, _Fsa > &__fmt, regex_constants::match_flag_type __flags=regex_constants::match_default)
Search for a regular expression within a string for multiple times, and replace the matched parts thr...
regex_token_iterator operator++(int)
Postincrements a regex_token_iterator.
regex_iterator(const regex_iterator &)=default
Copy constructs a regex_iterator.
basic_string< char_type, _St, _Sa > format(const basic_string< char_type, _St, _Sa > &__fmt, match_flag_type __flags=regex_constants::format_default) const
match_results(const _Alloc &__a) noexcept
Constructs a default match_results container.
bool regex_match(const basic_string< _Ch_type, _Ch_traits, _Str_allocator > &__s, const basic_regex< _Ch_type, _Rx_traits > &__re, regex_constants::match_flag_type __flags=regex_constants::match_default)
Indicates if there is a match between the regular expression e and a string.
match_results(const match_results &)=default
Copy constructs a match_results.
bool regex_match(const _Ch_type *__s, match_results< const _Ch_type *, _Alloc > &__m, const basic_regex< _Ch_type, _Rx_traits > &__re, regex_constants::match_flag_type __f=regex_constants::match_default)
Determines if there is a match between the regular expression e and a C-style null-terminated string.
bool operator>(const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const &__rhs)
Tests the ordering of a regular expression submatch and a character.
_Out_iter format(_Out_iter __out, const basic_string< char_type, _St, _Sa > &__fmt, match_flag_type __flags=regex_constants::format_default) const
const_iterator cbegin() const noexcept
Gets an iterator to the start of the sub_match collection.
constexpr match_flag_type match_default
basic_regex & operator=(const basic_string< _Ch_type, _Ch_traits, _Alloc > &__s)
Replaces a regular expression with a new one constructed from a string.
constexpr syntax_option_type awk
regex_iterator()=default
Provides a singular iterator, useful for indicating one-past-the-end of a range.
string_type str(size_type __sub=0) const
Gets the match or submatch converted to a string type.
regex_iterator & operator=(const regex_iterator &)=default
Copy assigns one regex_iterator to another.
const value_type & operator*() const noexcept
Dereferences a regex_iterator.
bool operator>(const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const *__rhs)
Tests the ordering of a regular expression submatch and a C string.
static constexpr flag_type optimize
bool regex_search(const _Ch_type *__s, const basic_regex< _Ch_type, _Rx_traits > &__e, regex_constants::match_flag_type __f=regex_constants::match_default)
Searches for a regular expression within a C-string.
regex_token_iterator()
Default constructs a regex_token_iterator.
basic_regex & operator=(basic_regex &&__rhs) noexcept
Move-assigns one regular expression to another.
bool operator>=(const sub_match< _Bi_iter > &__lhs, typename iterator_traits< _Bi_iter >::value_type const &__rhs)
Tests the ordering of a regular expression submatch and a character.
bool operator>(typename iterator_traits< _Bi_iter >::value_type const &__lhs, const sub_match< _Bi_iter > &__rhs)
Tests the ordering of a character and a regular expression submatch.
basic_regex< char > regex
Standard regular expressions.
const_iterator end() const noexcept
Gets an iterator to one-past-the-end of the collection.
constexpr syntax_option_type extended
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...
int compare(const value_type *__s) const
Compares this sub_match to a string.
regex_token_iterator< const char * > cregex_token_iterator
Token iterator for C-style NULL-terminated strings.
regex_token_iterator< string::const_iterator > sregex_token_iterator
Token iterator for standard strings.
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.
bool regex_match(const basic_string< _Ch_type, _Ch_traits, _Ch_alloc > &&, match_results< typename basic_string< _Ch_type, _Ch_traits, _Ch_alloc >::const_iterator, _Alloc > &, const basic_regex< _Ch_type, _Rx_traits > &, regex_constants::match_flag_type=regex_constants::match_default)=delete
Prevent unsafe attempts to get match_results from a temporary string.
constexpr syntax_option_type basic
sub_match< const wchar_t * > wcsub_match
Regex submatch over a C-style null-terminated wide string.
bool operator>=(const sub_match< _Bi_iter > &__lhs, const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__rhs)
Tests the ordering of a regular expression submatch and a string.
match_results< string::const_iterator > smatch
Tests the equivalence of two regular expression submatches.
char_type translate_nocase(char_type __c) const
Translates a character into a case-insensitive equivalent.
match_flag_type
This is a bitmask type indicating regex matching rules.
regex_iterator< string::const_iterator > sregex_iterator
Token iterator for C-style NULL-terminated strings.
bool operator==(const match_results< _Bi_iter, _Alloc > &__m1, const match_results< _Bi_iter, _Alloc > &__m2)
Compares two match_results for equality.
basic_string< _Ch_type > regex_replace(const _Ch_type *__s, 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 C-string for multiple times, and replace the matched parts t...
match_results< const char * > cmatch
Tests the equivalence of two regular expression submatches.
const_reference suffix() const
Gets a sub_match representing the match suffix.
basic_regex & operator=(const _Ch_type *__p)
Replaces a regular expression with a new one constructed from a C-style null-terminated string.
locale_type getloc() const
Gets the locale currently imbued in the regular expression object.
static constexpr flag_type awk
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...
bool ready() const noexcept
Indicates if the match_results is ready.
bool empty() const noexcept
Indicates if the match_results contains no results.
bool regex_match(const _Ch_type *__s, const basic_regex< _Ch_type, _Rx_traits > &__re, regex_constants::match_flag_type __f=regex_constants::match_default)
Indicates if there is a match between the regular expression e and a C-style null-terminated string.
constexpr syntax_option_type icase
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...
flag_type flags() const
Gets the flags used to construct the regular expression or in the last call to assign().
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...
basic_regex & assign(_InputIterator __first, _InputIterator __last, flag_type __flags=ECMAScript)
Assigns a new regular expression to a regex object.
regex_token_iterator< wstring::const_iterator > wsregex_token_iterator
Token iterator for standard wide-character strings.
bool operator>(const sub_match< _Bi_iter > &__lhs, const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__rhs)
Tests the ordering of a regular expression submatch and a string.
bool operator>(typename iterator_traits< _Bi_iter >::value_type const *__lhs, const sub_match< _Bi_iter > &__rhs)
Tests the ordering of a C string and a regular expression submatch.
locale_type getloc() const
Gets a copy of the current locale in use by the regex_traits object.
constexpr syntax_option_type optimize
string_type format(const char_type *__fmt, match_flag_type __flags=regex_constants::format_default) const
bool regex_search(const basic_string< _Ch_type, _Ch_traits, _String_allocator > &__s, const basic_regex< _Ch_type, _Rx_traits > &__e, regex_constants::match_flag_type __flags=regex_constants::match_default)
Searches for a regular expression within a string.
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...
string_type str() const
Gets the matching sequence as a string.
constexpr match_flag_type format_default
const value_type * operator->() const noexcept
Selects a regex_iterator member.
static constexpr flag_type egrep
bool operator>=(const sub_match< _BiIter > &__lhs, const sub_match< _BiIter > &__rhs)
Tests the ordering of two regular expression submatches.
constexpr syntax_option_type nosubs
bool operator>(const sub_match< _BiIter > &__lhs, const sub_match< _BiIter > &__rhs)
Tests the ordering of two regular expression submatches.
bool isctype(_Ch_type __c, char_class_type __f) const
Determines if c is a member of an identified class.
void swap(match_results< _Bi_iter, _Alloc > &__lhs, match_results< _Bi_iter, _Alloc > &__rhs) noexcept
Swaps two match results.
match_results()
Constructs a default match_results container.
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...
bool operator==(const regex_iterator &) const noexcept
Tests the equivalence of two regex iterators.
const_iterator cend() const noexcept
Gets an iterator to one-past-the-end of the collection.
bool operator==(typename iterator_traits< _Bi_iter >::value_type const &__lhs, const sub_match< _Bi_iter > &__rhs)
Tests the equivalence of a character and a regular expression submatch.
match_results< const wchar_t * > wcmatch
Tests the equivalence of two regular expression submatches.
void swap(basic_regex< _Ch_type, _Rx_traits > &__lhs, basic_regex< _Ch_type, _Rx_traits > &__rhs)
Swaps the contents of two regular expression objects.
bool regex_search(const basic_string< _Ch_type, _Ch_traits, _Ch_alloc > &__s, match_results< typename basic_string< _Ch_type, _Ch_traits, _Ch_alloc >::const_iterator, _Alloc > &__m, const basic_regex< _Ch_type, _Rx_traits > &__e, regex_constants::match_flag_type __f=regex_constants::match_default)
Searches for a regular expression within a string.
bool operator>(const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__lhs, const sub_match< _Bi_iter > &__rhs)
Tests the ordering of a string and a regular expression submatch.
bool operator!=(typename iterator_traits< _Bi_iter >::value_type const &__lhs, const sub_match< _Bi_iter > &__rhs)
Tests the inequivalence of a character and a regular expression submatch.
basic_regex< wchar_t > wregex
Standard wide-character regular expressions.
locale_type imbue(locale_type __loc)
Imbues the regex_traits object with a copy of a new locale.
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.
regex_token_iterator & operator=(const regex_token_iterator &__rhs)
Assigns a regex_token_iterator to another.
basic_regex & operator=(initializer_list< _Ch_type > __l)
Replaces a regular expression with a new one constructed from an initializer list.
const value_type * operator->() const
Selects a regex_token_iterator member.
_Out_iter regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last, const basic_regex< _Ch_type, _Rx_traits > &__e, const _Ch_type *__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...
basic_string< _Ch_type, _St, _Sa > regex_replace(const basic_string< _Ch_type, _St, _Sa > &__s, const basic_regex< _Ch_type, _Rx_traits > &__e, const _Ch_type *__fmt, regex_constants::match_flag_type __flags=regex_constants::match_default)
Search for a regular expression within a string for multiple times, and replace the matched parts thr...
int compare(const sub_match &__s) const
Compares this and another matched sequence.
bool operator==(typename iterator_traits< _Bi_iter >::value_type const *__lhs, const sub_match< _Bi_iter > &__rhs)
Tests the equivalence of a C string and a regular expression submatch.
string_type transform(_Fwd_iter __first, _Fwd_iter __last) const
Gets a sort key for a character sequence.
int compare(const string_type &__s) const
Compares this sub_match to a string.
const_iterator begin() const noexcept
Gets an iterator to the start of the sub_match collection.
bool regex_match(const basic_string< _Ch_type, _Ch_traits, _Ch_alloc > &__s, match_results< typename basic_string< _Ch_type, _Ch_traits, _Ch_alloc >::const_iterator, _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 a string.
bool regex_match(_Bi_iter __first, _Bi_iter __last, const basic_regex< _Ch_type, _Rx_traits > &__re, regex_constants::match_flag_type __flags=regex_constants::match_default)
Indicates if there is a match between the regular expression e and all of the character sequence [fir...
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)
bool operator==(const sub_match< _BiIter > &__lhs, const sub_match< _BiIter > &__rhs)
Tests the equivalence of two regular expression submatches.
regex_iterator< const wchar_t * > wcregex_iterator
Token iterator for C-style NULL-terminated strings.
~basic_regex()
Destroys a basic regular expression.
bool operator!=(const sub_match< _BiIter > &__lhs, const sub_match< _BiIter > &__rhs)
Tests the inequivalence of two regular expression submatches.
bool operator!=(const sub_match< _Bi_iter > &__lhs, const __sub_match_string< _Bi_iter, _Ch_traits, _Ch_alloc > &__rhs)
Tests the inequivalence of a regular expression submatch and a string.
static constexpr flag_type nosubs
bool operator>=(typename iterator_traits< _Bi_iter >::value_type const *__lhs, const sub_match< _Bi_iter > &__rhs)
Tests the ordering of a C string and a regular expression submatch.
constexpr syntax_option_type grep
constexpr back_insert_iterator< _Container > back_inserter(_Container &__x)
ISO C++ entities toplevel namespace is std.
bitset< _Nb > operator&(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
constexpr auto size(const _Container &__cont) noexcept(noexcept(__cont.size())) -> decltype(__cont.size())
Return the size of a container.
constexpr auto data(_Container &__cont) noexcept(noexcept(__cont.data())) -> decltype(__cont.data())
Return the data pointer of a container.
__numeric_traits_integer< _Tp > __int_traits
Convenience alias for __numeric_traits<integer-type>.
constexpr _Iterator __base(_Iterator __it)
typename _Size< _Alloc, difference_type >::type size_type
The allocator's size type.
Managing sequences of characters and character-like objects.
const _CharT * c_str() const noexcept
Return const pointer to null-terminated contents.
size_type size() const noexcept
Returns the number of characters in the string, not including any null-termination.
const _CharT * data() const noexcept
Return const pointer to contents.
Basis for explicit traits specializations.
Traits class for iterators.
Container class for localization functionality.
Facet for localized string comparison.
Primary class template ctype facet.
The results of a match or search operation.
Takes a regex and an input string and does the matching.
Describes aspects of a regular expression.
A smart pointer with reference-counted copy semantics.
Forward iterators support a superset of input iterator operations.
Struct holding two objects of arbitrary type.
A standard container which offers fixed time access to individual elements in any order.
bool empty() const noexcept
allocator_type get_allocator() const noexcept
Get a copy of the memory allocation object.
size_type max_size() const noexcept
void assign(size_type __n, const value_type &__val)
Assigns a given value to a vector.
void swap(vector &__x) noexcept
Swaps data with another vector.
iterator begin() noexcept
size_type size() const noexcept
reference operator[](size_type __n) noexcept
Subscript access to the data contained in the vector.