60 #ifndef _STL_ITERATOR_H 61 #define _STL_ITERATOR_H 1 69 #if __cplusplus >= 201103L 73 #if __cplusplus > 201703L 74 # define __cpp_lib_array_constexpr 201811L 75 # define __cpp_lib_constexpr_iterator 201811L 76 #elif __cplusplus == 201703L 77 # define __cpp_lib_array_constexpr 201803L 80 #if __cplusplus > 201703L 87 namespace std _GLIBCXX_VISIBILITY(default)
89 _GLIBCXX_BEGIN_NAMESPACE_VERSION
96 #if __cplusplus > 201703L && __cpp_lib_concepts 101 template<
typename _Cat,
typename _Limit,
typename _Otherwise = _Cat>
102 using __clamp_iter_cat
103 = conditional_t<derived_from<_Cat, _Limit>, _Limit, _Otherwise>;
126 template<
typename _Iterator>
128 :
public iterator<typename iterator_traits<_Iterator>::iterator_category,
129 typename iterator_traits<_Iterator>::value_type,
130 typename iterator_traits<_Iterator>::difference_type,
131 typename iterator_traits<_Iterator>::pointer,
132 typename iterator_traits<_Iterator>::reference>
134 template<
typename _Iter>
137 #if __cpp_lib_concepts 140 template<
typename _Iter>
141 static constexpr
bool __convertible = !is_same_v<_Iter, _Iterator>
142 && convertible_to<const _Iter&, _Iterator>;
151 typedef _Iterator iterator_type;
152 typedef typename __traits_type::pointer pointer;
153 #if __cplusplus <= 201703L 154 typedef typename __traits_type::difference_type difference_type;
155 typedef typename __traits_type::reference reference;
157 using iterator_concept
162 = __detail::__clamp_iter_cat<
typename __traits_type::iterator_category,
165 using difference_type = iter_difference_t<_Iterator>;
166 using reference = iter_reference_t<_Iterator>;
182 explicit _GLIBCXX17_CONSTEXPR
190 : current(__x.current) { }
192 #if __cplusplus >= 201103L 200 template<
typename _Iter>
201 #if __cpp_lib_concepts 202 requires __convertible<_Iter>
206 : current(__x.current) { }
208 #if __cplusplus >= 201103L 209 template<
typename _Iter>
210 #if __cpp_lib_concepts 211 requires __convertible<_Iter>
212 && assignable_from<_Iterator&, const _Iter&>
218 current = __x.current;
226 _GLIBCXX17_CONSTEXPR iterator_type
240 _GLIBCXX17_CONSTEXPR reference
243 _Iterator __tmp = current;
252 _GLIBCXX17_CONSTEXPR pointer
254 #if __cplusplus > 201703L && __cpp_concepts >= 201907L 255 requires is_pointer_v<_Iterator>
256 || requires(
const _Iterator __i) { __i.operator->(); }
261 _Iterator __tmp = current;
263 return _S_to_pointer(__tmp);
365 _GLIBCXX17_CONSTEXPR reference
367 {
return *(*
this + __n); }
369 #if __cplusplus > 201703L && __cpp_lib_concepts 370 friend constexpr iter_rvalue_reference_t<_Iterator>
372 noexcept(is_nothrow_copy_constructible_v<_Iterator>
373 && noexcept(ranges::iter_move(--std::declval<_Iterator&>())))
375 auto __tmp = __i.base();
376 return ranges::iter_move(--__tmp);
379 template<indirectly_swappable<_Iterator> _Iter2>
380 friend constexpr
void 382 const reverse_iterator<_Iter2>& __y)
383 noexcept(is_nothrow_copy_constructible_v<_Iterator>
384 && is_nothrow_copy_constructible_v<_Iter2>
385 && noexcept(ranges::iter_swap(--std::declval<_Iterator&>(),
386 --std::declval<_Iter2&>())))
388 auto __xtmp = __x.base();
389 auto __ytmp = __y.base();
390 ranges::iter_swap(--__xtmp, --__ytmp);
395 template<
typename _Tp>
396 static _GLIBCXX17_CONSTEXPR _Tp*
397 _S_to_pointer(_Tp* __p)
400 template<
typename _Tp>
401 static _GLIBCXX17_CONSTEXPR pointer
402 _S_to_pointer(_Tp __t)
403 {
return __t.operator->(); }
416 #if __cplusplus <= 201703L || ! defined __cpp_lib_concepts 417 template<
typename _Iterator>
418 inline _GLIBCXX17_CONSTEXPR
bool 421 {
return __x.
base() == __y.
base(); }
423 template<
typename _Iterator>
424 inline _GLIBCXX17_CONSTEXPR
bool 425 operator<(const reverse_iterator<_Iterator>& __x,
426 const reverse_iterator<_Iterator>& __y)
427 {
return __y.base() < __x.base(); }
429 template<
typename _Iterator>
430 inline _GLIBCXX17_CONSTEXPR
bool 431 operator!=(
const reverse_iterator<_Iterator>& __x,
432 const reverse_iterator<_Iterator>& __y)
433 {
return !(__x == __y); }
435 template<
typename _Iterator>
436 inline _GLIBCXX17_CONSTEXPR
bool 437 operator>(
const reverse_iterator<_Iterator>& __x,
438 const reverse_iterator<_Iterator>& __y)
439 {
return __y < __x; }
441 template<
typename _Iterator>
442 inline _GLIBCXX17_CONSTEXPR
bool 443 operator<=(const reverse_iterator<_Iterator>& __x,
444 const reverse_iterator<_Iterator>& __y)
445 {
return !(__y < __x); }
447 template<
typename _Iterator>
448 inline _GLIBCXX17_CONSTEXPR
bool 449 operator>=(
const reverse_iterator<_Iterator>& __x,
450 const reverse_iterator<_Iterator>& __y)
451 {
return !(__x < __y); }
456 template<
typename _IteratorL,
typename _IteratorR>
457 inline _GLIBCXX17_CONSTEXPR
bool 458 operator==(
const reverse_iterator<_IteratorL>& __x,
459 const reverse_iterator<_IteratorR>& __y)
460 {
return __x.base() == __y.base(); }
462 template<
typename _IteratorL,
typename _IteratorR>
463 inline _GLIBCXX17_CONSTEXPR
bool 464 operator<(const reverse_iterator<_IteratorL>& __x,
465 const reverse_iterator<_IteratorR>& __y)
466 {
return __x.base() > __y.base(); }
468 template<
typename _IteratorL,
typename _IteratorR>
469 inline _GLIBCXX17_CONSTEXPR
bool 470 operator!=(
const reverse_iterator<_IteratorL>& __x,
471 const reverse_iterator<_IteratorR>& __y)
472 {
return __x.base() != __y.base(); }
474 template<
typename _IteratorL,
typename _IteratorR>
475 inline _GLIBCXX17_CONSTEXPR
bool 476 operator>(
const reverse_iterator<_IteratorL>& __x,
477 const reverse_iterator<_IteratorR>& __y)
478 {
return __x.base() < __y.base(); }
480 template<
typename _IteratorL,
typename _IteratorR>
481 inline _GLIBCXX17_CONSTEXPR
bool 482 operator<=(const reverse_iterator<_IteratorL>& __x,
483 const reverse_iterator<_IteratorR>& __y)
484 {
return __x.base() >= __y.base(); }
486 template<
typename _IteratorL,
typename _IteratorR>
487 inline _GLIBCXX17_CONSTEXPR
bool 488 operator>=(
const reverse_iterator<_IteratorL>& __x,
489 const reverse_iterator<_IteratorR>& __y)
490 {
return __x.base() <= __y.base(); }
492 template<
typename _IteratorL,
typename _IteratorR>
494 operator==(
const reverse_iterator<_IteratorL>& __x,
495 const reverse_iterator<_IteratorR>& __y)
496 requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
497 {
return __x.base() == __y.base(); }
499 template<
typename _IteratorL,
typename _IteratorR>
501 operator!=(
const reverse_iterator<_IteratorL>& __x,
502 const reverse_iterator<_IteratorR>& __y)
503 requires requires { { __x.base() != __y.base() } -> convertible_to<bool>; }
504 {
return __x.base() != __y.base(); }
506 template<
typename _IteratorL,
typename _IteratorR>
508 operator<(const reverse_iterator<_IteratorL>& __x,
509 const reverse_iterator<_IteratorR>& __y)
510 requires requires { { __x.base() > __y.base() } -> convertible_to<bool>; }
511 {
return __x.base() > __y.base(); }
513 template<
typename _IteratorL,
typename _IteratorR>
515 operator>(
const reverse_iterator<_IteratorL>& __x,
516 const reverse_iterator<_IteratorR>& __y)
517 requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
518 {
return __x.base() < __y.base(); }
520 template<
typename _IteratorL,
typename _IteratorR>
522 operator<=(const reverse_iterator<_IteratorL>& __x,
523 const reverse_iterator<_IteratorR>& __y)
524 requires requires { { __x.base() >= __y.base() } -> convertible_to<bool>; }
525 {
return __x.base() >= __y.base(); }
527 template<
typename _IteratorL,
typename _IteratorR>
529 operator>=(
const reverse_iterator<_IteratorL>& __x,
530 const reverse_iterator<_IteratorR>& __y)
531 requires requires { { __x.base() <= __y.base() } -> convertible_to<bool>; }
532 {
return __x.base() <= __y.base(); }
534 template<
typename _IteratorL,
535 three_way_comparable_with<_IteratorL> _IteratorR>
536 constexpr compare_three_way_result_t<_IteratorL, _IteratorR>
537 operator<=>(
const reverse_iterator<_IteratorL>& __x,
538 const reverse_iterator<_IteratorR>& __y)
539 {
return __y.base() <=> __x.base(); }
543 #if __cplusplus < 201103L 544 template<
typename _Iterator>
545 inline typename reverse_iterator<_Iterator>::difference_type
546 operator-(
const reverse_iterator<_Iterator>& __x,
547 const reverse_iterator<_Iterator>& __y)
548 {
return __y.base() - __x.base(); }
550 template<
typename _IteratorL,
typename _IteratorR>
551 inline typename reverse_iterator<_IteratorL>::difference_type
552 operator-(
const reverse_iterator<_IteratorL>& __x,
553 const reverse_iterator<_IteratorR>& __y)
554 {
return __y.base() - __x.base(); }
558 template<
typename _IteratorL,
typename _IteratorR>
559 inline _GLIBCXX17_CONSTEXPR
auto 560 operator-(
const reverse_iterator<_IteratorL>& __x,
561 const reverse_iterator<_IteratorR>& __y)
562 -> decltype(__y.base() - __x.base())
563 {
return __y.base() - __x.base(); }
566 template<
typename _Iterator>
567 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
568 operator+(
typename reverse_iterator<_Iterator>::difference_type __n,
569 const reverse_iterator<_Iterator>& __x)
570 {
return reverse_iterator<_Iterator>(__x.base() - __n); }
572 #if __cplusplus >= 201103L 574 template<
typename _Iterator>
575 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
576 __make_reverse_iterator(_Iterator __i)
577 {
return reverse_iterator<_Iterator>(__i); }
579 # if __cplusplus >= 201402L 580 # define __cpp_lib_make_reverse_iterator 201402 585 template<
typename _Iterator>
586 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
590 # if __cplusplus > 201703L && defined __cpp_lib_concepts 591 template<
typename _Iterator1,
typename _Iterator2>
592 requires (!sized_sentinel_for<_Iterator1, _Iterator2>)
593 inline constexpr
bool 594 disable_sized_sentinel_for<reverse_iterator<_Iterator1>,
595 reverse_iterator<_Iterator2>> =
true;
599 template<
typename _Iterator>
602 __niter_base(reverse_iterator<_Iterator> __it)
603 -> decltype(__make_reverse_iterator(__niter_base(__it.base())))
604 {
return __make_reverse_iterator(__niter_base(__it.base())); }
606 template<
typename _Iterator>
607 struct __is_move_iterator<reverse_iterator<_Iterator> >
608 : __is_move_iterator<_Iterator>
611 template<
typename _Iterator>
614 __miter_base(reverse_iterator<_Iterator> __it)
615 -> decltype(__make_reverse_iterator(__miter_base(__it.base())))
616 {
return __make_reverse_iterator(__miter_base(__it.base())); }
630 template<
typename _Container>
632 :
public iterator<output_iterator_tag, void, void, void, void>
635 _Container* container;
640 #if __cplusplus > 201703L 647 explicit _GLIBCXX20_CONSTEXPR
662 #if __cplusplus < 201103L 664 operator=(
typename _Container::const_reference __value)
666 container->push_back(__value);
672 operator=(
const typename _Container::value_type& __value)
674 container->push_back(__value);
680 operator=(
typename _Container::value_type&& __value)
682 container->push_back(
std::move(__value));
717 template<
typename _Container>
719 inline back_insert_iterator<_Container>
733 template<
typename _Container>
735 :
public iterator<output_iterator_tag, void, void, void, void>
738 _Container* container;
743 #if __cplusplus > 201703L 750 explicit _GLIBCXX20_CONSTEXPR
765 #if __cplusplus < 201103L 767 operator=(
typename _Container::const_reference __value)
769 container->push_front(__value);
775 operator=(
const typename _Container::value_type& __value)
777 container->push_front(__value);
783 operator=(
typename _Container::value_type&& __value)
785 container->push_front(
std::move(__value));
820 template<
typename _Container>
822 inline front_insert_iterator<_Container>
840 template<
typename _Container>
842 :
public iterator<output_iterator_tag, void, void, void, void>
844 #if __cplusplus > 201703L && defined __cpp_lib_concepts 845 using _Iter = std::__detail::__range_iter_t<_Container>;
848 _Container* container =
nullptr;
849 _Iter iter = _Iter();
851 typedef typename _Container::iterator _Iter;
854 _Container* container;
862 #if __cplusplus > 201703L && defined __cpp_lib_concepts 899 #if __cplusplus < 201103L 901 operator=(
typename _Container::const_reference __value)
903 iter = container->insert(iter, __value);
910 operator=(
const typename _Container::value_type& __value)
912 iter = container->insert(iter, __value);
919 operator=(
typename _Container::value_type&& __value)
921 iter = container->insert(iter,
std::move(__value));
958 #if __cplusplus > 201703L && defined __cpp_lib_concepts 959 template<
typename _Container>
960 constexpr insert_iterator<_Container>
961 inserter(_Container& __x, std::__detail::__range_iter_t<_Container> __i)
962 {
return insert_iterator<_Container>(__x, __i); }
964 template<
typename _Container>
965 inline insert_iterator<_Container>
966 inserter(_Container& __x,
typename _Container::iterator __i)
972 _GLIBCXX_END_NAMESPACE_VERSION
975 namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
977 _GLIBCXX_BEGIN_NAMESPACE_VERSION
986 template<
typename _Iterator,
typename _Container>
987 class __normal_iterator
990 _Iterator _M_current;
995 typedef _Iterator iterator_type;
996 typedef typename __traits_type::iterator_category iterator_category;
997 typedef typename __traits_type::value_type value_type;
998 typedef typename __traits_type::difference_type difference_type;
999 typedef typename __traits_type::reference reference;
1000 typedef typename __traits_type::pointer pointer;
1002 #if __cplusplus > 201703L && __cpp_lib_concepts 1003 using iterator_concept = std::__detail::__iter_concept<_Iterator>;
1006 _GLIBCXX_CONSTEXPR __normal_iterator() _GLIBCXX_NOEXCEPT
1007 : _M_current(_Iterator()) { }
1009 explicit _GLIBCXX20_CONSTEXPR
1010 __normal_iterator(
const _Iterator& __i) _GLIBCXX_NOEXCEPT
1011 : _M_current(__i) { }
1014 template<
typename _Iter>
1015 _GLIBCXX20_CONSTEXPR
1016 __normal_iterator(
const __normal_iterator<_Iter,
1017 typename __enable_if<
1018 (std::__are_same<_Iter, typename _Container::pointer>::__value),
1019 _Container>::__type>& __i) _GLIBCXX_NOEXCEPT
1020 : _M_current(__i.base()) { }
1023 _GLIBCXX20_CONSTEXPR
1026 {
return *_M_current; }
1028 _GLIBCXX20_CONSTEXPR
1030 operator->() const _GLIBCXX_NOEXCEPT
1031 {
return _M_current; }
1033 _GLIBCXX20_CONSTEXPR
1035 operator++() _GLIBCXX_NOEXCEPT
1041 _GLIBCXX20_CONSTEXPR
1043 operator++(
int) _GLIBCXX_NOEXCEPT
1044 {
return __normal_iterator(_M_current++); }
1047 _GLIBCXX20_CONSTEXPR
1049 operator--() _GLIBCXX_NOEXCEPT
1055 _GLIBCXX20_CONSTEXPR
1057 operator--(
int) _GLIBCXX_NOEXCEPT
1058 {
return __normal_iterator(_M_current--); }
1061 _GLIBCXX20_CONSTEXPR
1063 operator[](difference_type __n)
const _GLIBCXX_NOEXCEPT
1064 {
return _M_current[__n]; }
1066 _GLIBCXX20_CONSTEXPR
1068 operator+=(difference_type __n) _GLIBCXX_NOEXCEPT
1069 { _M_current += __n;
return *
this; }
1071 _GLIBCXX20_CONSTEXPR
1073 operator+(difference_type __n)
const _GLIBCXX_NOEXCEPT
1074 {
return __normal_iterator(_M_current + __n); }
1076 _GLIBCXX20_CONSTEXPR
1078 operator-=(difference_type __n) _GLIBCXX_NOEXCEPT
1079 { _M_current -= __n;
return *
this; }
1081 _GLIBCXX20_CONSTEXPR
1083 operator-(difference_type __n)
const _GLIBCXX_NOEXCEPT
1084 {
return __normal_iterator(_M_current - __n); }
1086 _GLIBCXX20_CONSTEXPR
1088 base() const _GLIBCXX_NOEXCEPT
1089 {
return _M_current; }
1100 #if __cpp_lib_three_way_comparison 1101 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1102 requires requires (_IteratorL __lhs, _IteratorR __rhs)
1103 { { __lhs == __rhs } -> std::convertible_to<bool>; }
1105 operator==(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1106 const __normal_iterator<_IteratorR, _Container>& __rhs)
1107 noexcept(noexcept(__lhs.base() == __rhs.base()))
1108 {
return __lhs.base() == __rhs.base(); }
1110 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1111 constexpr std::__detail::__synth3way_t<_IteratorR, _IteratorL>
1112 operator<=>(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1113 const __normal_iterator<_IteratorR, _Container>& __rhs)
1114 noexcept(noexcept(std::__detail::__synth3way(__lhs.base(), __rhs.base())))
1115 {
return std::__detail::__synth3way(__lhs.base(), __rhs.base()); }
1118 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1119 _GLIBCXX20_CONSTEXPR
1121 operator==(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1122 const __normal_iterator<_IteratorR, _Container>& __rhs)
1124 {
return __lhs.base() == __rhs.base(); }
1126 template<
typename _Iterator,
typename _Container>
1127 _GLIBCXX20_CONSTEXPR
1129 operator==(
const __normal_iterator<_Iterator, _Container>& __lhs,
1130 const __normal_iterator<_Iterator, _Container>& __rhs)
1132 {
return __lhs.base() == __rhs.base(); }
1134 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1135 _GLIBCXX20_CONSTEXPR
1137 operator!=(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1138 const __normal_iterator<_IteratorR, _Container>& __rhs)
1140 {
return __lhs.base() != __rhs.base(); }
1142 template<
typename _Iterator,
typename _Container>
1143 _GLIBCXX20_CONSTEXPR
1145 operator!=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1146 const __normal_iterator<_Iterator, _Container>& __rhs)
1148 {
return __lhs.base() != __rhs.base(); }
1151 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1153 operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
1154 const __normal_iterator<_IteratorR, _Container>& __rhs)
1156 {
return __lhs.base() < __rhs.base(); }
1158 template<
typename _Iterator,
typename _Container>
1159 _GLIBCXX20_CONSTEXPR
1161 operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
1162 const __normal_iterator<_Iterator, _Container>& __rhs)
1164 {
return __lhs.base() < __rhs.base(); }
1166 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1168 operator>(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1169 const __normal_iterator<_IteratorR, _Container>& __rhs)
1171 {
return __lhs.base() > __rhs.base(); }
1173 template<
typename _Iterator,
typename _Container>
1174 _GLIBCXX20_CONSTEXPR
1176 operator>(
const __normal_iterator<_Iterator, _Container>& __lhs,
1177 const __normal_iterator<_Iterator, _Container>& __rhs)
1179 {
return __lhs.base() > __rhs.base(); }
1181 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1183 operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
1184 const __normal_iterator<_IteratorR, _Container>& __rhs)
1186 {
return __lhs.base() <= __rhs.base(); }
1188 template<
typename _Iterator,
typename _Container>
1189 _GLIBCXX20_CONSTEXPR
1191 operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
1192 const __normal_iterator<_Iterator, _Container>& __rhs)
1194 {
return __lhs.base() <= __rhs.base(); }
1196 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1198 operator>=(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1199 const __normal_iterator<_IteratorR, _Container>& __rhs)
1201 {
return __lhs.base() >= __rhs.base(); }
1203 template<
typename _Iterator,
typename _Container>
1204 _GLIBCXX20_CONSTEXPR
1206 operator>=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1207 const __normal_iterator<_Iterator, _Container>& __rhs)
1209 {
return __lhs.base() >= __rhs.base(); }
1210 #endif // three-way comparison 1216 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1217 #if __cplusplus >= 201103L 1219 _GLIBCXX20_CONSTEXPR
1221 operator-(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1222 const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept
1223 -> decltype(__lhs.base() - __rhs.base())
1225 inline typename __normal_iterator<_IteratorL, _Container>::difference_type
1226 operator-(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1227 const __normal_iterator<_IteratorR, _Container>& __rhs)
1229 {
return __lhs.base() - __rhs.base(); }
1231 template<
typename _Iterator,
typename _Container>
1232 _GLIBCXX20_CONSTEXPR
1233 inline typename __normal_iterator<_Iterator, _Container>::difference_type
1234 operator-(
const __normal_iterator<_Iterator, _Container>& __lhs,
1235 const __normal_iterator<_Iterator, _Container>& __rhs)
1237 {
return __lhs.base() - __rhs.base(); }
1239 template<
typename _Iterator,
typename _Container>
1240 _GLIBCXX20_CONSTEXPR
1241 inline __normal_iterator<_Iterator, _Container>
1242 operator+(
typename __normal_iterator<_Iterator, _Container>::difference_type
1243 __n,
const __normal_iterator<_Iterator, _Container>& __i)
1245 {
return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
1247 _GLIBCXX_END_NAMESPACE_VERSION
1250 namespace std _GLIBCXX_VISIBILITY(default)
1252 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1254 template<
typename _Iterator,
typename _Container>
1255 _GLIBCXX20_CONSTEXPR
1257 __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it)
1259 {
return __it.base(); }
1261 #if __cplusplus >= 201103L 1267 #if __cplusplus > 201703L && __cpp_lib_concepts 1268 template<semiregular _Sent>
1274 noexcept(is_nothrow_default_constructible_v<_Sent>)
1278 move_sentinel(_Sent __s)
1279 noexcept(is_nothrow_move_constructible_v<_Sent>)
1282 template<
typename _S2> requires convertible_to<const _S2&, _Sent>
1284 move_sentinel(
const move_sentinel<_S2>& __s)
1285 noexcept(is_nothrow_constructible_v<_Sent, const _S2&>)
1286 : _M_last(__s.base())
1289 template<
typename _S2> requires assignable_from<_Sent&, const _S2&>
1290 constexpr move_sentinel&
1291 operator=(
const move_sentinel<_S2>& __s)
1292 noexcept(is_nothrow_assignable_v<_Sent, const _S2&>)
1294 _M_last = __s.base();
1300 noexcept(is_nothrow_copy_constructible_v<_Sent>)
1310 #if __cplusplus > 201703L && __cpp_lib_concepts 1311 template<
typename _Iterator>
1312 struct __move_iter_cat
1315 template<
typename _Iterator>
1316 requires requires {
typename iterator_traits<_Iterator>::iterator_category; }
1317 struct __move_iter_cat<_Iterator>
1319 using iterator_category
1320 = __clamp_iter_cat<typename iterator_traits<_Iterator>::iterator_category,
1321 random_access_iterator_tag>;
1335 template<
typename _Iterator>
1337 #if __cplusplus > 201703L && __cpp_lib_concepts
1338 :
public __detail::__move_iter_cat<_Iterator>
1341 _Iterator _M_current;
1344 #if ! (__cplusplus > 201703L && __cpp_lib_concepts) 1345 using __base_ref =
typename __traits_type::reference;
1348 template<
typename _Iter2>
1351 #if __cpp_lib_concepts 1354 template<
typename _Iter2>
1355 static constexpr
bool __convertible = !is_same_v<_Iter2, _Iterator>
1356 && convertible_to<const _Iter2&, _Iterator>;
1360 using iterator_type = _Iterator;
1362 #if __cplusplus > 201703L && __cpp_lib_concepts 1365 using value_type = iter_value_t<_Iterator>;
1366 using difference_type = iter_difference_t<_Iterator>;
1367 using pointer = _Iterator;
1368 using reference = iter_rvalue_reference_t<_Iterator>;
1370 typedef typename __traits_type::iterator_category iterator_category;
1371 typedef typename __traits_type::value_type value_type;
1372 typedef typename __traits_type::difference_type difference_type;
1374 typedef _Iterator pointer;
1378 typename remove_reference<__base_ref>::type&&,
1382 _GLIBCXX17_CONSTEXPR
1386 explicit _GLIBCXX17_CONSTEXPR
1390 template<
typename _Iter>
1391 #if __cpp_lib_concepts 1392 requires __convertible<_Iter>
1394 _GLIBCXX17_CONSTEXPR
1396 : _M_current(__i._M_current) { }
1398 template<
typename _Iter>
1399 #if __cpp_lib_concepts 1400 requires __convertible<_Iter>
1401 && assignable_from<_Iterator&, const _Iter&>
1403 _GLIBCXX17_CONSTEXPR
1406 _M_current = __i._M_current;
1410 #if __cplusplus <= 201703L 1411 _GLIBCXX17_CONSTEXPR iterator_type
1413 {
return _M_current; }
1415 constexpr
const iterator_type&
1416 base()
const & noexcept
1417 {
return _M_current; }
1419 constexpr iterator_type
1426 #if __cplusplus > 201703L && __cpp_lib_concepts 1427 {
return ranges::iter_move(_M_current); }
1429 {
return static_cast<reference>(*_M_current); }
1432 _GLIBCXX17_CONSTEXPR pointer
1434 {
return _M_current; }
1451 #if __cpp_lib_concepts 1453 operator++(
int) requires (!forward_iterator<_Iterator>)
1477 operator+=(difference_type __n)
1488 operator-=(difference_type __n)
1495 operator[](difference_type __n)
const 1496 #if __cplusplus > 201703L && __cpp_lib_concepts 1497 {
return ranges::iter_move(_M_current + __n); }
1502 #if __cplusplus > 201703L && __cpp_lib_concepts 1503 template<sentinel_for<_Iterator> _Sent>
1504 friend constexpr
bool 1505 operator==(
const move_iterator& __x,
const move_sentinel<_Sent>& __y)
1506 {
return __x.base() == __y.base(); }
1508 template<sized_sentinel_for<_Iterator> _Sent>
1509 friend constexpr iter_difference_t<_Iterator>
1511 {
return __x.base() - __y.base(); }
1513 template<sized_sentinel_for<_Iterator> _Sent>
1514 friend constexpr iter_difference_t<_Iterator>
1516 {
return __x.base() - __y.base(); }
1518 friend constexpr iter_rvalue_reference_t<_Iterator>
1520 noexcept(noexcept(ranges::iter_move(__i._M_current)))
1521 {
return ranges::iter_move(__i._M_current); }
1523 template<indirectly_swappable<_Iterator> _Iter2>
1524 friend constexpr
void 1526 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1527 {
return ranges::iter_swap(__x._M_current, __y._M_current); }
1531 template<
typename _IteratorL,
typename _IteratorR>
1532 inline _GLIBCXX17_CONSTEXPR
bool 1535 #if __cplusplus > 201703L && __cpp_lib_concepts 1536 requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
1538 {
return __x.base() == __y.base(); }
1540 #if __cpp_lib_three_way_comparison 1541 template<
typename _IteratorL,
1542 three_way_comparable_with<_IteratorL> _IteratorR>
1543 constexpr compare_three_way_result_t<_IteratorL, _IteratorR>
1544 operator<=>(
const move_iterator<_IteratorL>& __x,
1545 const move_iterator<_IteratorR>& __y)
1546 {
return __x.base() <=> __y.base(); }
1548 template<
typename _IteratorL,
typename _IteratorR>
1549 inline _GLIBCXX17_CONSTEXPR
bool 1550 operator!=(
const move_iterator<_IteratorL>& __x,
1551 const move_iterator<_IteratorR>& __y)
1552 {
return !(__x == __y); }
1555 template<
typename _IteratorL,
typename _IteratorR>
1556 inline _GLIBCXX17_CONSTEXPR
bool 1557 operator<(const move_iterator<_IteratorL>& __x,
1558 const move_iterator<_IteratorR>& __y)
1559 #
if __cplusplus > 201703L && __cpp_lib_concepts
1560 requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
1562 {
return __x.base() < __y.base(); }
1564 template<
typename _IteratorL,
typename _IteratorR>
1565 inline _GLIBCXX17_CONSTEXPR
bool 1566 operator<=(const move_iterator<_IteratorL>& __x,
1567 const move_iterator<_IteratorR>& __y)
1568 #
if __cplusplus > 201703L && __cpp_lib_concepts
1569 requires requires { { __y.base() < __x.base() } -> convertible_to<bool>; }
1571 {
return !(__y < __x); }
1573 template<
typename _IteratorL,
typename _IteratorR>
1574 inline _GLIBCXX17_CONSTEXPR
bool 1575 operator>(
const move_iterator<_IteratorL>& __x,
1576 const move_iterator<_IteratorR>& __y)
1577 #if __cplusplus > 201703L && __cpp_lib_concepts 1578 requires requires { { __y.base() < __x.base() } -> convertible_to<bool>; }
1580 {
return __y < __x; }
1582 template<
typename _IteratorL,
typename _IteratorR>
1583 inline _GLIBCXX17_CONSTEXPR
bool 1584 operator>=(
const move_iterator<_IteratorL>& __x,
1585 const move_iterator<_IteratorR>& __y)
1586 #if __cplusplus > 201703L && __cpp_lib_concepts 1587 requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
1589 {
return !(__x < __y); }
1591 #if ! (__cplusplus > 201703L && __cpp_lib_concepts) 1599 template<
typename _Iterator>
1600 inline _GLIBCXX17_CONSTEXPR
bool 1601 operator==(
const move_iterator<_Iterator>& __x,
1602 const move_iterator<_Iterator>& __y)
1603 {
return __x.base() == __y.base(); }
1605 template<
typename _Iterator>
1606 inline _GLIBCXX17_CONSTEXPR
bool 1607 operator!=(
const move_iterator<_Iterator>& __x,
1608 const move_iterator<_Iterator>& __y)
1609 {
return !(__x == __y); }
1611 template<
typename _Iterator>
1612 inline _GLIBCXX17_CONSTEXPR
bool 1613 operator<(const move_iterator<_Iterator>& __x,
1614 const move_iterator<_Iterator>& __y)
1615 {
return __x.base() < __y.base(); }
1617 template<
typename _Iterator>
1618 inline _GLIBCXX17_CONSTEXPR
bool 1619 operator<=(const move_iterator<_Iterator>& __x,
1620 const move_iterator<_Iterator>& __y)
1621 {
return !(__y < __x); }
1623 template<
typename _Iterator>
1624 inline _GLIBCXX17_CONSTEXPR
bool 1625 operator>(
const move_iterator<_Iterator>& __x,
1626 const move_iterator<_Iterator>& __y)
1627 {
return __y < __x; }
1629 template<
typename _Iterator>
1630 inline _GLIBCXX17_CONSTEXPR
bool 1631 operator>=(
const move_iterator<_Iterator>& __x,
1632 const move_iterator<_Iterator>& __y)
1633 {
return !(__x < __y); }
1637 template<
typename _IteratorL,
typename _IteratorR>
1638 inline _GLIBCXX17_CONSTEXPR
auto 1639 operator-(
const move_iterator<_IteratorL>& __x,
1640 const move_iterator<_IteratorR>& __y)
1641 -> decltype(__x.base() - __y.base())
1642 {
return __x.base() - __y.base(); }
1644 template<
typename _Iterator>
1645 inline _GLIBCXX17_CONSTEXPR move_iterator<_Iterator>
1646 operator+(
typename move_iterator<_Iterator>::difference_type __n,
1647 const move_iterator<_Iterator>& __x)
1648 {
return __x + __n; }
1650 template<
typename _Iterator>
1651 inline _GLIBCXX17_CONSTEXPR move_iterator<_Iterator>
1652 make_move_iterator(_Iterator __i)
1653 {
return move_iterator<_Iterator>(
std::move(__i)); }
1655 template<
typename _Iterator,
typename _ReturnType
1656 =
typename conditional<__move_if_noexcept_cond
1657 <
typename iterator_traits<_Iterator>::value_type>::value,
1658 _Iterator, move_iterator<_Iterator>>::type>
1659 inline _GLIBCXX17_CONSTEXPR _ReturnType
1660 __make_move_if_noexcept_iterator(_Iterator __i)
1661 {
return _ReturnType(__i); }
1665 template<
typename _Tp,
typename _ReturnType
1666 =
typename conditional<__move_if_noexcept_cond<_Tp>::value,
1667 const _Tp*, move_iterator<_Tp*>>::type>
1668 inline _GLIBCXX17_CONSTEXPR _ReturnType
1669 __make_move_if_noexcept_iterator(_Tp* __i)
1670 {
return _ReturnType(__i); }
1672 #if __cplusplus > 201703L && __cpp_lib_concepts 1677 template<
typename _It>
1678 concept __common_iter_has_arrow = indirectly_readable<const _It>
1679 && (requires(
const _It& __it) { __it.operator->(); }
1680 || is_reference_v<iter_reference_t<_It>>
1681 || constructible_from<iter_value_t<_It>, iter_reference_t<_It>>);
1683 template<
typename _It>
1684 concept __common_iter_use_postfix_proxy
1685 = (!requires (_It& __i) { { *__i++ } -> __can_reference; })
1686 && constructible_from<iter_value_t<_It>, iter_reference_t<_It>>
1687 && move_constructible<iter_value_t<_It>>;
1691 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
1692 requires (!same_as<_It, _Sent>) && copyable<_It>
1693 class common_iterator
1695 template<
typename _Tp,
typename _Up>
1696 static constexpr
bool 1699 if constexpr (is_trivially_default_constructible_v<_Tp>)
1700 return is_nothrow_assignable_v<_Tp, _Up>;
1702 return is_nothrow_constructible_v<_Tp, _Up>;
1705 template<
typename _It2,
typename _Sent2>
1706 static constexpr
bool 1708 {
return _S_noexcept1<_It, _It2>() && _S_noexcept1<_Sent, _Sent2>(); }
1712 iter_value_t<_It> _M_keep;
1714 __arrow_proxy(iter_reference_t<_It>&& __x)
1717 friend class common_iterator;
1720 const iter_value_t<_It>*
1725 class __postfix_proxy
1727 iter_value_t<_It> _M_keep;
1729 __postfix_proxy(iter_reference_t<_It>&& __x)
1730 : _M_keep(
std::
forward<iter_reference_t<_It>>(__x)) { }
1732 friend class common_iterator;
1735 const iter_value_t<_It>&
1743 noexcept(is_nothrow_default_constructible_v<_It>)
1744 : _M_it(), _M_index(0)
1748 common_iterator(_It __i)
1749 noexcept(is_nothrow_move_constructible_v<_It>)
1750 : _M_it(
std::
move(__i)), _M_index(0)
1754 common_iterator(_Sent __s)
1755 noexcept(is_nothrow_move_constructible_v<_Sent>)
1756 : _M_sent(
std::
move(__s)), _M_index(1)
1759 template<
typename _It2,
typename _Sent2>
1760 requires convertible_to<const _It2&, _It>
1761 && convertible_to<const _Sent2&, _Sent>
1763 common_iterator(
const common_iterator<_It2, _Sent2>& __x)
1764 noexcept(_S_noexcept<const _It2&, const _Sent2&>())
1765 : _M_valueless(), _M_index(__x._M_index)
1769 if constexpr (is_trivially_default_constructible_v<_It>)
1774 else if (_M_index == 1)
1776 if constexpr (is_trivially_default_constructible_v<_Sent>)
1784 common_iterator(
const common_iterator& __x)
1785 noexcept(_S_noexcept<const _It&, const _Sent&>())
1786 : _M_valueless(), _M_index(__x._M_index)
1790 if constexpr (is_trivially_default_constructible_v<_It>)
1795 else if (_M_index == 1)
1797 if constexpr (is_trivially_default_constructible_v<_Sent>)
1805 operator=(
const common_iterator& __x)
1806 noexcept(is_nothrow_copy_assignable_v<_It>
1807 && is_nothrow_copy_assignable_v<_Sent>
1808 && is_nothrow_copy_constructible_v<_It>
1809 && is_nothrow_copy_constructible_v<_Sent>)
1811 return this->
operator=<_It, _Sent>(__x);
1814 template<
typename _It2,
typename _Sent2>
1815 requires convertible_to<const _It2&, _It>
1816 && convertible_to<const _Sent2&, _Sent>
1817 && assignable_from<_It&, const _It2&>
1818 && assignable_from<_Sent&, const _Sent2&>
1820 operator=(
const common_iterator<_It2, _Sent2>& __x)
1821 noexcept(is_nothrow_constructible_v<_It, const _It2&>
1822 && is_nothrow_constructible_v<_Sent, const _Sent2&>
1823 && is_nothrow_assignable_v<_It, const _It2&>
1824 && is_nothrow_assignable_v<_Sent, const _Sent2&>)
1826 switch(_M_index << 2 | __x._M_index)
1832 _M_sent = __x._M_sent;
1851 __glibcxx_assert(__x._M_has_value());
1852 __builtin_unreachable();
1873 __glibcxx_assert(_M_index == 0);
1878 operator*() const requires
__detail::__dereferenceable<const _It>
1880 __glibcxx_assert(_M_index == 0);
1885 operator->() const requires
__detail::__common_iter_has_arrow<_It>
1887 __glibcxx_assert(_M_index == 0);
1888 if constexpr (is_pointer_v<_It> || requires { _M_it.operator->(); })
1890 else if constexpr (is_reference_v<iter_reference_t<_It>>)
1892 auto&& __tmp = *_M_it;
1896 return __arrow_proxy{*_M_it};
1902 __glibcxx_assert(_M_index == 0);
1910 __glibcxx_assert(_M_index == 0);
1911 if constexpr (forward_iterator<_It>)
1913 common_iterator __tmp = *
this;
1917 else if constexpr (!__detail::__common_iter_use_postfix_proxy<_It>)
1921 __postfix_proxy __p(**
this);
1927 template<
typename _It2, sentinel_for<_It> _Sent2>
1928 requires sentinel_for<_Sent, _It2>
1930 operator==(
const common_iterator& __x,
1931 const common_iterator<_It2, _Sent2>& __y)
1933 switch(__x._M_index << 2 | __y._M_index)
1939 return __x._M_it == __y._M_sent;
1941 return __x._M_sent == __y._M_it;
1943 __glibcxx_assert(__x._M_has_value());
1944 __glibcxx_assert(__y._M_has_value());
1945 __builtin_unreachable();
1949 template<
typename _It2, sentinel_for<_It> _Sent2>
1950 requires sentinel_for<_Sent, _It2> && equality_comparable_with<_It, _It2>
1952 operator==(
const common_iterator& __x,
1953 const common_iterator<_It2, _Sent2>& __y)
1955 switch(__x._M_index << 2 | __y._M_index)
1960 return __x._M_it == __y._M_it;
1962 return __x._M_it == __y._M_sent;
1964 return __x._M_sent == __y._M_it;
1966 __glibcxx_assert(__x._M_has_value());
1967 __glibcxx_assert(__y._M_has_value());
1968 __builtin_unreachable();
1972 template<sized_sentinel_for<_It> _It2, sized_sentinel_for<_It> _Sent2>
1973 requires sized_sentinel_for<_Sent, _It2>
1974 friend iter_difference_t<_It2>
1976 const common_iterator<_It2, _Sent2>& __y)
1978 switch(__x._M_index << 2 | __y._M_index)
1983 return __x._M_it - __y._M_it;
1985 return __x._M_it - __y._M_sent;
1987 return __x._M_sent - __y._M_it;
1989 __glibcxx_assert(__x._M_has_value());
1990 __glibcxx_assert(__y._M_has_value());
1991 __builtin_unreachable();
1995 friend iter_rvalue_reference_t<_It>
1996 iter_move(
const common_iterator& __i)
1997 noexcept(noexcept(ranges::iter_move(std::declval<const _It&>())))
1998 requires input_iterator<_It>
2000 __glibcxx_assert(__i._M_index == 0);
2001 return ranges::iter_move(__i._M_it);
2004 template<indirectly_swappable<_It> _It2,
typename _Sent2>
2006 iter_swap(
const common_iterator& __x,
2007 const common_iterator<_It2, _Sent2>& __y)
2008 noexcept(noexcept(ranges::iter_swap(std::declval<const _It&>(),
2009 std::declval<const _It2&>())))
2011 __glibcxx_assert(__x._M_index == 0);
2012 __glibcxx_assert(__y._M_index == 0);
2013 return ranges::iter_swap(__x._M_it, __y._M_it);
2017 template<input_or_output_iterator _It2, sentinel_for<_It2> _Sent2>
2018 friend class common_iterator;
2020 bool _M_has_value() const noexcept {
return _M_index < 2; }
2026 unsigned char _M_valueless;
2028 unsigned char _M_index;
2031 template<
typename _It,
typename _Sent>
2032 struct incrementable_traits<common_iterator<_It, _Sent>>
2034 using difference_type = iter_difference_t<_It>;
2037 template<input_iterator _It,
typename _Sent>
2038 struct iterator_traits<common_iterator<_It, _Sent>>
2041 template<
typename _Iter>
2047 template<
typename _Iter>
2048 requires __detail::__common_iter_has_arrow<_Iter>
2051 using _CIter = common_iterator<_Iter, _Sent>;
2052 using type = decltype(std::declval<const _CIter&>().operator->());
2058 using _Traits = iterator_traits<_It>;
2059 if constexpr (requires { requires derived_from<
typename _Traits::iterator_category,
2060 forward_iterator_tag>; })
2061 return forward_iterator_tag{};
2063 return input_iterator_tag{};
2067 using iterator_concept = conditional_t<forward_iterator<_It>,
2068 forward_iterator_tag, input_iterator_tag>;
2069 using iterator_category = decltype(_S_iter_cat());
2070 using value_type = iter_value_t<_It>;
2071 using difference_type = iter_difference_t<_It>;
2072 using pointer =
typename __ptr<_It>::type;
2073 using reference = iter_reference_t<_It>;
2080 template<
typename _It>
2081 struct __counted_iter_value_type
2084 template<indirectly_readable _It>
2085 struct __counted_iter_value_type<_It>
2086 {
using value_type = iter_value_t<_It>; };
2088 template<
typename _It>
2089 struct __counted_iter_concept
2092 template<
typename _It>
2093 requires requires {
typename _It::iterator_concept; }
2094 struct __counted_iter_concept<_It>
2095 {
using iterator_concept =
typename _It::iterator_concept; };
2097 template<
typename _It>
2098 struct __counted_iter_cat
2101 template<
typename _It>
2102 requires requires {
typename _It::iterator_category; }
2103 struct __counted_iter_cat<_It>
2104 {
using iterator_category =
typename _It::iterator_category; };
2108 template<input_or_output_iterator _It>
2109 class counted_iterator
2110 :
public __detail::__counted_iter_value_type<_It>,
2111 public __detail::__counted_iter_concept<_It>,
2112 public __detail::__counted_iter_cat<_It>
2115 using iterator_type = _It;
2117 using difference_type = iter_difference_t<_It>;
2121 constexpr counted_iterator() =
default;
2124 counted_iterator(_It __i, iter_difference_t<_It> __n)
2125 : _M_current(
std::
move(__i)), _M_length(__n)
2126 { __glibcxx_assert(__n >= 0); }
2128 template<
typename _It2>
2129 requires convertible_to<const _It2&, _It>
2131 counted_iterator(
const counted_iterator<_It2>& __x)
2132 : _M_current(__x._M_current), _M_length(__x._M_length)
2135 template<
typename _It2>
2136 requires assignable_from<_It&, const _It2&>
2137 constexpr counted_iterator&
2138 operator=(
const counted_iterator<_It2>& __x)
2140 _M_current = __x._M_current;
2141 _M_length = __x._M_length;
2145 constexpr
const _It&
2146 base() const & noexcept
2147 {
return _M_current; }
2151 noexcept(is_nothrow_move_constructible_v<_It>)
2154 constexpr iter_difference_t<_It>
2155 count() const noexcept {
return _M_length; }
2157 constexpr decltype(
auto)
2159 noexcept(noexcept(*_M_current))
2161 __glibcxx_assert( _M_length > 0 );
2165 constexpr decltype(
auto)
2167 noexcept(noexcept(*_M_current))
2168 requires
__detail::__dereferenceable<const _It>
2170 __glibcxx_assert( _M_length > 0 );
2175 operator->() const noexcept
2176 requires contiguous_iterator<_It>
2177 {
return std::to_address(_M_current); }
2179 constexpr counted_iterator&
2182 __glibcxx_assert(_M_length > 0);
2191 __glibcxx_assert(_M_length > 0);
2195 return _M_current++;
2198 __throw_exception_again;
2203 constexpr counted_iterator
2204 operator++(
int) requires forward_iterator<_It>
2211 constexpr counted_iterator&
2212 operator--() requires bidirectional_iterator<_It>
2219 constexpr counted_iterator
2220 operator--(
int) requires bidirectional_iterator<_It>
2227 constexpr counted_iterator
2228 operator+(iter_difference_t<_It> __n)
const 2229 requires random_access_iterator<_It>
2230 {
return counted_iterator(_M_current + __n, _M_length - __n); }
2232 friend constexpr counted_iterator
2233 operator+(iter_difference_t<_It> __n,
const counted_iterator& __x)
2234 requires random_access_iterator<_It>
2235 {
return __x + __n; }
2237 constexpr counted_iterator&
2238 operator+=(iter_difference_t<_It> __n)
2239 requires random_access_iterator<_It>
2241 __glibcxx_assert(__n <= _M_length);
2247 constexpr counted_iterator
2248 operator-(iter_difference_t<_It> __n)
const 2249 requires random_access_iterator<_It>
2250 {
return counted_iterator(_M_current - __n, _M_length + __n); }
2252 template<common_with<_It> _It2>
2253 friend constexpr iter_difference_t<_It2>
2255 const counted_iterator<_It2>& __y)
2256 {
return __y._M_length - __x._M_length; }
2258 friend constexpr iter_difference_t<_It>
2259 operator-(
const counted_iterator& __x, default_sentinel_t)
2260 {
return -__x._M_length; }
2262 friend constexpr iter_difference_t<_It>
2263 operator-(default_sentinel_t,
const counted_iterator& __y)
2264 {
return __y._M_length; }
2266 constexpr counted_iterator&
2267 operator-=(iter_difference_t<_It> __n)
2268 requires random_access_iterator<_It>
2270 __glibcxx_assert(-__n <= _M_length);
2276 constexpr decltype(
auto)
2277 operator[](iter_difference_t<_It> __n) const
2278 noexcept(noexcept(_M_current[__n]))
2279 requires random_access_iterator<_It>
2281 __glibcxx_assert(__n < _M_length);
2282 return _M_current[__n];
2285 template<common_with<_It> _It2>
2286 friend constexpr
bool 2287 operator==(
const counted_iterator& __x,
2288 const counted_iterator<_It2>& __y)
2289 {
return __x._M_length == __y._M_length; }
2291 friend constexpr
bool 2292 operator==(
const counted_iterator& __x, default_sentinel_t)
2293 {
return __x._M_length == 0; }
2295 template<common_with<_It> _It2>
2296 friend constexpr strong_ordering
2297 operator<=>(
const counted_iterator& __x,
2298 const counted_iterator<_It2>& __y)
2299 {
return __y._M_length <=> __x._M_length; }
2301 friend constexpr iter_rvalue_reference_t<_It>
2302 iter_move(
const counted_iterator& __i)
2303 noexcept(noexcept(ranges::iter_move(__i._M_current)))
2304 requires input_iterator<_It>
2306 __glibcxx_assert( __i._M_length > 0 );
2307 return ranges::iter_move(__i._M_current);
2310 template<indirectly_swappable<_It> _It2>
2311 friend constexpr
void 2312 iter_swap(
const counted_iterator& __x,
2313 const counted_iterator<_It2>& __y)
2314 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
2316 __glibcxx_assert( __x._M_length > 0 && __y._M_length > 0 );
2317 ranges::iter_swap(__x._M_current, __y._M_current);
2321 template<input_or_output_iterator _It2>
friend class counted_iterator;
2323 _It _M_current = _It();
2324 iter_difference_t<_It> _M_length = 0;
2327 template<input_iterator _It>
2328 requires same_as<__detail::__iter_traits<_It>, iterator_traits<_It>>
2329 struct iterator_traits<counted_iterator<_It>> : iterator_traits<_It>
2331 using pointer = conditional_t<contiguous_iterator<_It>,
2332 add_pointer_t<iter_reference_t<_It>>,
2339 template<
typename _Iterator>
2341 __niter_base(move_iterator<_Iterator> __it)
2342 -> decltype(make_move_iterator(__niter_base(__it.base())))
2343 {
return make_move_iterator(__niter_base(__it.base())); }
2345 template<
typename _Iterator>
2346 struct __is_move_iterator<move_iterator<_Iterator> >
2348 enum { __value = 1 };
2349 typedef __true_type __type;
2352 template<
typename _Iterator>
2354 __miter_base(move_iterator<_Iterator> __it)
2355 -> decltype(__miter_base(__it.base()))
2356 {
return __miter_base(__it.base()); }
2358 #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) std::make_move_iterator(_Iter) 2359 #define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) \ 2360 std::__make_move_if_noexcept_iterator(_Iter) 2362 #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) (_Iter) 2363 #define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) (_Iter) 2366 #if __cpp_deduction_guides >= 201606 2369 template<
typename _InputIterator>
2371 typename iterator_traits<_InputIterator>::value_type::first_type>;
2373 template<
typename _InputIterator>
2374 using __iter_val_t =
2375 typename iterator_traits<_InputIterator>::value_type::second_type;
2377 template<
typename _T1,
typename _T2>
2380 template<
typename _InputIterator>
2381 using __iter_to_alloc_t =
2382 pair<add_const_t<__iter_key_t<_InputIterator>>,
2383 __iter_val_t<_InputIterator>>;
2384 #endif // __cpp_deduction_guides 2386 _GLIBCXX_END_NAMESPACE_VERSION
2389 #ifdef _GLIBCXX_DEBUG constexpr back_insert_iterator & operator=(const typename _Container::value_type &__value)
constexpr front_insert_iterator & operator=(const typename _Container::value_type &__value)
constexpr reverse_iterator()
constexpr reference operator*() const
constexpr front_insert_iterator & operator*()
Simply returns *this.
constexpr insert_iterator & operator++(int)
Simply returns *this. (This iterator does not move.)
constexpr front_insert_iterator< _Container > front_inserter(_Container &__x)
Bidirectional iterators support a superset of forward iterator operations.
constexpr insert_iterator & operator++()
Simply returns *this. (This iterator does not move.)
constexpr reverse_iterator operator+(difference_type __n) const
Traits class for iterators.
constexpr reference operator[](difference_type __n) const
void difference_type
Distance between iterators is represented as this type.
constexpr _Tp && forward(typename std::remove_reference< _Tp >::type &__t) noexcept
Forward an lvalue.
constexpr back_insert_iterator(_Container &__x)
The only way to create this iterator is with a container.
Turns assignment into insertion.
constexpr back_insert_iterator & operator*()
Simply returns *this.
iterator_traits< _Iterator >::iterator_category iterator_category
One of the tag types.
_Container container_type
A nested typedef for the type of whatever container you used.
constexpr reverse_iterator & operator+=(difference_type __n)
constexpr insert_iterator & operator=(const typename _Container::value_type &__value)
constexpr complex< _Tp > operator-(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x minus y.
constexpr complex< _Tp > operator*(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x times y.
Turns assignment into insertion.
constexpr back_insert_iterator operator++(int)
Simply returns *this. (This iterator does not move.)
constexpr front_insert_iterator operator++(int)
Simply returns *this. (This iterator does not move.)
constexpr reverse_iterator operator--(int)
Struct holding two objects of arbitrary type.
constexpr reverse_iterator operator++(int)
_Container container_type
A nested typedef for the type of whatever container you used.
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
Random-access iterators support a superset of bidirectional iterator operations.
Define a member typedef type to one of two argument types.
GNU extensions for public use.
constexpr insert_iterator(_Container &__x, _Iter __i)
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
_Container container_type
A nested typedef for the type of whatever container you used.
constexpr reverse_iterator & operator-=(difference_type __n)
constexpr complex< _Tp > operator+(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x plus y.
constexpr reverse_iterator operator-(difference_type __n) const
constexpr back_insert_iterator & operator++()
Simply returns *this. (This iterator does not move.)
typename remove_const< _Tp >::type remove_const_t
Alias template for remove_const.
iterator_traits< _Iterator >::value_type value_type
The type "pointed to" by the iterator.
constexpr insert_iterator & operator*()
Simply returns *this.
constexpr iterator_type base() const
constexpr reverse_iterator & operator++()
insert_iterator< _Container > inserter(_Container &__x, typename _Container::iterator __i)
constexpr reverse_iterator(const reverse_iterator &__x)
typename conditional< _Cond, _Iftrue, _Iffalse >::type conditional_t
Alias template for conditional.
constexpr pointer operator->() const
constexpr reverse_iterator(const reverse_iterator< _Iter > &__x)
constexpr front_insert_iterator & operator++()
Simply returns *this. (This iterator does not move.)
Turns assignment into insertion.
constexpr time_point< _Clock, typename common_type< duration< _Rep1, _Period1 >, _Dur2 >::type > operator+(const duration< _Rep1, _Period1 > &__lhs, const time_point< _Clock, _Dur2 > &__rhs)
Adjust a time point forwards by the given duration.
is_nothrow_copy_constructible
constexpr common_type< duration< _Rep1, _Period1 >, duration< _Rep2, _Period2 > >::type operator-(const duration< _Rep1, _Period1 > &__lhs, const duration< _Rep2, _Period2 > &__rhs)
The difference between two durations.
ISO C++ entities toplevel namespace is std.
constexpr front_insert_iterator(_Container &__x)
The only way to create this iterator is with a container.
constexpr reverse_iterator(iterator_type __x)
constexpr back_insert_iterator< _Container > back_inserter(_Container &__x)
constexpr duration< __common_rep_t< _Rep2, _Rep1 >, _Period > operator*(const _Rep1 &__s, const duration< _Rep2, _Period > &__d)
constexpr reverse_iterator< _Iterator > make_reverse_iterator(_Iterator __i)
Generator function for reverse_iterator.
constexpr reverse_iterator & operator--()