60 #ifndef _STL_ITERATOR_H
61 #define _STL_ITERATOR_H 1
69 #if __cplusplus >= 201103L
73 #if __cplusplus > 201703L
74 # define __cpp_lib_array_constexpr 201811L
75 # define __cpp_lib_constexpr_iterator 201811L
76 #elif __cplusplus == 201703L
77 # define __cpp_lib_array_constexpr 201803L
80 #if __cplusplus > 201703L
87 namespace std _GLIBCXX_VISIBILITY(default)
89 _GLIBCXX_BEGIN_NAMESPACE_VERSION
96 #if __cplusplus > 201703L && __cpp_lib_concepts
101 template<
typename _Cat,
typename _Limit,
typename _Otherwise = _Cat>
102 using __clamp_iter_cat
103 = conditional_t<derived_from<_Cat, _Limit>, _Limit, _Otherwise>;
126 template<
typename _Iterator>
128 :
public iterator<typename iterator_traits<_Iterator>::iterator_category,
129 typename iterator_traits<_Iterator>::value_type,
130 typename iterator_traits<_Iterator>::difference_type,
131 typename iterator_traits<_Iterator>::pointer,
132 typename iterator_traits<_Iterator>::reference>
134 template<
typename _Iter>
137 #if __cpp_lib_concepts
140 template<
typename _Iter>
141 static constexpr
bool __convertible = !is_same_v<_Iter, _Iterator>
142 && convertible_to<const _Iter&, _Iterator>;
151 typedef _Iterator iterator_type;
152 typedef typename __traits_type::difference_type difference_type;
153 typedef typename __traits_type::pointer pointer;
154 typedef typename __traits_type::reference reference;
156 #if __cplusplus > 201703L && __cpp_lib_concepts
157 using iterator_concept
162 = __detail::__clamp_iter_cat<
typename __traits_type::iterator_category,
179 explicit _GLIBCXX17_CONSTEXPR
187 : current(__x.current) { }
189 #if __cplusplus >= 201103L
197 template<
typename _Iter>
198 #if __cpp_lib_concepts
199 requires __convertible<_Iter>
203 : current(__x.current) { }
205 #if __cplusplus >= 201103L
206 template<
typename _Iter>
207 #if __cpp_lib_concepts
208 requires __convertible<_Iter>
209 && assignable_from<_Iterator&, const _Iter&>
215 current = __x.current;
223 _GLIBCXX17_CONSTEXPR iterator_type
237 _GLIBCXX17_CONSTEXPR reference
240 _Iterator __tmp = current;
249 _GLIBCXX17_CONSTEXPR pointer
251 #if __cplusplus > 201703L && __cpp_concepts >= 201907L
252 requires is_pointer_v<_Iterator>
253 || requires(
const _Iterator __i) { __i.operator->(); }
258 _Iterator __tmp = current;
260 return _S_to_pointer(__tmp);
268 _GLIBCXX17_CONSTEXPR reverse_iterator&
362 _GLIBCXX17_CONSTEXPR reference
364 {
return *(*
this + __n); }
366 #if __cplusplus > 201703L && __cpp_lib_concepts
367 friend constexpr iter_rvalue_reference_t<_Iterator>
369 noexcept(is_nothrow_copy_constructible_v<_Iterator>
370 && noexcept(ranges::iter_move(--std::declval<_Iterator&>())))
372 auto __tmp = __i.base();
373 return ranges::iter_move(--__tmp);
376 template<indirectly_swappable<_Iterator> _Iter2>
377 friend constexpr
void
378 iter_swap(
const reverse_iterator& __x,
379 const reverse_iterator<_Iter2>& __y)
380 noexcept(is_nothrow_copy_constructible_v<_Iterator>
381 && is_nothrow_copy_constructible_v<_Iter2>
382 && noexcept(ranges::iter_swap(--std::declval<_Iterator&>(),
383 --std::declval<_Iter2&>())))
385 auto __xtmp = __x.base();
386 auto __ytmp = __y.base();
387 ranges::iter_swap(--__xtmp, --__ytmp);
392 template<
typename _Tp>
393 static _GLIBCXX17_CONSTEXPR _Tp*
394 _S_to_pointer(_Tp* __p)
397 template<
typename _Tp>
398 static _GLIBCXX17_CONSTEXPR pointer
399 _S_to_pointer(_Tp __t)
400 {
return __t.operator->(); }
413 #if __cplusplus <= 201703L || ! defined __cpp_lib_concepts
414 template<
typename _Iterator>
415 inline _GLIBCXX17_CONSTEXPR
bool
418 {
return __x.
base() == __y.
base(); }
420 template<
typename _Iterator>
421 inline _GLIBCXX17_CONSTEXPR
bool
422 operator<(
const reverse_iterator<_Iterator>& __x,
423 const reverse_iterator<_Iterator>& __y)
424 {
return __y.base() < __x.base(); }
426 template<
typename _Iterator>
427 inline _GLIBCXX17_CONSTEXPR
bool
428 operator!=(
const reverse_iterator<_Iterator>& __x,
429 const reverse_iterator<_Iterator>& __y)
430 {
return !(__x == __y); }
432 template<
typename _Iterator>
433 inline _GLIBCXX17_CONSTEXPR
bool
434 operator>(
const reverse_iterator<_Iterator>& __x,
435 const reverse_iterator<_Iterator>& __y)
436 {
return __y < __x; }
438 template<
typename _Iterator>
439 inline _GLIBCXX17_CONSTEXPR
bool
440 operator<=(
const reverse_iterator<_Iterator>& __x,
441 const reverse_iterator<_Iterator>& __y)
442 {
return !(__y < __x); }
444 template<
typename _Iterator>
445 inline _GLIBCXX17_CONSTEXPR
bool
446 operator>=(
const reverse_iterator<_Iterator>& __x,
447 const reverse_iterator<_Iterator>& __y)
448 {
return !(__x < __y); }
453 template<
typename _IteratorL,
typename _IteratorR>
454 inline _GLIBCXX17_CONSTEXPR
bool
455 operator==(
const reverse_iterator<_IteratorL>& __x,
456 const reverse_iterator<_IteratorR>& __y)
457 {
return __x.base() == __y.base(); }
459 template<
typename _IteratorL,
typename _IteratorR>
460 inline _GLIBCXX17_CONSTEXPR
bool
461 operator<(
const reverse_iterator<_IteratorL>& __x,
462 const reverse_iterator<_IteratorR>& __y)
463 {
return __x.base() > __y.base(); }
465 template<
typename _IteratorL,
typename _IteratorR>
466 inline _GLIBCXX17_CONSTEXPR
bool
467 operator!=(
const reverse_iterator<_IteratorL>& __x,
468 const reverse_iterator<_IteratorR>& __y)
469 {
return __x.base() != __y.base(); }
471 template<
typename _IteratorL,
typename _IteratorR>
472 inline _GLIBCXX17_CONSTEXPR
bool
473 operator>(
const reverse_iterator<_IteratorL>& __x,
474 const reverse_iterator<_IteratorR>& __y)
475 {
return __x.base() < __y.base(); }
477 template<
typename _IteratorL,
typename _IteratorR>
478 inline _GLIBCXX17_CONSTEXPR
bool
479 operator<=(
const reverse_iterator<_IteratorL>& __x,
480 const reverse_iterator<_IteratorR>& __y)
481 {
return __x.base() >= __y.base(); }
483 template<
typename _IteratorL,
typename _IteratorR>
484 inline _GLIBCXX17_CONSTEXPR
bool
485 operator>=(
const reverse_iterator<_IteratorL>& __x,
486 const reverse_iterator<_IteratorR>& __y)
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,
typename _IteratorR>
505 operator<(
const reverse_iterator<_IteratorL>& __x,
506 const reverse_iterator<_IteratorR>& __y)
507 requires requires { { __x.base() > __y.base() } -> convertible_to<bool>; }
508 {
return __x.base() > __y.base(); }
510 template<
typename _IteratorL,
typename _IteratorR>
512 operator>(
const reverse_iterator<_IteratorL>& __x,
513 const reverse_iterator<_IteratorR>& __y)
514 requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
515 {
return __x.base() < __y.base(); }
517 template<
typename _IteratorL,
typename _IteratorR>
519 operator<=(
const reverse_iterator<_IteratorL>& __x,
520 const reverse_iterator<_IteratorR>& __y)
521 requires requires { { __x.base() >= __y.base() } -> convertible_to<bool>; }
522 {
return __x.base() >= __y.base(); }
524 template<
typename _IteratorL,
typename _IteratorR>
526 operator>=(
const reverse_iterator<_IteratorL>& __x,
527 const reverse_iterator<_IteratorR>& __y)
528 requires requires { { __x.base() <= __y.base() } -> convertible_to<bool>; }
529 {
return __x.base() <= __y.base(); }
531 template<
typename _IteratorL,
532 three_way_comparable_with<_IteratorL> _IteratorR>
533 constexpr compare_three_way_result_t<_IteratorL, _IteratorR>
534 operator<=>(
const reverse_iterator<_IteratorL>& __x,
535 const reverse_iterator<_IteratorR>& __y)
536 {
return __y.base() <=> __x.base(); }
540 #if __cplusplus < 201103L
541 template<
typename _Iterator>
542 inline typename reverse_iterator<_Iterator>::difference_type
543 operator-(
const reverse_iterator<_Iterator>& __x,
544 const reverse_iterator<_Iterator>& __y)
545 {
return __y.base() - __x.base(); }
547 template<
typename _IteratorL,
typename _IteratorR>
548 inline typename reverse_iterator<_IteratorL>::difference_type
549 operator-(
const reverse_iterator<_IteratorL>& __x,
550 const reverse_iterator<_IteratorR>& __y)
551 {
return __y.base() - __x.base(); }
555 template<
typename _IteratorL,
typename _IteratorR>
556 inline _GLIBCXX17_CONSTEXPR
auto
557 operator-(
const reverse_iterator<_IteratorL>& __x,
558 const reverse_iterator<_IteratorR>& __y)
559 -> decltype(__y.base() - __x.base())
560 {
return __y.base() - __x.base(); }
563 template<
typename _Iterator>
564 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
565 operator+(
typename reverse_iterator<_Iterator>::difference_type __n,
566 const reverse_iterator<_Iterator>& __x)
567 {
return reverse_iterator<_Iterator>(__x.base() - __n); }
569 #if __cplusplus >= 201103L
571 template<
typename _Iterator>
572 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
573 __make_reverse_iterator(_Iterator __i)
574 {
return reverse_iterator<_Iterator>(__i); }
576 # if __cplusplus >= 201402L
577 # define __cpp_lib_make_reverse_iterator 201402
582 template<
typename _Iterator>
583 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
587 # if __cplusplus > 201703L && defined __cpp_lib_concepts
588 template<
typename _Iterator1,
typename _Iterator2>
589 requires (!sized_sentinel_for<_Iterator1, _Iterator2>)
590 inline constexpr
bool
591 disable_sized_sentinel_for<reverse_iterator<_Iterator1>,
592 reverse_iterator<_Iterator2>> =
true;
596 template<
typename _Iterator>
599 __niter_base(reverse_iterator<_Iterator> __it)
600 -> decltype(__make_reverse_iterator(__niter_base(__it.base())))
601 {
return __make_reverse_iterator(__niter_base(__it.base())); }
603 template<
typename _Iterator>
604 struct __is_move_iterator<reverse_iterator<_Iterator> >
605 : __is_move_iterator<_Iterator>
608 template<
typename _Iterator>
611 __miter_base(reverse_iterator<_Iterator> __it)
612 -> decltype(__make_reverse_iterator(__miter_base(__it.base())))
613 {
return __make_reverse_iterator(__miter_base(__it.base())); }
627 template<
typename _Container>
629 :
public iterator<output_iterator_tag, void, void, void, void>
632 _Container* container;
637 #if __cplusplus > 201703L
644 explicit _GLIBCXX20_CONSTEXPR
659 #if __cplusplus < 201103L
661 operator=(
typename _Container::const_reference __value)
663 container->push_back(__value);
669 operator=(
const typename _Container::value_type& __value)
671 container->push_back(__value);
677 operator=(
typename _Container::value_type&& __value)
679 container->push_back(
std::move(__value));
714 template<
typename _Container>
716 inline back_insert_iterator<_Container>
730 template<
typename _Container>
732 :
public iterator<output_iterator_tag, void, void, void, void>
735 _Container* container;
740 #if __cplusplus > 201703L
747 explicit _GLIBCXX20_CONSTEXPR
762 #if __cplusplus < 201103L
764 operator=(
typename _Container::const_reference __value)
766 container->push_front(__value);
772 operator=(
const typename _Container::value_type& __value)
774 container->push_front(__value);
780 operator=(
typename _Container::value_type&& __value)
782 container->push_front(
std::move(__value));
817 template<
typename _Container>
819 inline front_insert_iterator<_Container>
837 template<
typename _Container>
839 :
public iterator<output_iterator_tag, void, void, void, void>
841 #if __cplusplus > 201703L && defined __cpp_lib_concepts
842 using _Iter = std::__detail::__range_iter_t<_Container>;
845 _Container* container =
nullptr;
846 _Iter iter = _Iter();
848 typedef typename _Container::iterator _Iter;
851 _Container* container;
859 #if __cplusplus > 201703L && defined __cpp_lib_concepts
896 #if __cplusplus < 201103L
898 operator=(
typename _Container::const_reference __value)
900 iter = container->insert(iter, __value);
907 operator=(
const typename _Container::value_type& __value)
909 iter = container->insert(iter, __value);
916 operator=(
typename _Container::value_type&& __value)
918 iter = container->insert(iter,
std::move(__value));
955 #if __cplusplus > 201703L && defined __cpp_lib_concepts
956 template<
typename _Container>
957 constexpr insert_iterator<_Container>
958 inserter(_Container& __x, std::__detail::__range_iter_t<_Container> __i)
959 {
return insert_iterator<_Container>(__x, __i); }
961 template<
typename _Container>
962 inline insert_iterator<_Container>
963 inserter(_Container& __x,
typename _Container::iterator __i)
969 _GLIBCXX_END_NAMESPACE_VERSION
972 namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
974 _GLIBCXX_BEGIN_NAMESPACE_VERSION
983 template<
typename _Iterator,
typename _Container>
984 class __normal_iterator
987 _Iterator _M_current;
992 typedef _Iterator iterator_type;
993 typedef typename __traits_type::iterator_category iterator_category;
994 typedef typename __traits_type::value_type value_type;
995 typedef typename __traits_type::difference_type difference_type;
996 typedef typename __traits_type::reference reference;
997 typedef typename __traits_type::pointer pointer;
999 #if __cplusplus > 201703L && __cpp_lib_concepts
1000 using iterator_concept = std::__detail::__iter_concept<_Iterator>;
1003 _GLIBCXX_CONSTEXPR __normal_iterator() _GLIBCXX_NOEXCEPT
1004 : _M_current(_Iterator()) { }
1006 explicit _GLIBCXX20_CONSTEXPR
1007 __normal_iterator(
const _Iterator& __i) _GLIBCXX_NOEXCEPT
1008 : _M_current(__i) { }
1011 template<
typename _Iter>
1012 _GLIBCXX20_CONSTEXPR
1013 __normal_iterator(
const __normal_iterator<_Iter,
1014 typename __enable_if<
1015 (std::__are_same<_Iter, typename _Container::pointer>::__value),
1016 _Container>::__type>& __i) _GLIBCXX_NOEXCEPT
1017 : _M_current(__i.base()) { }
1020 _GLIBCXX20_CONSTEXPR
1023 {
return *_M_current; }
1025 _GLIBCXX20_CONSTEXPR
1028 {
return _M_current; }
1030 _GLIBCXX20_CONSTEXPR
1032 operator++() _GLIBCXX_NOEXCEPT
1038 _GLIBCXX20_CONSTEXPR
1040 operator++(
int) _GLIBCXX_NOEXCEPT
1041 {
return __normal_iterator(_M_current++); }
1044 _GLIBCXX20_CONSTEXPR
1046 operator--() _GLIBCXX_NOEXCEPT
1052 _GLIBCXX20_CONSTEXPR
1054 operator--(
int) _GLIBCXX_NOEXCEPT
1055 {
return __normal_iterator(_M_current--); }
1058 _GLIBCXX20_CONSTEXPR
1060 operator[](difference_type __n)
const _GLIBCXX_NOEXCEPT
1061 {
return _M_current[__n]; }
1063 _GLIBCXX20_CONSTEXPR
1065 operator+=(difference_type __n) _GLIBCXX_NOEXCEPT
1066 { _M_current += __n;
return *
this; }
1068 _GLIBCXX20_CONSTEXPR
1070 operator+(difference_type __n)
const _GLIBCXX_NOEXCEPT
1071 {
return __normal_iterator(_M_current + __n); }
1073 _GLIBCXX20_CONSTEXPR
1075 operator-=(difference_type __n) _GLIBCXX_NOEXCEPT
1076 { _M_current -= __n;
return *
this; }
1078 _GLIBCXX20_CONSTEXPR
1080 operator-(difference_type __n)
const _GLIBCXX_NOEXCEPT
1081 {
return __normal_iterator(_M_current - __n); }
1083 _GLIBCXX20_CONSTEXPR
1085 base() const _GLIBCXX_NOEXCEPT
1086 {
return _M_current; }
1097 #if __cpp_lib_three_way_comparison
1098 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1099 requires requires (_IteratorL __lhs, _IteratorR __rhs)
1100 { { __lhs == __rhs } -> std::convertible_to<bool>; }
1102 operator==(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1103 const __normal_iterator<_IteratorR, _Container>& __rhs)
1104 noexcept(noexcept(__lhs.base() == __rhs.base()))
1105 {
return __lhs.base() == __rhs.base(); }
1107 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1108 constexpr std::__detail::__synth3way_t<_IteratorR, _IteratorL>
1109 operator<=>(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1110 const __normal_iterator<_IteratorR, _Container>& __rhs)
1111 noexcept(noexcept(std::__detail::__synth3way(__lhs.base(), __rhs.base())))
1112 {
return std::__detail::__synth3way(__lhs.base(), __rhs.base()); }
1115 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1116 _GLIBCXX20_CONSTEXPR
1118 operator==(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1119 const __normal_iterator<_IteratorR, _Container>& __rhs)
1121 {
return __lhs.base() == __rhs.base(); }
1123 template<
typename _Iterator,
typename _Container>
1124 _GLIBCXX20_CONSTEXPR
1126 operator==(
const __normal_iterator<_Iterator, _Container>& __lhs,
1127 const __normal_iterator<_Iterator, _Container>& __rhs)
1129 {
return __lhs.base() == __rhs.base(); }
1131 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1132 _GLIBCXX20_CONSTEXPR
1134 operator!=(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1135 const __normal_iterator<_IteratorR, _Container>& __rhs)
1137 {
return __lhs.base() != __rhs.base(); }
1139 template<
typename _Iterator,
typename _Container>
1140 _GLIBCXX20_CONSTEXPR
1142 operator!=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1143 const __normal_iterator<_Iterator, _Container>& __rhs)
1145 {
return __lhs.base() != __rhs.base(); }
1148 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1150 operator<(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1151 const __normal_iterator<_IteratorR, _Container>& __rhs)
1153 {
return __lhs.base() < __rhs.base(); }
1155 template<
typename _Iterator,
typename _Container>
1156 _GLIBCXX20_CONSTEXPR
1158 operator<(
const __normal_iterator<_Iterator, _Container>& __lhs,
1159 const __normal_iterator<_Iterator, _Container>& __rhs)
1161 {
return __lhs.base() < __rhs.base(); }
1163 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1165 operator>(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1166 const __normal_iterator<_IteratorR, _Container>& __rhs)
1168 {
return __lhs.base() > __rhs.base(); }
1170 template<
typename _Iterator,
typename _Container>
1171 _GLIBCXX20_CONSTEXPR
1173 operator>(
const __normal_iterator<_Iterator, _Container>& __lhs,
1174 const __normal_iterator<_Iterator, _Container>& __rhs)
1176 {
return __lhs.base() > __rhs.base(); }
1178 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1180 operator<=(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1181 const __normal_iterator<_IteratorR, _Container>& __rhs)
1183 {
return __lhs.base() <= __rhs.base(); }
1185 template<
typename _Iterator,
typename _Container>
1186 _GLIBCXX20_CONSTEXPR
1188 operator<=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1189 const __normal_iterator<_Iterator, _Container>& __rhs)
1191 {
return __lhs.base() <= __rhs.base(); }
1193 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
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
1203 operator>=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1204 const __normal_iterator<_Iterator, _Container>& __rhs)
1206 {
return __lhs.base() >= __rhs.base(); }
1213 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1214 #if __cplusplus >= 201103L
1216 _GLIBCXX20_CONSTEXPR
1218 operator-(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1219 const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept
1220 -> decltype(__lhs.base() - __rhs.base())
1222 inline typename __normal_iterator<_IteratorL, _Container>::difference_type
1223 operator-(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1224 const __normal_iterator<_IteratorR, _Container>& __rhs)
1226 {
return __lhs.base() - __rhs.base(); }
1228 template<
typename _Iterator,
typename _Container>
1229 _GLIBCXX20_CONSTEXPR
1230 inline typename __normal_iterator<_Iterator, _Container>::difference_type
1231 operator-(
const __normal_iterator<_Iterator, _Container>& __lhs,
1232 const __normal_iterator<_Iterator, _Container>& __rhs)
1234 {
return __lhs.base() - __rhs.base(); }
1236 template<
typename _Iterator,
typename _Container>
1237 _GLIBCXX20_CONSTEXPR
1238 inline __normal_iterator<_Iterator, _Container>
1239 operator+(
typename __normal_iterator<_Iterator, _Container>::difference_type
1240 __n,
const __normal_iterator<_Iterator, _Container>& __i)
1242 {
return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
1244 _GLIBCXX_END_NAMESPACE_VERSION
1247 namespace std _GLIBCXX_VISIBILITY(default)
1249 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1251 template<
typename _Iterator,
typename _Container>
1252 _GLIBCXX20_CONSTEXPR
1254 __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it)
1256 {
return __it.base(); }
1258 #if __cplusplus >= 201103L
1264 #if __cplusplus > 201703L && __cpp_lib_concepts
1265 template<semiregular _Sent>
1271 noexcept(is_nothrow_default_constructible_v<_Sent>)
1275 move_sentinel(_Sent __s)
1276 noexcept(is_nothrow_move_constructible_v<_Sent>)
1279 template<
typename _S2> requires convertible_to<const _S2&, _Sent>
1281 move_sentinel(
const move_sentinel<_S2>& __s)
1282 noexcept(is_nothrow_constructible_v<_Sent, const _S2&>)
1283 : _M_last(__s.base())
1286 template<
typename _S2> requires assignable_from<_Sent&, const _S2&>
1287 constexpr move_sentinel&
1288 operator=(
const move_sentinel<_S2>& __s)
1289 noexcept(is_nothrow_assignable_v<_Sent, const _S2&>)
1291 _M_last = __s.base();
1297 noexcept(is_nothrow_copy_constructible_v<_Sent>)
1314 template<
typename _Iterator>
1317 _Iterator _M_current;
1320 #if __cplusplus > 201703L && __cpp_lib_concepts
1321 using __base_cat =
typename __traits_type::iterator_category;
1323 using __base_ref =
typename __traits_type::reference;
1326 template<
typename _Iter2>
1329 #if __cpp_lib_concepts
1332 template<
typename _Iter2>
1333 static constexpr
bool __convertible = !is_same_v<_Iter2, _Iterator>
1334 && convertible_to<const _Iter2&, _Iterator>;
1338 using iterator_type = _Iterator;
1340 #if __cplusplus > 201703L && __cpp_lib_concepts
1342 using iterator_category
1343 = __detail::__clamp_iter_cat<__base_cat, random_access_iterator_tag>;
1344 using value_type = iter_value_t<_Iterator>;
1345 using difference_type = iter_difference_t<_Iterator>;
1346 using pointer = _Iterator;
1347 using reference = iter_rvalue_reference_t<_Iterator>;
1349 typedef typename __traits_type::iterator_category iterator_category;
1350 typedef typename __traits_type::value_type value_type;
1351 typedef typename __traits_type::difference_type difference_type;
1353 typedef _Iterator pointer;
1357 typename remove_reference<__base_ref>::type&&,
1358 __base_ref>::type reference;
1361 _GLIBCXX17_CONSTEXPR
1365 explicit _GLIBCXX17_CONSTEXPR
1369 template<
typename _Iter>
1370 #if __cpp_lib_concepts
1371 requires __convertible<_Iter>
1373 _GLIBCXX17_CONSTEXPR
1375 : _M_current(__i._M_current) { }
1377 template<
typename _Iter>
1378 #if __cpp_lib_concepts
1379 requires __convertible<_Iter>
1380 && assignable_from<_Iterator&, const _Iter&>
1382 _GLIBCXX17_CONSTEXPR
1385 _M_current = __i._M_current;
1389 #if __cplusplus <= 201703L
1390 _GLIBCXX17_CONSTEXPR iterator_type
1392 {
return _M_current; }
1394 constexpr iterator_type
1396 #if __cpp_lib_concepts
1397 requires copy_constructible<iterator_type>
1399 {
return _M_current; }
1401 constexpr iterator_type
1406 _GLIBCXX17_CONSTEXPR reference
1408 #if __cplusplus > 201703L && __cpp_lib_concepts
1409 {
return ranges::iter_move(_M_current); }
1411 {
return static_cast<reference
>(*_M_current); }
1414 _GLIBCXX17_CONSTEXPR pointer
1416 {
return _M_current; }
1433 #if __cpp_lib_concepts
1435 operator++(
int) requires (!forward_iterator<_Iterator>)
1455 operator+(difference_type __n)
const
1459 operator+=(difference_type __n)
1466 operator-(difference_type __n)
const
1470 operator-=(difference_type __n)
1476 _GLIBCXX17_CONSTEXPR reference
1477 operator[](difference_type __n)
const
1478 #if __cplusplus > 201703L && __cpp_lib_concepts
1479 {
return ranges::iter_move(_M_current + __n); }
1484 #if __cplusplus > 201703L && __cpp_lib_concepts
1485 template<sentinel_for<_Iterator> _Sent>
1486 friend constexpr
bool
1487 operator==(
const move_iterator& __x,
const move_sentinel<_Sent>& __y)
1488 {
return __x.base() == __y.base(); }
1490 template<sized_sentinel_for<_Iterator> _Sent>
1491 friend constexpr iter_difference_t<_Iterator>
1492 operator-(
const move_sentinel<_Sent>& __x,
const move_iterator& __y)
1493 {
return __x.base() - __y.base(); }
1495 template<sized_sentinel_for<_Iterator> _Sent>
1496 friend constexpr iter_difference_t<_Iterator>
1497 operator-(
const move_iterator& __x,
const move_sentinel<_Sent>& __y)
1498 {
return __x.base() - __y.base(); }
1500 friend constexpr iter_rvalue_reference_t<_Iterator>
1502 noexcept(noexcept(ranges::iter_move(__i._M_current)))
1503 {
return ranges::iter_move(__i._M_current); }
1505 template<indirectly_swappable<_Iterator> _Iter2>
1506 friend constexpr
void
1508 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1509 {
return ranges::iter_swap(__x._M_current, __y._M_current); }
1513 template<
typename _IteratorL,
typename _IteratorR>
1514 inline _GLIBCXX17_CONSTEXPR
bool
1517 #if __cplusplus > 201703L && __cpp_lib_concepts
1518 requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
1520 {
return __x.base() == __y.base(); }
1522 #if __cpp_lib_three_way_comparison
1523 template<
typename _IteratorL,
1524 three_way_comparable_with<_IteratorL> _IteratorR>
1525 constexpr compare_three_way_result_t<_IteratorL, _IteratorR>
1526 operator<=>(
const move_iterator<_IteratorL>& __x,
1527 const move_iterator<_IteratorR>& __y)
1528 {
return __x.base() <=> __y.base(); }
1530 template<
typename _IteratorL,
typename _IteratorR>
1531 inline _GLIBCXX17_CONSTEXPR
bool
1532 operator!=(
const move_iterator<_IteratorL>& __x,
1533 const move_iterator<_IteratorR>& __y)
1534 {
return !(__x == __y); }
1537 template<
typename _IteratorL,
typename _IteratorR>
1538 inline _GLIBCXX17_CONSTEXPR
bool
1539 operator<(
const move_iterator<_IteratorL>& __x,
1540 const move_iterator<_IteratorR>& __y)
1541 #if __cplusplus > 201703L && __cpp_lib_concepts
1542 requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
1544 {
return __x.base() < __y.base(); }
1546 template<
typename _IteratorL,
typename _IteratorR>
1547 inline _GLIBCXX17_CONSTEXPR
bool
1548 operator<=(
const move_iterator<_IteratorL>& __x,
1549 const move_iterator<_IteratorR>& __y)
1550 #if __cplusplus > 201703L && __cpp_lib_concepts
1551 requires requires { { __y.base() < __x.base() } -> convertible_to<bool>; }
1553 {
return !(__y < __x); }
1555 template<
typename _IteratorL,
typename _IteratorR>
1556 inline _GLIBCXX17_CONSTEXPR
bool
1557 operator>(
const move_iterator<_IteratorL>& __x,
1558 const move_iterator<_IteratorR>& __y)
1559 #if __cplusplus > 201703L && __cpp_lib_concepts
1560 requires requires { { __y.base() < __x.base() } -> convertible_to<bool>; }
1562 {
return __y < __x; }
1564 template<
typename _IteratorL,
typename _IteratorR>
1565 inline _GLIBCXX17_CONSTEXPR
bool
1566 operator>=(
const move_iterator<_IteratorL>& __x,
1567 const move_iterator<_IteratorR>& __y)
1568 #if __cplusplus > 201703L && __cpp_lib_concepts
1569 requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
1571 {
return !(__x < __y); }
1573 #if ! (__cplusplus > 201703L && __cpp_lib_concepts)
1581 template<
typename _Iterator>
1582 inline _GLIBCXX17_CONSTEXPR
bool
1583 operator==(
const move_iterator<_Iterator>& __x,
1584 const move_iterator<_Iterator>& __y)
1585 {
return __x.base() == __y.base(); }
1587 template<
typename _Iterator>
1588 inline _GLIBCXX17_CONSTEXPR
bool
1589 operator!=(
const move_iterator<_Iterator>& __x,
1590 const move_iterator<_Iterator>& __y)
1591 {
return !(__x == __y); }
1593 template<
typename _Iterator>
1594 inline _GLIBCXX17_CONSTEXPR
bool
1595 operator<(
const move_iterator<_Iterator>& __x,
1596 const move_iterator<_Iterator>& __y)
1597 {
return __x.base() < __y.base(); }
1599 template<
typename _Iterator>
1600 inline _GLIBCXX17_CONSTEXPR
bool
1601 operator<=(
const move_iterator<_Iterator>& __x,
1602 const move_iterator<_Iterator>& __y)
1603 {
return !(__y < __x); }
1605 template<
typename _Iterator>
1606 inline _GLIBCXX17_CONSTEXPR
bool
1607 operator>(
const move_iterator<_Iterator>& __x,
1608 const move_iterator<_Iterator>& __y)
1609 {
return __y < __x; }
1611 template<
typename _Iterator>
1612 inline _GLIBCXX17_CONSTEXPR
bool
1613 operator>=(
const move_iterator<_Iterator>& __x,
1614 const move_iterator<_Iterator>& __y)
1615 {
return !(__x < __y); }
1619 template<
typename _IteratorL,
typename _IteratorR>
1620 inline _GLIBCXX17_CONSTEXPR
auto
1621 operator-(
const move_iterator<_IteratorL>& __x,
1622 const move_iterator<_IteratorR>& __y)
1623 -> decltype(__x.base() - __y.base())
1624 {
return __x.base() - __y.base(); }
1626 template<
typename _Iterator>
1627 inline _GLIBCXX17_CONSTEXPR move_iterator<_Iterator>
1628 operator+(
typename move_iterator<_Iterator>::difference_type __n,
1629 const move_iterator<_Iterator>& __x)
1630 {
return __x + __n; }
1632 template<
typename _Iterator>
1633 inline _GLIBCXX17_CONSTEXPR move_iterator<_Iterator>
1634 make_move_iterator(_Iterator __i)
1635 {
return move_iterator<_Iterator>(
std::move(__i)); }
1637 template<
typename _Iterator,
typename _ReturnType
1638 =
typename conditional<__move_if_noexcept_cond
1639 <
typename iterator_traits<_Iterator>::value_type>::value,
1640 _Iterator, move_iterator<_Iterator>>::type>
1641 inline _GLIBCXX17_CONSTEXPR _ReturnType
1642 __make_move_if_noexcept_iterator(_Iterator __i)
1643 {
return _ReturnType(__i); }
1647 template<
typename _Tp,
typename _ReturnType
1648 =
typename conditional<__move_if_noexcept_cond<_Tp>::value,
1649 const _Tp*, move_iterator<_Tp*>>::type>
1650 inline _GLIBCXX17_CONSTEXPR _ReturnType
1651 __make_move_if_noexcept_iterator(_Tp* __i)
1652 {
return _ReturnType(__i); }
1654 #if __cplusplus > 201703L && __cpp_lib_concepts
1659 template<
typename _It>
1660 concept __common_iter_has_arrow = indirectly_readable<const _It>
1661 && (requires(
const _It& __it) { __it.operator->(); }
1662 || is_reference_v<iter_reference_t<_It>>
1663 || constructible_from<iter_value_t<_It>, iter_reference_t<_It>>);
1668 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
1669 requires (!same_as<_It, _Sent>) && copyable<_It>
1670 class common_iterator
1672 template<
typename _Tp,
typename _Up>
1673 static constexpr
bool
1676 if constexpr (is_trivially_default_constructible_v<_Tp>)
1677 return is_nothrow_assignable_v<_Tp, _Up>;
1679 return is_nothrow_constructible_v<_Tp, _Up>;
1682 template<
typename _It2,
typename _Sent2>
1683 static constexpr
bool
1685 {
return _S_noexcept1<_It, _It2>() && _S_noexcept1<_Sent, _Sent2>(); }
1689 iter_value_t<_It> _M_keep;
1691 _Proxy(iter_reference_t<_It>&& __x)
1694 friend class common_iterator;
1697 const iter_value_t<_It>*
1705 noexcept(is_nothrow_default_constructible_v<_It>)
1706 : _M_it(), _M_index(0)
1710 common_iterator(_It __i)
1711 noexcept(is_nothrow_move_constructible_v<_It>)
1712 : _M_it(
std::
move(__i)), _M_index(0)
1716 common_iterator(_Sent __s)
1717 noexcept(is_nothrow_move_constructible_v<_Sent>)
1718 : _M_sent(
std::
move(__s)), _M_index(1)
1721 template<
typename _It2,
typename _Sent2>
1722 requires convertible_to<const _It2&, _It>
1723 && convertible_to<const _Sent2&, _Sent>
1725 common_iterator(
const common_iterator<_It2, _Sent2>& __x)
1726 noexcept(_S_noexcept<const _It2&, const _Sent2&>())
1727 : _M_valueless(), _M_index(__x._M_index)
1731 if constexpr (is_trivially_default_constructible_v<_It>)
1736 else if (_M_index == 1)
1738 if constexpr (is_trivially_default_constructible_v<_Sent>)
1746 common_iterator(
const common_iterator& __x)
1747 noexcept(_S_noexcept<const _It&, const _Sent&>())
1748 : _M_valueless(), _M_index(__x._M_index)
1752 if constexpr (is_trivially_default_constructible_v<_It>)
1757 else if (_M_index == 1)
1759 if constexpr (is_trivially_default_constructible_v<_Sent>)
1768 noexcept(is_nothrow_copy_assignable_v<_It>
1769 && is_nothrow_copy_assignable_v<_Sent>
1770 && is_nothrow_copy_constructible_v<_It>
1771 && is_nothrow_copy_constructible_v<_Sent>)
1773 return this->
operator=<_It, _Sent>(__x);
1776 template<
typename _It2,
typename _Sent2>
1777 requires convertible_to<const _It2&, _It>
1778 && convertible_to<const _Sent2&, _Sent>
1779 && assignable_from<_It&, const _It2&>
1780 && assignable_from<_Sent&, const _Sent2&>
1782 operator=(
const common_iterator<_It2, _Sent2>& __x)
1783 noexcept(is_nothrow_constructible_v<_It, const _It2&>
1784 && is_nothrow_constructible_v<_Sent, const _Sent2&>
1785 && is_nothrow_assignable_v<_It, const _It2&>
1786 && is_nothrow_assignable_v<_Sent, const _Sent2&>)
1788 switch(_M_index << 2 | __x._M_index)
1794 _M_sent = __x._M_sent;
1813 __glibcxx_assert(__x._M_has_value());
1814 __builtin_unreachable();
1835 __glibcxx_assert(_M_index == 0);
1840 operator*() const requires __detail::__dereferenceable<const _It>
1842 __glibcxx_assert(_M_index == 0);
1847 operator->() const requires __detail::__common_iter_has_arrow<_It>
1849 __glibcxx_assert(_M_index == 0);
1850 if constexpr (is_pointer_v<_It> || requires { _M_it.operator->(); })
1852 else if constexpr (is_reference_v<iter_reference_t<_It>>)
1854 auto&& __tmp = *_M_it;
1858 return _Proxy{*_M_it};
1864 __glibcxx_assert(_M_index == 0);
1872 __glibcxx_assert(_M_index == 0);
1873 if constexpr (forward_iterator<_It>)
1875 common_iterator __tmp = *
this;
1883 template<
typename _It2, sentinel_for<_It> _Sent2>
1884 requires sentinel_for<_Sent, _It2>
1886 operator==(
const common_iterator& __x,
1887 const common_iterator<_It2, _Sent2>& __y)
1889 switch(__x._M_index << 2 | __y._M_index)
1895 return __x._M_it == __y._M_sent;
1897 return __x._M_sent == __y._M_it;
1899 __glibcxx_assert(__x._M_has_value());
1900 __glibcxx_assert(__y._M_has_value());
1901 __builtin_unreachable();
1905 template<
typename _It2, sentinel_for<_It> _Sent2>
1906 requires sentinel_for<_Sent, _It2> && equality_comparable_with<_It, _It2>
1908 operator==(
const common_iterator& __x,
1909 const common_iterator<_It2, _Sent2>& __y)
1911 switch(__x._M_index << 2 | __y._M_index)
1916 return __x._M_it == __y._M_it;
1918 return __x._M_it == __y._M_sent;
1920 return __x._M_sent == __y._M_it;
1922 __glibcxx_assert(__x._M_has_value());
1923 __glibcxx_assert(__y._M_has_value());
1924 __builtin_unreachable();
1928 template<sized_sentinel_for<_It> _It2, sized_sentinel_for<_It> _Sent2>
1929 requires sized_sentinel_for<_Sent, _It2>
1930 friend iter_difference_t<_It2>
1932 const common_iterator<_It2, _Sent2>& __y)
1934 switch(__x._M_index << 2 | __y._M_index)
1939 return __x._M_it - __y._M_it;
1941 return __x._M_it - __y._M_sent;
1943 return __x._M_sent - __y._M_it;
1945 __glibcxx_assert(__x._M_has_value());
1946 __glibcxx_assert(__y._M_has_value());
1947 __builtin_unreachable();
1951 friend iter_rvalue_reference_t<_It>
1952 iter_move(
const common_iterator& __i)
1953 noexcept(noexcept(ranges::iter_move(std::declval<const _It&>())))
1954 requires input_iterator<_It>
1956 __glibcxx_assert(__i._M_index == 0);
1957 return ranges::iter_move(__i._M_it);
1960 template<indirectly_swappable<_It> _It2,
typename _Sent2>
1962 iter_swap(
const common_iterator& __x,
1963 const common_iterator<_It2, _Sent2>& __y)
1964 noexcept(noexcept(ranges::iter_swap(std::declval<const _It&>(),
1965 std::declval<const _It2&>())))
1967 __glibcxx_assert(__x._M_index == 0);
1968 __glibcxx_assert(__y._M_index == 0);
1969 return ranges::iter_swap(__x._M_it, __y._M_it);
1973 template<input_or_output_iterator _It2, sentinel_for<_It2> _Sent2>
1974 friend class common_iterator;
1976 bool _M_has_value() const noexcept {
return _M_index < 2; }
1982 unsigned char _M_valueless;
1984 unsigned char _M_index;
1987 template<
typename _It,
typename _Sent>
1988 struct incrementable_traits<common_iterator<_It, _Sent>>
1990 using difference_type = iter_difference_t<_It>;
1993 template<input_iterator _It,
typename _Sent>
1994 struct iterator_traits<common_iterator<_It, _Sent>>
1997 template<
typename _Iter>
2003 template<
typename _Iter>
2004 requires __detail::__common_iter_has_arrow<_Iter>
2007 using _CIter = common_iterator<_Iter, _Sent>;
2008 using type = decltype(std::declval<const _CIter&>().operator->());
2012 using iterator_concept = conditional_t<forward_iterator<_It>,
2013 forward_iterator_tag, input_iterator_tag>;
2014 using iterator_category = __detail::__clamp_iter_cat<
2015 typename iterator_traits<_It>::iterator_category,
2016 forward_iterator_tag, input_iterator_tag>;
2017 using value_type = iter_value_t<_It>;
2018 using difference_type = iter_difference_t<_It>;
2019 using pointer =
typename __ptr<_It>::type;
2020 using reference = iter_reference_t<_It>;
2026 template<input_or_output_iterator _It>
2027 class counted_iterator
2030 using iterator_type = _It;
2032 constexpr counted_iterator() =
default;
2035 counted_iterator(_It __i, iter_difference_t<_It> __n)
2036 : _M_current(
std::
move(__i)), _M_length(__n)
2037 { __glibcxx_assert(__n >= 0); }
2039 template<
typename _It2>
2040 requires convertible_to<const _It2&, _It>
2042 counted_iterator(
const counted_iterator<_It2>& __x)
2043 : _M_current(__x._M_current), _M_length(__x._M_length)
2046 template<
typename _It2>
2047 requires assignable_from<_It&, const _It2&>
2048 constexpr counted_iterator&
2049 operator=(
const counted_iterator<_It2>& __x)
2051 _M_current = __x._M_current;
2052 _M_length = __x._M_length;
2058 noexcept(is_nothrow_copy_constructible_v<_It>)
2059 requires copy_constructible<_It>
2060 {
return _M_current; }
2064 noexcept(is_nothrow_move_constructible_v<_It>)
2067 constexpr iter_difference_t<_It>
2068 count() const noexcept {
return _M_length; }
2070 constexpr decltype(
auto)
2072 noexcept(noexcept(*_M_current))
2074 __glibcxx_assert( _M_length > 0 );
2078 constexpr decltype(
auto)
2080 noexcept(noexcept(*_M_current))
2081 requires __detail::__dereferenceable<const _It>
2083 __glibcxx_assert( _M_length > 0 );
2087 constexpr counted_iterator&
2090 __glibcxx_assert(_M_length > 0);
2099 __glibcxx_assert(_M_length > 0);
2103 return _M_current++;
2106 __throw_exception_again;
2111 constexpr counted_iterator
2112 operator++(
int) requires forward_iterator<_It>
2119 constexpr counted_iterator&
2120 operator--() requires bidirectional_iterator<_It>
2127 constexpr counted_iterator
2128 operator--(
int) requires bidirectional_iterator<_It>
2135 constexpr counted_iterator
2136 operator+(iter_difference_t<_It> __n)
const
2137 requires random_access_iterator<_It>
2138 {
return counted_iterator(_M_current + __n, _M_length - __n); }
2140 friend constexpr counted_iterator
2141 operator+(iter_difference_t<_It> __n,
const counted_iterator& __x)
2142 requires random_access_iterator<_It>
2143 {
return __x + __n; }
2145 constexpr counted_iterator&
2146 operator+=(iter_difference_t<_It> __n)
2147 requires random_access_iterator<_It>
2149 __glibcxx_assert(__n <= _M_length);
2155 constexpr counted_iterator
2156 operator-(iter_difference_t<_It> __n)
const
2157 requires random_access_iterator<_It>
2158 {
return counted_iterator(_M_current - __n, _M_length + __n); }
2160 template<common_with<_It> _It2>
2161 friend constexpr iter_difference_t<_It2>
2163 const counted_iterator<_It2>& __y)
2164 {
return __y._M_length - __x._M_length; }
2166 friend constexpr iter_difference_t<_It>
2167 operator-(
const counted_iterator& __x, default_sentinel_t)
2168 {
return -__x._M_length; }
2170 friend constexpr iter_difference_t<_It>
2171 operator-(default_sentinel_t,
const counted_iterator& __y)
2172 {
return __y._M_length; }
2174 constexpr counted_iterator&
2175 operator-=(iter_difference_t<_It> __n)
2176 requires random_access_iterator<_It>
2178 __glibcxx_assert(-__n <= _M_length);
2184 constexpr decltype(
auto)
2185 operator[](iter_difference_t<_It> __n) const
2186 noexcept(noexcept(_M_current[__n]))
2187 requires random_access_iterator<_It>
2189 __glibcxx_assert(__n < _M_length);
2190 return _M_current[__n];
2193 template<common_with<_It> _It2>
2194 friend constexpr
bool
2195 operator==(
const counted_iterator& __x,
2196 const counted_iterator<_It2>& __y)
2197 {
return __x._M_length == __y._M_length; }
2199 friend constexpr
bool
2200 operator==(
const counted_iterator& __x, default_sentinel_t)
2201 {
return __x._M_length == 0; }
2203 template<common_with<_It> _It2>
2204 friend constexpr strong_ordering
2205 operator<=>(
const counted_iterator& __x,
2206 const counted_iterator<_It2>& __y)
2207 {
return __y._M_length <=> __x._M_length; }
2209 friend constexpr iter_rvalue_reference_t<_It>
2210 iter_move(
const counted_iterator& __i)
2211 noexcept(noexcept(ranges::iter_move(__i._M_current)))
2212 requires input_iterator<_It>
2214 __glibcxx_assert( __i._M_length > 0 );
2215 return ranges::iter_move(__i._M_current);
2218 template<indirectly_swappable<_It> _It2>
2219 friend constexpr
void
2220 iter_swap(
const counted_iterator& __x,
2221 const counted_iterator<_It2>& __y)
2222 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
2224 __glibcxx_assert( __x._M_length > 0 && __y._M_length > 0 );
2225 ranges::iter_swap(__x._M_current, __y._M_current);
2229 template<input_or_output_iterator _It2>
friend class counted_iterator;
2231 _It _M_current = _It();
2232 iter_difference_t<_It> _M_length = 0;
2235 template<
typename _It>
2236 struct incrementable_traits<counted_iterator<_It>>
2238 using difference_type = iter_difference_t<_It>;
2241 template<input_iterator _It>
2242 struct iterator_traits<counted_iterator<_It>> : iterator_traits<_It>
2244 using pointer = void;
2250 template<
typename _Iterator>
2252 __niter_base(move_iterator<_Iterator> __it)
2253 -> decltype(make_move_iterator(__niter_base(__it.base())))
2254 {
return make_move_iterator(__niter_base(__it.base())); }
2256 template<
typename _Iterator>
2257 struct __is_move_iterator<move_iterator<_Iterator> >
2259 enum { __value = 1 };
2260 typedef __true_type __type;
2263 template<
typename _Iterator>
2265 __miter_base(move_iterator<_Iterator> __it)
2266 -> decltype(__miter_base(__it.base()))
2267 {
return __miter_base(__it.base()); }
2269 #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) std::make_move_iterator(_Iter)
2270 #define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) \
2271 std::__make_move_if_noexcept_iterator(_Iter)
2273 #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) (_Iter)
2274 #define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) (_Iter)
2277 #if __cpp_deduction_guides >= 201606
2280 template<
typename _InputIterator>
2282 typename iterator_traits<_InputIterator>::value_type::first_type>;
2284 template<
typename _InputIterator>
2285 using __iter_val_t =
2286 typename iterator_traits<_InputIterator>::value_type::second_type;
2288 template<
typename _T1,
typename _T2>
2291 template<
typename _InputIterator>
2292 using __iter_to_alloc_t =
2293 pair<add_const_t<__iter_key_t<_InputIterator>>,
2294 __iter_val_t<_InputIterator>>;
2297 _GLIBCXX_END_NAMESPACE_VERSION
2300 #ifdef _GLIBCXX_DEBUG
auto_ptr & operator=(auto_ptr &__a)
auto_ptr assignment operator.
element_type * operator->() const
Smart pointer dereferencing.
element_type & operator*() const
Smart pointer dereferencing.
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 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 reverse_iterator< _Iterator > make_reverse_iterator(_Iterator __i)
Generator function for reverse_iterator.
constexpr pointer operator->() const
constexpr iterator_type base() const
_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 front_insert_iterator operator++(int)
Simply returns *this. (This iterator does not move.)
constexpr reverse_iterator operator+(difference_type __n) const
constexpr reverse_iterator(iterator_type __x)
constexpr front_insert_iterator(_Container &__x)
The only way to create this iterator is with a container.
constexpr back_insert_iterator & operator++()
Simply returns *this. (This iterator does not move.)
constexpr insert_iterator & operator++()
Simply returns *this. (This iterator does not move.)
insert_iterator< _Container > inserter(_Container &__x, typename _Container::iterator __i)
_Container container_type
A nested typedef for the type of whatever container you used.
constexpr reverse_iterator & operator+=(difference_type __n)
constexpr reference operator[](difference_type __n) const
constexpr front_insert_iterator & operator++()
Simply returns *this. (This iterator does not move.)
constexpr insert_iterator & operator++(int)
Simply returns *this. (This iterator does not move.)
constexpr front_insert_iterator< _Container > front_inserter(_Container &__x)
constexpr front_insert_iterator & operator*()
Simply returns *this.
constexpr front_insert_iterator & operator=(const typename _Container::value_type &__value)
constexpr back_insert_iterator(_Container &__x)
The only way to create this iterator is with a container.
constexpr reverse_iterator & operator--()
constexpr insert_iterator & operator=(const typename _Container::value_type &__value)
constexpr reverse_iterator(const reverse_iterator &__x)
constexpr reverse_iterator & operator-=(difference_type __n)
constexpr insert_iterator(_Container &__x, _Iter __i)
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 back_insert_iterator< _Container > back_inserter(_Container &__x)
constexpr reverse_iterator operator++(int)
constexpr insert_iterator & operator*()
Simply returns *this.
constexpr reverse_iterator & operator++()
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.
Turns assignment into insertion.
Turns assignment into insertion.
Turns assignment into insertion.
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.