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
86 namespace std _GLIBCXX_VISIBILITY(default)
88 _GLIBCXX_BEGIN_NAMESPACE_VERSION
95 #if __cplusplus > 201703L && __cpp_lib_concepts
100 template<
typename _Cat,
typename _Limit,
typename _Otherwise = _Cat>
101 using __clamp_iter_cat
102 = conditional_t<derived_from<_Cat, _Limit>, _Limit, _Otherwise>;
125 template<
typename _Iterator>
127 :
public iterator<typename iterator_traits<_Iterator>::iterator_category,
128 typename iterator_traits<_Iterator>::value_type,
129 typename iterator_traits<_Iterator>::difference_type,
130 typename iterator_traits<_Iterator>::pointer,
131 typename iterator_traits<_Iterator>::reference>
139 typedef _Iterator iterator_type;
140 typedef typename __traits_type::pointer pointer;
141 #if __cplusplus <= 201703L
142 typedef typename __traits_type::difference_type difference_type;
143 typedef typename __traits_type::reference reference;
145 using iterator_concept
150 = __detail::__clamp_iter_cat<
typename __traits_type::iterator_category,
153 using difference_type = iter_difference_t<_Iterator>;
154 using reference = iter_reference_t<_Iterator>;
170 explicit _GLIBCXX17_CONSTEXPR
178 : current(__x.current) { }
180 #if __cplusplus >= 201103L
188 template<
typename _Iter>
191 : current(__x.
base()) { }
196 _GLIBCXX17_CONSTEXPR iterator_type
210 _GLIBCXX17_CONSTEXPR reference
213 _Iterator __tmp = current;
222 _GLIBCXX17_CONSTEXPR pointer
224 #if __cplusplus > 201703L && __cpp_concepts >= 201907L
225 requires is_pointer_v<_Iterator>
226 || requires(
const _Iterator __i) { __i.operator->(); }
231 _Iterator __tmp = current;
233 return _S_to_pointer(__tmp);
335 _GLIBCXX17_CONSTEXPR reference
337 {
return *(*
this + __n); }
339 #if __cplusplus > 201703L && __cpp_lib_concepts
340 friend constexpr iter_rvalue_reference_t<_Iterator>
342 noexcept(is_nothrow_copy_constructible_v<_Iterator>
343 && noexcept(ranges::iter_move(--std::declval<_Iterator&>())))
345 auto __tmp = __i.base();
346 return ranges::iter_move(--__tmp);
349 template<indirectly_swappable<_Iterator> _Iter2>
350 friend constexpr
void
352 const reverse_iterator<_Iter2>& __y)
353 noexcept(is_nothrow_copy_constructible_v<_Iterator>
354 && is_nothrow_copy_constructible_v<_Iter2>
355 && noexcept(ranges::iter_swap(--std::declval<_Iterator&>(),
356 --std::declval<_Iter2&>())))
358 auto __xtmp = __x.base();
359 auto __ytmp = __y.base();
360 ranges::iter_swap(--__xtmp, --__ytmp);
365 template<
typename _Tp>
366 static _GLIBCXX17_CONSTEXPR _Tp*
367 _S_to_pointer(_Tp* __p)
370 template<
typename _Tp>
371 static _GLIBCXX17_CONSTEXPR pointer
372 _S_to_pointer(_Tp __t)
373 {
return __t.operator->(); }
386 #if __cplusplus <= 201703L || ! defined __cpp_lib_concepts
387 template<
typename _Iterator>
388 inline _GLIBCXX17_CONSTEXPR
bool
391 {
return __x.
base() == __y.
base(); }
393 template<
typename _Iterator>
394 inline _GLIBCXX17_CONSTEXPR
bool
395 operator<(
const reverse_iterator<_Iterator>& __x,
396 const reverse_iterator<_Iterator>& __y)
397 {
return __y.base() < __x.base(); }
399 template<
typename _Iterator>
400 inline _GLIBCXX17_CONSTEXPR
bool
401 operator!=(
const reverse_iterator<_Iterator>& __x,
402 const reverse_iterator<_Iterator>& __y)
403 {
return !(__x == __y); }
405 template<
typename _Iterator>
406 inline _GLIBCXX17_CONSTEXPR
bool
407 operator>(
const reverse_iterator<_Iterator>& __x,
408 const reverse_iterator<_Iterator>& __y)
409 {
return __y < __x; }
411 template<
typename _Iterator>
412 inline _GLIBCXX17_CONSTEXPR
bool
413 operator<=(
const reverse_iterator<_Iterator>& __x,
414 const reverse_iterator<_Iterator>& __y)
415 {
return !(__y < __x); }
417 template<
typename _Iterator>
418 inline _GLIBCXX17_CONSTEXPR
bool
419 operator>=(
const reverse_iterator<_Iterator>& __x,
420 const reverse_iterator<_Iterator>& __y)
421 {
return !(__x < __y); }
425 template<
typename _IteratorL,
typename _IteratorR>
426 inline _GLIBCXX17_CONSTEXPR
bool
427 operator==(
const reverse_iterator<_IteratorL>& __x,
428 const reverse_iterator<_IteratorR>& __y)
429 {
return __x.base() == __y.base(); }
431 template<
typename _IteratorL,
typename _IteratorR>
432 inline _GLIBCXX17_CONSTEXPR
bool
433 operator<(
const reverse_iterator<_IteratorL>& __x,
434 const reverse_iterator<_IteratorR>& __y)
435 {
return __y.base() < __x.base(); }
437 template<
typename _IteratorL,
typename _IteratorR>
438 inline _GLIBCXX17_CONSTEXPR
bool
439 operator!=(
const reverse_iterator<_IteratorL>& __x,
440 const reverse_iterator<_IteratorR>& __y)
441 {
return !(__x == __y); }
443 template<
typename _IteratorL,
typename _IteratorR>
444 inline _GLIBCXX17_CONSTEXPR
bool
445 operator>(
const reverse_iterator<_IteratorL>& __x,
446 const reverse_iterator<_IteratorR>& __y)
447 {
return __y < __x; }
449 template<
typename _IteratorL,
typename _IteratorR>
450 inline _GLIBCXX17_CONSTEXPR
bool
451 operator<=(
const reverse_iterator<_IteratorL>& __x,
452 const reverse_iterator<_IteratorR>& __y)
453 {
return !(__y < __x); }
455 template<
typename _IteratorL,
typename _IteratorR>
456 inline _GLIBCXX17_CONSTEXPR
bool
457 operator>=(
const reverse_iterator<_IteratorL>& __x,
458 const reverse_iterator<_IteratorR>& __y)
459 {
return !(__x < __y); }
461 template<
typename _IteratorL,
typename _IteratorR>
463 operator==(
const reverse_iterator<_IteratorL>& __x,
464 const reverse_iterator<_IteratorR>& __y)
465 requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
466 {
return __x.base() == __y.base(); }
468 template<
typename _IteratorL,
typename _IteratorR>
470 operator!=(
const reverse_iterator<_IteratorL>& __x,
471 const reverse_iterator<_IteratorR>& __y)
472 requires requires { { __x.base() != __y.base() } -> convertible_to<bool>; }
473 {
return __x.base() != __y.base(); }
475 template<
typename _IteratorL,
typename _IteratorR>
477 operator<(
const reverse_iterator<_IteratorL>& __x,
478 const reverse_iterator<_IteratorR>& __y)
479 requires requires { { __x.base() > __y.base() } -> convertible_to<bool>; }
480 {
return __x.base() > __y.base(); }
482 template<
typename _IteratorL,
typename _IteratorR>
484 operator>(
const reverse_iterator<_IteratorL>& __x,
485 const reverse_iterator<_IteratorR>& __y)
486 requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
487 {
return __x.base() < __y.base(); }
489 template<
typename _IteratorL,
typename _IteratorR>
491 operator<=(
const reverse_iterator<_IteratorL>& __x,
492 const reverse_iterator<_IteratorR>& __y)
493 requires requires { { __x.base() >= __y.base() } -> convertible_to<bool>; }
494 {
return __x.base() >= __y.base(); }
496 template<
typename _IteratorL,
typename _IteratorR>
498 operator>=(
const reverse_iterator<_IteratorL>& __x,
499 const reverse_iterator<_IteratorR>& __y)
500 requires requires { { __x.base() <= __y.base() } -> convertible_to<bool>; }
501 {
return __x.base() <= __y.base(); }
503 template<
typename _IteratorL,
504 three_way_comparable_with<_IteratorL> _IteratorR>
505 constexpr compare_three_way_result_t<_IteratorL, _IteratorR>
506 operator<=>(
const reverse_iterator<_IteratorL>& __x,
507 const reverse_iterator<_IteratorR>& __y)
508 {
return __y.base() <=> __x.base(); }
512 #if __cplusplus < 201103L
513 template<
typename _Iterator>
514 inline typename reverse_iterator<_Iterator>::difference_type
515 operator-(
const reverse_iterator<_Iterator>& __x,
516 const reverse_iterator<_Iterator>& __y)
517 {
return __y.base() - __x.base(); }
519 template<
typename _IteratorL,
typename _IteratorR>
520 inline typename reverse_iterator<_IteratorL>::difference_type
521 operator-(
const reverse_iterator<_IteratorL>& __x,
522 const reverse_iterator<_IteratorR>& __y)
523 {
return __y.base() - __x.base(); }
527 template<
typename _IteratorL,
typename _IteratorR>
528 inline _GLIBCXX17_CONSTEXPR
auto
529 operator-(
const reverse_iterator<_IteratorL>& __x,
530 const reverse_iterator<_IteratorR>& __y)
531 -> decltype(__y.base() - __x.base())
532 {
return __y.base() - __x.base(); }
535 template<
typename _Iterator>
536 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
537 operator+(
typename reverse_iterator<_Iterator>::difference_type __n,
538 const reverse_iterator<_Iterator>& __x)
539 {
return reverse_iterator<_Iterator>(__x.base() - __n); }
541 #if __cplusplus >= 201103L
543 template<
typename _Iterator>
544 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
545 __make_reverse_iterator(_Iterator __i)
546 {
return reverse_iterator<_Iterator>(__i); }
548 # if __cplusplus >= 201402L
549 # define __cpp_lib_make_reverse_iterator 201402
554 template<
typename _Iterator>
555 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
559 # if __cplusplus > 201703L && defined __cpp_lib_concepts
560 template<
typename _Iterator1,
typename _Iterator2>
561 requires (!sized_sentinel_for<_Iterator1, _Iterator2>)
562 inline constexpr
bool
563 disable_sized_sentinel_for<reverse_iterator<_Iterator1>,
564 reverse_iterator<_Iterator2>> =
true;
568 template<
typename _Iterator>
571 __niter_base(reverse_iterator<_Iterator> __it)
572 -> decltype(__make_reverse_iterator(__niter_base(__it.base())))
573 {
return __make_reverse_iterator(__niter_base(__it.base())); }
575 template<
typename _Iterator>
576 struct __is_move_iterator<reverse_iterator<_Iterator> >
577 : __is_move_iterator<_Iterator>
580 template<
typename _Iterator>
583 __miter_base(reverse_iterator<_Iterator> __it)
584 -> decltype(__make_reverse_iterator(__miter_base(__it.base())))
585 {
return __make_reverse_iterator(__miter_base(__it.base())); }
599 template<
typename _Container>
601 :
public iterator<output_iterator_tag, void, void, void, void>
604 _Container* container;
609 #if __cplusplus > 201703L
616 explicit _GLIBCXX20_CONSTEXPR
631 #if __cplusplus < 201103L
633 operator=(
typename _Container::const_reference __value)
635 container->push_back(__value);
641 operator=(
const typename _Container::value_type& __value)
643 container->push_back(__value);
649 operator=(
typename _Container::value_type&& __value)
651 container->push_back(
std::move(__value));
686 template<
typename _Container>
688 inline back_insert_iterator<_Container>
702 template<
typename _Container>
704 :
public iterator<output_iterator_tag, void, void, void, void>
707 _Container* container;
712 #if __cplusplus > 201703L
719 explicit _GLIBCXX20_CONSTEXPR
734 #if __cplusplus < 201103L
736 operator=(
typename _Container::const_reference __value)
738 container->push_front(__value);
744 operator=(
const typename _Container::value_type& __value)
746 container->push_front(__value);
752 operator=(
typename _Container::value_type&& __value)
754 container->push_front(
std::move(__value));
789 template<
typename _Container>
791 inline front_insert_iterator<_Container>
809 template<
typename _Container>
811 :
public iterator<output_iterator_tag, void, void, void, void>
813 #if __cplusplus > 201703L && defined __cpp_lib_concepts
814 using _Iter = std::__detail::__range_iter_t<_Container>;
817 _Container* container =
nullptr;
818 _Iter iter = _Iter();
820 typedef typename _Container::iterator _Iter;
823 _Container* container;
831 #if __cplusplus > 201703L && defined __cpp_lib_concepts
868 #if __cplusplus < 201103L
870 operator=(
typename _Container::const_reference __value)
872 iter = container->insert(iter, __value);
879 operator=(
const typename _Container::value_type& __value)
881 iter = container->insert(iter, __value);
888 operator=(
typename _Container::value_type&& __value)
890 iter = container->insert(iter,
std::move(__value));
927 #if __cplusplus > 201703L && defined __cpp_lib_concepts
928 template<
typename _Container>
929 constexpr insert_iterator<_Container>
930 inserter(_Container& __x, std::__detail::__range_iter_t<_Container> __i)
931 {
return insert_iterator<_Container>(__x, __i); }
933 template<
typename _Container>
934 inline insert_iterator<_Container>
935 inserter(_Container& __x,
typename _Container::iterator __i)
941 _GLIBCXX_END_NAMESPACE_VERSION
944 namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
946 _GLIBCXX_BEGIN_NAMESPACE_VERSION
955 template<
typename _Iterator,
typename _Container>
956 class __normal_iterator
959 _Iterator _M_current;
964 typedef _Iterator iterator_type;
965 typedef typename __traits_type::iterator_category iterator_category;
966 typedef typename __traits_type::value_type value_type;
967 typedef typename __traits_type::difference_type difference_type;
968 typedef typename __traits_type::reference reference;
969 typedef typename __traits_type::pointer pointer;
971 #if __cplusplus > 201703L && __cpp_lib_concepts
972 using iterator_concept = std::__detail::__iter_concept<_Iterator>;
975 _GLIBCXX_CONSTEXPR __normal_iterator() _GLIBCXX_NOEXCEPT
976 : _M_current(_Iterator()) { }
978 explicit _GLIBCXX20_CONSTEXPR
979 __normal_iterator(
const _Iterator& __i) _GLIBCXX_NOEXCEPT
980 : _M_current(__i) { }
983 template<
typename _Iter>
985 __normal_iterator(
const __normal_iterator<_Iter,
986 typename __enable_if<
987 (std::__are_same<_Iter, typename _Container::pointer>::__value),
988 _Container>::__type>& __i) _GLIBCXX_NOEXCEPT
989 : _M_current(__i.base()) { }
995 {
return *_M_current; }
999 operator->() const _GLIBCXX_NOEXCEPT
1000 {
return _M_current; }
1002 _GLIBCXX20_CONSTEXPR
1004 operator++() _GLIBCXX_NOEXCEPT
1010 _GLIBCXX20_CONSTEXPR
1012 operator++(
int) _GLIBCXX_NOEXCEPT
1013 {
return __normal_iterator(_M_current++); }
1016 _GLIBCXX20_CONSTEXPR
1018 operator--() _GLIBCXX_NOEXCEPT
1024 _GLIBCXX20_CONSTEXPR
1026 operator--(
int) _GLIBCXX_NOEXCEPT
1027 {
return __normal_iterator(_M_current--); }
1030 _GLIBCXX20_CONSTEXPR
1032 operator[](difference_type __n)
const _GLIBCXX_NOEXCEPT
1033 {
return _M_current[__n]; }
1035 _GLIBCXX20_CONSTEXPR
1037 operator+=(difference_type __n) _GLIBCXX_NOEXCEPT
1038 { _M_current += __n;
return *
this; }
1040 _GLIBCXX20_CONSTEXPR
1042 operator+(difference_type __n)
const _GLIBCXX_NOEXCEPT
1043 {
return __normal_iterator(_M_current + __n); }
1045 _GLIBCXX20_CONSTEXPR
1047 operator-=(difference_type __n) _GLIBCXX_NOEXCEPT
1048 { _M_current -= __n;
return *
this; }
1050 _GLIBCXX20_CONSTEXPR
1052 operator-(difference_type __n)
const _GLIBCXX_NOEXCEPT
1053 {
return __normal_iterator(_M_current - __n); }
1055 _GLIBCXX20_CONSTEXPR
1057 base() const _GLIBCXX_NOEXCEPT
1058 {
return _M_current; }
1069 #if __cpp_lib_three_way_comparison
1070 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1071 requires requires (_IteratorL __lhs, _IteratorR __rhs)
1072 { { __lhs == __rhs } -> std::convertible_to<bool>; }
1074 operator==(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1075 const __normal_iterator<_IteratorR, _Container>& __rhs)
1076 noexcept(noexcept(__lhs.base() == __rhs.base()))
1077 {
return __lhs.base() == __rhs.base(); }
1079 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1080 constexpr std::__detail::__synth3way_t<_IteratorR, _IteratorL>
1081 operator<=>(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1082 const __normal_iterator<_IteratorR, _Container>& __rhs)
1083 noexcept(noexcept(std::__detail::__synth3way(__lhs.base(), __rhs.base())))
1084 {
return std::__detail::__synth3way(__lhs.base(), __rhs.base()); }
1087 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1088 _GLIBCXX20_CONSTEXPR
1090 operator==(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1091 const __normal_iterator<_IteratorR, _Container>& __rhs)
1093 {
return __lhs.base() == __rhs.base(); }
1095 template<
typename _Iterator,
typename _Container>
1096 _GLIBCXX20_CONSTEXPR
1098 operator==(
const __normal_iterator<_Iterator, _Container>& __lhs,
1099 const __normal_iterator<_Iterator, _Container>& __rhs)
1101 {
return __lhs.base() == __rhs.base(); }
1103 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1104 _GLIBCXX20_CONSTEXPR
1106 operator!=(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1107 const __normal_iterator<_IteratorR, _Container>& __rhs)
1109 {
return __lhs.base() != __rhs.base(); }
1111 template<
typename _Iterator,
typename _Container>
1112 _GLIBCXX20_CONSTEXPR
1114 operator!=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1115 const __normal_iterator<_Iterator, _Container>& __rhs)
1117 {
return __lhs.base() != __rhs.base(); }
1120 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1122 operator<(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1123 const __normal_iterator<_IteratorR, _Container>& __rhs)
1125 {
return __lhs.base() < __rhs.base(); }
1127 template<
typename _Iterator,
typename _Container>
1128 _GLIBCXX20_CONSTEXPR
1130 operator<(
const __normal_iterator<_Iterator, _Container>& __lhs,
1131 const __normal_iterator<_Iterator, _Container>& __rhs)
1133 {
return __lhs.base() < __rhs.base(); }
1135 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1137 operator>(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1138 const __normal_iterator<_IteratorR, _Container>& __rhs)
1140 {
return __lhs.base() > __rhs.base(); }
1142 template<
typename _Iterator,
typename _Container>
1143 _GLIBCXX20_CONSTEXPR
1145 operator>(
const __normal_iterator<_Iterator, _Container>& __lhs,
1146 const __normal_iterator<_Iterator, _Container>& __rhs)
1148 {
return __lhs.base() > __rhs.base(); }
1150 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1152 operator<=(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1153 const __normal_iterator<_IteratorR, _Container>& __rhs)
1155 {
return __lhs.base() <= __rhs.base(); }
1157 template<
typename _Iterator,
typename _Container>
1158 _GLIBCXX20_CONSTEXPR
1160 operator<=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1161 const __normal_iterator<_Iterator, _Container>& __rhs)
1163 {
return __lhs.base() <= __rhs.base(); }
1165 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1167 operator>=(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1168 const __normal_iterator<_IteratorR, _Container>& __rhs)
1170 {
return __lhs.base() >= __rhs.base(); }
1172 template<
typename _Iterator,
typename _Container>
1173 _GLIBCXX20_CONSTEXPR
1175 operator>=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1176 const __normal_iterator<_Iterator, _Container>& __rhs)
1178 {
return __lhs.base() >= __rhs.base(); }
1185 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1186 #if __cplusplus >= 201103L
1188 _GLIBCXX20_CONSTEXPR
1190 operator-(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1191 const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept
1192 -> decltype(__lhs.base() - __rhs.base())
1194 inline typename __normal_iterator<_IteratorL, _Container>::difference_type
1195 operator-(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1196 const __normal_iterator<_IteratorR, _Container>& __rhs)
1198 {
return __lhs.base() - __rhs.base(); }
1200 template<
typename _Iterator,
typename _Container>
1201 _GLIBCXX20_CONSTEXPR
1202 inline typename __normal_iterator<_Iterator, _Container>::difference_type
1203 operator-(
const __normal_iterator<_Iterator, _Container>& __lhs,
1204 const __normal_iterator<_Iterator, _Container>& __rhs)
1206 {
return __lhs.base() - __rhs.base(); }
1208 template<
typename _Iterator,
typename _Container>
1209 _GLIBCXX20_CONSTEXPR
1210 inline __normal_iterator<_Iterator, _Container>
1211 operator+(
typename __normal_iterator<_Iterator, _Container>::difference_type
1212 __n,
const __normal_iterator<_Iterator, _Container>& __i)
1214 {
return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
1216 _GLIBCXX_END_NAMESPACE_VERSION
1219 namespace std _GLIBCXX_VISIBILITY(default)
1221 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1223 template<
typename _Iterator,
typename _Container>
1224 _GLIBCXX20_CONSTEXPR
1226 __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it)
1228 {
return __it.base(); }
1230 #if __cplusplus >= 201103L
1236 #if __cplusplus > 201703L && __cpp_lib_concepts
1237 template<semiregular _Sent>
1243 noexcept(is_nothrow_default_constructible_v<_Sent>)
1247 move_sentinel(_Sent __s)
1248 noexcept(is_nothrow_move_constructible_v<_Sent>)
1251 template<
typename _S2> requires convertible_to<const _S2&, _Sent>
1253 move_sentinel(
const move_sentinel<_S2>& __s)
1254 noexcept(is_nothrow_constructible_v<_Sent, const _S2&>)
1255 : _M_last(__s.base())
1258 template<
typename _S2> requires assignable_from<_Sent&, const _S2&>
1259 constexpr move_sentinel&
1260 operator=(
const move_sentinel<_S2>& __s)
1261 noexcept(is_nothrow_assignable_v<_Sent, const _S2&>)
1263 _M_last = __s.base();
1269 noexcept(is_nothrow_copy_constructible_v<_Sent>)
1279 #if __cplusplus > 201703L && __cpp_lib_concepts
1280 template<
typename _Iterator>
1281 struct __move_iter_cat
1284 template<
typename _Iterator>
1285 requires requires {
typename iterator_traits<_Iterator>::iterator_category; }
1286 struct __move_iter_cat<_Iterator>
1288 using iterator_category
1289 = __clamp_iter_cat<typename iterator_traits<_Iterator>::iterator_category,
1290 random_access_iterator_tag>;
1304 template<
typename _Iterator>
1306 #if __cplusplus > 201703L && __cpp_lib_concepts
1307 :
public __detail::__move_iter_cat<_Iterator>
1310 _Iterator _M_current;
1313 #if ! (__cplusplus > 201703L && __cpp_lib_concepts)
1314 using __base_ref =
typename __traits_type::reference;
1318 using iterator_type = _Iterator;
1320 #if __cplusplus > 201703L && __cpp_lib_concepts
1323 using value_type = iter_value_t<_Iterator>;
1324 using difference_type = iter_difference_t<_Iterator>;
1325 using pointer = _Iterator;
1326 using reference = iter_rvalue_reference_t<_Iterator>;
1328 typedef typename __traits_type::iterator_category iterator_category;
1329 typedef typename __traits_type::value_type value_type;
1330 typedef typename __traits_type::difference_type difference_type;
1332 typedef _Iterator pointer;
1336 typename remove_reference<__base_ref>::type&&,
1337 __base_ref>::type reference;
1340 _GLIBCXX17_CONSTEXPR
1344 explicit _GLIBCXX17_CONSTEXPR
1348 template<
typename _Iter>
1349 _GLIBCXX17_CONSTEXPR
1351 : _M_current(__i.base()) { }
1353 template<
typename _Iter>
1354 _GLIBCXX17_CONSTEXPR
1357 _M_current = __i.base();
1361 #if __cplusplus <= 201703L
1362 _GLIBCXX17_CONSTEXPR iterator_type
1364 {
return _M_current; }
1366 constexpr
const iterator_type&
1367 base()
const & noexcept
1368 {
return _M_current; }
1370 constexpr iterator_type
1375 _GLIBCXX17_CONSTEXPR reference
1377 #if __cplusplus > 201703L && __cpp_lib_concepts
1378 {
return ranges::iter_move(_M_current); }
1380 {
return static_cast<reference
>(*_M_current); }
1383 _GLIBCXX17_CONSTEXPR pointer
1385 {
return _M_current; }
1402 #if __cpp_lib_concepts
1404 operator++(
int) requires (!forward_iterator<_Iterator>)
1428 operator+=(difference_type __n)
1439 operator-=(difference_type __n)
1445 _GLIBCXX17_CONSTEXPR reference
1446 operator[](difference_type __n)
const
1447 #if __cplusplus > 201703L && __cpp_lib_concepts
1448 {
return ranges::iter_move(_M_current + __n); }
1453 #if __cplusplus > 201703L && __cpp_lib_concepts
1454 template<sentinel_for<_Iterator> _Sent>
1455 friend constexpr
bool
1456 operator==(
const move_iterator& __x,
const move_sentinel<_Sent>& __y)
1457 {
return __x.base() == __y.base(); }
1459 template<sized_sentinel_for<_Iterator> _Sent>
1460 friend constexpr iter_difference_t<_Iterator>
1462 {
return __x.base() - __y.base(); }
1464 template<sized_sentinel_for<_Iterator> _Sent>
1465 friend constexpr iter_difference_t<_Iterator>
1467 {
return __x.base() - __y.base(); }
1469 friend constexpr iter_rvalue_reference_t<_Iterator>
1471 noexcept(noexcept(ranges::iter_move(__i._M_current)))
1472 {
return ranges::iter_move(__i._M_current); }
1474 template<indirectly_swappable<_Iterator> _Iter2>
1475 friend constexpr
void
1477 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1478 {
return ranges::iter_swap(__x._M_current, __y._M_current); }
1482 template<
typename _IteratorL,
typename _IteratorR>
1483 inline _GLIBCXX17_CONSTEXPR
bool
1486 #if __cplusplus > 201703L && __cpp_lib_concepts
1487 requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
1489 {
return __x.base() == __y.base(); }
1491 #if __cpp_lib_three_way_comparison
1492 template<
typename _IteratorL,
1493 three_way_comparable_with<_IteratorL> _IteratorR>
1494 constexpr compare_three_way_result_t<_IteratorL, _IteratorR>
1495 operator<=>(
const move_iterator<_IteratorL>& __x,
1496 const move_iterator<_IteratorR>& __y)
1497 {
return __x.base() <=> __y.base(); }
1499 template<
typename _IteratorL,
typename _IteratorR>
1500 inline _GLIBCXX17_CONSTEXPR
bool
1501 operator!=(
const move_iterator<_IteratorL>& __x,
1502 const move_iterator<_IteratorR>& __y)
1503 {
return !(__x == __y); }
1506 template<
typename _IteratorL,
typename _IteratorR>
1507 inline _GLIBCXX17_CONSTEXPR
bool
1508 operator<(
const move_iterator<_IteratorL>& __x,
1509 const move_iterator<_IteratorR>& __y)
1510 #if __cplusplus > 201703L && __cpp_lib_concepts
1511 requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
1513 {
return __x.base() < __y.base(); }
1515 template<
typename _IteratorL,
typename _IteratorR>
1516 inline _GLIBCXX17_CONSTEXPR
bool
1517 operator<=(
const move_iterator<_IteratorL>& __x,
1518 const move_iterator<_IteratorR>& __y)
1519 #if __cplusplus > 201703L && __cpp_lib_concepts
1520 requires requires { { __y.base() < __x.base() } -> convertible_to<bool>; }
1522 {
return !(__y < __x); }
1524 template<
typename _IteratorL,
typename _IteratorR>
1525 inline _GLIBCXX17_CONSTEXPR
bool
1526 operator>(
const move_iterator<_IteratorL>& __x,
1527 const move_iterator<_IteratorR>& __y)
1528 #if __cplusplus > 201703L && __cpp_lib_concepts
1529 requires requires { { __y.base() < __x.base() } -> convertible_to<bool>; }
1531 {
return __y < __x; }
1533 template<
typename _IteratorL,
typename _IteratorR>
1534 inline _GLIBCXX17_CONSTEXPR
bool
1535 operator>=(
const move_iterator<_IteratorL>& __x,
1536 const move_iterator<_IteratorR>& __y)
1537 #if __cplusplus > 201703L && __cpp_lib_concepts
1538 requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
1540 {
return !(__x < __y); }
1542 #if ! (__cplusplus > 201703L && __cpp_lib_concepts)
1550 template<
typename _Iterator>
1551 inline _GLIBCXX17_CONSTEXPR
bool
1552 operator==(
const move_iterator<_Iterator>& __x,
1553 const move_iterator<_Iterator>& __y)
1554 {
return __x.base() == __y.base(); }
1556 template<
typename _Iterator>
1557 inline _GLIBCXX17_CONSTEXPR
bool
1558 operator!=(
const move_iterator<_Iterator>& __x,
1559 const move_iterator<_Iterator>& __y)
1560 {
return !(__x == __y); }
1562 template<
typename _Iterator>
1563 inline _GLIBCXX17_CONSTEXPR
bool
1564 operator<(
const move_iterator<_Iterator>& __x,
1565 const move_iterator<_Iterator>& __y)
1566 {
return __x.base() < __y.base(); }
1568 template<
typename _Iterator>
1569 inline _GLIBCXX17_CONSTEXPR
bool
1570 operator<=(
const move_iterator<_Iterator>& __x,
1571 const move_iterator<_Iterator>& __y)
1572 {
return !(__y < __x); }
1574 template<
typename _Iterator>
1575 inline _GLIBCXX17_CONSTEXPR
bool
1576 operator>(
const move_iterator<_Iterator>& __x,
1577 const move_iterator<_Iterator>& __y)
1578 {
return __y < __x; }
1580 template<
typename _Iterator>
1581 inline _GLIBCXX17_CONSTEXPR
bool
1582 operator>=(
const move_iterator<_Iterator>& __x,
1583 const move_iterator<_Iterator>& __y)
1584 {
return !(__x < __y); }
1588 template<
typename _IteratorL,
typename _IteratorR>
1589 inline _GLIBCXX17_CONSTEXPR
auto
1590 operator-(
const move_iterator<_IteratorL>& __x,
1591 const move_iterator<_IteratorR>& __y)
1592 -> decltype(__x.base() - __y.base())
1593 {
return __x.base() - __y.base(); }
1595 template<
typename _Iterator>
1596 inline _GLIBCXX17_CONSTEXPR move_iterator<_Iterator>
1597 operator+(
typename move_iterator<_Iterator>::difference_type __n,
1598 const move_iterator<_Iterator>& __x)
1599 {
return __x + __n; }
1601 template<
typename _Iterator>
1602 inline _GLIBCXX17_CONSTEXPR move_iterator<_Iterator>
1603 make_move_iterator(_Iterator __i)
1604 {
return move_iterator<_Iterator>(
std::move(__i)); }
1606 template<
typename _Iterator,
typename _ReturnType
1607 =
typename conditional<__move_if_noexcept_cond
1608 <
typename iterator_traits<_Iterator>::value_type>::value,
1609 _Iterator, move_iterator<_Iterator>>::type>
1610 inline _GLIBCXX17_CONSTEXPR _ReturnType
1611 __make_move_if_noexcept_iterator(_Iterator __i)
1612 {
return _ReturnType(__i); }
1616 template<
typename _Tp,
typename _ReturnType
1617 =
typename conditional<__move_if_noexcept_cond<_Tp>::value,
1618 const _Tp*, move_iterator<_Tp*>>::type>
1619 inline _GLIBCXX17_CONSTEXPR _ReturnType
1620 __make_move_if_noexcept_iterator(_Tp* __i)
1621 {
return _ReturnType(__i); }
1623 #if __cplusplus > 201703L && __cpp_lib_concepts
1628 template<
typename _It>
1629 concept __common_iter_has_arrow = indirectly_readable<const _It>
1630 && (requires(
const _It& __it) { __it.operator->(); }
1631 || is_reference_v<iter_reference_t<_It>>
1632 || constructible_from<iter_value_t<_It>, iter_reference_t<_It>>);
1634 template<
typename _It>
1635 concept __common_iter_use_postfix_proxy
1636 = (!requires (_It& __i) { { *__i++ } -> __can_reference; })
1637 && constructible_from<iter_value_t<_It>, iter_reference_t<_It>>
1638 && move_constructible<iter_value_t<_It>>;
1642 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
1643 requires (!same_as<_It, _Sent>) && copyable<_It>
1644 class common_iterator
1646 template<
typename _Tp,
typename _Up>
1647 static constexpr
bool
1650 if constexpr (is_trivially_default_constructible_v<_Tp>)
1651 return is_nothrow_assignable_v<_Tp, _Up>;
1653 return is_nothrow_constructible_v<_Tp, _Up>;
1656 template<
typename _It2,
typename _Sent2>
1657 static constexpr
bool
1659 {
return _S_noexcept1<_It, _It2>() && _S_noexcept1<_Sent, _Sent2>(); }
1663 iter_value_t<_It> _M_keep;
1665 __arrow_proxy(iter_reference_t<_It>&& __x)
1668 friend class common_iterator;
1671 const iter_value_t<_It>*
1676 class __postfix_proxy
1678 iter_value_t<_It> _M_keep;
1680 __postfix_proxy(iter_reference_t<_It>&& __x)
1681 : _M_keep(
std::
forward<iter_reference_t<_It>>(__x)) { }
1683 friend class common_iterator;
1686 const iter_value_t<_It>&
1694 noexcept(is_nothrow_default_constructible_v<_It>)
1695 : _M_it(), _M_index(0)
1699 common_iterator(_It __i)
1700 noexcept(is_nothrow_move_constructible_v<_It>)
1701 : _M_it(
std::
move(__i)), _M_index(0)
1705 common_iterator(_Sent __s)
1706 noexcept(is_nothrow_move_constructible_v<_Sent>)
1707 : _M_sent(
std::
move(__s)), _M_index(1)
1710 template<
typename _It2,
typename _Sent2>
1711 requires convertible_to<const _It2&, _It>
1712 && convertible_to<const _Sent2&, _Sent>
1714 common_iterator(
const common_iterator<_It2, _Sent2>& __x)
1715 noexcept(_S_noexcept<const _It2&, const _Sent2&>())
1716 : _M_valueless(), _M_index(__x._M_index)
1720 if constexpr (is_trivially_default_constructible_v<_It>)
1725 else if (_M_index == 1)
1727 if constexpr (is_trivially_default_constructible_v<_Sent>)
1735 common_iterator(
const common_iterator& __x)
1736 noexcept(_S_noexcept<const _It&, const _Sent&>())
1737 : _M_valueless(), _M_index(__x._M_index)
1741 if constexpr (is_trivially_default_constructible_v<_It>)
1746 else if (_M_index == 1)
1748 if constexpr (is_trivially_default_constructible_v<_Sent>)
1756 operator=(
const common_iterator& __x)
1757 noexcept(is_nothrow_copy_assignable_v<_It>
1758 && is_nothrow_copy_assignable_v<_Sent>
1759 && is_nothrow_copy_constructible_v<_It>
1760 && is_nothrow_copy_constructible_v<_Sent>)
1762 return this->
operator=<_It, _Sent>(__x);
1765 template<
typename _It2,
typename _Sent2>
1766 requires convertible_to<const _It2&, _It>
1767 && convertible_to<const _Sent2&, _Sent>
1768 && assignable_from<_It&, const _It2&>
1769 && assignable_from<_Sent&, const _Sent2&>
1771 operator=(
const common_iterator<_It2, _Sent2>& __x)
1772 noexcept(is_nothrow_constructible_v<_It, const _It2&>
1773 && is_nothrow_constructible_v<_Sent, const _Sent2&>
1774 && is_nothrow_assignable_v<_It, const _It2&>
1775 && is_nothrow_assignable_v<_Sent, const _Sent2&>)
1777 switch(_M_index << 2 | __x._M_index)
1783 _M_sent = __x._M_sent;
1802 __glibcxx_assert(__x._M_has_value());
1803 __builtin_unreachable();
1824 __glibcxx_assert(_M_index == 0);
1829 operator*() const requires __detail::__dereferenceable<const _It>
1831 __glibcxx_assert(_M_index == 0);
1836 operator->() const requires __detail::__common_iter_has_arrow<_It>
1838 __glibcxx_assert(_M_index == 0);
1839 if constexpr (is_pointer_v<_It> || requires { _M_it.operator->(); })
1841 else if constexpr (is_reference_v<iter_reference_t<_It>>)
1843 auto&& __tmp = *_M_it;
1847 return __arrow_proxy{*_M_it};
1853 __glibcxx_assert(_M_index == 0);
1861 __glibcxx_assert(_M_index == 0);
1862 if constexpr (forward_iterator<_It>)
1864 common_iterator __tmp = *
this;
1868 else if constexpr (!__detail::__common_iter_use_postfix_proxy<_It>)
1872 __postfix_proxy __p(**
this);
1878 template<
typename _It2, sentinel_for<_It> _Sent2>
1879 requires sentinel_for<_Sent, _It2>
1881 operator==(
const common_iterator& __x,
1882 const common_iterator<_It2, _Sent2>& __y)
1884 switch(__x._M_index << 2 | __y._M_index)
1890 return __x._M_it == __y._M_sent;
1892 return __x._M_sent == __y._M_it;
1894 __glibcxx_assert(__x._M_has_value());
1895 __glibcxx_assert(__y._M_has_value());
1896 __builtin_unreachable();
1900 template<
typename _It2, sentinel_for<_It> _Sent2>
1901 requires sentinel_for<_Sent, _It2> && equality_comparable_with<_It, _It2>
1903 operator==(
const common_iterator& __x,
1904 const common_iterator<_It2, _Sent2>& __y)
1906 switch(__x._M_index << 2 | __y._M_index)
1911 return __x._M_it == __y._M_it;
1913 return __x._M_it == __y._M_sent;
1915 return __x._M_sent == __y._M_it;
1917 __glibcxx_assert(__x._M_has_value());
1918 __glibcxx_assert(__y._M_has_value());
1919 __builtin_unreachable();
1923 template<sized_sentinel_for<_It> _It2, sized_sentinel_for<_It> _Sent2>
1924 requires sized_sentinel_for<_Sent, _It2>
1925 friend iter_difference_t<_It2>
1927 const common_iterator<_It2, _Sent2>& __y)
1929 switch(__x._M_index << 2 | __y._M_index)
1934 return __x._M_it - __y._M_it;
1936 return __x._M_it - __y._M_sent;
1938 return __x._M_sent - __y._M_it;
1940 __glibcxx_assert(__x._M_has_value());
1941 __glibcxx_assert(__y._M_has_value());
1942 __builtin_unreachable();
1946 friend iter_rvalue_reference_t<_It>
1947 iter_move(
const common_iterator& __i)
1948 noexcept(noexcept(ranges::iter_move(std::declval<const _It&>())))
1949 requires input_iterator<_It>
1951 __glibcxx_assert(__i._M_index == 0);
1952 return ranges::iter_move(__i._M_it);
1955 template<indirectly_swappable<_It> _It2,
typename _Sent2>
1957 iter_swap(
const common_iterator& __x,
1958 const common_iterator<_It2, _Sent2>& __y)
1959 noexcept(noexcept(ranges::iter_swap(std::declval<const _It&>(),
1960 std::declval<const _It2&>())))
1962 __glibcxx_assert(__x._M_index == 0);
1963 __glibcxx_assert(__y._M_index == 0);
1964 return ranges::iter_swap(__x._M_it, __y._M_it);
1968 template<input_or_output_iterator _It2, sentinel_for<_It2> _Sent2>
1969 friend class common_iterator;
1971 bool _M_has_value() const noexcept {
return _M_index < 2; }
1977 unsigned char _M_valueless;
1979 unsigned char _M_index;
1982 template<
typename _It,
typename _Sent>
1983 struct incrementable_traits<common_iterator<_It, _Sent>>
1985 using difference_type = iter_difference_t<_It>;
1988 template<input_iterator _It,
typename _Sent>
1989 struct iterator_traits<common_iterator<_It, _Sent>>
1992 template<
typename _Iter>
1998 template<
typename _Iter>
1999 requires __detail::__common_iter_has_arrow<_Iter>
2002 using _CIter = common_iterator<_Iter, _Sent>;
2003 using type = decltype(std::declval<const _CIter&>().operator->());
2009 using _Traits = iterator_traits<_It>;
2010 if constexpr (requires { requires derived_from<
typename _Traits::iterator_category,
2011 forward_iterator_tag>; })
2012 return forward_iterator_tag{};
2014 return input_iterator_tag{};
2018 using iterator_concept = conditional_t<forward_iterator<_It>,
2019 forward_iterator_tag, input_iterator_tag>;
2020 using iterator_category = decltype(_S_iter_cat());
2021 using value_type = iter_value_t<_It>;
2022 using difference_type = iter_difference_t<_It>;
2023 using pointer =
typename __ptr<_It>::type;
2024 using reference = iter_reference_t<_It>;
2031 template<
typename _It>
2032 struct __counted_iter_value_type
2035 template<indirectly_readable _It>
2036 struct __counted_iter_value_type<_It>
2037 {
using value_type = iter_value_t<_It>; };
2039 template<
typename _It>
2040 struct __counted_iter_concept
2043 template<
typename _It>
2044 requires requires {
typename _It::iterator_concept; }
2045 struct __counted_iter_concept<_It>
2046 {
using iterator_concept =
typename _It::iterator_concept; };
2048 template<
typename _It>
2049 struct __counted_iter_cat
2052 template<
typename _It>
2053 requires requires {
typename _It::iterator_category; }
2054 struct __counted_iter_cat<_It>
2055 {
using iterator_category =
typename _It::iterator_category; };
2059 template<input_or_output_iterator _It>
2060 class counted_iterator
2061 :
public __detail::__counted_iter_value_type<_It>,
2062 public __detail::__counted_iter_concept<_It>,
2063 public __detail::__counted_iter_cat<_It>
2066 using iterator_type = _It;
2068 using difference_type = iter_difference_t<_It>;
2072 constexpr counted_iterator() =
default;
2075 counted_iterator(_It __i, iter_difference_t<_It> __n)
2076 : _M_current(
std::
move(__i)), _M_length(__n)
2077 { __glibcxx_assert(__n >= 0); }
2079 template<
typename _It2>
2080 requires convertible_to<const _It2&, _It>
2082 counted_iterator(
const counted_iterator<_It2>& __x)
2083 : _M_current(__x._M_current), _M_length(__x._M_length)
2086 template<
typename _It2>
2087 requires assignable_from<_It&, const _It2&>
2088 constexpr counted_iterator&
2089 operator=(
const counted_iterator<_It2>& __x)
2091 _M_current = __x._M_current;
2092 _M_length = __x._M_length;
2096 constexpr
const _It&
2097 base() const & noexcept
2098 {
return _M_current; }
2102 noexcept(is_nothrow_move_constructible_v<_It>)
2105 constexpr iter_difference_t<_It>
2106 count() const noexcept {
return _M_length; }
2108 constexpr decltype(
auto)
2110 noexcept(noexcept(*_M_current))
2111 {
return *_M_current; }
2113 constexpr decltype(
auto)
2115 noexcept(noexcept(*_M_current))
2116 requires __detail::__dereferenceable<const _It>
2117 {
return *_M_current; }
2120 operator->() const noexcept
2121 requires contiguous_iterator<_It>
2122 {
return std::to_address(_M_current); }
2124 constexpr counted_iterator&
2127 __glibcxx_assert(_M_length > 0);
2136 __glibcxx_assert(_M_length > 0);
2140 return _M_current++;
2143 __throw_exception_again;
2148 constexpr counted_iterator
2149 operator++(
int) requires forward_iterator<_It>
2156 constexpr counted_iterator&
2157 operator--() requires bidirectional_iterator<_It>
2164 constexpr counted_iterator
2165 operator--(
int) requires bidirectional_iterator<_It>
2172 constexpr counted_iterator
2173 operator+(iter_difference_t<_It> __n)
const
2174 requires random_access_iterator<_It>
2175 {
return counted_iterator(_M_current + __n, _M_length - __n); }
2177 friend constexpr counted_iterator
2178 operator+(iter_difference_t<_It> __n,
const counted_iterator& __x)
2179 requires random_access_iterator<_It>
2180 {
return __x + __n; }
2182 constexpr counted_iterator&
2183 operator+=(iter_difference_t<_It> __n)
2184 requires random_access_iterator<_It>
2186 __glibcxx_assert(__n <= _M_length);
2192 constexpr counted_iterator
2193 operator-(iter_difference_t<_It> __n)
const
2194 requires random_access_iterator<_It>
2195 {
return counted_iterator(_M_current - __n, _M_length + __n); }
2197 template<common_with<_It> _It2>
2198 friend constexpr iter_difference_t<_It2>
2200 const counted_iterator<_It2>& __y)
2201 {
return __y._M_length - __x._M_length; }
2203 friend constexpr iter_difference_t<_It>
2204 operator-(
const counted_iterator& __x, default_sentinel_t)
2205 {
return -__x._M_length; }
2207 friend constexpr iter_difference_t<_It>
2208 operator-(default_sentinel_t,
const counted_iterator& __y)
2209 {
return __y._M_length; }
2211 constexpr counted_iterator&
2212 operator-=(iter_difference_t<_It> __n)
2213 requires random_access_iterator<_It>
2215 __glibcxx_assert(-__n <= _M_length);
2221 constexpr decltype(
auto)
2222 operator[](iter_difference_t<_It> __n) const
2223 noexcept(noexcept(_M_current[__n]))
2224 requires random_access_iterator<_It>
2226 __glibcxx_assert(__n < _M_length);
2227 return _M_current[__n];
2230 template<common_with<_It> _It2>
2231 friend constexpr
bool
2232 operator==(
const counted_iterator& __x,
2233 const counted_iterator<_It2>& __y)
2234 {
return __x._M_length == __y._M_length; }
2236 friend constexpr
bool
2237 operator==(
const counted_iterator& __x, default_sentinel_t)
2238 {
return __x._M_length == 0; }
2240 template<common_with<_It> _It2>
2241 friend constexpr strong_ordering
2242 operator<=>(
const counted_iterator& __x,
2243 const counted_iterator<_It2>& __y)
2244 {
return __y._M_length <=> __x._M_length; }
2246 friend constexpr iter_rvalue_reference_t<_It>
2247 iter_move(
const counted_iterator& __i)
2248 noexcept(noexcept(ranges::iter_move(__i._M_current)))
2249 requires input_iterator<_It>
2250 {
return ranges::iter_move(__i._M_current); }
2252 template<indirectly_swappable<_It> _It2>
2253 friend constexpr
void
2254 iter_swap(
const counted_iterator& __x,
2255 const counted_iterator<_It2>& __y)
2256 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
2257 { ranges::iter_swap(__x._M_current, __y._M_current); }
2260 template<input_or_output_iterator _It2>
friend class counted_iterator;
2262 _It _M_current = _It();
2263 iter_difference_t<_It> _M_length = 0;
2266 template<input_iterator _It>
2267 requires same_as<__detail::__iter_traits<_It>, iterator_traits<_It>>
2268 struct iterator_traits<counted_iterator<_It>> : iterator_traits<_It>
2270 using pointer = conditional_t<contiguous_iterator<_It>,
2271 add_pointer_t<iter_reference_t<_It>>,
2278 template<
typename _Iterator>
2280 __niter_base(move_iterator<_Iterator> __it)
2281 -> decltype(make_move_iterator(__niter_base(__it.base())))
2282 {
return make_move_iterator(__niter_base(__it.base())); }
2284 template<
typename _Iterator>
2285 struct __is_move_iterator<move_iterator<_Iterator> >
2287 enum { __value = 1 };
2288 typedef __true_type __type;
2291 template<
typename _Iterator>
2293 __miter_base(move_iterator<_Iterator> __it)
2294 -> decltype(__miter_base(__it.base()))
2295 {
return __miter_base(__it.base()); }
2297 #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) std::make_move_iterator(_Iter)
2298 #define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) \
2299 std::__make_move_if_noexcept_iterator(_Iter)
2301 #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) (_Iter)
2302 #define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) (_Iter)
2305 #if __cpp_deduction_guides >= 201606
2308 template<
typename _InputIterator>
2310 typename iterator_traits<_InputIterator>::value_type::first_type>;
2312 template<
typename _InputIterator>
2313 using __iter_val_t =
2314 typename iterator_traits<_InputIterator>::value_type::second_type;
2316 template<
typename _T1,
typename _T2>
2319 template<
typename _InputIterator>
2320 using __iter_to_alloc_t =
2321 pair<add_const_t<__iter_key_t<_InputIterator>>,
2322 __iter_val_t<_InputIterator>>;
2325 _GLIBCXX_END_NAMESPACE_VERSION
2328 #ifdef _GLIBCXX_DEBUG
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.