60 #ifndef _STL_ITERATOR_H
61 #define _STL_ITERATOR_H 1
68 #if __cplusplus >= 201103L
72 #if __cplusplus > 201703L
73 # define __cpp_lib_array_constexpr 201811L
74 # define __cpp_lib_constexpr_iterator 201811L
75 #elif __cplusplus == 201703L
76 # define __cpp_lib_array_constexpr 201803L
79 #if __cplusplus > 201703L
85 namespace std _GLIBCXX_VISIBILITY(default)
87 _GLIBCXX_BEGIN_NAMESPACE_VERSION
94 #if __cplusplus > 201703L && __cpp_lib_concepts
99 template<
typename _Cat,
typename _Limit,
typename _Otherwise = _Cat>
100 using __clamp_iter_cat
101 = conditional_t<derived_from<_Cat, _Limit>, _Limit, _Otherwise>;
124 template<
typename _Iterator>
126 :
public iterator<typename iterator_traits<_Iterator>::iterator_category,
127 typename iterator_traits<_Iterator>::value_type,
128 typename iterator_traits<_Iterator>::difference_type,
129 typename iterator_traits<_Iterator>::pointer,
130 typename iterator_traits<_Iterator>::reference>
138 typedef _Iterator iterator_type;
139 typedef typename __traits_type::pointer pointer;
140 #if __cplusplus <= 201703L
141 typedef typename __traits_type::difference_type difference_type;
142 typedef typename __traits_type::reference reference;
144 using iterator_concept
149 = __detail::__clamp_iter_cat<
typename __traits_type::iterator_category,
152 using difference_type = iter_difference_t<_Iterator>;
153 using reference = iter_reference_t<_Iterator>;
169 explicit _GLIBCXX17_CONSTEXPR
177 : current(__x.current) { }
179 #if __cplusplus >= 201103L
187 template<
typename _Iter>
190 : current(__x.
base()) { }
195 _GLIBCXX17_CONSTEXPR iterator_type
209 _GLIBCXX17_CONSTEXPR reference
212 _Iterator __tmp = current;
221 _GLIBCXX17_CONSTEXPR pointer
223 #if __cplusplus > 201703L && __cpp_concepts >= 201907L
224 requires is_pointer_v<_Iterator>
225 || requires(
const _Iterator __i) { __i.operator->(); }
230 _Iterator __tmp = current;
232 return _S_to_pointer(__tmp);
334 _GLIBCXX17_CONSTEXPR reference
336 {
return *(*
this + __n); }
338 #if __cplusplus > 201703L && __cpp_lib_concepts
339 friend constexpr iter_rvalue_reference_t<_Iterator>
341 noexcept(is_nothrow_copy_constructible_v<_Iterator>
342 && noexcept(ranges::iter_move(--std::declval<_Iterator&>())))
344 auto __tmp = __i.base();
345 return ranges::iter_move(--__tmp);
348 template<indirectly_swappable<_Iterator> _Iter2>
349 friend constexpr
void
351 const reverse_iterator<_Iter2>& __y)
352 noexcept(is_nothrow_copy_constructible_v<_Iterator>
353 && is_nothrow_copy_constructible_v<_Iter2>
354 && noexcept(ranges::iter_swap(--std::declval<_Iterator&>(),
355 --std::declval<_Iter2&>())))
357 auto __xtmp = __x.base();
358 auto __ytmp = __y.base();
359 ranges::iter_swap(--__xtmp, --__ytmp);
364 template<
typename _Tp>
365 static _GLIBCXX17_CONSTEXPR _Tp*
366 _S_to_pointer(_Tp* __p)
369 template<
typename _Tp>
370 static _GLIBCXX17_CONSTEXPR pointer
371 _S_to_pointer(_Tp __t)
372 {
return __t.operator->(); }
385 #if __cplusplus <= 201703L || ! defined __cpp_lib_concepts
386 template<
typename _Iterator>
387 inline _GLIBCXX17_CONSTEXPR
bool
390 {
return __x.
base() == __y.
base(); }
392 template<
typename _Iterator>
393 inline _GLIBCXX17_CONSTEXPR
bool
394 operator<(
const reverse_iterator<_Iterator>& __x,
395 const reverse_iterator<_Iterator>& __y)
396 {
return __y.base() < __x.base(); }
398 template<
typename _Iterator>
399 inline _GLIBCXX17_CONSTEXPR
bool
400 operator!=(
const reverse_iterator<_Iterator>& __x,
401 const reverse_iterator<_Iterator>& __y)
402 {
return !(__x == __y); }
404 template<
typename _Iterator>
405 inline _GLIBCXX17_CONSTEXPR
bool
406 operator>(
const reverse_iterator<_Iterator>& __x,
407 const reverse_iterator<_Iterator>& __y)
408 {
return __y < __x; }
410 template<
typename _Iterator>
411 inline _GLIBCXX17_CONSTEXPR
bool
412 operator<=(
const reverse_iterator<_Iterator>& __x,
413 const reverse_iterator<_Iterator>& __y)
414 {
return !(__y < __x); }
416 template<
typename _Iterator>
417 inline _GLIBCXX17_CONSTEXPR
bool
418 operator>=(
const reverse_iterator<_Iterator>& __x,
419 const reverse_iterator<_Iterator>& __y)
420 {
return !(__x < __y); }
424 template<
typename _IteratorL,
typename _IteratorR>
425 inline _GLIBCXX17_CONSTEXPR
bool
426 operator==(
const reverse_iterator<_IteratorL>& __x,
427 const reverse_iterator<_IteratorR>& __y)
428 {
return __x.base() == __y.base(); }
430 template<
typename _IteratorL,
typename _IteratorR>
431 inline _GLIBCXX17_CONSTEXPR
bool
432 operator<(
const reverse_iterator<_IteratorL>& __x,
433 const reverse_iterator<_IteratorR>& __y)
434 {
return __y.base() < __x.base(); }
436 template<
typename _IteratorL,
typename _IteratorR>
437 inline _GLIBCXX17_CONSTEXPR
bool
438 operator!=(
const reverse_iterator<_IteratorL>& __x,
439 const reverse_iterator<_IteratorR>& __y)
440 {
return !(__x == __y); }
442 template<
typename _IteratorL,
typename _IteratorR>
443 inline _GLIBCXX17_CONSTEXPR
bool
444 operator>(
const reverse_iterator<_IteratorL>& __x,
445 const reverse_iterator<_IteratorR>& __y)
446 {
return __y < __x; }
448 template<
typename _IteratorL,
typename _IteratorR>
449 inline _GLIBCXX17_CONSTEXPR
bool
450 operator<=(
const reverse_iterator<_IteratorL>& __x,
451 const reverse_iterator<_IteratorR>& __y)
452 {
return !(__y < __x); }
454 template<
typename _IteratorL,
typename _IteratorR>
455 inline _GLIBCXX17_CONSTEXPR
bool
456 operator>=(
const reverse_iterator<_IteratorL>& __x,
457 const reverse_iterator<_IteratorR>& __y)
458 {
return !(__x < __y); }
460 template<
typename _IteratorL,
typename _IteratorR>
462 operator==(
const reverse_iterator<_IteratorL>& __x,
463 const reverse_iterator<_IteratorR>& __y)
464 requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
465 {
return __x.base() == __y.base(); }
467 template<
typename _IteratorL,
typename _IteratorR>
469 operator!=(
const reverse_iterator<_IteratorL>& __x,
470 const reverse_iterator<_IteratorR>& __y)
471 requires requires { { __x.base() != __y.base() } -> convertible_to<bool>; }
472 {
return __x.base() != __y.base(); }
474 template<
typename _IteratorL,
typename _IteratorR>
476 operator<(
const reverse_iterator<_IteratorL>& __x,
477 const reverse_iterator<_IteratorR>& __y)
478 requires requires { { __x.base() > __y.base() } -> convertible_to<bool>; }
479 {
return __x.base() > __y.base(); }
481 template<
typename _IteratorL,
typename _IteratorR>
483 operator>(
const reverse_iterator<_IteratorL>& __x,
484 const reverse_iterator<_IteratorR>& __y)
485 requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
486 {
return __x.base() < __y.base(); }
488 template<
typename _IteratorL,
typename _IteratorR>
490 operator<=(
const reverse_iterator<_IteratorL>& __x,
491 const reverse_iterator<_IteratorR>& __y)
492 requires requires { { __x.base() >= __y.base() } -> convertible_to<bool>; }
493 {
return __x.base() >= __y.base(); }
495 template<
typename _IteratorL,
typename _IteratorR>
497 operator>=(
const reverse_iterator<_IteratorL>& __x,
498 const reverse_iterator<_IteratorR>& __y)
499 requires requires { { __x.base() <= __y.base() } -> convertible_to<bool>; }
500 {
return __x.base() <= __y.base(); }
502 template<
typename _IteratorL,
503 three_way_comparable_with<_IteratorL> _IteratorR>
504 constexpr compare_three_way_result_t<_IteratorL, _IteratorR>
505 operator<=>(
const reverse_iterator<_IteratorL>& __x,
506 const reverse_iterator<_IteratorR>& __y)
507 {
return __y.base() <=> __x.base(); }
511 #if __cplusplus < 201103L
512 template<
typename _Iterator>
513 inline typename reverse_iterator<_Iterator>::difference_type
514 operator-(
const reverse_iterator<_Iterator>& __x,
515 const reverse_iterator<_Iterator>& __y)
516 {
return __y.base() - __x.base(); }
518 template<
typename _IteratorL,
typename _IteratorR>
519 inline typename reverse_iterator<_IteratorL>::difference_type
520 operator-(
const reverse_iterator<_IteratorL>& __x,
521 const reverse_iterator<_IteratorR>& __y)
522 {
return __y.base() - __x.base(); }
526 template<
typename _IteratorL,
typename _IteratorR>
527 inline _GLIBCXX17_CONSTEXPR
auto
528 operator-(
const reverse_iterator<_IteratorL>& __x,
529 const reverse_iterator<_IteratorR>& __y)
530 -> decltype(__y.base() - __x.base())
531 {
return __y.base() - __x.base(); }
534 template<
typename _Iterator>
535 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
536 operator+(
typename reverse_iterator<_Iterator>::difference_type __n,
537 const reverse_iterator<_Iterator>& __x)
538 {
return reverse_iterator<_Iterator>(__x.base() - __n); }
540 #if __cplusplus >= 201103L
542 template<
typename _Iterator>
543 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
544 __make_reverse_iterator(_Iterator __i)
545 {
return reverse_iterator<_Iterator>(__i); }
547 # if __cplusplus >= 201402L
548 # define __cpp_lib_make_reverse_iterator 201402
553 template<
typename _Iterator>
554 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
558 # if __cplusplus > 201703L && defined __cpp_lib_concepts
559 template<
typename _Iterator1,
typename _Iterator2>
560 requires (!sized_sentinel_for<_Iterator1, _Iterator2>)
561 inline constexpr
bool
562 disable_sized_sentinel_for<reverse_iterator<_Iterator1>,
563 reverse_iterator<_Iterator2>> =
true;
567 template<
typename _Iterator>
570 __niter_base(reverse_iterator<_Iterator> __it)
571 -> decltype(__make_reverse_iterator(__niter_base(__it.base())))
572 {
return __make_reverse_iterator(__niter_base(__it.base())); }
574 template<
typename _Iterator>
575 struct __is_move_iterator<reverse_iterator<_Iterator> >
576 : __is_move_iterator<_Iterator>
579 template<
typename _Iterator>
582 __miter_base(reverse_iterator<_Iterator> __it)
583 -> decltype(__make_reverse_iterator(__miter_base(__it.base())))
584 {
return __make_reverse_iterator(__miter_base(__it.base())); }
598 template<
typename _Container>
600 :
public iterator<output_iterator_tag, void, void, void, void>
603 _Container* container;
608 #if __cplusplus > 201703L
615 explicit _GLIBCXX20_CONSTEXPR
630 #if __cplusplus < 201103L
632 operator=(
typename _Container::const_reference __value)
634 container->push_back(__value);
640 operator=(
const typename _Container::value_type& __value)
642 container->push_back(__value);
648 operator=(
typename _Container::value_type&& __value)
650 container->push_back(
std::move(__value));
685 template<
typename _Container>
687 inline back_insert_iterator<_Container>
701 template<
typename _Container>
703 :
public iterator<output_iterator_tag, void, void, void, void>
706 _Container* container;
711 #if __cplusplus > 201703L
718 explicit _GLIBCXX20_CONSTEXPR
733 #if __cplusplus < 201103L
735 operator=(
typename _Container::const_reference __value)
737 container->push_front(__value);
743 operator=(
const typename _Container::value_type& __value)
745 container->push_front(__value);
751 operator=(
typename _Container::value_type&& __value)
753 container->push_front(
std::move(__value));
788 template<
typename _Container>
790 inline front_insert_iterator<_Container>
808 template<
typename _Container>
810 :
public iterator<output_iterator_tag, void, void, void, void>
812 #if __cplusplus > 201703L && defined __cpp_lib_concepts
813 using _Iter = std::__detail::__range_iter_t<_Container>;
816 _Container* container =
nullptr;
817 _Iter iter = _Iter();
819 typedef typename _Container::iterator _Iter;
822 _Container* container;
830 #if __cplusplus > 201703L && defined __cpp_lib_concepts
867 #if __cplusplus < 201103L
869 operator=(
typename _Container::const_reference __value)
871 iter = container->insert(iter, __value);
878 operator=(
const typename _Container::value_type& __value)
880 iter = container->insert(iter, __value);
887 operator=(
typename _Container::value_type&& __value)
889 iter = container->insert(iter,
std::move(__value));
926 #if __cplusplus > 201703L && defined __cpp_lib_concepts
927 template<
typename _Container>
928 constexpr insert_iterator<_Container>
929 inserter(_Container& __x, std::__detail::__range_iter_t<_Container> __i)
930 {
return insert_iterator<_Container>(__x, __i); }
932 template<
typename _Container>
933 inline insert_iterator<_Container>
934 inserter(_Container& __x,
typename _Container::iterator __i)
940 _GLIBCXX_END_NAMESPACE_VERSION
943 namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
945 _GLIBCXX_BEGIN_NAMESPACE_VERSION
954 template<
typename _Iterator,
typename _Container>
955 class __normal_iterator
958 _Iterator _M_current;
963 typedef _Iterator iterator_type;
964 typedef typename __traits_type::iterator_category iterator_category;
965 typedef typename __traits_type::value_type value_type;
966 typedef typename __traits_type::difference_type difference_type;
967 typedef typename __traits_type::reference reference;
968 typedef typename __traits_type::pointer pointer;
970 #if __cplusplus > 201703L && __cpp_lib_concepts
971 using iterator_concept = std::__detail::__iter_concept<_Iterator>;
974 _GLIBCXX_CONSTEXPR __normal_iterator() _GLIBCXX_NOEXCEPT
975 : _M_current(_Iterator()) { }
977 explicit _GLIBCXX20_CONSTEXPR
978 __normal_iterator(
const _Iterator& __i) _GLIBCXX_NOEXCEPT
979 : _M_current(__i) { }
982 template<
typename _Iter>
984 __normal_iterator(
const __normal_iterator<_Iter,
985 typename __enable_if<
986 (std::__are_same<_Iter, typename _Container::pointer>::__value),
987 _Container>::__type>& __i) _GLIBCXX_NOEXCEPT
988 : _M_current(__i.base()) { }
994 {
return *_M_current; }
998 operator->() const _GLIBCXX_NOEXCEPT
999 {
return _M_current; }
1001 _GLIBCXX20_CONSTEXPR
1003 operator++() _GLIBCXX_NOEXCEPT
1009 _GLIBCXX20_CONSTEXPR
1011 operator++(
int) _GLIBCXX_NOEXCEPT
1012 {
return __normal_iterator(_M_current++); }
1015 _GLIBCXX20_CONSTEXPR
1017 operator--() _GLIBCXX_NOEXCEPT
1023 _GLIBCXX20_CONSTEXPR
1025 operator--(
int) _GLIBCXX_NOEXCEPT
1026 {
return __normal_iterator(_M_current--); }
1029 _GLIBCXX20_CONSTEXPR
1031 operator[](difference_type __n)
const _GLIBCXX_NOEXCEPT
1032 {
return _M_current[__n]; }
1034 _GLIBCXX20_CONSTEXPR
1036 operator+=(difference_type __n) _GLIBCXX_NOEXCEPT
1037 { _M_current += __n;
return *
this; }
1039 _GLIBCXX20_CONSTEXPR
1041 operator+(difference_type __n)
const _GLIBCXX_NOEXCEPT
1042 {
return __normal_iterator(_M_current + __n); }
1044 _GLIBCXX20_CONSTEXPR
1046 operator-=(difference_type __n) _GLIBCXX_NOEXCEPT
1047 { _M_current -= __n;
return *
this; }
1049 _GLIBCXX20_CONSTEXPR
1051 operator-(difference_type __n)
const _GLIBCXX_NOEXCEPT
1052 {
return __normal_iterator(_M_current - __n); }
1054 _GLIBCXX20_CONSTEXPR
1056 base() const _GLIBCXX_NOEXCEPT
1057 {
return _M_current; }
1068 #if __cpp_lib_three_way_comparison
1069 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1070 requires requires (_IteratorL __lhs, _IteratorR __rhs)
1071 { { __lhs == __rhs } -> std::convertible_to<bool>; }
1073 operator==(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1074 const __normal_iterator<_IteratorR, _Container>& __rhs)
1075 noexcept(noexcept(__lhs.base() == __rhs.base()))
1076 {
return __lhs.base() == __rhs.base(); }
1078 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1079 constexpr std::__detail::__synth3way_t<_IteratorR, _IteratorL>
1080 operator<=>(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1081 const __normal_iterator<_IteratorR, _Container>& __rhs)
1082 noexcept(noexcept(std::__detail::__synth3way(__lhs.base(), __rhs.base())))
1083 {
return std::__detail::__synth3way(__lhs.base(), __rhs.base()); }
1086 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1087 _GLIBCXX20_CONSTEXPR
1089 operator==(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1090 const __normal_iterator<_IteratorR, _Container>& __rhs)
1092 {
return __lhs.base() == __rhs.base(); }
1094 template<
typename _Iterator,
typename _Container>
1095 _GLIBCXX20_CONSTEXPR
1097 operator==(
const __normal_iterator<_Iterator, _Container>& __lhs,
1098 const __normal_iterator<_Iterator, _Container>& __rhs)
1100 {
return __lhs.base() == __rhs.base(); }
1102 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1103 _GLIBCXX20_CONSTEXPR
1105 operator!=(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1106 const __normal_iterator<_IteratorR, _Container>& __rhs)
1108 {
return __lhs.base() != __rhs.base(); }
1110 template<
typename _Iterator,
typename _Container>
1111 _GLIBCXX20_CONSTEXPR
1113 operator!=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1114 const __normal_iterator<_Iterator, _Container>& __rhs)
1116 {
return __lhs.base() != __rhs.base(); }
1119 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1121 operator<(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1122 const __normal_iterator<_IteratorR, _Container>& __rhs)
1124 {
return __lhs.base() < __rhs.base(); }
1126 template<
typename _Iterator,
typename _Container>
1127 _GLIBCXX20_CONSTEXPR
1129 operator<(
const __normal_iterator<_Iterator, _Container>& __lhs,
1130 const __normal_iterator<_Iterator, _Container>& __rhs)
1132 {
return __lhs.base() < __rhs.base(); }
1134 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1136 operator>(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1137 const __normal_iterator<_IteratorR, _Container>& __rhs)
1139 {
return __lhs.base() > __rhs.base(); }
1141 template<
typename _Iterator,
typename _Container>
1142 _GLIBCXX20_CONSTEXPR
1144 operator>(
const __normal_iterator<_Iterator, _Container>& __lhs,
1145 const __normal_iterator<_Iterator, _Container>& __rhs)
1147 {
return __lhs.base() > __rhs.base(); }
1149 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1151 operator<=(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1152 const __normal_iterator<_IteratorR, _Container>& __rhs)
1154 {
return __lhs.base() <= __rhs.base(); }
1156 template<
typename _Iterator,
typename _Container>
1157 _GLIBCXX20_CONSTEXPR
1159 operator<=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1160 const __normal_iterator<_Iterator, _Container>& __rhs)
1162 {
return __lhs.base() <= __rhs.base(); }
1164 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1166 operator>=(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1167 const __normal_iterator<_IteratorR, _Container>& __rhs)
1169 {
return __lhs.base() >= __rhs.base(); }
1171 template<
typename _Iterator,
typename _Container>
1172 _GLIBCXX20_CONSTEXPR
1174 operator>=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1175 const __normal_iterator<_Iterator, _Container>& __rhs)
1177 {
return __lhs.base() >= __rhs.base(); }
1184 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1185 #if __cplusplus >= 201103L
1187 _GLIBCXX20_CONSTEXPR
1189 operator-(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1190 const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept
1191 -> decltype(__lhs.base() - __rhs.base())
1193 inline typename __normal_iterator<_IteratorL, _Container>::difference_type
1194 operator-(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1195 const __normal_iterator<_IteratorR, _Container>& __rhs)
1197 {
return __lhs.base() - __rhs.base(); }
1199 template<
typename _Iterator,
typename _Container>
1200 _GLIBCXX20_CONSTEXPR
1201 inline typename __normal_iterator<_Iterator, _Container>::difference_type
1202 operator-(
const __normal_iterator<_Iterator, _Container>& __lhs,
1203 const __normal_iterator<_Iterator, _Container>& __rhs)
1205 {
return __lhs.base() - __rhs.base(); }
1207 template<
typename _Iterator,
typename _Container>
1208 _GLIBCXX20_CONSTEXPR
1209 inline __normal_iterator<_Iterator, _Container>
1210 operator+(
typename __normal_iterator<_Iterator, _Container>::difference_type
1211 __n,
const __normal_iterator<_Iterator, _Container>& __i)
1213 {
return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
1215 _GLIBCXX_END_NAMESPACE_VERSION
1218 namespace std _GLIBCXX_VISIBILITY(default)
1220 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1222 template<
typename _Iterator,
typename _Container>
1223 _GLIBCXX20_CONSTEXPR
1225 __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it)
1227 {
return __it.base(); }
1229 #if __cplusplus >= 201103L
1235 #if __cplusplus > 201703L && __cpp_lib_concepts
1236 template<semiregular _Sent>
1242 noexcept(is_nothrow_default_constructible_v<_Sent>)
1246 move_sentinel(_Sent __s)
1247 noexcept(is_nothrow_move_constructible_v<_Sent>)
1250 template<
typename _S2> requires convertible_to<const _S2&, _Sent>
1252 move_sentinel(
const move_sentinel<_S2>& __s)
1253 noexcept(is_nothrow_constructible_v<_Sent, const _S2&>)
1254 : _M_last(__s.base())
1257 template<
typename _S2> requires assignable_from<_Sent&, const _S2&>
1258 constexpr move_sentinel&
1259 operator=(
const move_sentinel<_S2>& __s)
1260 noexcept(is_nothrow_assignable_v<_Sent, const _S2&>)
1262 _M_last = __s.base();
1268 noexcept(is_nothrow_copy_constructible_v<_Sent>)
1278 #if __cplusplus > 201703L && __cpp_lib_concepts
1279 template<
typename _Iterator>
1280 struct __move_iter_cat
1283 template<
typename _Iterator>
1284 requires requires {
typename iterator_traits<_Iterator>::iterator_category; }
1285 struct __move_iter_cat<_Iterator>
1287 using iterator_category
1288 = __clamp_iter_cat<typename iterator_traits<_Iterator>::iterator_category,
1289 random_access_iterator_tag>;
1303 template<
typename _Iterator>
1305 #if __cplusplus > 201703L && __cpp_lib_concepts
1306 :
public __detail::__move_iter_cat<_Iterator>
1309 _Iterator _M_current;
1312 #if ! (__cplusplus > 201703L && __cpp_lib_concepts)
1313 using __base_ref =
typename __traits_type::reference;
1317 using iterator_type = _Iterator;
1319 #if __cplusplus > 201703L && __cpp_lib_concepts
1322 using value_type = iter_value_t<_Iterator>;
1323 using difference_type = iter_difference_t<_Iterator>;
1324 using pointer = _Iterator;
1325 using reference = iter_rvalue_reference_t<_Iterator>;
1327 typedef typename __traits_type::iterator_category iterator_category;
1328 typedef typename __traits_type::value_type value_type;
1329 typedef typename __traits_type::difference_type difference_type;
1331 typedef _Iterator pointer;
1335 typename remove_reference<__base_ref>::type&&,
1336 __base_ref>::type reference;
1339 _GLIBCXX17_CONSTEXPR
1343 explicit _GLIBCXX17_CONSTEXPR
1347 template<
typename _Iter>
1348 _GLIBCXX17_CONSTEXPR
1350 : _M_current(__i.base()) { }
1352 template<
typename _Iter>
1353 _GLIBCXX17_CONSTEXPR
1356 _M_current = __i.base();
1360 #if __cplusplus <= 201703L
1361 _GLIBCXX17_CONSTEXPR iterator_type
1363 {
return _M_current; }
1365 constexpr
const iterator_type&
1366 base()
const & noexcept
1367 {
return _M_current; }
1369 constexpr iterator_type
1374 _GLIBCXX17_CONSTEXPR reference
1376 #if __cplusplus > 201703L && __cpp_lib_concepts
1377 {
return ranges::iter_move(_M_current); }
1379 {
return static_cast<reference
>(*_M_current); }
1382 _GLIBCXX17_CONSTEXPR pointer
1384 {
return _M_current; }
1401 #if __cpp_lib_concepts
1403 operator++(
int) requires (!forward_iterator<_Iterator>)
1427 operator+=(difference_type __n)
1438 operator-=(difference_type __n)
1444 _GLIBCXX17_CONSTEXPR reference
1445 operator[](difference_type __n)
const
1446 #if __cplusplus > 201703L && __cpp_lib_concepts
1447 {
return ranges::iter_move(_M_current + __n); }
1452 #if __cplusplus > 201703L && __cpp_lib_concepts
1453 template<sentinel_for<_Iterator> _Sent>
1454 friend constexpr
bool
1455 operator==(
const move_iterator& __x,
const move_sentinel<_Sent>& __y)
1456 {
return __x.base() == __y.base(); }
1458 template<sized_sentinel_for<_Iterator> _Sent>
1459 friend constexpr iter_difference_t<_Iterator>
1461 {
return __x.base() - __y.base(); }
1463 template<sized_sentinel_for<_Iterator> _Sent>
1464 friend constexpr iter_difference_t<_Iterator>
1466 {
return __x.base() - __y.base(); }
1468 friend constexpr iter_rvalue_reference_t<_Iterator>
1470 noexcept(noexcept(ranges::iter_move(__i._M_current)))
1471 {
return ranges::iter_move(__i._M_current); }
1473 template<indirectly_swappable<_Iterator> _Iter2>
1474 friend constexpr
void
1476 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1477 {
return ranges::iter_swap(__x._M_current, __y._M_current); }
1481 template<
typename _IteratorL,
typename _IteratorR>
1482 inline _GLIBCXX17_CONSTEXPR
bool
1485 #if __cplusplus > 201703L && __cpp_lib_concepts
1486 requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
1488 {
return __x.base() == __y.base(); }
1490 #if __cpp_lib_three_way_comparison
1491 template<
typename _IteratorL,
1492 three_way_comparable_with<_IteratorL> _IteratorR>
1493 constexpr compare_three_way_result_t<_IteratorL, _IteratorR>
1494 operator<=>(
const move_iterator<_IteratorL>& __x,
1495 const move_iterator<_IteratorR>& __y)
1496 {
return __x.base() <=> __y.base(); }
1498 template<
typename _IteratorL,
typename _IteratorR>
1499 inline _GLIBCXX17_CONSTEXPR
bool
1500 operator!=(
const move_iterator<_IteratorL>& __x,
1501 const move_iterator<_IteratorR>& __y)
1502 {
return !(__x == __y); }
1505 template<
typename _IteratorL,
typename _IteratorR>
1506 inline _GLIBCXX17_CONSTEXPR
bool
1507 operator<(
const move_iterator<_IteratorL>& __x,
1508 const move_iterator<_IteratorR>& __y)
1509 #if __cplusplus > 201703L && __cpp_lib_concepts
1510 requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
1512 {
return __x.base() < __y.base(); }
1514 template<
typename _IteratorL,
typename _IteratorR>
1515 inline _GLIBCXX17_CONSTEXPR
bool
1516 operator<=(
const move_iterator<_IteratorL>& __x,
1517 const move_iterator<_IteratorR>& __y)
1518 #if __cplusplus > 201703L && __cpp_lib_concepts
1519 requires requires { { __y.base() < __x.base() } -> convertible_to<bool>; }
1521 {
return !(__y < __x); }
1523 template<
typename _IteratorL,
typename _IteratorR>
1524 inline _GLIBCXX17_CONSTEXPR
bool
1525 operator>(
const move_iterator<_IteratorL>& __x,
1526 const move_iterator<_IteratorR>& __y)
1527 #if __cplusplus > 201703L && __cpp_lib_concepts
1528 requires requires { { __y.base() < __x.base() } -> convertible_to<bool>; }
1530 {
return __y < __x; }
1532 template<
typename _IteratorL,
typename _IteratorR>
1533 inline _GLIBCXX17_CONSTEXPR
bool
1534 operator>=(
const move_iterator<_IteratorL>& __x,
1535 const move_iterator<_IteratorR>& __y)
1536 #if __cplusplus > 201703L && __cpp_lib_concepts
1537 requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
1539 {
return !(__x < __y); }
1541 #if ! (__cplusplus > 201703L && __cpp_lib_concepts)
1549 template<
typename _Iterator>
1550 inline _GLIBCXX17_CONSTEXPR
bool
1551 operator==(
const move_iterator<_Iterator>& __x,
1552 const move_iterator<_Iterator>& __y)
1553 {
return __x.base() == __y.base(); }
1555 template<
typename _Iterator>
1556 inline _GLIBCXX17_CONSTEXPR
bool
1557 operator!=(
const move_iterator<_Iterator>& __x,
1558 const move_iterator<_Iterator>& __y)
1559 {
return !(__x == __y); }
1561 template<
typename _Iterator>
1562 inline _GLIBCXX17_CONSTEXPR
bool
1563 operator<(
const move_iterator<_Iterator>& __x,
1564 const move_iterator<_Iterator>& __y)
1565 {
return __x.base() < __y.base(); }
1567 template<
typename _Iterator>
1568 inline _GLIBCXX17_CONSTEXPR
bool
1569 operator<=(
const move_iterator<_Iterator>& __x,
1570 const move_iterator<_Iterator>& __y)
1571 {
return !(__y < __x); }
1573 template<
typename _Iterator>
1574 inline _GLIBCXX17_CONSTEXPR
bool
1575 operator>(
const move_iterator<_Iterator>& __x,
1576 const move_iterator<_Iterator>& __y)
1577 {
return __y < __x; }
1579 template<
typename _Iterator>
1580 inline _GLIBCXX17_CONSTEXPR
bool
1581 operator>=(
const move_iterator<_Iterator>& __x,
1582 const move_iterator<_Iterator>& __y)
1583 {
return !(__x < __y); }
1587 template<
typename _IteratorL,
typename _IteratorR>
1588 inline _GLIBCXX17_CONSTEXPR
auto
1589 operator-(
const move_iterator<_IteratorL>& __x,
1590 const move_iterator<_IteratorR>& __y)
1591 -> decltype(__x.base() - __y.base())
1592 {
return __x.base() - __y.base(); }
1594 template<
typename _Iterator>
1595 inline _GLIBCXX17_CONSTEXPR move_iterator<_Iterator>
1596 operator+(
typename move_iterator<_Iterator>::difference_type __n,
1597 const move_iterator<_Iterator>& __x)
1598 {
return __x + __n; }
1600 template<
typename _Iterator>
1601 inline _GLIBCXX17_CONSTEXPR move_iterator<_Iterator>
1602 make_move_iterator(_Iterator __i)
1603 {
return move_iterator<_Iterator>(
std::move(__i)); }
1605 template<
typename _Iterator,
typename _ReturnType
1606 =
typename conditional<__move_if_noexcept_cond
1607 <
typename iterator_traits<_Iterator>::value_type>::value,
1608 _Iterator, move_iterator<_Iterator>>::type>
1609 inline _GLIBCXX17_CONSTEXPR _ReturnType
1610 __make_move_if_noexcept_iterator(_Iterator __i)
1611 {
return _ReturnType(__i); }
1615 template<
typename _Tp,
typename _ReturnType
1616 =
typename conditional<__move_if_noexcept_cond<_Tp>::value,
1617 const _Tp*, move_iterator<_Tp*>>::type>
1618 inline _GLIBCXX17_CONSTEXPR _ReturnType
1619 __make_move_if_noexcept_iterator(_Tp* __i)
1620 {
return _ReturnType(__i); }
1622 #if __cplusplus > 201703L && __cpp_lib_concepts
1627 template<
typename _It>
1628 concept __common_iter_has_arrow = indirectly_readable<const _It>
1629 && (requires(
const _It& __it) { __it.operator->(); }
1630 || is_reference_v<iter_reference_t<_It>>
1631 || constructible_from<iter_value_t<_It>, iter_reference_t<_It>>);
1633 template<
typename _It>
1634 concept __common_iter_use_postfix_proxy
1635 = (!requires (_It& __i) { { *__i++ } -> __can_reference; })
1636 && constructible_from<iter_value_t<_It>, iter_reference_t<_It>>
1637 && move_constructible<iter_value_t<_It>>;
1641 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
1642 requires (!same_as<_It, _Sent>) && copyable<_It>
1643 class common_iterator
1645 template<
typename _Tp,
typename _Up>
1646 static constexpr
bool
1649 if constexpr (is_trivially_default_constructible_v<_Tp>)
1650 return is_nothrow_assignable_v<_Tp, _Up>;
1652 return is_nothrow_constructible_v<_Tp, _Up>;
1655 template<
typename _It2,
typename _Sent2>
1656 static constexpr
bool
1658 {
return _S_noexcept1<_It, _It2>() && _S_noexcept1<_Sent, _Sent2>(); }
1662 iter_value_t<_It> _M_keep;
1664 __arrow_proxy(iter_reference_t<_It>&& __x)
1667 friend class common_iterator;
1670 const iter_value_t<_It>*
1675 class __postfix_proxy
1677 iter_value_t<_It> _M_keep;
1679 __postfix_proxy(iter_reference_t<_It>&& __x)
1680 : _M_keep(
std::
forward<iter_reference_t<_It>>(__x)) { }
1682 friend class common_iterator;
1685 const iter_value_t<_It>&
1693 noexcept(is_nothrow_default_constructible_v<_It>)
1694 : _M_it(), _M_index(0)
1698 common_iterator(_It __i)
1699 noexcept(is_nothrow_move_constructible_v<_It>)
1700 : _M_it(
std::
move(__i)), _M_index(0)
1704 common_iterator(_Sent __s)
1705 noexcept(is_nothrow_move_constructible_v<_Sent>)
1706 : _M_sent(
std::
move(__s)), _M_index(1)
1709 template<
typename _It2,
typename _Sent2>
1710 requires convertible_to<const _It2&, _It>
1711 && convertible_to<const _Sent2&, _Sent>
1713 common_iterator(
const common_iterator<_It2, _Sent2>& __x)
1714 noexcept(_S_noexcept<const _It2&, const _Sent2&>())
1715 : _M_valueless(), _M_index(__x._M_index)
1719 if constexpr (is_trivially_default_constructible_v<_It>)
1724 else if (_M_index == 1)
1726 if constexpr (is_trivially_default_constructible_v<_Sent>)
1734 common_iterator(
const common_iterator& __x)
1735 noexcept(_S_noexcept<const _It&, const _Sent&>())
1736 : _M_valueless(), _M_index(__x._M_index)
1740 if constexpr (is_trivially_default_constructible_v<_It>)
1745 else if (_M_index == 1)
1747 if constexpr (is_trivially_default_constructible_v<_Sent>)
1755 operator=(
const common_iterator& __x)
1756 noexcept(is_nothrow_copy_assignable_v<_It>
1757 && is_nothrow_copy_assignable_v<_Sent>
1758 && is_nothrow_copy_constructible_v<_It>
1759 && is_nothrow_copy_constructible_v<_Sent>)
1761 return this->
operator=<_It, _Sent>(__x);
1764 template<
typename _It2,
typename _Sent2>
1765 requires convertible_to<const _It2&, _It>
1766 && convertible_to<const _Sent2&, _Sent>
1767 && assignable_from<_It&, const _It2&>
1768 && assignable_from<_Sent&, const _Sent2&>
1770 operator=(
const common_iterator<_It2, _Sent2>& __x)
1771 noexcept(is_nothrow_constructible_v<_It, const _It2&>
1772 && is_nothrow_constructible_v<_Sent, const _Sent2&>
1773 && is_nothrow_assignable_v<_It, const _It2&>
1774 && is_nothrow_assignable_v<_Sent, const _Sent2&>)
1776 switch(_M_index << 2 | __x._M_index)
1782 _M_sent = __x._M_sent;
1801 __glibcxx_assert(__x._M_has_value());
1802 __builtin_unreachable();
1823 __glibcxx_assert(_M_index == 0);
1828 operator*() const requires __detail::__dereferenceable<const _It>
1830 __glibcxx_assert(_M_index == 0);
1835 operator->() const requires __detail::__common_iter_has_arrow<_It>
1837 __glibcxx_assert(_M_index == 0);
1838 if constexpr (is_pointer_v<_It> || requires { _M_it.operator->(); })
1840 else if constexpr (is_reference_v<iter_reference_t<_It>>)
1842 auto&& __tmp = *_M_it;
1846 return __arrow_proxy{*_M_it};
1852 __glibcxx_assert(_M_index == 0);
1860 __glibcxx_assert(_M_index == 0);
1861 if constexpr (forward_iterator<_It>)
1863 common_iterator __tmp = *
this;
1867 else if constexpr (!__detail::__common_iter_use_postfix_proxy<_It>)
1871 __postfix_proxy __p(**
this);
1877 template<
typename _It2, sentinel_for<_It> _Sent2>
1878 requires sentinel_for<_Sent, _It2>
1880 operator==(
const common_iterator& __x,
1881 const common_iterator<_It2, _Sent2>& __y)
1883 switch(__x._M_index << 2 | __y._M_index)
1889 return __x._M_it == __y._M_sent;
1891 return __x._M_sent == __y._M_it;
1893 __glibcxx_assert(__x._M_has_value());
1894 __glibcxx_assert(__y._M_has_value());
1895 __builtin_unreachable();
1899 template<
typename _It2, sentinel_for<_It> _Sent2>
1900 requires sentinel_for<_Sent, _It2> && equality_comparable_with<_It, _It2>
1902 operator==(
const common_iterator& __x,
1903 const common_iterator<_It2, _Sent2>& __y)
1905 switch(__x._M_index << 2 | __y._M_index)
1910 return __x._M_it == __y._M_it;
1912 return __x._M_it == __y._M_sent;
1914 return __x._M_sent == __y._M_it;
1916 __glibcxx_assert(__x._M_has_value());
1917 __glibcxx_assert(__y._M_has_value());
1918 __builtin_unreachable();
1922 template<sized_sentinel_for<_It> _It2, sized_sentinel_for<_It> _Sent2>
1923 requires sized_sentinel_for<_Sent, _It2>
1924 friend iter_difference_t<_It2>
1926 const common_iterator<_It2, _Sent2>& __y)
1928 switch(__x._M_index << 2 | __y._M_index)
1933 return __x._M_it - __y._M_it;
1935 return __x._M_it - __y._M_sent;
1937 return __x._M_sent - __y._M_it;
1939 __glibcxx_assert(__x._M_has_value());
1940 __glibcxx_assert(__y._M_has_value());
1941 __builtin_unreachable();
1945 friend iter_rvalue_reference_t<_It>
1946 iter_move(
const common_iterator& __i)
1947 noexcept(noexcept(ranges::iter_move(std::declval<const _It&>())))
1948 requires input_iterator<_It>
1950 __glibcxx_assert(__i._M_index == 0);
1951 return ranges::iter_move(__i._M_it);
1954 template<indirectly_swappable<_It> _It2,
typename _Sent2>
1956 iter_swap(
const common_iterator& __x,
1957 const common_iterator<_It2, _Sent2>& __y)
1958 noexcept(noexcept(ranges::iter_swap(std::declval<const _It&>(),
1959 std::declval<const _It2&>())))
1961 __glibcxx_assert(__x._M_index == 0);
1962 __glibcxx_assert(__y._M_index == 0);
1963 return ranges::iter_swap(__x._M_it, __y._M_it);
1967 template<input_or_output_iterator _It2, sentinel_for<_It2> _Sent2>
1968 friend class common_iterator;
1970 bool _M_has_value() const noexcept {
return _M_index < 2; }
1976 unsigned char _M_valueless;
1978 unsigned char _M_index;
1981 template<
typename _It,
typename _Sent>
1982 struct incrementable_traits<common_iterator<_It, _Sent>>
1984 using difference_type = iter_difference_t<_It>;
1987 template<input_iterator _It,
typename _Sent>
1988 struct iterator_traits<common_iterator<_It, _Sent>>
1991 template<
typename _Iter>
1997 template<
typename _Iter>
1998 requires __detail::__common_iter_has_arrow<_Iter>
2001 using _CIter = common_iterator<_Iter, _Sent>;
2002 using type = decltype(std::declval<const _CIter&>().operator->());
2008 using _Traits = iterator_traits<_It>;
2009 if constexpr (requires { requires derived_from<
typename _Traits::iterator_category,
2010 forward_iterator_tag>; })
2011 return forward_iterator_tag{};
2013 return input_iterator_tag{};
2017 using iterator_concept = conditional_t<forward_iterator<_It>,
2018 forward_iterator_tag, input_iterator_tag>;
2019 using iterator_category = decltype(_S_iter_cat());
2020 using value_type = iter_value_t<_It>;
2021 using difference_type = iter_difference_t<_It>;
2022 using pointer =
typename __ptr<_It>::type;
2023 using reference = iter_reference_t<_It>;
2030 template<
typename _It>
2031 struct __counted_iter_value_type
2034 template<indirectly_readable _It>
2035 struct __counted_iter_value_type<_It>
2036 {
using value_type = iter_value_t<_It>; };
2038 template<
typename _It>
2039 struct __counted_iter_concept
2042 template<
typename _It>
2043 requires requires {
typename _It::iterator_concept; }
2044 struct __counted_iter_concept<_It>
2045 {
using iterator_concept =
typename _It::iterator_concept; };
2047 template<
typename _It>
2048 struct __counted_iter_cat
2051 template<
typename _It>
2052 requires requires {
typename _It::iterator_category; }
2053 struct __counted_iter_cat<_It>
2054 {
using iterator_category =
typename _It::iterator_category; };
2058 template<input_or_output_iterator _It>
2059 class counted_iterator
2060 :
public __detail::__counted_iter_value_type<_It>,
2061 public __detail::__counted_iter_concept<_It>,
2062 public __detail::__counted_iter_cat<_It>
2065 using iterator_type = _It;
2067 using difference_type = iter_difference_t<_It>;
2071 constexpr counted_iterator() =
default;
2074 counted_iterator(_It __i, iter_difference_t<_It> __n)
2075 : _M_current(
std::
move(__i)), _M_length(__n)
2076 { __glibcxx_assert(__n >= 0); }
2078 template<
typename _It2>
2079 requires convertible_to<const _It2&, _It>
2081 counted_iterator(
const counted_iterator<_It2>& __x)
2082 : _M_current(__x._M_current), _M_length(__x._M_length)
2085 template<
typename _It2>
2086 requires assignable_from<_It&, const _It2&>
2087 constexpr counted_iterator&
2088 operator=(
const counted_iterator<_It2>& __x)
2090 _M_current = __x._M_current;
2091 _M_length = __x._M_length;
2095 constexpr
const _It&
2096 base() const & noexcept
2097 {
return _M_current; }
2101 noexcept(is_nothrow_move_constructible_v<_It>)
2104 constexpr iter_difference_t<_It>
2105 count() const noexcept {
return _M_length; }
2107 constexpr decltype(
auto)
2109 noexcept(noexcept(*_M_current))
2110 {
return *_M_current; }
2112 constexpr decltype(
auto)
2114 noexcept(noexcept(*_M_current))
2115 requires __detail::__dereferenceable<const _It>
2116 {
return *_M_current; }
2119 operator->() const noexcept
2120 requires contiguous_iterator<_It>
2121 {
return std::to_address(_M_current); }
2123 constexpr counted_iterator&
2126 __glibcxx_assert(_M_length > 0);
2135 __glibcxx_assert(_M_length > 0);
2139 return _M_current++;
2142 __throw_exception_again;
2147 constexpr counted_iterator
2148 operator++(
int) requires forward_iterator<_It>
2155 constexpr counted_iterator&
2156 operator--() requires bidirectional_iterator<_It>
2163 constexpr counted_iterator
2164 operator--(
int) requires bidirectional_iterator<_It>
2171 constexpr counted_iterator
2172 operator+(iter_difference_t<_It> __n)
const
2173 requires random_access_iterator<_It>
2174 {
return counted_iterator(_M_current + __n, _M_length - __n); }
2176 friend constexpr counted_iterator
2177 operator+(iter_difference_t<_It> __n,
const counted_iterator& __x)
2178 requires random_access_iterator<_It>
2179 {
return __x + __n; }
2181 constexpr counted_iterator&
2182 operator+=(iter_difference_t<_It> __n)
2183 requires random_access_iterator<_It>
2185 __glibcxx_assert(__n <= _M_length);
2191 constexpr counted_iterator
2192 operator-(iter_difference_t<_It> __n)
const
2193 requires random_access_iterator<_It>
2194 {
return counted_iterator(_M_current - __n, _M_length + __n); }
2196 template<common_with<_It> _It2>
2197 friend constexpr iter_difference_t<_It2>
2199 const counted_iterator<_It2>& __y)
2200 {
return __y._M_length - __x._M_length; }
2202 friend constexpr iter_difference_t<_It>
2203 operator-(
const counted_iterator& __x, default_sentinel_t)
2204 {
return -__x._M_length; }
2206 friend constexpr iter_difference_t<_It>
2207 operator-(default_sentinel_t,
const counted_iterator& __y)
2208 {
return __y._M_length; }
2210 constexpr counted_iterator&
2211 operator-=(iter_difference_t<_It> __n)
2212 requires random_access_iterator<_It>
2214 __glibcxx_assert(-__n <= _M_length);
2220 constexpr decltype(
auto)
2221 operator[](iter_difference_t<_It> __n) const
2222 noexcept(noexcept(_M_current[__n]))
2223 requires random_access_iterator<_It>
2225 __glibcxx_assert(__n < _M_length);
2226 return _M_current[__n];
2229 template<common_with<_It> _It2>
2230 friend constexpr
bool
2231 operator==(
const counted_iterator& __x,
2232 const counted_iterator<_It2>& __y)
2233 {
return __x._M_length == __y._M_length; }
2235 friend constexpr
bool
2236 operator==(
const counted_iterator& __x, default_sentinel_t)
2237 {
return __x._M_length == 0; }
2239 template<common_with<_It> _It2>
2240 friend constexpr strong_ordering
2241 operator<=>(
const counted_iterator& __x,
2242 const counted_iterator<_It2>& __y)
2243 {
return __y._M_length <=> __x._M_length; }
2245 friend constexpr iter_rvalue_reference_t<_It>
2246 iter_move(
const counted_iterator& __i)
2247 noexcept(noexcept(ranges::iter_move(__i._M_current)))
2248 requires input_iterator<_It>
2249 {
return ranges::iter_move(__i._M_current); }
2251 template<indirectly_swappable<_It> _It2>
2252 friend constexpr
void
2253 iter_swap(
const counted_iterator& __x,
2254 const counted_iterator<_It2>& __y)
2255 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
2256 { ranges::iter_swap(__x._M_current, __y._M_current); }
2259 template<input_or_output_iterator _It2>
friend class counted_iterator;
2261 _It _M_current = _It();
2262 iter_difference_t<_It> _M_length = 0;
2265 template<input_iterator _It>
2266 requires same_as<__detail::__iter_traits<_It>, iterator_traits<_It>>
2267 struct iterator_traits<counted_iterator<_It>> : iterator_traits<_It>
2269 using pointer = conditional_t<contiguous_iterator<_It>,
2270 add_pointer_t<iter_reference_t<_It>>,
2277 template<
typename _Iterator>
2279 __niter_base(move_iterator<_Iterator> __it)
2280 -> decltype(make_move_iterator(__niter_base(__it.base())))
2281 {
return make_move_iterator(__niter_base(__it.base())); }
2283 template<
typename _Iterator>
2284 struct __is_move_iterator<move_iterator<_Iterator> >
2286 enum { __value = 1 };
2287 typedef __true_type __type;
2290 template<
typename _Iterator>
2292 __miter_base(move_iterator<_Iterator> __it)
2293 -> decltype(__miter_base(__it.base()))
2294 {
return __miter_base(__it.base()); }
2296 #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) std::make_move_iterator(_Iter)
2297 #define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) \
2298 std::__make_move_if_noexcept_iterator(_Iter)
2300 #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) (_Iter)
2301 #define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) (_Iter)
2304 #if __cpp_deduction_guides >= 201606
2307 template<
typename _InputIterator>
2309 typename iterator_traits<_InputIterator>::value_type::first_type>;
2311 template<
typename _InputIterator>
2312 using __iter_val_t =
2313 typename iterator_traits<_InputIterator>::value_type::second_type;
2315 template<
typename _T1,
typename _T2>
2318 template<
typename _InputIterator>
2319 using __iter_to_alloc_t =
2320 pair<add_const_t<__iter_key_t<_InputIterator>>,
2321 __iter_val_t<_InputIterator>>;
2324 _GLIBCXX_END_NAMESPACE_VERSION
2327 #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.