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 __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 ! __cpp_lib_concepts
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);
271 _GLIBCXX17_CONSTEXPR reverse_iterator&
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
381 iter_swap(
const reverse_iterator& __x,
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(); }
544 template<
typename _Iterator>
546 operator==(
const reverse_iterator<_Iterator>& __x,
547 const reverse_iterator<_Iterator>& __y)
548 requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
549 {
return __x.base() == __y.base(); }
551 template<three_way_comparable _Iterator>
552 constexpr compare_three_way_result_t<_Iterator, _Iterator>
553 operator<=>(
const reverse_iterator<_Iterator>& __x,
554 const reverse_iterator<_Iterator>& __y)
555 {
return __y.base() <=> __x.base(); }
559 #if __cplusplus < 201103L
560 template<
typename _Iterator>
561 inline typename reverse_iterator<_Iterator>::difference_type
562 operator-(
const reverse_iterator<_Iterator>& __x,
563 const reverse_iterator<_Iterator>& __y)
564 {
return __y.base() - __x.base(); }
566 template<
typename _IteratorL,
typename _IteratorR>
567 inline typename reverse_iterator<_IteratorL>::difference_type
568 operator-(
const reverse_iterator<_IteratorL>& __x,
569 const reverse_iterator<_IteratorR>& __y)
570 {
return __y.base() - __x.base(); }
574 template<
typename _IteratorL,
typename _IteratorR>
575 inline _GLIBCXX17_CONSTEXPR
auto
576 operator-(
const reverse_iterator<_IteratorL>& __x,
577 const reverse_iterator<_IteratorR>& __y)
578 -> decltype(__y.base() - __x.base())
579 {
return __y.base() - __x.base(); }
582 template<
typename _Iterator>
583 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
584 operator+(
typename reverse_iterator<_Iterator>::difference_type __n,
585 const reverse_iterator<_Iterator>& __x)
586 {
return reverse_iterator<_Iterator>(__x.base() - __n); }
588 #if __cplusplus >= 201103L
590 template<
typename _Iterator>
591 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
592 __make_reverse_iterator(_Iterator __i)
593 {
return reverse_iterator<_Iterator>(__i); }
595 # if __cplusplus >= 201402L
596 # define __cpp_lib_make_reverse_iterator 201402
601 template<
typename _Iterator>
602 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
606 # if __cplusplus > 201703L && defined __cpp_lib_concepts
607 template<
typename _Iterator1,
typename _Iterator2>
608 requires (!sized_sentinel_for<_Iterator1, _Iterator2>)
609 inline constexpr
bool
610 disable_sized_sentinel_for<reverse_iterator<_Iterator1>,
611 reverse_iterator<_Iterator2>> =
true;
615 template<
typename _Iterator>
618 __niter_base(reverse_iterator<_Iterator> __it)
619 -> decltype(__make_reverse_iterator(__niter_base(__it.base())))
620 {
return __make_reverse_iterator(__niter_base(__it.base())); }
622 template<
typename _Iterator>
623 struct __is_move_iterator<reverse_iterator<_Iterator> >
624 : __is_move_iterator<_Iterator>
627 template<
typename _Iterator>
630 __miter_base(reverse_iterator<_Iterator> __it)
631 -> decltype(__make_reverse_iterator(__miter_base(__it.base())))
632 {
return __make_reverse_iterator(__miter_base(__it.base())); }
646 template<
typename _Container>
648 :
public iterator<output_iterator_tag, void, void, void, void>
651 _Container* container;
656 #if __cplusplus > 201703L
663 explicit _GLIBCXX20_CONSTEXPR
678 #if __cplusplus < 201103L
680 operator=(
typename _Container::const_reference __value)
682 container->push_back(__value);
688 operator=(
const typename _Container::value_type& __value)
690 container->push_back(__value);
696 operator=(
typename _Container::value_type&& __value)
698 container->push_back(
std::move(__value));
733 template<
typename _Container>
735 inline back_insert_iterator<_Container>
749 template<
typename _Container>
751 :
public iterator<output_iterator_tag, void, void, void, void>
754 _Container* container;
759 #if __cplusplus > 201703L
766 explicit _GLIBCXX20_CONSTEXPR
781 #if __cplusplus < 201103L
783 operator=(
typename _Container::const_reference __value)
785 container->push_front(__value);
791 operator=(
const typename _Container::value_type& __value)
793 container->push_front(__value);
799 operator=(
typename _Container::value_type&& __value)
801 container->push_front(
std::move(__value));
836 template<
typename _Container>
838 inline front_insert_iterator<_Container>
856 template<
typename _Container>
858 :
public iterator<output_iterator_tag, void, void, void, void>
860 #if __cplusplus > 201703L && defined __cpp_lib_concepts
861 using _Iter = std::__detail::__range_iter_t<_Container>;
864 _Container* container =
nullptr;
865 _Iter iter = _Iter();
867 typedef typename _Container::iterator _Iter;
870 _Container* container;
878 #if __cplusplus > 201703L && defined __cpp_lib_concepts
915 #if __cplusplus < 201103L
917 operator=(
typename _Container::const_reference __value)
919 iter = container->insert(iter, __value);
926 operator=(
const typename _Container::value_type& __value)
928 iter = container->insert(iter, __value);
935 operator=(
typename _Container::value_type&& __value)
937 iter = container->insert(iter,
std::move(__value));
974 #if __cplusplus > 201703L && defined __cpp_lib_concepts
975 template<
typename _Container>
976 constexpr insert_iterator<_Container>
977 inserter(_Container& __x, std::__detail::__range_iter_t<_Container> __i)
978 {
return insert_iterator<_Container>(__x, __i); }
980 template<
typename _Container>
981 inline insert_iterator<_Container>
982 inserter(_Container& __x,
typename _Container::iterator __i)
988 _GLIBCXX_END_NAMESPACE_VERSION
991 namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
993 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1002 template<
typename _Iterator,
typename _Container>
1003 class __normal_iterator
1006 _Iterator _M_current;
1011 typedef _Iterator iterator_type;
1012 typedef typename __traits_type::iterator_category iterator_category;
1013 typedef typename __traits_type::value_type value_type;
1014 typedef typename __traits_type::difference_type difference_type;
1015 typedef typename __traits_type::reference reference;
1016 typedef typename __traits_type::pointer pointer;
1018 #if __cplusplus > 201703L && __cpp_lib_concepts
1019 using iterator_concept = std::__detail::__iter_concept<_Iterator>;
1022 _GLIBCXX_CONSTEXPR __normal_iterator() _GLIBCXX_NOEXCEPT
1023 : _M_current(_Iterator()) { }
1025 explicit _GLIBCXX20_CONSTEXPR
1026 __normal_iterator(
const _Iterator& __i) _GLIBCXX_NOEXCEPT
1027 : _M_current(__i) { }
1030 template<
typename _Iter>
1031 _GLIBCXX20_CONSTEXPR
1032 __normal_iterator(
const __normal_iterator<_Iter,
1033 typename __enable_if<
1034 (std::__are_same<_Iter, typename _Container::pointer>::__value),
1035 _Container>::__type>& __i) _GLIBCXX_NOEXCEPT
1036 : _M_current(__i.base()) { }
1039 _GLIBCXX20_CONSTEXPR
1042 {
return *_M_current; }
1044 _GLIBCXX20_CONSTEXPR
1046 operator->() const _GLIBCXX_NOEXCEPT
1047 {
return _M_current; }
1049 _GLIBCXX20_CONSTEXPR
1051 operator++() _GLIBCXX_NOEXCEPT
1057 _GLIBCXX20_CONSTEXPR
1059 operator++(
int) _GLIBCXX_NOEXCEPT
1060 {
return __normal_iterator(_M_current++); }
1063 _GLIBCXX20_CONSTEXPR
1065 operator--() _GLIBCXX_NOEXCEPT
1071 _GLIBCXX20_CONSTEXPR
1073 operator--(
int) _GLIBCXX_NOEXCEPT
1074 {
return __normal_iterator(_M_current--); }
1077 _GLIBCXX20_CONSTEXPR
1079 operator[](difference_type __n)
const _GLIBCXX_NOEXCEPT
1080 {
return _M_current[__n]; }
1082 _GLIBCXX20_CONSTEXPR
1084 operator+=(difference_type __n) _GLIBCXX_NOEXCEPT
1085 { _M_current += __n;
return *
this; }
1087 _GLIBCXX20_CONSTEXPR
1089 operator+(difference_type __n)
const _GLIBCXX_NOEXCEPT
1090 {
return __normal_iterator(_M_current + __n); }
1092 _GLIBCXX20_CONSTEXPR
1094 operator-=(difference_type __n) _GLIBCXX_NOEXCEPT
1095 { _M_current -= __n;
return *
this; }
1097 _GLIBCXX20_CONSTEXPR
1099 operator-(difference_type __n)
const _GLIBCXX_NOEXCEPT
1100 {
return __normal_iterator(_M_current - __n); }
1102 _GLIBCXX20_CONSTEXPR
1104 base() const _GLIBCXX_NOEXCEPT
1105 {
return _M_current; }
1116 #if __cpp_lib_three_way_comparison
1117 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1118 requires requires (_IteratorL __lhs, _IteratorR __rhs)
1119 { { __lhs == __rhs } -> std::convertible_to<bool>; }
1121 operator==(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1122 const __normal_iterator<_IteratorR, _Container>& __rhs)
1123 noexcept(noexcept(__lhs.base() == __rhs.base()))
1124 {
return __lhs.base() == __rhs.base(); }
1126 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1127 constexpr std::__detail::__synth3way_t<_IteratorR, _IteratorL>
1128 operator<=>(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1129 const __normal_iterator<_IteratorR, _Container>& __rhs)
1130 noexcept(noexcept(std::__detail::__synth3way(__lhs.base(), __rhs.base())))
1131 {
return std::__detail::__synth3way(__lhs.base(), __rhs.base()); }
1133 template<
typename _Iterator,
typename _Container>
1135 operator==(
const __normal_iterator<_Iterator, _Container>& __lhs,
1136 const __normal_iterator<_Iterator, _Container>& __rhs)
1137 noexcept(noexcept(__lhs.base() == __rhs.base()))
1139 { __lhs.base() == __rhs.base() } -> std::convertible_to<bool>;
1141 {
return __lhs.base() == __rhs.base(); }
1143 template<
typename _Iterator,
typename _Container>
1144 constexpr std::__detail::__synth3way_t<_Iterator>
1145 operator<=>(
const __normal_iterator<_Iterator, _Container>& __lhs,
1146 const __normal_iterator<_Iterator, _Container>& __rhs)
1147 noexcept(noexcept(std::__detail::__synth3way(__lhs.base(), __rhs.base())))
1148 {
return std::__detail::__synth3way(__lhs.base(), __rhs.base()); }
1151 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1152 _GLIBCXX20_CONSTEXPR
1154 operator==(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1155 const __normal_iterator<_IteratorR, _Container>& __rhs)
1157 {
return __lhs.base() == __rhs.base(); }
1159 template<
typename _Iterator,
typename _Container>
1160 _GLIBCXX20_CONSTEXPR
1162 operator==(
const __normal_iterator<_Iterator, _Container>& __lhs,
1163 const __normal_iterator<_Iterator, _Container>& __rhs)
1165 {
return __lhs.base() == __rhs.base(); }
1167 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1168 _GLIBCXX20_CONSTEXPR
1170 operator!=(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1171 const __normal_iterator<_IteratorR, _Container>& __rhs)
1173 {
return __lhs.base() != __rhs.base(); }
1175 template<
typename _Iterator,
typename _Container>
1176 _GLIBCXX20_CONSTEXPR
1178 operator!=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1179 const __normal_iterator<_Iterator, _Container>& __rhs)
1181 {
return __lhs.base() != __rhs.base(); }
1184 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1186 operator<(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1187 const __normal_iterator<_IteratorR, _Container>& __rhs)
1189 {
return __lhs.base() < __rhs.base(); }
1191 template<
typename _Iterator,
typename _Container>
1192 _GLIBCXX20_CONSTEXPR
1194 operator<(
const __normal_iterator<_Iterator, _Container>& __lhs,
1195 const __normal_iterator<_Iterator, _Container>& __rhs)
1197 {
return __lhs.base() < __rhs.base(); }
1199 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1201 operator>(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1202 const __normal_iterator<_IteratorR, _Container>& __rhs)
1204 {
return __lhs.base() > __rhs.base(); }
1206 template<
typename _Iterator,
typename _Container>
1207 _GLIBCXX20_CONSTEXPR
1209 operator>(
const __normal_iterator<_Iterator, _Container>& __lhs,
1210 const __normal_iterator<_Iterator, _Container>& __rhs)
1212 {
return __lhs.base() > __rhs.base(); }
1214 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1216 operator<=(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1217 const __normal_iterator<_IteratorR, _Container>& __rhs)
1219 {
return __lhs.base() <= __rhs.base(); }
1221 template<
typename _Iterator,
typename _Container>
1222 _GLIBCXX20_CONSTEXPR
1224 operator<=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1225 const __normal_iterator<_Iterator, _Container>& __rhs)
1227 {
return __lhs.base() <= __rhs.base(); }
1229 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1231 operator>=(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1232 const __normal_iterator<_IteratorR, _Container>& __rhs)
1234 {
return __lhs.base() >= __rhs.base(); }
1236 template<
typename _Iterator,
typename _Container>
1237 _GLIBCXX20_CONSTEXPR
1239 operator>=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1240 const __normal_iterator<_Iterator, _Container>& __rhs)
1242 {
return __lhs.base() >= __rhs.base(); }
1249 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1250 #if __cplusplus >= 201103L
1252 _GLIBCXX20_CONSTEXPR
1254 operator-(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1255 const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept
1256 -> decltype(__lhs.base() - __rhs.base())
1258 inline typename __normal_iterator<_IteratorL, _Container>::difference_type
1259 operator-(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1260 const __normal_iterator<_IteratorR, _Container>& __rhs)
1262 {
return __lhs.base() - __rhs.base(); }
1264 template<
typename _Iterator,
typename _Container>
1265 _GLIBCXX20_CONSTEXPR
1266 inline typename __normal_iterator<_Iterator, _Container>::difference_type
1267 operator-(
const __normal_iterator<_Iterator, _Container>& __lhs,
1268 const __normal_iterator<_Iterator, _Container>& __rhs)
1270 {
return __lhs.base() - __rhs.base(); }
1272 template<
typename _Iterator,
typename _Container>
1273 _GLIBCXX20_CONSTEXPR
1274 inline __normal_iterator<_Iterator, _Container>
1275 operator+(
typename __normal_iterator<_Iterator, _Container>::difference_type
1276 __n,
const __normal_iterator<_Iterator, _Container>& __i)
1278 {
return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
1280 _GLIBCXX_END_NAMESPACE_VERSION
1283 namespace std _GLIBCXX_VISIBILITY(default)
1285 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1287 template<
typename _Iterator,
typename _Container>
1288 _GLIBCXX20_CONSTEXPR
1290 __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it)
1292 {
return __it.base(); }
1294 #if __cplusplus >= 201103L
1300 #if __cplusplus > 201703L && __cpp_lib_concepts
1301 template<semiregular _Sent>
1307 noexcept(is_nothrow_default_constructible_v<_Sent>)
1311 move_sentinel(_Sent __s)
1312 noexcept(is_nothrow_move_constructible_v<_Sent>)
1315 template<
typename _S2> requires convertible_to<const _S2&, _Sent>
1317 move_sentinel(
const move_sentinel<_S2>& __s)
1318 noexcept(is_nothrow_constructible_v<_Sent, const _S2&>)
1319 : _M_last(__s.base())
1322 template<
typename _S2> requires assignable_from<_Sent&, const _S2&>
1323 constexpr move_sentinel&
1324 operator=(
const move_sentinel<_S2>& __s)
1325 noexcept(is_nothrow_assignable_v<_Sent, const _S2&>)
1327 _M_last = __s.base();
1333 noexcept(is_nothrow_copy_constructible_v<_Sent>)
1343 #if __cplusplus > 201703L && __cpp_lib_concepts
1344 template<
typename _Iterator>
1345 struct __move_iter_cat
1348 template<
typename _Iterator>
1349 requires requires {
typename iterator_traits<_Iterator>::iterator_category; }
1350 struct __move_iter_cat<_Iterator>
1352 using iterator_category
1353 = __clamp_iter_cat<typename iterator_traits<_Iterator>::iterator_category,
1354 random_access_iterator_tag>;
1368 template<
typename _Iterator>
1370 #if __cplusplus > 201703L && __cpp_lib_concepts
1371 :
public __detail::__move_iter_cat<_Iterator>
1374 _Iterator _M_current;
1377 #if ! (__cplusplus > 201703L && __cpp_lib_concepts)
1378 using __base_ref =
typename __traits_type::reference;
1381 template<
typename _Iter2>
1384 #if __cpp_lib_concepts
1387 template<
typename _Iter2>
1388 static constexpr
bool __convertible = !is_same_v<_Iter2, _Iterator>
1389 && convertible_to<const _Iter2&, _Iterator>;
1393 using iterator_type = _Iterator;
1395 #if __cplusplus > 201703L && __cpp_lib_concepts
1398 using value_type = iter_value_t<_Iterator>;
1399 using difference_type = iter_difference_t<_Iterator>;
1400 using pointer = _Iterator;
1401 using reference = iter_rvalue_reference_t<_Iterator>;
1403 typedef typename __traits_type::iterator_category iterator_category;
1404 typedef typename __traits_type::value_type value_type;
1405 typedef typename __traits_type::difference_type difference_type;
1407 typedef _Iterator pointer;
1411 typename remove_reference<__base_ref>::type&&,
1415 _GLIBCXX17_CONSTEXPR
1419 explicit _GLIBCXX17_CONSTEXPR
1423 template<
typename _Iter>
1424 #if __cpp_lib_concepts
1425 requires __convertible<_Iter>
1427 _GLIBCXX17_CONSTEXPR
1429 : _M_current(__i._M_current) { }
1431 template<
typename _Iter>
1432 #if __cpp_lib_concepts
1433 requires __convertible<_Iter>
1434 && assignable_from<_Iterator&, const _Iter&>
1436 _GLIBCXX17_CONSTEXPR
1439 _M_current = __i._M_current;
1443 #if __cplusplus <= 201703L
1444 _GLIBCXX17_CONSTEXPR iterator_type
1446 {
return _M_current; }
1448 constexpr
const iterator_type&
1449 base()
const & noexcept
1450 {
return _M_current; }
1452 constexpr iterator_type
1459 #if __cplusplus > 201703L && __cpp_lib_concepts
1460 {
return ranges::iter_move(_M_current); }
1462 {
return static_cast<reference>(*_M_current); }
1465 _GLIBCXX17_CONSTEXPR pointer
1467 {
return _M_current; }
1484 #if __cpp_lib_concepts
1486 operator++(
int) requires (!forward_iterator<_Iterator>)
1510 operator+=(difference_type __n)
1521 operator-=(difference_type __n)
1528 operator[](difference_type __n)
const
1529 #if __cplusplus > 201703L && __cpp_lib_concepts
1530 {
return ranges::iter_move(_M_current + __n); }
1535 #if __cplusplus > 201703L && __cpp_lib_concepts
1536 template<sentinel_for<_Iterator> _Sent>
1537 friend constexpr
bool
1538 operator==(
const move_iterator& __x,
const move_sentinel<_Sent>& __y)
1539 {
return __x.base() == __y.base(); }
1541 template<sized_sentinel_for<_Iterator> _Sent>
1542 friend constexpr iter_difference_t<_Iterator>
1544 {
return __x.base() - __y.base(); }
1546 template<sized_sentinel_for<_Iterator> _Sent>
1547 friend constexpr iter_difference_t<_Iterator>
1549 {
return __x.base() - __y.base(); }
1551 friend constexpr iter_rvalue_reference_t<_Iterator>
1553 noexcept(noexcept(ranges::iter_move(__i._M_current)))
1554 {
return ranges::iter_move(__i._M_current); }
1556 template<indirectly_swappable<_Iterator> _Iter2>
1557 friend constexpr
void
1559 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1560 {
return ranges::iter_swap(__x._M_current, __y._M_current); }
1564 template<
typename _IteratorL,
typename _IteratorR>
1565 inline _GLIBCXX17_CONSTEXPR
bool
1568 #if __cplusplus > 201703L && __cpp_lib_concepts
1569 requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
1571 {
return __x.base() == __y.base(); }
1573 #if __cpp_lib_three_way_comparison
1574 template<
typename _IteratorL,
1575 three_way_comparable_with<_IteratorL> _IteratorR>
1576 constexpr compare_three_way_result_t<_IteratorL, _IteratorR>
1577 operator<=>(
const move_iterator<_IteratorL>& __x,
1578 const move_iterator<_IteratorR>& __y)
1579 {
return __x.base() <=> __y.base(); }
1581 template<
typename _IteratorL,
typename _IteratorR>
1582 inline _GLIBCXX17_CONSTEXPR
bool
1583 operator!=(
const move_iterator<_IteratorL>& __x,
1584 const move_iterator<_IteratorR>& __y)
1585 {
return !(__x == __y); }
1588 template<
typename _IteratorL,
typename _IteratorR>
1589 inline _GLIBCXX17_CONSTEXPR
bool
1590 operator<(
const move_iterator<_IteratorL>& __x,
1591 const move_iterator<_IteratorR>& __y)
1592 #if __cplusplus > 201703L && __cpp_lib_concepts
1593 requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
1595 {
return __x.base() < __y.base(); }
1597 template<
typename _IteratorL,
typename _IteratorR>
1598 inline _GLIBCXX17_CONSTEXPR
bool
1599 operator<=(
const move_iterator<_IteratorL>& __x,
1600 const move_iterator<_IteratorR>& __y)
1601 #if __cplusplus > 201703L && __cpp_lib_concepts
1602 requires requires { { __y.base() < __x.base() } -> convertible_to<bool>; }
1604 {
return !(__y < __x); }
1606 template<
typename _IteratorL,
typename _IteratorR>
1607 inline _GLIBCXX17_CONSTEXPR
bool
1608 operator>(
const move_iterator<_IteratorL>& __x,
1609 const move_iterator<_IteratorR>& __y)
1610 #if __cplusplus > 201703L && __cpp_lib_concepts
1611 requires requires { { __y.base() < __x.base() } -> convertible_to<bool>; }
1613 {
return __y < __x; }
1615 template<
typename _IteratorL,
typename _IteratorR>
1616 inline _GLIBCXX17_CONSTEXPR
bool
1617 operator>=(
const move_iterator<_IteratorL>& __x,
1618 const move_iterator<_IteratorR>& __y)
1619 #if __cplusplus > 201703L && __cpp_lib_concepts
1620 requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
1622 {
return !(__x < __y); }
1627 template<
typename _Iterator>
1628 inline _GLIBCXX17_CONSTEXPR
bool
1629 operator==(
const move_iterator<_Iterator>& __x,
1630 const move_iterator<_Iterator>& __y)
1631 {
return __x.base() == __y.base(); }
1633 #if __cpp_lib_three_way_comparison
1634 template<three_way_comparable _Iterator>
1635 constexpr compare_three_way_result_t<_Iterator>
1636 operator<=>(
const move_iterator<_Iterator>& __x,
1637 const move_iterator<_Iterator>& __y)
1638 {
return __x.base() <=> __y.base(); }
1640 template<
typename _Iterator>
1641 inline _GLIBCXX17_CONSTEXPR
bool
1642 operator!=(
const move_iterator<_Iterator>& __x,
1643 const move_iterator<_Iterator>& __y)
1644 {
return !(__x == __y); }
1646 template<
typename _Iterator>
1647 inline _GLIBCXX17_CONSTEXPR
bool
1648 operator<(
const move_iterator<_Iterator>& __x,
1649 const move_iterator<_Iterator>& __y)
1650 {
return __x.base() < __y.base(); }
1652 template<
typename _Iterator>
1653 inline _GLIBCXX17_CONSTEXPR
bool
1654 operator<=(
const move_iterator<_Iterator>& __x,
1655 const move_iterator<_Iterator>& __y)
1656 {
return !(__y < __x); }
1658 template<
typename _Iterator>
1659 inline _GLIBCXX17_CONSTEXPR
bool
1660 operator>(
const move_iterator<_Iterator>& __x,
1661 const move_iterator<_Iterator>& __y)
1662 {
return __y < __x; }
1664 template<
typename _Iterator>
1665 inline _GLIBCXX17_CONSTEXPR
bool
1666 operator>=(
const move_iterator<_Iterator>& __x,
1667 const move_iterator<_Iterator>& __y)
1668 {
return !(__x < __y); }
1672 template<
typename _IteratorL,
typename _IteratorR>
1673 inline _GLIBCXX17_CONSTEXPR
auto
1674 operator-(
const move_iterator<_IteratorL>& __x,
1675 const move_iterator<_IteratorR>& __y)
1676 -> decltype(__x.base() - __y.base())
1677 {
return __x.base() - __y.base(); }
1679 template<
typename _Iterator>
1680 inline _GLIBCXX17_CONSTEXPR move_iterator<_Iterator>
1681 operator+(
typename move_iterator<_Iterator>::difference_type __n,
1682 const move_iterator<_Iterator>& __x)
1683 {
return __x + __n; }
1685 template<
typename _Iterator>
1686 inline _GLIBCXX17_CONSTEXPR move_iterator<_Iterator>
1687 make_move_iterator(_Iterator __i)
1688 {
return move_iterator<_Iterator>(
std::move(__i)); }
1690 template<
typename _Iterator,
typename _ReturnType
1691 =
typename conditional<__move_if_noexcept_cond
1692 <
typename iterator_traits<_Iterator>::value_type>::value,
1693 _Iterator, move_iterator<_Iterator>>::type>
1694 inline _GLIBCXX17_CONSTEXPR _ReturnType
1695 __make_move_if_noexcept_iterator(_Iterator __i)
1696 {
return _ReturnType(__i); }
1700 template<
typename _Tp,
typename _ReturnType
1701 =
typename conditional<__move_if_noexcept_cond<_Tp>::value,
1702 const _Tp*, move_iterator<_Tp*>>::type>
1703 inline _GLIBCXX17_CONSTEXPR _ReturnType
1704 __make_move_if_noexcept_iterator(_Tp* __i)
1705 {
return _ReturnType(__i); }
1707 #if __cplusplus > 201703L && __cpp_lib_concepts
1712 template<
typename _It>
1713 concept __common_iter_has_arrow = indirectly_readable<const _It>
1714 && (requires(
const _It& __it) { __it.operator->(); }
1715 || is_reference_v<iter_reference_t<_It>>
1716 || constructible_from<iter_value_t<_It>, iter_reference_t<_It>>);
1718 template<
typename _It>
1719 concept __common_iter_use_postfix_proxy
1720 = (!requires (_It& __i) { { *__i++ } -> __can_reference; })
1721 && constructible_from<iter_value_t<_It>, iter_reference_t<_It>>
1722 && move_constructible<iter_value_t<_It>>;
1726 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
1727 requires (!same_as<_It, _Sent>) && copyable<_It>
1728 class common_iterator
1730 template<
typename _Tp,
typename _Up>
1731 static constexpr
bool
1734 if constexpr (is_trivially_default_constructible_v<_Tp>)
1735 return is_nothrow_assignable_v<_Tp, _Up>;
1737 return is_nothrow_constructible_v<_Tp, _Up>;
1740 template<
typename _It2,
typename _Sent2>
1741 static constexpr
bool
1743 {
return _S_noexcept1<_It, _It2>() && _S_noexcept1<_Sent, _Sent2>(); }
1747 iter_value_t<_It> _M_keep;
1750 __arrow_proxy(iter_reference_t<_It>&& __x)
1753 friend class common_iterator;
1756 constexpr
const iter_value_t<_It>*
1757 operator->() const noexcept
1761 class __postfix_proxy
1763 iter_value_t<_It> _M_keep;
1766 __postfix_proxy(iter_reference_t<_It>&& __x)
1767 : _M_keep(
std::
forward<iter_reference_t<_It>>(__x)) { }
1769 friend class common_iterator;
1772 constexpr
const iter_value_t<_It>&
1780 noexcept(is_nothrow_default_constructible_v<_It>)
1781 requires default_initializable<_It>
1782 : _M_it(), _M_index(0)
1786 common_iterator(_It __i)
1787 noexcept(is_nothrow_move_constructible_v<_It>)
1788 : _M_it(
std::
move(__i)), _M_index(0)
1792 common_iterator(_Sent __s)
1793 noexcept(is_nothrow_move_constructible_v<_Sent>)
1794 : _M_sent(
std::
move(__s)), _M_index(1)
1797 template<
typename _It2,
typename _Sent2>
1798 requires convertible_to<const _It2&, _It>
1799 && convertible_to<const _Sent2&, _Sent>
1801 common_iterator(
const common_iterator<_It2, _Sent2>& __x)
1802 noexcept(_S_noexcept<const _It2&, const _Sent2&>())
1803 : _M_valueless(), _M_index(__x._M_index)
1807 if constexpr (is_trivially_default_constructible_v<_It>)
1812 else if (_M_index == 1)
1814 if constexpr (is_trivially_default_constructible_v<_Sent>)
1822 common_iterator(
const common_iterator& __x)
1823 noexcept(_S_noexcept<const _It&, const _Sent&>())
1824 : _M_valueless(), _M_index(__x._M_index)
1828 if constexpr (is_trivially_default_constructible_v<_It>)
1833 else if (_M_index == 1)
1835 if constexpr (is_trivially_default_constructible_v<_Sent>)
1843 operator=(
const common_iterator& __x)
1844 noexcept(is_nothrow_copy_assignable_v<_It>
1845 && is_nothrow_copy_assignable_v<_Sent>
1846 && is_nothrow_copy_constructible_v<_It>
1847 && is_nothrow_copy_constructible_v<_Sent>)
1849 return this->
operator=<_It, _Sent>(__x);
1852 template<
typename _It2,
typename _Sent2>
1853 requires convertible_to<const _It2&, _It>
1854 && convertible_to<const _Sent2&, _Sent>
1855 && assignable_from<_It&, const _It2&>
1856 && assignable_from<_Sent&, const _Sent2&>
1858 operator=(
const common_iterator<_It2, _Sent2>& __x)
1859 noexcept(is_nothrow_constructible_v<_It, const _It2&>
1860 && is_nothrow_constructible_v<_Sent, const _Sent2&>
1861 && is_nothrow_assignable_v<_It, const _It2&>
1862 && is_nothrow_assignable_v<_Sent, const _Sent2&>)
1864 switch(_M_index << 2 | __x._M_index)
1870 _M_sent = __x._M_sent;
1889 __glibcxx_assert(__x._M_has_value());
1890 __builtin_unreachable();
1911 __glibcxx_assert(_M_index == 0);
1916 operator*() const requires __detail::__dereferenceable<const _It>
1918 __glibcxx_assert(_M_index == 0);
1923 operator->() const requires __detail::__common_iter_has_arrow<_It>
1925 __glibcxx_assert(_M_index == 0);
1926 if constexpr (is_pointer_v<_It> || requires { _M_it.operator->(); })
1928 else if constexpr (is_reference_v<iter_reference_t<_It>>)
1930 auto&& __tmp = *_M_it;
1934 return __arrow_proxy{*_M_it};
1940 __glibcxx_assert(_M_index == 0);
1948 __glibcxx_assert(_M_index == 0);
1949 if constexpr (forward_iterator<_It>)
1951 common_iterator __tmp = *
this;
1955 else if constexpr (!__detail::__common_iter_use_postfix_proxy<_It>)
1959 __postfix_proxy __p(**
this);
1965 template<
typename _It2, sentinel_for<_It> _Sent2>
1966 requires sentinel_for<_Sent, _It2>
1968 operator==(
const common_iterator& __x,
1969 const common_iterator<_It2, _Sent2>& __y)
1971 switch(__x._M_index << 2 | __y._M_index)
1977 return __x._M_it == __y._M_sent;
1979 return __x._M_sent == __y._M_it;
1981 __glibcxx_assert(__x._M_has_value());
1982 __glibcxx_assert(__y._M_has_value());
1983 __builtin_unreachable();
1987 template<
typename _It2, sentinel_for<_It> _Sent2>
1988 requires sentinel_for<_Sent, _It2> && equality_comparable_with<_It, _It2>
1990 operator==(
const common_iterator& __x,
1991 const common_iterator<_It2, _Sent2>& __y)
1993 switch(__x._M_index << 2 | __y._M_index)
1998 return __x._M_it == __y._M_it;
2000 return __x._M_it == __y._M_sent;
2002 return __x._M_sent == __y._M_it;
2004 __glibcxx_assert(__x._M_has_value());
2005 __glibcxx_assert(__y._M_has_value());
2006 __builtin_unreachable();
2010 template<sized_sentinel_for<_It> _It2, sized_sentinel_for<_It> _Sent2>
2011 requires sized_sentinel_for<_Sent, _It2>
2012 friend iter_difference_t<_It2>
2014 const common_iterator<_It2, _Sent2>& __y)
2016 switch(__x._M_index << 2 | __y._M_index)
2021 return __x._M_it - __y._M_it;
2023 return __x._M_it - __y._M_sent;
2025 return __x._M_sent - __y._M_it;
2027 __glibcxx_assert(__x._M_has_value());
2028 __glibcxx_assert(__y._M_has_value());
2029 __builtin_unreachable();
2033 friend iter_rvalue_reference_t<_It>
2034 iter_move(
const common_iterator& __i)
2035 noexcept(noexcept(ranges::iter_move(std::declval<const _It&>())))
2036 requires input_iterator<_It>
2038 __glibcxx_assert(__i._M_index == 0);
2039 return ranges::iter_move(__i._M_it);
2042 template<indirectly_swappable<_It> _It2,
typename _Sent2>
2044 iter_swap(
const common_iterator& __x,
2045 const common_iterator<_It2, _Sent2>& __y)
2046 noexcept(noexcept(ranges::iter_swap(std::declval<const _It&>(),
2047 std::declval<const _It2&>())))
2049 __glibcxx_assert(__x._M_index == 0);
2050 __glibcxx_assert(__y._M_index == 0);
2051 return ranges::iter_swap(__x._M_it, __y._M_it);
2055 template<input_or_output_iterator _It2, sentinel_for<_It2> _Sent2>
2056 friend class common_iterator;
2058 bool _M_has_value() const noexcept {
return _M_index < 2; }
2064 unsigned char _M_valueless;
2066 unsigned char _M_index;
2069 template<
typename _It,
typename _Sent>
2070 struct incrementable_traits<common_iterator<_It, _Sent>>
2072 using difference_type = iter_difference_t<_It>;
2075 template<input_iterator _It,
typename _Sent>
2076 struct iterator_traits<common_iterator<_It, _Sent>>
2079 template<
typename _Iter>
2085 template<
typename _Iter>
2086 requires __detail::__common_iter_has_arrow<_Iter>
2089 using _CIter = common_iterator<_Iter, _Sent>;
2090 using type = decltype(std::declval<const _CIter&>().operator->());
2096 using _Traits = iterator_traits<_It>;
2097 if constexpr (requires { requires derived_from<
typename _Traits::iterator_category,
2098 forward_iterator_tag>; })
2099 return forward_iterator_tag{};
2101 return input_iterator_tag{};
2105 using iterator_concept = conditional_t<forward_iterator<_It>,
2106 forward_iterator_tag, input_iterator_tag>;
2107 using iterator_category = decltype(_S_iter_cat());
2108 using value_type = iter_value_t<_It>;
2109 using difference_type = iter_difference_t<_It>;
2110 using pointer =
typename __ptr<_It>::type;
2111 using reference = iter_reference_t<_It>;
2118 template<
typename _It>
2119 struct __counted_iter_value_type
2122 template<indirectly_readable _It>
2123 struct __counted_iter_value_type<_It>
2124 {
using value_type = iter_value_t<_It>; };
2126 template<
typename _It>
2127 struct __counted_iter_concept
2130 template<
typename _It>
2131 requires requires {
typename _It::iterator_concept; }
2132 struct __counted_iter_concept<_It>
2133 {
using iterator_concept =
typename _It::iterator_concept; };
2135 template<
typename _It>
2136 struct __counted_iter_cat
2139 template<
typename _It>
2140 requires requires {
typename _It::iterator_category; }
2141 struct __counted_iter_cat<_It>
2142 {
using iterator_category =
typename _It::iterator_category; };
2146 template<input_or_output_iterator _It>
2147 class counted_iterator
2148 :
public __detail::__counted_iter_value_type<_It>,
2149 public __detail::__counted_iter_concept<_It>,
2150 public __detail::__counted_iter_cat<_It>
2153 using iterator_type = _It;
2155 using difference_type = iter_difference_t<_It>;
2159 constexpr counted_iterator() requires default_initializable<_It> = default;
2162 counted_iterator(_It __i, iter_difference_t<_It> __n)
2163 : _M_current(
std::
move(__i)), _M_length(__n)
2164 { __glibcxx_assert(__n >= 0); }
2166 template<
typename _It2>
2167 requires convertible_to<const _It2&, _It>
2169 counted_iterator(
const counted_iterator<_It2>& __x)
2170 : _M_current(__x._M_current), _M_length(__x._M_length)
2173 template<
typename _It2>
2174 requires assignable_from<_It&, const _It2&>
2175 constexpr counted_iterator&
2176 operator=(
const counted_iterator<_It2>& __x)
2178 _M_current = __x._M_current;
2179 _M_length = __x._M_length;
2183 constexpr
const _It&
2184 base() const & noexcept
2185 {
return _M_current; }
2189 noexcept(is_nothrow_move_constructible_v<_It>)
2192 constexpr iter_difference_t<_It>
2193 count() const noexcept {
return _M_length; }
2195 constexpr decltype(
auto)
2197 noexcept(noexcept(*_M_current))
2199 __glibcxx_assert( _M_length > 0 );
2203 constexpr decltype(
auto)
2205 noexcept(noexcept(*_M_current))
2206 requires __detail::__dereferenceable<const _It>
2208 __glibcxx_assert( _M_length > 0 );
2213 operator->() const noexcept
2214 requires contiguous_iterator<_It>
2215 {
return std::to_address(_M_current); }
2217 constexpr counted_iterator&
2220 __glibcxx_assert(_M_length > 0);
2229 __glibcxx_assert(_M_length > 0);
2233 return _M_current++;
2236 __throw_exception_again;
2241 constexpr counted_iterator
2242 operator++(
int) requires forward_iterator<_It>
2249 constexpr counted_iterator&
2250 operator--() requires bidirectional_iterator<_It>
2257 constexpr counted_iterator
2258 operator--(
int) requires bidirectional_iterator<_It>
2265 constexpr counted_iterator
2266 operator+(iter_difference_t<_It> __n)
const
2267 requires random_access_iterator<_It>
2268 {
return counted_iterator(_M_current + __n, _M_length - __n); }
2270 friend constexpr counted_iterator
2271 operator+(iter_difference_t<_It> __n,
const counted_iterator& __x)
2272 requires random_access_iterator<_It>
2273 {
return __x + __n; }
2275 constexpr counted_iterator&
2276 operator+=(iter_difference_t<_It> __n)
2277 requires random_access_iterator<_It>
2279 __glibcxx_assert(__n <= _M_length);
2285 constexpr counted_iterator
2286 operator-(iter_difference_t<_It> __n)
const
2287 requires random_access_iterator<_It>
2288 {
return counted_iterator(_M_current - __n, _M_length + __n); }
2290 template<common_with<_It> _It2>
2291 friend constexpr iter_difference_t<_It2>
2293 const counted_iterator<_It2>& __y)
2294 {
return __y._M_length - __x._M_length; }
2296 friend constexpr iter_difference_t<_It>
2297 operator-(
const counted_iterator& __x, default_sentinel_t)
2298 {
return -__x._M_length; }
2300 friend constexpr iter_difference_t<_It>
2301 operator-(default_sentinel_t,
const counted_iterator& __y)
2302 {
return __y._M_length; }
2304 constexpr counted_iterator&
2305 operator-=(iter_difference_t<_It> __n)
2306 requires random_access_iterator<_It>
2308 __glibcxx_assert(-__n <= _M_length);
2314 constexpr decltype(
auto)
2315 operator[](iter_difference_t<_It> __n) const
2316 noexcept(noexcept(_M_current[__n]))
2317 requires random_access_iterator<_It>
2319 __glibcxx_assert(__n < _M_length);
2320 return _M_current[__n];
2323 template<common_with<_It> _It2>
2324 friend constexpr
bool
2325 operator==(
const counted_iterator& __x,
2326 const counted_iterator<_It2>& __y)
2327 {
return __x._M_length == __y._M_length; }
2329 friend constexpr
bool
2330 operator==(
const counted_iterator& __x, default_sentinel_t)
2331 {
return __x._M_length == 0; }
2333 template<common_with<_It> _It2>
2334 friend constexpr strong_ordering
2335 operator<=>(
const counted_iterator& __x,
2336 const counted_iterator<_It2>& __y)
2337 {
return __y._M_length <=> __x._M_length; }
2339 friend constexpr iter_rvalue_reference_t<_It>
2340 iter_move(
const counted_iterator& __i)
2341 noexcept(noexcept(ranges::iter_move(__i._M_current)))
2342 requires input_iterator<_It>
2344 __glibcxx_assert( __i._M_length > 0 );
2345 return ranges::iter_move(__i._M_current);
2348 template<indirectly_swappable<_It> _It2>
2349 friend constexpr
void
2350 iter_swap(
const counted_iterator& __x,
2351 const counted_iterator<_It2>& __y)
2352 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
2354 __glibcxx_assert( __x._M_length > 0 && __y._M_length > 0 );
2355 ranges::iter_swap(__x._M_current, __y._M_current);
2359 template<input_or_output_iterator _It2>
friend class counted_iterator;
2361 _It _M_current = _It();
2362 iter_difference_t<_It> _M_length = 0;
2365 template<input_iterator _It>
2366 requires same_as<__detail::__iter_traits<_It>, iterator_traits<_It>>
2367 struct iterator_traits<counted_iterator<_It>> : iterator_traits<_It>
2369 using pointer = conditional_t<contiguous_iterator<_It>,
2370 add_pointer_t<iter_reference_t<_It>>,
2377 template<
typename _Iterator>
2378 _GLIBCXX20_CONSTEXPR
2380 __niter_base(move_iterator<_Iterator> __it)
2381 -> decltype(make_move_iterator(__niter_base(__it.base())))
2382 {
return make_move_iterator(__niter_base(__it.base())); }
2384 template<
typename _Iterator>
2385 struct __is_move_iterator<move_iterator<_Iterator> >
2387 enum { __value = 1 };
2388 typedef __true_type __type;
2391 template<
typename _Iterator>
2392 _GLIBCXX20_CONSTEXPR
2394 __miter_base(move_iterator<_Iterator> __it)
2395 -> decltype(__miter_base(__it.base()))
2396 {
return __miter_base(__it.base()); }
2398 #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) std::make_move_iterator(_Iter)
2399 #define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) \
2400 std::__make_move_if_noexcept_iterator(_Iter)
2402 #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) (_Iter)
2403 #define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) (_Iter)
2406 #if __cpp_deduction_guides >= 201606
2409 template<
typename _InputIterator>
2411 typename iterator_traits<_InputIterator>::value_type::first_type>;
2413 template<
typename _InputIterator>
2414 using __iter_val_t =
2415 typename iterator_traits<_InputIterator>::value_type::second_type;
2417 template<
typename _T1,
typename _T2>
2420 template<
typename _InputIterator>
2421 using __iter_to_alloc_t =
2422 pair<add_const_t<__iter_key_t<_InputIterator>>,
2423 __iter_val_t<_InputIterator>>;
2426 _GLIBCXX_END_NAMESPACE_VERSION
2429 #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.