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 >= 202002L
88 namespace std _GLIBCXX_VISIBILITY(default)
90 _GLIBCXX_BEGIN_NAMESPACE_VERSION
97 #if __cpp_lib_concepts
102 template<
typename _Cat,
typename _Limit,
typename _Otherwise = _Cat>
103 using __clamp_iter_cat
104 = conditional_t<derived_from<_Cat, _Limit>, _Limit, _Otherwise>;
127 template<
typename _Iterator>
129 :
public iterator<typename iterator_traits<_Iterator>::iterator_category,
130 typename iterator_traits<_Iterator>::value_type,
131 typename iterator_traits<_Iterator>::difference_type,
132 typename iterator_traits<_Iterator>::pointer,
133 typename iterator_traits<_Iterator>::reference>
135 template<
typename _Iter>
138 #if __cpp_lib_concepts
141 template<
typename _Iter>
142 static constexpr
bool __convertible = !is_same_v<_Iter, _Iterator>
143 && convertible_to<const _Iter&, _Iterator>;
152 typedef _Iterator iterator_type;
153 typedef typename __traits_type::pointer pointer;
154 #if ! __cpp_lib_concepts
155 typedef typename __traits_type::difference_type difference_type;
156 typedef typename __traits_type::reference reference;
158 using iterator_concept
163 = __detail::__clamp_iter_cat<
typename __traits_type::iterator_category,
166 using difference_type = iter_difference_t<_Iterator>;
167 using reference = iter_reference_t<_Iterator>;
183 explicit _GLIBCXX17_CONSTEXPR
191 : current(__x.current) { }
193 #if __cplusplus >= 201103L
201 template<
typename _Iter>
202 #if __cpp_lib_concepts
203 requires __convertible<_Iter>
207 : current(__x.current) { }
209 #if __cplusplus >= 201103L
210 template<
typename _Iter>
211 #if __cpp_lib_concepts
212 requires __convertible<_Iter>
213 && assignable_from<_Iterator&, const _Iter&>
219 current = __x.current;
227 _GLIBCXX17_CONSTEXPR iterator_type
241 _GLIBCXX17_CONSTEXPR reference
244 _Iterator __tmp = current;
253 _GLIBCXX17_CONSTEXPR pointer
255 #if __cplusplus > 201703L && __cpp_concepts >= 201907L
256 requires is_pointer_v<_Iterator>
257 || requires(
const _Iterator __i) { __i.operator->(); }
262 _Iterator __tmp = current;
264 return _S_to_pointer(__tmp);
272 _GLIBCXX17_CONSTEXPR reverse_iterator&
366 _GLIBCXX17_CONSTEXPR reference
368 {
return *(*
this + __n); }
370 #if __cplusplus > 201703L && __cpp_lib_concepts
371 friend constexpr iter_rvalue_reference_t<_Iterator>
373 noexcept(is_nothrow_copy_constructible_v<_Iterator>
374 && noexcept(ranges::iter_move(--std::declval<_Iterator&>())))
376 auto __tmp = __i.base();
377 return ranges::iter_move(--__tmp);
380 template<indirectly_swappable<_Iterator> _Iter2>
381 friend constexpr
void
382 iter_swap(
const reverse_iterator& __x,
383 const reverse_iterator<_Iter2>& __y)
384 noexcept(is_nothrow_copy_constructible_v<_Iterator>
385 && is_nothrow_copy_constructible_v<_Iter2>
386 && noexcept(ranges::iter_swap(--std::declval<_Iterator&>(),
387 --std::declval<_Iter2&>())))
389 auto __xtmp = __x.base();
390 auto __ytmp = __y.base();
391 ranges::iter_swap(--__xtmp, --__ytmp);
396 template<
typename _Tp>
397 static _GLIBCXX17_CONSTEXPR _Tp*
398 _S_to_pointer(_Tp* __p)
401 template<
typename _Tp>
402 static _GLIBCXX17_CONSTEXPR pointer
403 _S_to_pointer(_Tp __t)
404 {
return __t.operator->(); }
417 #if __cplusplus <= 201703L || ! defined __cpp_lib_concepts
418 template<
typename _Iterator>
419 inline _GLIBCXX17_CONSTEXPR
bool
422 {
return __x.
base() == __y.
base(); }
424 template<
typename _Iterator>
425 inline _GLIBCXX17_CONSTEXPR
bool
426 operator<(
const reverse_iterator<_Iterator>& __x,
427 const reverse_iterator<_Iterator>& __y)
428 {
return __y.base() < __x.base(); }
430 template<
typename _Iterator>
431 inline _GLIBCXX17_CONSTEXPR
bool
432 operator!=(
const reverse_iterator<_Iterator>& __x,
433 const reverse_iterator<_Iterator>& __y)
434 {
return !(__x == __y); }
436 template<
typename _Iterator>
437 inline _GLIBCXX17_CONSTEXPR
bool
438 operator>(
const reverse_iterator<_Iterator>& __x,
439 const reverse_iterator<_Iterator>& __y)
440 {
return __y < __x; }
442 template<
typename _Iterator>
443 inline _GLIBCXX17_CONSTEXPR
bool
444 operator<=(
const reverse_iterator<_Iterator>& __x,
445 const reverse_iterator<_Iterator>& __y)
446 {
return !(__y < __x); }
448 template<
typename _Iterator>
449 inline _GLIBCXX17_CONSTEXPR
bool
450 operator>=(
const reverse_iterator<_Iterator>& __x,
451 const reverse_iterator<_Iterator>& __y)
452 {
return !(__x < __y); }
457 template<
typename _IteratorL,
typename _IteratorR>
458 inline _GLIBCXX17_CONSTEXPR
bool
459 operator==(
const reverse_iterator<_IteratorL>& __x,
460 const reverse_iterator<_IteratorR>& __y)
461 {
return __x.base() == __y.base(); }
463 template<
typename _IteratorL,
typename _IteratorR>
464 inline _GLIBCXX17_CONSTEXPR
bool
465 operator<(
const reverse_iterator<_IteratorL>& __x,
466 const reverse_iterator<_IteratorR>& __y)
467 {
return __x.base() > __y.base(); }
469 template<
typename _IteratorL,
typename _IteratorR>
470 inline _GLIBCXX17_CONSTEXPR
bool
471 operator!=(
const reverse_iterator<_IteratorL>& __x,
472 const reverse_iterator<_IteratorR>& __y)
473 {
return __x.base() != __y.base(); }
475 template<
typename _IteratorL,
typename _IteratorR>
476 inline _GLIBCXX17_CONSTEXPR
bool
477 operator>(
const reverse_iterator<_IteratorL>& __x,
478 const reverse_iterator<_IteratorR>& __y)
479 {
return __x.base() < __y.base(); }
481 template<
typename _IteratorL,
typename _IteratorR>
482 inline _GLIBCXX17_CONSTEXPR
bool
483 operator<=(
const reverse_iterator<_IteratorL>& __x,
484 const reverse_iterator<_IteratorR>& __y)
485 {
return __x.base() >= __y.base(); }
487 template<
typename _IteratorL,
typename _IteratorR>
488 inline _GLIBCXX17_CONSTEXPR
bool
489 operator>=(
const reverse_iterator<_IteratorL>& __x,
490 const reverse_iterator<_IteratorR>& __y)
491 {
return __x.base() <= __y.base(); }
493 template<
typename _IteratorL,
typename _IteratorR>
495 operator==(
const reverse_iterator<_IteratorL>& __x,
496 const reverse_iterator<_IteratorR>& __y)
497 requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
498 {
return __x.base() == __y.base(); }
500 template<
typename _IteratorL,
typename _IteratorR>
502 operator!=(
const reverse_iterator<_IteratorL>& __x,
503 const reverse_iterator<_IteratorR>& __y)
504 requires requires { { __x.base() != __y.base() } -> convertible_to<bool>; }
505 {
return __x.base() != __y.base(); }
507 template<
typename _IteratorL,
typename _IteratorR>
509 operator<(
const reverse_iterator<_IteratorL>& __x,
510 const reverse_iterator<_IteratorR>& __y)
511 requires requires { { __x.base() > __y.base() } -> convertible_to<bool>; }
512 {
return __x.base() > __y.base(); }
514 template<
typename _IteratorL,
typename _IteratorR>
516 operator>(
const reverse_iterator<_IteratorL>& __x,
517 const reverse_iterator<_IteratorR>& __y)
518 requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
519 {
return __x.base() < __y.base(); }
521 template<
typename _IteratorL,
typename _IteratorR>
523 operator<=(
const reverse_iterator<_IteratorL>& __x,
524 const reverse_iterator<_IteratorR>& __y)
525 requires requires { { __x.base() >= __y.base() } -> convertible_to<bool>; }
526 {
return __x.base() >= __y.base(); }
528 template<
typename _IteratorL,
typename _IteratorR>
530 operator>=(
const reverse_iterator<_IteratorL>& __x,
531 const reverse_iterator<_IteratorR>& __y)
532 requires requires { { __x.base() <= __y.base() } -> convertible_to<bool>; }
533 {
return __x.base() <= __y.base(); }
535 template<
typename _IteratorL,
536 three_way_comparable_with<_IteratorL> _IteratorR>
537 constexpr compare_three_way_result_t<_IteratorL, _IteratorR>
538 operator<=>(
const reverse_iterator<_IteratorL>& __x,
539 const reverse_iterator<_IteratorR>& __y)
540 {
return __y.base() <=> __x.base(); }
545 template<
typename _Iterator>
547 operator==(
const reverse_iterator<_Iterator>& __x,
548 const reverse_iterator<_Iterator>& __y)
549 requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
550 {
return __x.base() == __y.base(); }
552 template<three_way_comparable _Iterator>
553 constexpr compare_three_way_result_t<_Iterator, _Iterator>
554 operator<=>(
const reverse_iterator<_Iterator>& __x,
555 const reverse_iterator<_Iterator>& __y)
556 {
return __y.base() <=> __x.base(); }
560 #if __cplusplus < 201103L
561 template<
typename _Iterator>
562 inline typename reverse_iterator<_Iterator>::difference_type
563 operator-(
const reverse_iterator<_Iterator>& __x,
564 const reverse_iterator<_Iterator>& __y)
565 {
return __y.base() - __x.base(); }
567 template<
typename _IteratorL,
typename _IteratorR>
568 inline typename reverse_iterator<_IteratorL>::difference_type
569 operator-(
const reverse_iterator<_IteratorL>& __x,
570 const reverse_iterator<_IteratorR>& __y)
571 {
return __y.base() - __x.base(); }
575 template<
typename _IteratorL,
typename _IteratorR>
576 inline _GLIBCXX17_CONSTEXPR
auto
577 operator-(
const reverse_iterator<_IteratorL>& __x,
578 const reverse_iterator<_IteratorR>& __y)
579 -> decltype(__y.base() - __x.base())
580 {
return __y.base() - __x.base(); }
583 template<
typename _Iterator>
584 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
585 operator+(
typename reverse_iterator<_Iterator>::difference_type __n,
586 const reverse_iterator<_Iterator>& __x)
587 {
return reverse_iterator<_Iterator>(__x.base() - __n); }
589 #if __cplusplus >= 201103L
591 template<
typename _Iterator>
592 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
593 __make_reverse_iterator(_Iterator __i)
594 {
return reverse_iterator<_Iterator>(__i); }
596 # if __cplusplus >= 201402L
597 # define __cpp_lib_make_reverse_iterator 201402
602 template<
typename _Iterator>
603 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
607 # if __cplusplus > 201703L && defined __cpp_lib_concepts
608 template<
typename _Iterator1,
typename _Iterator2>
609 requires (!sized_sentinel_for<_Iterator1, _Iterator2>)
610 inline constexpr
bool
611 disable_sized_sentinel_for<reverse_iterator<_Iterator1>,
612 reverse_iterator<_Iterator2>> =
true;
616 template<
typename _Iterator>
619 __niter_base(reverse_iterator<_Iterator> __it)
620 -> decltype(__make_reverse_iterator(__niter_base(__it.base())))
621 {
return __make_reverse_iterator(__niter_base(__it.base())); }
623 template<
typename _Iterator>
624 struct __is_move_iterator<reverse_iterator<_Iterator> >
625 : __is_move_iterator<_Iterator>
628 template<
typename _Iterator>
631 __miter_base(reverse_iterator<_Iterator> __it)
632 -> decltype(__make_reverse_iterator(__miter_base(__it.base())))
633 {
return __make_reverse_iterator(__miter_base(__it.base())); }
647 template<
typename _Container>
649 :
public iterator<output_iterator_tag, void, void, void, void>
652 _Container* container;
657 #if __cplusplus > 201703L
664 explicit _GLIBCXX20_CONSTEXPR
679 #if __cplusplus < 201103L
681 operator=(
typename _Container::const_reference __value)
683 container->push_back(__value);
689 operator=(
const typename _Container::value_type& __value)
691 container->push_back(__value);
697 operator=(
typename _Container::value_type&& __value)
699 container->push_back(
std::move(__value));
734 template<
typename _Container>
736 inline back_insert_iterator<_Container>
750 template<
typename _Container>
752 :
public iterator<output_iterator_tag, void, void, void, void>
755 _Container* container;
760 #if __cplusplus > 201703L
767 explicit _GLIBCXX20_CONSTEXPR
782 #if __cplusplus < 201103L
784 operator=(
typename _Container::const_reference __value)
786 container->push_front(__value);
792 operator=(
const typename _Container::value_type& __value)
794 container->push_front(__value);
800 operator=(
typename _Container::value_type&& __value)
802 container->push_front(
std::move(__value));
837 template<
typename _Container>
839 inline front_insert_iterator<_Container>
857 template<
typename _Container>
859 :
public iterator<output_iterator_tag, void, void, void, void>
861 #if __cplusplus > 201703L && defined __cpp_lib_concepts
862 using _Iter = std::__detail::__range_iter_t<_Container>;
865 _Container* container =
nullptr;
866 _Iter iter = _Iter();
868 typedef typename _Container::iterator _Iter;
871 _Container* container;
879 #if __cplusplus > 201703L && defined __cpp_lib_concepts
916 #if __cplusplus < 201103L
918 operator=(
typename _Container::const_reference __value)
920 iter = container->insert(iter, __value);
927 operator=(
const typename _Container::value_type& __value)
929 iter = container->insert(iter, __value);
936 operator=(
typename _Container::value_type&& __value)
938 iter = container->insert(iter,
std::move(__value));
975 #if __cplusplus > 201703L && defined __cpp_lib_concepts
976 template<
typename _Container>
977 constexpr insert_iterator<_Container>
978 inserter(_Container& __x, std::__detail::__range_iter_t<_Container> __i)
979 {
return insert_iterator<_Container>(__x, __i); }
981 template<
typename _Container>
982 inline insert_iterator<_Container>
983 inserter(_Container& __x,
typename _Container::iterator __i)
989 _GLIBCXX_END_NAMESPACE_VERSION
992 namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
994 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1003 template<
typename _Iterator,
typename _Container>
1004 class __normal_iterator
1007 _Iterator _M_current;
1012 typedef _Iterator iterator_type;
1013 typedef typename __traits_type::iterator_category iterator_category;
1014 typedef typename __traits_type::value_type value_type;
1015 typedef typename __traits_type::difference_type difference_type;
1016 typedef typename __traits_type::reference reference;
1017 typedef typename __traits_type::pointer pointer;
1019 #if __cplusplus > 201703L && __cpp_lib_concepts
1020 using iterator_concept = std::__detail::__iter_concept<_Iterator>;
1023 _GLIBCXX_CONSTEXPR __normal_iterator() _GLIBCXX_NOEXCEPT
1024 : _M_current(_Iterator()) { }
1026 explicit _GLIBCXX20_CONSTEXPR
1027 __normal_iterator(
const _Iterator& __i) _GLIBCXX_NOEXCEPT
1028 : _M_current(__i) { }
1031 template<
typename _Iter>
1032 _GLIBCXX20_CONSTEXPR
1033 __normal_iterator(
const __normal_iterator<_Iter,
1034 typename __enable_if<
1035 (std::__are_same<_Iter, typename _Container::pointer>::__value),
1036 _Container>::__type>& __i) _GLIBCXX_NOEXCEPT
1037 : _M_current(__i.base()) { }
1040 _GLIBCXX20_CONSTEXPR
1043 {
return *_M_current; }
1045 _GLIBCXX20_CONSTEXPR
1047 operator->() const _GLIBCXX_NOEXCEPT
1048 {
return _M_current; }
1050 _GLIBCXX20_CONSTEXPR
1052 operator++() _GLIBCXX_NOEXCEPT
1058 _GLIBCXX20_CONSTEXPR
1060 operator++(
int) _GLIBCXX_NOEXCEPT
1061 {
return __normal_iterator(_M_current++); }
1064 _GLIBCXX20_CONSTEXPR
1066 operator--() _GLIBCXX_NOEXCEPT
1072 _GLIBCXX20_CONSTEXPR
1074 operator--(
int) _GLIBCXX_NOEXCEPT
1075 {
return __normal_iterator(_M_current--); }
1078 _GLIBCXX20_CONSTEXPR
1080 operator[](difference_type __n)
const _GLIBCXX_NOEXCEPT
1081 {
return _M_current[__n]; }
1083 _GLIBCXX20_CONSTEXPR
1085 operator+=(difference_type __n) _GLIBCXX_NOEXCEPT
1086 { _M_current += __n;
return *
this; }
1088 _GLIBCXX20_CONSTEXPR
1090 operator+(difference_type __n)
const _GLIBCXX_NOEXCEPT
1091 {
return __normal_iterator(_M_current + __n); }
1093 _GLIBCXX20_CONSTEXPR
1095 operator-=(difference_type __n) _GLIBCXX_NOEXCEPT
1096 { _M_current -= __n;
return *
this; }
1098 _GLIBCXX20_CONSTEXPR
1100 operator-(difference_type __n)
const _GLIBCXX_NOEXCEPT
1101 {
return __normal_iterator(_M_current - __n); }
1103 _GLIBCXX20_CONSTEXPR
1105 base() const _GLIBCXX_NOEXCEPT
1106 {
return _M_current; }
1117 #if __cpp_lib_three_way_comparison
1118 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1119 requires requires (_IteratorL __lhs, _IteratorR __rhs)
1120 { { __lhs == __rhs } -> std::convertible_to<bool>; }
1122 operator==(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1123 const __normal_iterator<_IteratorR, _Container>& __rhs)
1124 noexcept(noexcept(__lhs.base() == __rhs.base()))
1125 {
return __lhs.base() == __rhs.base(); }
1127 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1128 constexpr std::__detail::__synth3way_t<_IteratorR, _IteratorL>
1129 operator<=>(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1130 const __normal_iterator<_IteratorR, _Container>& __rhs)
1131 noexcept(noexcept(std::__detail::__synth3way(__lhs.base(), __rhs.base())))
1132 {
return std::__detail::__synth3way(__lhs.base(), __rhs.base()); }
1134 template<
typename _Iterator,
typename _Container>
1136 operator==(
const __normal_iterator<_Iterator, _Container>& __lhs,
1137 const __normal_iterator<_Iterator, _Container>& __rhs)
1138 noexcept(noexcept(__lhs.base() == __rhs.base()))
1140 { __lhs.base() == __rhs.base() } -> std::convertible_to<bool>;
1142 {
return __lhs.base() == __rhs.base(); }
1144 template<
typename _Iterator,
typename _Container>
1145 constexpr std::__detail::__synth3way_t<_Iterator>
1146 operator<=>(
const __normal_iterator<_Iterator, _Container>& __lhs,
1147 const __normal_iterator<_Iterator, _Container>& __rhs)
1148 noexcept(noexcept(std::__detail::__synth3way(__lhs.base(), __rhs.base())))
1149 {
return std::__detail::__synth3way(__lhs.base(), __rhs.base()); }
1152 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1153 _GLIBCXX20_CONSTEXPR
1155 operator==(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1156 const __normal_iterator<_IteratorR, _Container>& __rhs)
1158 {
return __lhs.base() == __rhs.base(); }
1160 template<
typename _Iterator,
typename _Container>
1161 _GLIBCXX20_CONSTEXPR
1163 operator==(
const __normal_iterator<_Iterator, _Container>& __lhs,
1164 const __normal_iterator<_Iterator, _Container>& __rhs)
1166 {
return __lhs.base() == __rhs.base(); }
1168 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1169 _GLIBCXX20_CONSTEXPR
1171 operator!=(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1172 const __normal_iterator<_IteratorR, _Container>& __rhs)
1174 {
return __lhs.base() != __rhs.base(); }
1176 template<
typename _Iterator,
typename _Container>
1177 _GLIBCXX20_CONSTEXPR
1179 operator!=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1180 const __normal_iterator<_Iterator, _Container>& __rhs)
1182 {
return __lhs.base() != __rhs.base(); }
1185 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1187 operator<(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1188 const __normal_iterator<_IteratorR, _Container>& __rhs)
1190 {
return __lhs.base() < __rhs.base(); }
1192 template<
typename _Iterator,
typename _Container>
1193 _GLIBCXX20_CONSTEXPR
1195 operator<(
const __normal_iterator<_Iterator, _Container>& __lhs,
1196 const __normal_iterator<_Iterator, _Container>& __rhs)
1198 {
return __lhs.base() < __rhs.base(); }
1200 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1202 operator>(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1203 const __normal_iterator<_IteratorR, _Container>& __rhs)
1205 {
return __lhs.base() > __rhs.base(); }
1207 template<
typename _Iterator,
typename _Container>
1208 _GLIBCXX20_CONSTEXPR
1210 operator>(
const __normal_iterator<_Iterator, _Container>& __lhs,
1211 const __normal_iterator<_Iterator, _Container>& __rhs)
1213 {
return __lhs.base() > __rhs.base(); }
1215 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1217 operator<=(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1218 const __normal_iterator<_IteratorR, _Container>& __rhs)
1220 {
return __lhs.base() <= __rhs.base(); }
1222 template<
typename _Iterator,
typename _Container>
1223 _GLIBCXX20_CONSTEXPR
1225 operator<=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1226 const __normal_iterator<_Iterator, _Container>& __rhs)
1228 {
return __lhs.base() <= __rhs.base(); }
1230 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1232 operator>=(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1233 const __normal_iterator<_IteratorR, _Container>& __rhs)
1235 {
return __lhs.base() >= __rhs.base(); }
1237 template<
typename _Iterator,
typename _Container>
1238 _GLIBCXX20_CONSTEXPR
1240 operator>=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1241 const __normal_iterator<_Iterator, _Container>& __rhs)
1243 {
return __lhs.base() >= __rhs.base(); }
1250 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1251 #if __cplusplus >= 201103L
1253 _GLIBCXX20_CONSTEXPR
1255 operator-(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1256 const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept
1257 -> decltype(__lhs.base() - __rhs.base())
1259 inline typename __normal_iterator<_IteratorL, _Container>::difference_type
1260 operator-(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1261 const __normal_iterator<_IteratorR, _Container>& __rhs)
1263 {
return __lhs.base() - __rhs.base(); }
1265 template<
typename _Iterator,
typename _Container>
1266 _GLIBCXX20_CONSTEXPR
1267 inline typename __normal_iterator<_Iterator, _Container>::difference_type
1268 operator-(
const __normal_iterator<_Iterator, _Container>& __lhs,
1269 const __normal_iterator<_Iterator, _Container>& __rhs)
1271 {
return __lhs.base() - __rhs.base(); }
1273 template<
typename _Iterator,
typename _Container>
1274 _GLIBCXX20_CONSTEXPR
1275 inline __normal_iterator<_Iterator, _Container>
1276 operator+(
typename __normal_iterator<_Iterator, _Container>::difference_type
1277 __n,
const __normal_iterator<_Iterator, _Container>& __i)
1279 {
return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
1281 _GLIBCXX_END_NAMESPACE_VERSION
1284 namespace std _GLIBCXX_VISIBILITY(default)
1286 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1288 template<
typename _Iterator,
typename _Container>
1289 _GLIBCXX20_CONSTEXPR
1291 __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it)
1293 {
return __it.base(); }
1295 #if __cplusplus >= 201103L
1301 #if __cplusplus > 201703L && __cpp_lib_concepts
1302 template<semiregular _Sent>
1308 noexcept(is_nothrow_default_constructible_v<_Sent>)
1312 move_sentinel(_Sent __s)
1313 noexcept(is_nothrow_move_constructible_v<_Sent>)
1316 template<
typename _S2> requires convertible_to<const _S2&, _Sent>
1318 move_sentinel(
const move_sentinel<_S2>& __s)
1319 noexcept(is_nothrow_constructible_v<_Sent, const _S2&>)
1320 : _M_last(__s.base())
1323 template<
typename _S2> requires assignable_from<_Sent&, const _S2&>
1324 constexpr move_sentinel&
1325 operator=(
const move_sentinel<_S2>& __s)
1326 noexcept(is_nothrow_assignable_v<_Sent, const _S2&>)
1328 _M_last = __s.base();
1334 noexcept(is_nothrow_copy_constructible_v<_Sent>)
1344 #if __cplusplus > 201703L && __cpp_lib_concepts
1345 template<
typename _Iterator>
1346 struct __move_iter_cat
1349 template<
typename _Iterator>
1350 requires requires {
typename iterator_traits<_Iterator>::iterator_category; }
1351 struct __move_iter_cat<_Iterator>
1353 using iterator_category
1354 = __clamp_iter_cat<typename iterator_traits<_Iterator>::iterator_category,
1355 random_access_iterator_tag>;
1369 template<
typename _Iterator>
1371 #if __cplusplus > 201703L && __cpp_lib_concepts
1372 :
public __detail::__move_iter_cat<_Iterator>
1375 _Iterator _M_current;
1378 #if ! (__cplusplus > 201703L && __cpp_lib_concepts)
1379 using __base_ref =
typename __traits_type::reference;
1382 template<
typename _Iter2>
1385 #if __cpp_lib_concepts
1388 template<
typename _Iter2>
1389 static constexpr
bool __convertible = !is_same_v<_Iter2, _Iterator>
1390 && convertible_to<const _Iter2&, _Iterator>;
1394 using iterator_type = _Iterator;
1396 #if __cplusplus > 201703L && __cpp_lib_concepts
1399 using value_type = iter_value_t<_Iterator>;
1400 using difference_type = iter_difference_t<_Iterator>;
1401 using pointer = _Iterator;
1402 using reference = iter_rvalue_reference_t<_Iterator>;
1404 typedef typename __traits_type::iterator_category iterator_category;
1405 typedef typename __traits_type::value_type value_type;
1406 typedef typename __traits_type::difference_type difference_type;
1408 typedef _Iterator pointer;
1412 typename remove_reference<__base_ref>::type&&,
1416 _GLIBCXX17_CONSTEXPR
1420 explicit _GLIBCXX17_CONSTEXPR
1424 template<
typename _Iter>
1425 #if __cpp_lib_concepts
1426 requires __convertible<_Iter>
1428 _GLIBCXX17_CONSTEXPR
1430 : _M_current(__i._M_current) { }
1432 template<
typename _Iter>
1433 #if __cpp_lib_concepts
1434 requires __convertible<_Iter>
1435 && assignable_from<_Iterator&, const _Iter&>
1437 _GLIBCXX17_CONSTEXPR
1440 _M_current = __i._M_current;
1444 #if __cplusplus <= 201703L
1445 _GLIBCXX17_CONSTEXPR iterator_type
1447 {
return _M_current; }
1449 constexpr
const iterator_type&
1450 base()
const & noexcept
1451 {
return _M_current; }
1453 constexpr iterator_type
1460 #if __cplusplus > 201703L && __cpp_lib_concepts
1461 {
return ranges::iter_move(_M_current); }
1463 {
return static_cast<reference>(*_M_current); }
1466 _GLIBCXX17_CONSTEXPR pointer
1468 {
return _M_current; }
1485 #if __cpp_lib_concepts
1487 operator++(
int) requires (!forward_iterator<_Iterator>)
1511 operator+=(difference_type __n)
1522 operator-=(difference_type __n)
1529 operator[](difference_type __n)
const
1530 #if __cplusplus > 201703L && __cpp_lib_concepts
1531 {
return ranges::iter_move(_M_current + __n); }
1536 #if __cplusplus > 201703L && __cpp_lib_concepts
1537 template<sentinel_for<_Iterator> _Sent>
1538 friend constexpr
bool
1539 operator==(
const move_iterator& __x,
const move_sentinel<_Sent>& __y)
1540 {
return __x.base() == __y.base(); }
1542 template<sized_sentinel_for<_Iterator> _Sent>
1543 friend constexpr iter_difference_t<_Iterator>
1545 {
return __x.base() - __y.base(); }
1547 template<sized_sentinel_for<_Iterator> _Sent>
1548 friend constexpr iter_difference_t<_Iterator>
1550 {
return __x.base() - __y.base(); }
1552 friend constexpr iter_rvalue_reference_t<_Iterator>
1554 noexcept(noexcept(ranges::iter_move(__i._M_current)))
1555 {
return ranges::iter_move(__i._M_current); }
1557 template<indirectly_swappable<_Iterator> _Iter2>
1558 friend constexpr
void
1560 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1561 {
return ranges::iter_swap(__x._M_current, __y._M_current); }
1565 template<
typename _IteratorL,
typename _IteratorR>
1566 inline _GLIBCXX17_CONSTEXPR
bool
1569 #if __cplusplus > 201703L && __cpp_lib_concepts
1570 requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
1572 {
return __x.base() == __y.base(); }
1574 #if __cpp_lib_three_way_comparison
1575 template<
typename _IteratorL,
1576 three_way_comparable_with<_IteratorL> _IteratorR>
1577 constexpr compare_three_way_result_t<_IteratorL, _IteratorR>
1578 operator<=>(
const move_iterator<_IteratorL>& __x,
1579 const move_iterator<_IteratorR>& __y)
1580 {
return __x.base() <=> __y.base(); }
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 {
return !(__x == __y); }
1589 template<
typename _IteratorL,
typename _IteratorR>
1590 inline _GLIBCXX17_CONSTEXPR
bool
1591 operator<(
const move_iterator<_IteratorL>& __x,
1592 const move_iterator<_IteratorR>& __y)
1593 #if __cplusplus > 201703L && __cpp_lib_concepts
1594 requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
1596 {
return __x.base() < __y.base(); }
1598 template<
typename _IteratorL,
typename _IteratorR>
1599 inline _GLIBCXX17_CONSTEXPR
bool
1600 operator<=(
const move_iterator<_IteratorL>& __x,
1601 const move_iterator<_IteratorR>& __y)
1602 #if __cplusplus > 201703L && __cpp_lib_concepts
1603 requires requires { { __y.base() < __x.base() } -> convertible_to<bool>; }
1605 {
return !(__y < __x); }
1607 template<
typename _IteratorL,
typename _IteratorR>
1608 inline _GLIBCXX17_CONSTEXPR
bool
1609 operator>(
const move_iterator<_IteratorL>& __x,
1610 const move_iterator<_IteratorR>& __y)
1611 #if __cplusplus > 201703L && __cpp_lib_concepts
1612 requires requires { { __y.base() < __x.base() } -> convertible_to<bool>; }
1614 {
return __y < __x; }
1616 template<
typename _IteratorL,
typename _IteratorR>
1617 inline _GLIBCXX17_CONSTEXPR
bool
1618 operator>=(
const move_iterator<_IteratorL>& __x,
1619 const move_iterator<_IteratorR>& __y)
1620 #if __cplusplus > 201703L && __cpp_lib_concepts
1621 requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
1623 {
return !(__x < __y); }
1628 template<
typename _Iterator>
1629 inline _GLIBCXX17_CONSTEXPR
bool
1630 operator==(
const move_iterator<_Iterator>& __x,
1631 const move_iterator<_Iterator>& __y)
1632 {
return __x.base() == __y.base(); }
1634 #if __cpp_lib_three_way_comparison
1635 template<three_way_comparable _Iterator>
1636 constexpr compare_three_way_result_t<_Iterator>
1637 operator<=>(
const move_iterator<_Iterator>& __x,
1638 const move_iterator<_Iterator>& __y)
1639 {
return __x.base() <=> __y.base(); }
1641 template<
typename _Iterator>
1642 inline _GLIBCXX17_CONSTEXPR
bool
1643 operator!=(
const move_iterator<_Iterator>& __x,
1644 const move_iterator<_Iterator>& __y)
1645 {
return !(__x == __y); }
1647 template<
typename _Iterator>
1648 inline _GLIBCXX17_CONSTEXPR
bool
1649 operator<(
const move_iterator<_Iterator>& __x,
1650 const move_iterator<_Iterator>& __y)
1651 {
return __x.base() < __y.base(); }
1653 template<
typename _Iterator>
1654 inline _GLIBCXX17_CONSTEXPR
bool
1655 operator<=(
const move_iterator<_Iterator>& __x,
1656 const move_iterator<_Iterator>& __y)
1657 {
return !(__y < __x); }
1659 template<
typename _Iterator>
1660 inline _GLIBCXX17_CONSTEXPR
bool
1661 operator>(
const move_iterator<_Iterator>& __x,
1662 const move_iterator<_Iterator>& __y)
1663 {
return __y < __x; }
1665 template<
typename _Iterator>
1666 inline _GLIBCXX17_CONSTEXPR
bool
1667 operator>=(
const move_iterator<_Iterator>& __x,
1668 const move_iterator<_Iterator>& __y)
1669 {
return !(__x < __y); }
1673 template<
typename _IteratorL,
typename _IteratorR>
1674 inline _GLIBCXX17_CONSTEXPR
auto
1675 operator-(
const move_iterator<_IteratorL>& __x,
1676 const move_iterator<_IteratorR>& __y)
1677 -> decltype(__x.base() - __y.base())
1678 {
return __x.base() - __y.base(); }
1680 template<
typename _Iterator>
1681 inline _GLIBCXX17_CONSTEXPR move_iterator<_Iterator>
1682 operator+(
typename move_iterator<_Iterator>::difference_type __n,
1683 const move_iterator<_Iterator>& __x)
1684 {
return __x + __n; }
1686 template<
typename _Iterator>
1687 inline _GLIBCXX17_CONSTEXPR move_iterator<_Iterator>
1688 make_move_iterator(_Iterator __i)
1689 {
return move_iterator<_Iterator>(
std::move(__i)); }
1691 template<
typename _Iterator,
typename _ReturnType
1692 =
typename conditional<__move_if_noexcept_cond
1693 <
typename iterator_traits<_Iterator>::value_type>::value,
1694 _Iterator, move_iterator<_Iterator>>::type>
1695 inline _GLIBCXX17_CONSTEXPR _ReturnType
1696 __make_move_if_noexcept_iterator(_Iterator __i)
1697 {
return _ReturnType(__i); }
1701 template<
typename _Tp,
typename _ReturnType
1702 =
typename conditional<__move_if_noexcept_cond<_Tp>::value,
1703 const _Tp*, move_iterator<_Tp*>>::type>
1704 inline _GLIBCXX17_CONSTEXPR _ReturnType
1705 __make_move_if_noexcept_iterator(_Tp* __i)
1706 {
return _ReturnType(__i); }
1708 #if __cplusplus > 201703L && __cpp_lib_concepts
1713 template<
typename _It>
1714 concept __common_iter_has_arrow = indirectly_readable<const _It>
1715 && (requires(
const _It& __it) { __it.operator->(); }
1716 || is_reference_v<iter_reference_t<_It>>
1717 || constructible_from<iter_value_t<_It>, iter_reference_t<_It>>);
1719 template<
typename _It>
1720 concept __common_iter_use_postfix_proxy
1721 = (!requires (_It& __i) { { *__i++ } -> __can_reference; })
1722 && constructible_from<iter_value_t<_It>, iter_reference_t<_It>>
1723 && move_constructible<iter_value_t<_It>>;
1727 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
1728 requires (!same_as<_It, _Sent>) && copyable<_It>
1729 class common_iterator
1731 template<
typename _Tp,
typename _Up>
1732 static constexpr
bool
1735 if constexpr (is_trivially_default_constructible_v<_Tp>)
1736 return is_nothrow_assignable_v<_Tp&, _Up>;
1738 return is_nothrow_constructible_v<_Tp, _Up>;
1741 template<
typename _It2,
typename _Sent2>
1742 static constexpr
bool
1744 {
return _S_noexcept1<_It, _It2>() && _S_noexcept1<_Sent, _Sent2>(); }
1748 iter_value_t<_It> _M_keep;
1751 __arrow_proxy(iter_reference_t<_It>&& __x)
1754 friend class common_iterator;
1757 constexpr
const iter_value_t<_It>*
1758 operator->() const noexcept
1762 class __postfix_proxy
1764 iter_value_t<_It> _M_keep;
1767 __postfix_proxy(iter_reference_t<_It>&& __x)
1768 : _M_keep(
std::
forward<iter_reference_t<_It>>(__x)) { }
1770 friend class common_iterator;
1773 constexpr
const iter_value_t<_It>&
1781 noexcept(is_nothrow_default_constructible_v<_It>)
1782 requires default_initializable<_It>
1783 : _M_it(), _M_index(0)
1787 common_iterator(_It __i)
1788 noexcept(is_nothrow_move_constructible_v<_It>)
1789 : _M_it(
std::
move(__i)), _M_index(0)
1793 common_iterator(_Sent __s)
1794 noexcept(is_nothrow_move_constructible_v<_Sent>)
1795 : _M_sent(
std::
move(__s)), _M_index(1)
1798 template<
typename _It2,
typename _Sent2>
1799 requires convertible_to<const _It2&, _It>
1800 && convertible_to<const _Sent2&, _Sent>
1802 common_iterator(
const common_iterator<_It2, _Sent2>& __x)
1803 noexcept(_S_noexcept<const _It2&, const _Sent2&>())
1804 : _M_valueless(), _M_index(__x._M_index)
1806 __glibcxx_assert(__x._M_has_value());
1809 if constexpr (is_trivially_default_constructible_v<_It>)
1814 else if (_M_index == 1)
1816 if constexpr (is_trivially_default_constructible_v<_Sent>)
1824 common_iterator(
const common_iterator& __x)
1825 noexcept(_S_noexcept<const _It&, const _Sent&>())
1826 : _M_valueless(), _M_index(__x._M_index)
1830 if constexpr (is_trivially_default_constructible_v<_It>)
1835 else if (_M_index == 1)
1837 if constexpr (is_trivially_default_constructible_v<_Sent>)
1838 _M_sent = __x._M_sent;
1845 common_iterator(common_iterator&& __x)
1846 noexcept(_S_noexcept<_It, _Sent>())
1847 : _M_valueless(), _M_index(__x._M_index)
1851 if constexpr (is_trivially_default_constructible_v<_It>)
1856 else if (_M_index == 1)
1858 if constexpr (is_trivially_default_constructible_v<_Sent>)
1866 constexpr common_iterator&
1867 operator=(
const common_iterator&) =
default;
1869 constexpr common_iterator&
1870 operator=(
const common_iterator& __x)
1871 noexcept(is_nothrow_copy_assignable_v<_It>
1872 && is_nothrow_copy_assignable_v<_Sent>
1873 && is_nothrow_copy_constructible_v<_It>
1874 && is_nothrow_copy_constructible_v<_Sent>)
1875 requires (!is_trivially_copy_assignable_v<_It>
1876 || !is_trivially_copy_assignable_v<_Sent>)
1882 constexpr common_iterator&
1883 operator=(common_iterator&&) =
default;
1885 constexpr common_iterator&
1886 operator=(common_iterator&& __x)
1887 noexcept(is_nothrow_move_assignable_v<_It>
1888 && is_nothrow_move_assignable_v<_Sent>
1889 && is_nothrow_move_constructible_v<_It>
1890 && is_nothrow_move_constructible_v<_Sent>)
1891 requires (!is_trivially_move_assignable_v<_It>
1892 || !is_trivially_move_assignable_v<_Sent>)
1898 template<
typename _It2,
typename _Sent2>
1899 requires convertible_to<const _It2&, _It>
1900 && convertible_to<const _Sent2&, _Sent>
1901 && assignable_from<_It&, const _It2&>
1902 && assignable_from<_Sent&, const _Sent2&>
1903 constexpr common_iterator&
1904 operator=(
const common_iterator<_It2, _Sent2>& __x)
1905 noexcept(is_nothrow_constructible_v<_It, const _It2&>
1906 && is_nothrow_constructible_v<_Sent, const _Sent2&>
1907 && is_nothrow_assignable_v<_It&, const _It2&>
1908 && is_nothrow_assignable_v<_Sent&, const _Sent2&>)
1910 __glibcxx_assert(__x._M_has_value());
1920 else if (_M_index == 1)
1925 constexpr decltype(
auto)
1928 __glibcxx_assert(_M_index == 0);
1933 constexpr decltype(
auto)
1934 operator*() const requires __detail::__dereferenceable<const _It>
1936 __glibcxx_assert(_M_index == 0);
1942 operator->() const requires __detail::__common_iter_has_arrow<_It>
1944 __glibcxx_assert(_M_index == 0);
1945 if constexpr (is_pointer_v<_It> || requires { _M_it.operator->(); })
1947 else if constexpr (is_reference_v<iter_reference_t<_It>>)
1949 auto&& __tmp = *_M_it;
1953 return __arrow_proxy{*_M_it};
1956 constexpr common_iterator&
1959 __glibcxx_assert(_M_index == 0);
1964 constexpr decltype(
auto)
1967 __glibcxx_assert(_M_index == 0);
1968 if constexpr (forward_iterator<_It>)
1970 common_iterator __tmp = *
this;
1974 else if constexpr (!__detail::__common_iter_use_postfix_proxy<_It>)
1978 __postfix_proxy __p(**
this);
1984 template<
typename _It2, sentinel_for<_It> _Sent2>
1985 requires sentinel_for<_Sent, _It2>
1986 friend constexpr
bool
1987 operator== [[nodiscard]] (
const common_iterator& __x,
1988 const common_iterator<_It2, _Sent2>& __y)
1990 switch(__x._M_index << 2 | __y._M_index)
1996 return __x._M_it == __y._M_sent;
1998 return __x._M_sent == __y._M_it;
2000 __glibcxx_assert(__x._M_has_value());
2001 __glibcxx_assert(__y._M_has_value());
2002 __builtin_unreachable();
2006 template<
typename _It2, sentinel_for<_It> _Sent2>
2007 requires sentinel_for<_Sent, _It2> && equality_comparable_with<_It, _It2>
2008 friend constexpr
bool
2009 operator== [[nodiscard]] (
const common_iterator& __x,
2010 const common_iterator<_It2, _Sent2>& __y)
2012 switch(__x._M_index << 2 | __y._M_index)
2017 return __x._M_it == __y._M_it;
2019 return __x._M_it == __y._M_sent;
2021 return __x._M_sent == __y._M_it;
2023 __glibcxx_assert(__x._M_has_value());
2024 __glibcxx_assert(__y._M_has_value());
2025 __builtin_unreachable();
2029 template<sized_sentinel_for<_It> _It2, sized_sentinel_for<_It> _Sent2>
2030 requires sized_sentinel_for<_Sent, _It2>
2031 friend constexpr iter_difference_t<_It2>
2032 operator- [[nodiscard]] (
const common_iterator& __x,
2033 const common_iterator<_It2, _Sent2>& __y)
2035 switch(__x._M_index << 2 | __y._M_index)
2040 return __x._M_it - __y._M_it;
2042 return __x._M_it - __y._M_sent;
2044 return __x._M_sent - __y._M_it;
2046 __glibcxx_assert(__x._M_has_value());
2047 __glibcxx_assert(__y._M_has_value());
2048 __builtin_unreachable();
2053 friend constexpr iter_rvalue_reference_t<_It>
2054 iter_move(
const common_iterator& __i)
2055 noexcept(noexcept(ranges::iter_move(std::declval<const _It&>())))
2056 requires input_iterator<_It>
2058 __glibcxx_assert(__i._M_index == 0);
2059 return ranges::iter_move(__i._M_it);
2062 template<indirectly_swappable<_It> _It2,
typename _Sent2>
2063 friend constexpr
void
2064 iter_swap(
const common_iterator& __x,
2065 const common_iterator<_It2, _Sent2>& __y)
2066 noexcept(noexcept(ranges::iter_swap(std::declval<const _It&>(),
2067 std::declval<const _It2&>())))
2069 __glibcxx_assert(__x._M_index == 0);
2070 __glibcxx_assert(__y._M_index == 0);
2071 return ranges::iter_swap(__x._M_it, __y._M_it);
2075 template<input_or_output_iterator _It2, sentinel_for<_It2> _Sent2>
2076 requires (!same_as<_It2, _Sent2>) && copyable<_It2>
2077 friend class common_iterator;
2080 _M_has_value() const noexcept {
return _M_index != _S_valueless; }
2082 template<
typename _CIt>
2084 _M_assign(_CIt&& __x)
2086 if (_M_index == __x._M_index)
2089 _M_it = std::forward<_CIt>(__x)._M_it;
2090 else if (_M_index == 1)
2091 _M_sent = std::forward<_CIt>(__x)._M_sent;
2097 else if (_M_index == 1)
2099 _M_index = _S_valueless;
2101 if (__x._M_index == 0)
2103 std::forward<_CIt>(__x)._M_it);
2104 else if (__x._M_index == 1)
2106 std::forward<_CIt>(__x)._M_sent);
2107 _M_index = __x._M_index;
2115 unsigned char _M_valueless;
2117 unsigned char _M_index;
2119 static constexpr
unsigned char _S_valueless{2};
2122 template<
typename _It,
typename _Sent>
2123 struct incrementable_traits<common_iterator<_It, _Sent>>
2125 using difference_type = iter_difference_t<_It>;
2128 template<input_iterator _It,
typename _Sent>
2129 struct iterator_traits<common_iterator<_It, _Sent>>
2132 template<
typename _Iter>
2138 template<
typename _Iter>
2139 requires __detail::__common_iter_has_arrow<_Iter>
2142 using _CIter = common_iterator<_Iter, _Sent>;
2143 using type = decltype(std::declval<const _CIter&>().operator->());
2149 using _Traits = iterator_traits<_It>;
2150 if constexpr (requires { requires derived_from<
typename _Traits::iterator_category,
2151 forward_iterator_tag>; })
2152 return forward_iterator_tag{};
2154 return input_iterator_tag{};
2158 using iterator_concept = conditional_t<forward_iterator<_It>,
2159 forward_iterator_tag, input_iterator_tag>;
2160 using iterator_category = decltype(_S_iter_cat());
2161 using value_type = iter_value_t<_It>;
2162 using difference_type = iter_difference_t<_It>;
2163 using pointer =
typename __ptr<_It>::type;
2164 using reference = iter_reference_t<_It>;
2171 template<
typename _It>
2172 struct __counted_iter_value_type
2175 template<indirectly_readable _It>
2176 struct __counted_iter_value_type<_It>
2177 {
using value_type = iter_value_t<_It>; };
2179 template<
typename _It>
2180 struct __counted_iter_concept
2183 template<
typename _It>
2184 requires requires {
typename _It::iterator_concept; }
2185 struct __counted_iter_concept<_It>
2186 {
using iterator_concept =
typename _It::iterator_concept; };
2188 template<
typename _It>
2189 struct __counted_iter_cat
2192 template<
typename _It>
2193 requires requires {
typename _It::iterator_category; }
2194 struct __counted_iter_cat<_It>
2195 {
using iterator_category =
typename _It::iterator_category; };
2199 template<input_or_output_iterator _It>
2200 class counted_iterator
2201 :
public __detail::__counted_iter_value_type<_It>,
2202 public __detail::__counted_iter_concept<_It>,
2203 public __detail::__counted_iter_cat<_It>
2206 using iterator_type = _It;
2208 using difference_type = iter_difference_t<_It>;
2212 constexpr counted_iterator() requires default_initializable<_It> = default;
2215 counted_iterator(_It __i, iter_difference_t<_It> __n)
2216 : _M_current(
std::
move(__i)), _M_length(__n)
2217 { __glibcxx_assert(__n >= 0); }
2219 template<
typename _It2>
2220 requires convertible_to<const _It2&, _It>
2222 counted_iterator(
const counted_iterator<_It2>& __x)
2223 : _M_current(__x._M_current), _M_length(__x._M_length)
2226 template<
typename _It2>
2227 requires assignable_from<_It&, const _It2&>
2228 constexpr counted_iterator&
2229 operator=(
const counted_iterator<_It2>& __x)
2231 _M_current = __x._M_current;
2232 _M_length = __x._M_length;
2236 constexpr
const _It&
2237 base() const & noexcept
2238 {
return _M_current; }
2242 noexcept(is_nothrow_move_constructible_v<_It>)
2245 constexpr iter_difference_t<_It>
2246 count() const noexcept {
return _M_length; }
2248 constexpr decltype(
auto)
2250 noexcept(noexcept(*_M_current))
2252 __glibcxx_assert( _M_length > 0 );
2256 constexpr decltype(
auto)
2258 noexcept(noexcept(*_M_current))
2259 requires __detail::__dereferenceable<const _It>
2261 __glibcxx_assert( _M_length > 0 );
2266 operator->() const noexcept
2267 requires contiguous_iterator<_It>
2268 {
return std::to_address(_M_current); }
2270 constexpr counted_iterator&
2273 __glibcxx_assert(_M_length > 0);
2279 constexpr decltype(
auto)
2282 __glibcxx_assert(_M_length > 0);
2286 return _M_current++;
2289 __throw_exception_again;
2293 constexpr counted_iterator
2294 operator++(
int) requires forward_iterator<_It>
2301 constexpr counted_iterator&
2302 operator--() requires bidirectional_iterator<_It>
2309 constexpr counted_iterator
2310 operator--(
int) requires bidirectional_iterator<_It>
2317 constexpr counted_iterator
2318 operator+(iter_difference_t<_It> __n)
const
2319 requires random_access_iterator<_It>
2320 {
return counted_iterator(_M_current + __n, _M_length - __n); }
2322 friend constexpr counted_iterator
2323 operator+(iter_difference_t<_It> __n,
const counted_iterator& __x)
2324 requires random_access_iterator<_It>
2325 {
return __x + __n; }
2327 constexpr counted_iterator&
2328 operator+=(iter_difference_t<_It> __n)
2329 requires random_access_iterator<_It>
2331 __glibcxx_assert(__n <= _M_length);
2337 constexpr counted_iterator
2338 operator-(iter_difference_t<_It> __n)
const
2339 requires random_access_iterator<_It>
2340 {
return counted_iterator(_M_current - __n, _M_length + __n); }
2342 template<common_with<_It> _It2>
2343 friend constexpr iter_difference_t<_It2>
2345 const counted_iterator<_It2>& __y)
2346 {
return __y._M_length - __x._M_length; }
2348 friend constexpr iter_difference_t<_It>
2349 operator-(
const counted_iterator& __x, default_sentinel_t)
2350 {
return -__x._M_length; }
2352 friend constexpr iter_difference_t<_It>
2353 operator-(default_sentinel_t,
const counted_iterator& __y)
2354 {
return __y._M_length; }
2356 constexpr counted_iterator&
2357 operator-=(iter_difference_t<_It> __n)
2358 requires random_access_iterator<_It>
2360 __glibcxx_assert(-__n <= _M_length);
2366 constexpr decltype(
auto)
2367 operator[](iter_difference_t<_It> __n) const
2368 noexcept(noexcept(_M_current[__n]))
2369 requires random_access_iterator<_It>
2371 __glibcxx_assert(__n < _M_length);
2372 return _M_current[__n];
2375 template<common_with<_It> _It2>
2376 friend constexpr
bool
2377 operator==(
const counted_iterator& __x,
2378 const counted_iterator<_It2>& __y)
2379 {
return __x._M_length == __y._M_length; }
2381 friend constexpr
bool
2382 operator==(
const counted_iterator& __x, default_sentinel_t)
2383 {
return __x._M_length == 0; }
2385 template<common_with<_It> _It2>
2386 friend constexpr strong_ordering
2387 operator<=>(
const counted_iterator& __x,
2388 const counted_iterator<_It2>& __y)
2389 {
return __y._M_length <=> __x._M_length; }
2391 friend constexpr iter_rvalue_reference_t<_It>
2392 iter_move(
const counted_iterator& __i)
2393 noexcept(noexcept(ranges::iter_move(__i._M_current)))
2394 requires input_iterator<_It>
2396 __glibcxx_assert( __i._M_length > 0 );
2397 return ranges::iter_move(__i._M_current);
2400 template<indirectly_swappable<_It> _It2>
2401 friend constexpr
void
2402 iter_swap(
const counted_iterator& __x,
2403 const counted_iterator<_It2>& __y)
2404 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
2406 __glibcxx_assert( __x._M_length > 0 && __y._M_length > 0 );
2407 ranges::iter_swap(__x._M_current, __y._M_current);
2411 template<input_or_output_iterator _It2>
friend class counted_iterator;
2413 _It _M_current = _It();
2414 iter_difference_t<_It> _M_length = 0;
2417 template<input_iterator _It>
2418 requires same_as<__detail::__iter_traits<_It>, iterator_traits<_It>>
2419 struct iterator_traits<counted_iterator<_It>> : iterator_traits<_It>
2421 using pointer = conditional_t<contiguous_iterator<_It>,
2422 add_pointer_t<iter_reference_t<_It>>,
2429 template<
typename _Iterator>
2430 _GLIBCXX20_CONSTEXPR
2432 __niter_base(move_iterator<_Iterator> __it)
2433 -> decltype(make_move_iterator(__niter_base(__it.base())))
2434 {
return make_move_iterator(__niter_base(__it.base())); }
2436 template<
typename _Iterator>
2437 struct __is_move_iterator<move_iterator<_Iterator> >
2439 enum { __value = 1 };
2440 typedef __true_type __type;
2443 template<
typename _Iterator>
2444 _GLIBCXX20_CONSTEXPR
2446 __miter_base(move_iterator<_Iterator> __it)
2447 -> decltype(__miter_base(__it.base()))
2448 {
return __miter_base(__it.base()); }
2450 #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) std::make_move_iterator(_Iter)
2451 #define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) \
2452 std::__make_move_if_noexcept_iterator(_Iter)
2454 #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) (_Iter)
2455 #define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) (_Iter)
2458 #if __cpp_deduction_guides >= 201606
2461 template<
typename _InputIterator>
2463 typename iterator_traits<_InputIterator>::value_type::first_type>;
2465 template<
typename _InputIterator>
2466 using __iter_val_t =
2467 typename iterator_traits<_InputIterator>::value_type::second_type;
2469 template<
typename _T1,
typename _T2>
2472 template<
typename _InputIterator>
2473 using __iter_to_alloc_t =
2474 pair<add_const_t<__iter_key_t<_InputIterator>>,
2475 __iter_val_t<_InputIterator>>;
2478 _GLIBCXX_END_NAMESPACE_VERSION
2481 #ifdef _GLIBCXX_DEBUG
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.
constexpr duration< __common_rep_t< _Rep2, _Rep1 >, _Period > operator*(const _Rep1 &__s, const duration< _Rep2, _Period > &__d)
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.
constexpr complex< _Tp > operator*(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x times y.
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 plus y.
typename conditional< _Cond, _Iftrue, _Iffalse >::type conditional_t
Alias template for conditional.
typename remove_const< _Tp >::type remove_const_t
Alias template for remove_const.
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
constexpr _Tp && forward(typename std::remove_reference< _Tp >::type &__t) noexcept
Forward an lvalue.
constexpr reverse_iterator< _Iterator > make_reverse_iterator(_Iterator __i)
Generator function for reverse_iterator.
insert_iterator< _Container > inserter(_Container &__x, typename _Container::iterator __i)
constexpr front_insert_iterator< _Container > front_inserter(_Container &__x)
constexpr back_insert_iterator< _Container > back_inserter(_Container &__x)
ISO C++ entities toplevel namespace is std.
GNU extensions for public use.
Define a member typedef type to one of two argument types.
is_nothrow_copy_constructible
Traits class for iterators.
constexpr pointer operator->() const
constexpr iterator_type base() const
constexpr reverse_iterator operator+(difference_type __n) const
constexpr reverse_iterator(iterator_type __x)
constexpr reverse_iterator & operator+=(difference_type __n)
constexpr reference operator[](difference_type __n) const
constexpr reverse_iterator & operator--()
constexpr reverse_iterator(const reverse_iterator &__x)
constexpr reverse_iterator & operator-=(difference_type __n)
constexpr reverse_iterator(const reverse_iterator< _Iter > &__x)
constexpr reverse_iterator operator--(int)
constexpr reference operator*() const
constexpr reverse_iterator operator-(difference_type __n) const
constexpr reverse_iterator()
constexpr reverse_iterator operator++(int)
constexpr reverse_iterator & operator++()
Turns assignment into insertion.
constexpr back_insert_iterator operator++(int)
Simply returns *this. (This iterator does not move.)
_Container container_type
A nested typedef for the type of whatever container you used.
constexpr back_insert_iterator & operator*()
Simply returns *this.
constexpr back_insert_iterator & operator=(const typename _Container::value_type &__value)
constexpr back_insert_iterator & operator++()
Simply returns *this. (This iterator does not move.)
constexpr back_insert_iterator(_Container &__x)
The only way to create this iterator is with a container.
Turns assignment into insertion.
_Container container_type
A nested typedef for the type of whatever container you used.
constexpr front_insert_iterator operator++(int)
Simply returns *this. (This iterator does not move.)
constexpr front_insert_iterator(_Container &__x)
The only way to create this iterator is with a container.
constexpr front_insert_iterator & operator++()
Simply returns *this. (This iterator does not move.)
constexpr front_insert_iterator & operator*()
Simply returns *this.
constexpr front_insert_iterator & operator=(const typename _Container::value_type &__value)
Turns assignment into insertion.
constexpr insert_iterator & operator++()
Simply returns *this. (This iterator does not move.)
_Container container_type
A nested typedef for the type of whatever container you used.
constexpr insert_iterator & operator++(int)
Simply returns *this. (This iterator does not move.)
constexpr insert_iterator & operator=(const typename _Container::value_type &__value)
constexpr insert_iterator(_Container &__x, _Iter __i)
constexpr insert_iterator & operator*()
Simply returns *this.
Bidirectional iterators support a superset of forward iterator operations.
Random-access iterators support a superset of bidirectional iterator operations.
iterator_traits< _Iterator >::iterator_category iterator_category
One of the tag types.
void difference_type
Distance between iterators is represented as this type.
iterator_traits< _Iterator >::value_type value_type
The type "pointed to" by the iterator.
Struct holding two objects of arbitrary type.