60 #ifndef _STL_ITERATOR_H
61 #define _STL_ITERATOR_H 1
69 #if __cplusplus >= 201103L
73 #if __cplusplus >= 202002L
81 #if __glibcxx_tuple_like
85 namespace std _GLIBCXX_VISIBILITY(default)
87 _GLIBCXX_BEGIN_NAMESPACE_VERSION
94 #ifdef __glibcxx_concepts
100 template<
typename _Cat,
typename _Limit,
typename _Otherwise = _Cat>
101 using __clamp_iter_cat
102 = __conditional_t<derived_from<_Cat, _Limit>, _Limit, _Otherwise>;
108 #pragma GCC diagnostic push
109 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
130 template<
typename _Iterator>
132 :
public iterator<typename iterator_traits<_Iterator>::iterator_category,
133 typename iterator_traits<_Iterator>::value_type,
134 typename iterator_traits<_Iterator>::difference_type,
135 typename iterator_traits<_Iterator>::pointer,
136 typename iterator_traits<_Iterator>::reference>
138 template<
typename _Iter>
141 #ifdef __glibcxx_concepts
144 template<
typename _Iter>
145 static constexpr
bool __convertible = !is_same_v<_Iter, _Iterator>
146 && convertible_to<const _Iter&, _Iterator>;
155 typedef _Iterator iterator_type;
156 typedef typename __traits_type::pointer pointer;
157 #ifndef __glibcxx_concepts
158 typedef typename __traits_type::difference_type difference_type;
159 typedef typename __traits_type::reference reference;
161 using iterator_concept
162 = __conditional_t<random_access_iterator<_Iterator>,
165 using iterator_category
166 = __detail::__clamp_iter_cat<
typename __traits_type::iterator_category,
168 using value_type = iter_value_t<_Iterator>;
169 using difference_type = iter_difference_t<_Iterator>;
170 using reference = iter_reference_t<_Iterator>;
182 _GLIBCXX_NOEXCEPT_IF(noexcept(_Iterator()))
189 explicit _GLIBCXX17_CONSTEXPR
191 _GLIBCXX_NOEXCEPT_IF(noexcept(_Iterator(__x)))
200 _GLIBCXX_NOEXCEPT_IF(noexcept(_Iterator(__x.current)))
201 : current(__x.current)
204 #if __cplusplus >= 201103L
212 template<
typename _Iter>
213 #ifdef __glibcxx_concepts
218 _GLIBCXX_NOEXCEPT_IF(noexcept(_Iterator(__x.current)))
219 : current(__x.current)
222 #if __cplusplus >= 201103L
223 template<
typename _Iter>
224 # ifdef __glibcxx_concepts
226 && assignable_from<_Iterator&, const _Iter&>
231 _GLIBCXX_NOEXCEPT_IF(noexcept(current = __x.current))
233 current = __x.current;
242 _GLIBCXX17_CONSTEXPR iterator_type
244 _GLIBCXX_NOEXCEPT_IF(noexcept(_Iterator(current)))
258 _GLIBCXX17_CONSTEXPR reference
261 _Iterator __tmp = current;
271 _GLIBCXX17_CONSTEXPR pointer
273 #ifdef __glibcxx_concepts
275 ||
requires(
const _Iterator __i) { __i.operator->(); }
280 _Iterator __tmp = current;
282 return _S_to_pointer(__tmp);
290 _GLIBCXX17_CONSTEXPR reverse_iterator&
387 _GLIBCXX17_CONSTEXPR reference
389 {
return *(*
this + __n); }
391 #ifdef __glibcxx_ranges
393 friend constexpr iter_rvalue_reference_t<_Iterator>
395 noexcept(is_nothrow_copy_constructible_v<_Iterator>
396 && noexcept(ranges::iter_move(--std::declval<_Iterator&>())))
398 auto __tmp = __i.base();
399 return ranges::iter_move(--__tmp);
402 template<indirectly_swappable<_Iterator> _Iter2>
403 friend constexpr
void
404 iter_swap(
const reverse_iterator& __x,
405 const reverse_iterator<_Iter2>& __y)
406 noexcept(is_nothrow_copy_constructible_v<_Iterator>
407 && is_nothrow_copy_constructible_v<_Iter2>
408 && noexcept(ranges::iter_swap(--std::declval<_Iterator&>(),
409 --std::declval<_Iter2&>())))
411 auto __xtmp = __x.base();
412 auto __ytmp = __y.base();
413 ranges::iter_swap(--__xtmp, --__ytmp);
418 template<
typename _Tp>
419 static _GLIBCXX17_CONSTEXPR _Tp*
420 _S_to_pointer(_Tp* __p)
423 template<
typename _Tp>
424 static _GLIBCXX17_CONSTEXPR pointer
425 _S_to_pointer(_Tp __t)
426 {
return __t.operator->(); }
439 #ifndef __glibcxx_concepts
440 template<
typename _Iterator>
442 inline _GLIBCXX17_CONSTEXPR
bool
443 operator==(
const reverse_iterator<_Iterator>& __x,
444 const reverse_iterator<_Iterator>& __y)
445 {
return __x.base() == __y.base(); }
447 template<
typename _Iterator>
449 inline _GLIBCXX17_CONSTEXPR
bool
450 operator<(
const reverse_iterator<_Iterator>& __x,
451 const reverse_iterator<_Iterator>& __y)
452 {
return __y.base() < __x.base(); }
454 template<
typename _Iterator>
456 inline _GLIBCXX17_CONSTEXPR
bool
457 operator!=(
const reverse_iterator<_Iterator>& __x,
458 const reverse_iterator<_Iterator>& __y)
459 {
return !(__x == __y); }
461 template<
typename _Iterator>
463 inline _GLIBCXX17_CONSTEXPR
bool
464 operator>(
const reverse_iterator<_Iterator>& __x,
465 const reverse_iterator<_Iterator>& __y)
466 {
return __y < __x; }
468 template<
typename _Iterator>
470 inline _GLIBCXX17_CONSTEXPR
bool
471 operator<=(
const reverse_iterator<_Iterator>& __x,
472 const reverse_iterator<_Iterator>& __y)
473 {
return !(__y < __x); }
475 template<
typename _Iterator>
477 inline _GLIBCXX17_CONSTEXPR
bool
478 operator>=(
const reverse_iterator<_Iterator>& __x,
479 const reverse_iterator<_Iterator>& __y)
480 {
return !(__x < __y); }
485 template<
typename _IteratorL,
typename _IteratorR>
487 inline _GLIBCXX17_CONSTEXPR
bool
488 operator==(
const reverse_iterator<_IteratorL>& __x,
489 const reverse_iterator<_IteratorR>& __y)
490 {
return __x.base() == __y.base(); }
492 template<
typename _IteratorL,
typename _IteratorR>
494 inline _GLIBCXX17_CONSTEXPR
bool
495 operator<(
const reverse_iterator<_IteratorL>& __x,
496 const reverse_iterator<_IteratorR>& __y)
497 {
return __x.base() > __y.base(); }
499 template<
typename _IteratorL,
typename _IteratorR>
501 inline _GLIBCXX17_CONSTEXPR
bool
502 operator!=(
const reverse_iterator<_IteratorL>& __x,
503 const reverse_iterator<_IteratorR>& __y)
504 {
return __x.base() != __y.base(); }
506 template<
typename _IteratorL,
typename _IteratorR>
508 inline _GLIBCXX17_CONSTEXPR
bool
509 operator>(
const reverse_iterator<_IteratorL>& __x,
510 const reverse_iterator<_IteratorR>& __y)
511 {
return __x.base() < __y.base(); }
513 template<
typename _IteratorL,
typename _IteratorR>
514 inline _GLIBCXX17_CONSTEXPR
bool
515 operator<=(
const reverse_iterator<_IteratorL>& __x,
516 const reverse_iterator<_IteratorR>& __y)
517 {
return __x.base() >= __y.base(); }
519 template<
typename _IteratorL,
typename _IteratorR>
521 inline _GLIBCXX17_CONSTEXPR
bool
522 operator>=(
const reverse_iterator<_IteratorL>& __x,
523 const reverse_iterator<_IteratorR>& __y)
524 {
return __x.base() <= __y.base(); }
526 template<
typename _IteratorL,
typename _IteratorR>
532 {
return __x.base() == __y.base(); }
534 template<
typename _IteratorL,
typename _IteratorR>
537 operator!=(
const reverse_iterator<_IteratorL>& __x,
538 const reverse_iterator<_IteratorR>& __y)
540 {
return __x.base() != __y.base(); }
542 template<
typename _IteratorL,
typename _IteratorR>
545 operator<(
const reverse_iterator<_IteratorL>& __x,
546 const reverse_iterator<_IteratorR>& __y)
548 {
return __x.base() > __y.base(); }
550 template<
typename _IteratorL,
typename _IteratorR>
553 operator>(
const reverse_iterator<_IteratorL>& __x,
554 const reverse_iterator<_IteratorR>& __y)
556 {
return __x.base() < __y.base(); }
558 template<
typename _IteratorL,
typename _IteratorR>
561 operator<=(
const reverse_iterator<_IteratorL>& __x,
562 const reverse_iterator<_IteratorR>& __y)
564 {
return __x.base() >= __y.base(); }
566 template<
typename _IteratorL,
typename _IteratorR>
569 operator>=(
const reverse_iterator<_IteratorL>& __x,
570 const reverse_iterator<_IteratorR>& __y)
572 {
return __x.base() <= __y.base(); }
574 template<
typename _IteratorL,
575 three_way_comparable_with<_IteratorL> _IteratorR>
577 constexpr compare_three_way_result_t<_IteratorL, _IteratorR>
578 operator<=>(
const reverse_iterator<_IteratorL>& __x,
579 const reverse_iterator<_IteratorR>& __y)
580 {
return __y.base() <=> __x.base(); }
585 template<
typename _Iterator>
588 operator==(
const reverse_iterator<_Iterator>& __x,
589 const reverse_iterator<_Iterator>& __y)
591 {
return __x.base() == __y.base(); }
593 template<three_way_comparable _Iterator>
595 constexpr compare_three_way_result_t<_Iterator, _Iterator>
596 operator<=>(
const reverse_iterator<_Iterator>& __x,
597 const reverse_iterator<_Iterator>& __y)
598 {
return __y.base() <=> __x.base(); }
602 #if __cplusplus < 201103L
603 template<
typename _Iterator>
604 inline typename reverse_iterator<_Iterator>::difference_type
605 operator-(
const reverse_iterator<_Iterator>& __x,
606 const reverse_iterator<_Iterator>& __y)
607 {
return __y.base() - __x.base(); }
609 template<
typename _IteratorL,
typename _IteratorR>
610 inline typename reverse_iterator<_IteratorL>::difference_type
611 operator-(
const reverse_iterator<_IteratorL>& __x,
612 const reverse_iterator<_IteratorR>& __y)
613 {
return __y.base() - __x.base(); }
617 template<
typename _IteratorL,
typename _IteratorR>
619 inline _GLIBCXX17_CONSTEXPR
auto
620 operator-(
const reverse_iterator<_IteratorL>& __x,
621 const reverse_iterator<_IteratorR>& __y)
622 -> decltype(__y.base() - __x.base())
623 {
return __y.base() - __x.base(); }
626 template<
typename _Iterator>
628 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
629 operator+(
typename reverse_iterator<_Iterator>::difference_type __n,
630 const reverse_iterator<_Iterator>& __x)
631 {
return reverse_iterator<_Iterator>(__x.base() - __n); }
633 #if __cplusplus >= 201103L
635 template<
typename _Iterator>
636 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
637 __make_reverse_iterator(_Iterator __i)
638 {
return reverse_iterator<_Iterator>(__i); }
640 # ifdef __glibcxx_make_reverse_iterator
644 template<
typename _Iterator>
646 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
650 # ifdef __glibcxx_ranges
651 template<
typename _Iterator1,
typename _Iterator2>
652 requires (!sized_sentinel_for<_Iterator1, _Iterator2>)
653 inline constexpr
bool
654 disable_sized_sentinel_for<reverse_iterator<_Iterator1>,
655 reverse_iterator<_Iterator2>> =
true;
659 template<
typename _Iterator>
660 struct __is_move_iterator<reverse_iterator<_Iterator> >
661 : __is_move_iterator<_Iterator>
676 template<
typename _Container>
678 :
public iterator<output_iterator_tag, void, void, void, void>
681 _Container* container;
686 #ifdef __glibcxx_ranges
687 using difference_type = ptrdiff_t;
691 explicit _GLIBCXX20_CONSTEXPR
706 #if __cplusplus < 201103L
708 operator=(
typename _Container::const_reference __value)
710 container->push_back(__value);
716 operator=(
const typename _Container::value_type& __value)
718 container->push_back(__value);
724 operator=(
typename _Container::value_type&& __value)
726 container->push_back(
std::move(__value));
732 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
761 template<
typename _Container>
762 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
763 inline back_insert_iterator<_Container>
777 template<
typename _Container>
779 :
public iterator<output_iterator_tag, void, void, void, void>
782 _Container* container;
787 #ifdef __glibcxx_ranges
788 using difference_type = ptrdiff_t;
792 explicit _GLIBCXX20_CONSTEXPR
807 #if __cplusplus < 201103L
809 operator=(
typename _Container::const_reference __value)
811 container->push_front(__value);
817 operator=(
const typename _Container::value_type& __value)
819 container->push_front(__value);
825 operator=(
typename _Container::value_type&& __value)
827 container->push_front(
std::move(__value));
833 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
862 template<
typename _Container>
863 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
864 inline front_insert_iterator<_Container>
882 template<
typename _Container>
884 :
public iterator<output_iterator_tag, void, void, void, void>
886 #ifdef __glibcxx_ranges
887 using _Iter = std::__detail::__range_iter_t<_Container>;
889 typedef typename _Container::iterator _Iter;
892 _Container* container;
899 #ifdef __glibcxx_ranges
900 using difference_type = ptrdiff_t;
934 #if __cplusplus < 201103L
936 operator=(
typename _Container::const_reference __value)
938 iter = container->insert(iter, __value);
945 operator=(
const typename _Container::value_type& __value)
947 iter = container->insert(iter, __value);
954 operator=(
typename _Container::value_type&& __value)
956 iter = container->insert(iter,
std::move(__value));
963 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
981 #pragma GCC diagnostic pop
995 #ifdef __glibcxx_ranges
996 template<
typename _Container>
998 constexpr insert_iterator<_Container>
999 inserter(_Container& __x, std::__detail::__range_iter_t<_Container> __i)
1002 template<
typename _Container>
1004 inline insert_iterator<_Container>
1005 inserter(_Container& __x,
typename _Container::iterator __i)
1006 {
return insert_iterator<_Container>(__x, __i); }
1011 _GLIBCXX_END_NAMESPACE_VERSION
1014 namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
1016 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1025 template<
typename _Iterator,
typename _Container>
1026 class __normal_iterator
1029 _Iterator _M_current;
1033 #if __cplusplus >= 201103L && ! defined __glibcxx_concepts
1034 template<
typename _Iter>
1035 using __convertible_from
1036 = std::__enable_if_t<std::is_convertible<_Iter, _Iterator>::value>;
1040 typedef _Iterator iterator_type;
1041 typedef typename __traits_type::iterator_category iterator_category;
1042 typedef typename __traits_type::value_type value_type;
1043 typedef typename __traits_type::difference_type difference_type;
1044 typedef typename __traits_type::reference reference;
1045 typedef typename __traits_type::pointer pointer;
1047 #ifdef __glibcxx_ranges
1048 using iterator_concept = std::__detail::__iter_concept<_Iterator>;
1051 __attribute__((__always_inline__))
1053 __normal_iterator() _GLIBCXX_NOEXCEPT
1056 __attribute__((__always_inline__))
1057 explicit _GLIBCXX_CONSTEXPR
1058 __normal_iterator(
const _Iterator& __i) _GLIBCXX_NOEXCEPT
1059 : _M_current(__i) { }
1062 #if __cplusplus >= 201103L
1063 # ifdef __glibcxx_concepts
1064 template<
typename _Iter>
requires std::is_convertible_v<_Iter, _Iterator>
1066 template<
typename _Iter,
typename = __convertible_from<_Iter>>
1068 [[__gnu__::__always_inline__]]
1070 __normal_iterator(
const __normal_iterator<_Iter, _Container>& __i)
1075 template<
typename _Iter>
1076 __attribute__((__always_inline__))
1077 __normal_iterator(
const __normal_iterator<_Iter,
1078 typename __enable_if<
1079 (std::__are_same<_Iter, typename _Container::pointer>::__value),
1080 _Container>::__type>& __i)
1082 : _M_current(__i.base()) { }
1086 _GLIBCXX_NODISCARD __attribute__((__always_inline__))
1090 {
return *_M_current; }
1092 _GLIBCXX_NODISCARD __attribute__((__always_inline__))
1095 operator->() const _GLIBCXX_NOEXCEPT
1096 {
return _M_current; }
1098 __attribute__((__always_inline__))
1099 _GLIBCXX14_CONSTEXPR
1101 operator++() _GLIBCXX_NOEXCEPT
1107 __attribute__((__always_inline__))
1108 _GLIBCXX14_CONSTEXPR
1110 operator++(
int) _GLIBCXX_NOEXCEPT
1111 {
return __normal_iterator(_M_current++); }
1115 __attribute__((__always_inline__))
1116 _GLIBCXX14_CONSTEXPR
1118 operator--() _GLIBCXX_NOEXCEPT
1124 __attribute__((__always_inline__))
1125 _GLIBCXX14_CONSTEXPR
1127 operator--(
int) _GLIBCXX_NOEXCEPT
1128 {
return __normal_iterator(_M_current--); }
1132 _GLIBCXX_NODISCARD __attribute__((__always_inline__))
1135 operator[](difference_type __n)
const _GLIBCXX_NOEXCEPT
1136 {
return _M_current[__n]; }
1138 __attribute__((__always_inline__))
1139 _GLIBCXX14_CONSTEXPR
1141 operator+=(difference_type __n) _GLIBCXX_NOEXCEPT
1142 { _M_current += __n;
return *
this; }
1144 _GLIBCXX_NODISCARD __attribute__((__always_inline__))
1147 operator+(difference_type __n)
const _GLIBCXX_NOEXCEPT
1148 {
return __normal_iterator(_M_current + __n); }
1150 __attribute__((__always_inline__))
1151 _GLIBCXX14_CONSTEXPR
1153 operator-=(difference_type __n) _GLIBCXX_NOEXCEPT
1154 { _M_current -= __n;
return *
this; }
1156 _GLIBCXX_NODISCARD __attribute__((__always_inline__))
1159 operator-(difference_type __n)
const _GLIBCXX_NOEXCEPT
1160 {
return __normal_iterator(_M_current - __n); }
1162 _GLIBCXX_NODISCARD __attribute__((__always_inline__))
1165 base() const _GLIBCXX_NOEXCEPT
1166 {
return _M_current; }
1177 #ifdef __cpp_lib_three_way_comparison
1178 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1179 [[nodiscard, __gnu__::__always_inline__]]
1181 operator==(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1182 const __normal_iterator<_IteratorR, _Container>& __rhs)
1183 noexcept(noexcept(__lhs.base() == __rhs.base()))
1185 { __lhs.base() == __rhs.base() } -> std::convertible_to<bool>;
1187 {
return __lhs.base() == __rhs.base(); }
1189 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1190 [[nodiscard, __gnu__::__always_inline__]]
1191 constexpr std::__detail::__synth3way_t<_IteratorR, _IteratorL>
1192 operator<=>(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1193 const __normal_iterator<_IteratorR, _Container>& __rhs)
1194 noexcept(noexcept(std::__detail::__synth3way(__lhs.base(), __rhs.base())))
1195 {
return std::__detail::__synth3way(__lhs.base(), __rhs.base()); }
1197 template<
typename _Iterator,
typename _Container>
1198 [[nodiscard, __gnu__::__always_inline__]]
1200 operator==(
const __normal_iterator<_Iterator, _Container>& __lhs,
1201 const __normal_iterator<_Iterator, _Container>& __rhs)
1202 noexcept(noexcept(__lhs.base() == __rhs.base()))
1204 { __lhs.base() == __rhs.base() } -> std::convertible_to<bool>;
1206 {
return __lhs.base() == __rhs.base(); }
1208 template<
typename _Iterator,
typename _Container>
1209 [[nodiscard, __gnu__::__always_inline__]]
1210 constexpr std::__detail::__synth3way_t<_Iterator>
1211 operator<=>(
const __normal_iterator<_Iterator, _Container>& __lhs,
1212 const __normal_iterator<_Iterator, _Container>& __rhs)
1213 noexcept(noexcept(std::__detail::__synth3way(__lhs.base(), __rhs.base())))
1214 {
return std::__detail::__synth3way(__lhs.base(), __rhs.base()); }
1217 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1218 _GLIBCXX_NODISCARD __attribute__((__always_inline__)) _GLIBCXX_CONSTEXPR
1220 operator==(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1221 const __normal_iterator<_IteratorR, _Container>& __rhs)
1223 {
return __lhs.base() == __rhs.base(); }
1225 template<
typename _Iterator,
typename _Container>
1226 _GLIBCXX_NODISCARD __attribute__((__always_inline__)) _GLIBCXX_CONSTEXPR
1228 operator==(
const __normal_iterator<_Iterator, _Container>& __lhs,
1229 const __normal_iterator<_Iterator, _Container>& __rhs)
1231 {
return __lhs.base() == __rhs.base(); }
1233 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1234 _GLIBCXX_NODISCARD __attribute__((__always_inline__)) _GLIBCXX_CONSTEXPR
1236 operator!=(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1237 const __normal_iterator<_IteratorR, _Container>& __rhs)
1239 {
return __lhs.base() != __rhs.base(); }
1241 template<
typename _Iterator,
typename _Container>
1242 _GLIBCXX_NODISCARD __attribute__((__always_inline__)) _GLIBCXX_CONSTEXPR
1244 operator!=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1245 const __normal_iterator<_Iterator, _Container>& __rhs)
1247 {
return __lhs.base() != __rhs.base(); }
1250 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1251 _GLIBCXX_NODISCARD __attribute__((__always_inline__)) _GLIBCXX_CONSTEXPR
1253 operator<(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1254 const __normal_iterator<_IteratorR, _Container>& __rhs)
1256 {
return __lhs.base() < __rhs.base(); }
1258 template<
typename _Iterator,
typename _Container>
1259 _GLIBCXX_NODISCARD __attribute__((__always_inline__)) _GLIBCXX20_CONSTEXPR
1261 operator<(
const __normal_iterator<_Iterator, _Container>& __lhs,
1262 const __normal_iterator<_Iterator, _Container>& __rhs)
1264 {
return __lhs.base() < __rhs.base(); }
1266 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1267 _GLIBCXX_NODISCARD __attribute__((__always_inline__)) _GLIBCXX_CONSTEXPR
1269 operator>(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1270 const __normal_iterator<_IteratorR, _Container>& __rhs)
1272 {
return __lhs.base() > __rhs.base(); }
1274 template<
typename _Iterator,
typename _Container>
1275 _GLIBCXX_NODISCARD __attribute__((__always_inline__)) _GLIBCXX_CONSTEXPR
1277 operator>(
const __normal_iterator<_Iterator, _Container>& __lhs,
1278 const __normal_iterator<_Iterator, _Container>& __rhs)
1280 {
return __lhs.base() > __rhs.base(); }
1282 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1283 _GLIBCXX_NODISCARD __attribute__((__always_inline__)) _GLIBCXX_CONSTEXPR
1285 operator<=(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1286 const __normal_iterator<_IteratorR, _Container>& __rhs)
1288 {
return __lhs.base() <= __rhs.base(); }
1290 template<
typename _Iterator,
typename _Container>
1291 _GLIBCXX_NODISCARD __attribute__((__always_inline__)) _GLIBCXX_CONSTEXPR
1293 operator<=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1294 const __normal_iterator<_Iterator, _Container>& __rhs)
1296 {
return __lhs.base() <= __rhs.base(); }
1298 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1299 _GLIBCXX_NODISCARD __attribute__((__always_inline__)) _GLIBCXX_CONSTEXPR
1301 operator>=(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1302 const __normal_iterator<_IteratorR, _Container>& __rhs)
1304 {
return __lhs.base() >= __rhs.base(); }
1306 template<
typename _Iterator,
typename _Container>
1307 _GLIBCXX_NODISCARD __attribute__((__always_inline__)) _GLIBCXX_CONSTEXPR
1309 operator>=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1310 const __normal_iterator<_Iterator, _Container>& __rhs)
1312 {
return __lhs.base() >= __rhs.base(); }
1319 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1320 #if __cplusplus >= 201103L
1322 [[__nodiscard__, __gnu__::__always_inline__]]
1324 operator-(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1325 const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept
1326 -> decltype(__lhs.base() - __rhs.base())
1328 inline typename __normal_iterator<_IteratorL, _Container>::difference_type
1329 operator-(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1330 const __normal_iterator<_IteratorR, _Container>& __rhs)
1332 {
return __lhs.base() - __rhs.base(); }
1334 template<
typename _Iterator,
typename _Container>
1335 _GLIBCXX_NODISCARD __attribute__((__always_inline__)) _GLIBCXX_CONSTEXPR
1336 inline typename __normal_iterator<_Iterator, _Container>::difference_type
1337 operator-(
const __normal_iterator<_Iterator, _Container>& __lhs,
1338 const __normal_iterator<_Iterator, _Container>& __rhs)
1340 {
return __lhs.base() - __rhs.base(); }
1342 template<
typename _Iterator,
typename _Container>
1343 _GLIBCXX_NODISCARD __attribute__((__always_inline__)) _GLIBCXX_CONSTEXPR
1344 inline __normal_iterator<_Iterator, _Container>
1345 operator+(
typename __normal_iterator<_Iterator, _Container>::difference_type
1346 __n,
const __normal_iterator<_Iterator, _Container>& __i)
1348 {
return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
1350 _GLIBCXX_END_NAMESPACE_VERSION
1353 namespace std _GLIBCXX_VISIBILITY(default)
1355 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1357 #if __cplusplus >= 201103L
1363 #ifdef __glibcxx_ranges
1365 template<semiregular _Sent>
1371 noexcept(is_nothrow_default_constructible_v<_Sent>)
1376 noexcept(is_nothrow_move_constructible_v<_Sent>)
1379 template<
typename _S2> requires convertible_to<const _S2&, _Sent>
1382 noexcept(is_nothrow_constructible_v<_Sent, const _S2&>)
1383 : _M_last(__s.base())
1386 template<
typename _S2> requires assignable_from<_Sent&, const _S2&>
1389 noexcept(is_nothrow_assignable_v<_Sent, const _S2&>)
1391 _M_last = __s.base();
1398 noexcept(is_nothrow_copy_constructible_v<_Sent>)
1408 template<
typename _Iterator>
1409 struct __move_iter_cat
1412 template<
typename _Iterator>
1413 requires requires {
typename __iter_category_t<_Iterator>; }
1414 struct __move_iter_cat<_Iterator>
1416 using iterator_category
1417 = __clamp_iter_cat<__iter_category_t<_Iterator>,
1418 random_access_iterator_tag>;
1434 template<
typename _Iterator>
1436 #ifdef __glibcxx_ranges
1437 :
public __detail::__move_iter_cat<_Iterator>
1440 _Iterator _M_current;
1443 #ifndef __glibcxx_ranges
1444 using __base_ref =
typename __traits_type::reference;
1447 template<
typename _Iter2>
1450 #ifdef __glibcxx_concepts
1453 template<
typename _Iter2>
1454 static constexpr
bool __convertible = !is_same_v<_Iter2, _Iterator>
1455 && convertible_to<const _Iter2&, _Iterator>;
1458 #ifdef __glibcxx_ranges
1462 if constexpr (random_access_iterator<_Iterator>)
1464 else if constexpr (bidirectional_iterator<_Iterator>)
1466 else if constexpr (forward_iterator<_Iterator>)
1474 using iterator_type = _Iterator;
1476 #ifdef __glibcxx_move_iterator_concept
1477 using iterator_concept = decltype(_S_iter_concept());
1480 using value_type = iter_value_t<_Iterator>;
1481 using difference_type = iter_difference_t<_Iterator>;
1482 using pointer = _Iterator;
1483 using reference = iter_rvalue_reference_t<_Iterator>;
1485 typedef typename __traits_type::iterator_category iterator_category;
1486 typedef typename __traits_type::value_type value_type;
1487 typedef typename __traits_type::difference_type difference_type;
1489 typedef _Iterator pointer;
1493 = __conditional_t<is_reference<__base_ref>::value,
1494 typename remove_reference<__base_ref>::type&&,
1498 _GLIBCXX17_CONSTEXPR
1502 explicit _GLIBCXX17_CONSTEXPR
1506 template<
typename _Iter>
1507 #ifdef __glibcxx_concepts
1510 _GLIBCXX17_CONSTEXPR
1512 : _M_current(__i._M_current) { }
1514 template<
typename _Iter>
1515 #ifdef __glibcxx_concepts
1517 && assignable_from<_Iterator&, const _Iter&>
1519 _GLIBCXX17_CONSTEXPR
1522 _M_current = __i._M_current;
1526 #if __cplusplus <= 201703L
1528 _GLIBCXX17_CONSTEXPR iterator_type
1530 {
return _M_current; }
1533 constexpr
const iterator_type&
1534 base()
const & noexcept
1535 {
return _M_current; }
1538 constexpr iterator_type
1544 _GLIBCXX17_CONSTEXPR reference
1546 #ifdef __glibcxx_ranges
1547 {
return ranges::iter_move(_M_current); }
1549 {
return static_cast<reference
>(*_M_current); }
1553 _GLIBCXX17_CONSTEXPR pointer
1555 {
return _M_current; }
1572 #ifdef __glibcxx_concepts
1574 operator++(
int)
requires (!forward_iterator<_Iterator>)
1595 operator+(difference_type __n)
const
1599 operator+=(difference_type __n)
1607 operator-(difference_type __n)
const
1611 operator-=(difference_type __n)
1618 _GLIBCXX17_CONSTEXPR reference
1619 operator[](difference_type __n)
const
1620 #ifdef __glibcxx_ranges
1621 {
return ranges::iter_move(_M_current + __n); }
1626 #ifdef __glibcxx_ranges
1627 template<sentinel_for<_Iterator> _Sent>
1629 friend constexpr
bool
1631 {
return __x.base() == __y.base(); }
1633 template<sized_sentinel_for<_Iterator> _Sent>
1635 friend constexpr iter_difference_t<_Iterator>
1637 {
return __x.base() - __y.base(); }
1639 template<sized_sentinel_for<_Iterator> _Sent>
1641 friend constexpr iter_difference_t<_Iterator>
1643 {
return __x.base() - __y.base(); }
1646 friend constexpr iter_rvalue_reference_t<_Iterator>
1648 noexcept(noexcept(ranges::iter_move(__i._M_current)))
1649 {
return ranges::iter_move(__i._M_current); }
1651 template<indirectly_swappable<_Iterator> _Iter2>
1652 friend constexpr
void
1654 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1655 {
return ranges::iter_swap(__x._M_current, __y._M_current); }
1659 template<
typename _IteratorL,
typename _IteratorR>
1661 inline _GLIBCXX17_CONSTEXPR
bool
1664 #ifdef __glibcxx_concepts
1665 requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
1667 {
return __x.base() == __y.base(); }
1669 #ifdef __cpp_lib_three_way_comparison
1670 template<
typename _IteratorL,
1671 three_way_comparable_with<_IteratorL> _IteratorR>
1673 constexpr compare_three_way_result_t<_IteratorL, _IteratorR>
1674 operator<=>(
const move_iterator<_IteratorL>& __x,
1675 const move_iterator<_IteratorR>& __y)
1676 {
return __x.base() <=> __y.base(); }
1678 template<
typename _IteratorL,
typename _IteratorR>
1680 inline _GLIBCXX17_CONSTEXPR
bool
1681 operator!=(
const move_iterator<_IteratorL>& __x,
1682 const move_iterator<_IteratorR>& __y)
1683 {
return !(__x == __y); }
1686 template<
typename _IteratorL,
typename _IteratorR>
1688 inline _GLIBCXX17_CONSTEXPR
bool
1689 operator<(
const move_iterator<_IteratorL>& __x,
1690 const move_iterator<_IteratorR>& __y)
1691 #ifdef __glibcxx_concepts
1694 {
return __x.base() < __y.base(); }
1696 template<
typename _IteratorL,
typename _IteratorR>
1698 inline _GLIBCXX17_CONSTEXPR
bool
1699 operator<=(
const move_iterator<_IteratorL>& __x,
1700 const move_iterator<_IteratorR>& __y)
1701 #ifdef __glibcxx_concepts
1704 {
return !(__y < __x); }
1706 template<
typename _IteratorL,
typename _IteratorR>
1708 inline _GLIBCXX17_CONSTEXPR
bool
1709 operator>(
const move_iterator<_IteratorL>& __x,
1710 const move_iterator<_IteratorR>& __y)
1711 #ifdef __glibcxx_concepts
1714 {
return __y < __x; }
1716 template<
typename _IteratorL,
typename _IteratorR>
1718 inline _GLIBCXX17_CONSTEXPR
bool
1719 operator>=(
const move_iterator<_IteratorL>& __x,
1720 const move_iterator<_IteratorR>& __y)
1721 #ifdef __glibcxx_concepts
1724 {
return !(__x < __y); }
1729 template<
typename _Iterator>
1731 inline _GLIBCXX17_CONSTEXPR
bool
1732 operator==(
const move_iterator<_Iterator>& __x,
1733 const move_iterator<_Iterator>& __y)
1735 {
return __x.base() == __y.base(); }
1737 #ifdef __cpp_lib_three_way_comparison
1738 template<three_way_comparable _Iterator>
1740 constexpr compare_three_way_result_t<_Iterator>
1741 operator<=>(
const move_iterator<_Iterator>& __x,
1742 const move_iterator<_Iterator>& __y)
1743 {
return __x.base() <=> __y.base(); }
1745 template<
typename _Iterator>
1747 inline _GLIBCXX17_CONSTEXPR
bool
1748 operator!=(
const move_iterator<_Iterator>& __x,
1749 const move_iterator<_Iterator>& __y)
1750 {
return !(__x == __y); }
1752 template<
typename _Iterator>
1754 inline _GLIBCXX17_CONSTEXPR
bool
1755 operator<(
const move_iterator<_Iterator>& __x,
1756 const move_iterator<_Iterator>& __y)
1757 {
return __x.base() < __y.base(); }
1759 template<
typename _Iterator>
1761 inline _GLIBCXX17_CONSTEXPR
bool
1762 operator<=(
const move_iterator<_Iterator>& __x,
1763 const move_iterator<_Iterator>& __y)
1764 {
return !(__y < __x); }
1766 template<
typename _Iterator>
1768 inline _GLIBCXX17_CONSTEXPR
bool
1769 operator>(
const move_iterator<_Iterator>& __x,
1770 const move_iterator<_Iterator>& __y)
1771 {
return __y < __x; }
1773 template<
typename _Iterator>
1775 inline _GLIBCXX17_CONSTEXPR
bool
1776 operator>=(
const move_iterator<_Iterator>& __x,
1777 const move_iterator<_Iterator>& __y)
1778 {
return !(__x < __y); }
1782 template<
typename _IteratorL,
typename _IteratorR>
1784 inline _GLIBCXX17_CONSTEXPR
auto
1785 operator-(
const move_iterator<_IteratorL>& __x,
1786 const move_iterator<_IteratorR>& __y)
1787 -> decltype(__x.base() - __y.base())
1788 {
return __x.base() - __y.base(); }
1790 template<
typename _Iterator>
1792 inline _GLIBCXX17_CONSTEXPR move_iterator<_Iterator>
1793 operator+(
typename move_iterator<_Iterator>::difference_type __n,
1794 const move_iterator<_Iterator>& __x)
1795 #ifdef __glibcxx_concepts
1798 {
return __x + __n; }
1800 template<
typename _Iterator>
1802 inline _GLIBCXX17_CONSTEXPR move_iterator<_Iterator>
1803 make_move_iterator(_Iterator __i)
1804 {
return move_iterator<_Iterator>(
std::move(__i)); }
1806 template<
typename _Iterator,
typename _ReturnType
1807 = __conditional_t<__move_if_noexcept_cond
1808 <
typename iterator_traits<_Iterator>::value_type>::value,
1809 _Iterator, move_iterator<_Iterator>>>
1811 constexpr _ReturnType
1812 __make_move_if_noexcept_iterator(_Iterator __i)
1813 {
return _ReturnType(__i); }
1817 template<
typename _Tp,
typename _ReturnType
1818 = __conditional_t<__move_if_noexcept_cond<_Tp>::value,
1819 const _Tp*, move_iterator<_Tp*>>>
1821 constexpr _ReturnType
1822 __make_move_if_noexcept_iterator(_Tp* __i)
1823 {
return _ReturnType(__i); }
1825 template<
typename _Iterator>
1826 struct __is_move_iterator<move_iterator<_Iterator> >
1828 enum { __value = 1 };
1829 typedef __true_type __type;
1832 #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) std::make_move_iterator(_Iter)
1833 #define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) \
1834 std::__make_move_if_noexcept_iterator(_Iter)
1836 #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) (_Iter)
1837 #define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) (_Iter)
1840 #ifdef __glibcxx_ranges
1843 template<
typename _Iterator1,
typename _Iterator2>
1844 requires (!sized_sentinel_for<_Iterator1, _Iterator2>)
1845 inline constexpr
bool
1846 disable_sized_sentinel_for<move_iterator<_Iterator1>,
1847 move_iterator<_Iterator2>> =
true;
1854 template<
typename _It>
1855 concept __common_iter_has_arrow = indirectly_readable<const _It>
1856 && (requires(
const _It& __it) { __it.operator->(); }
1857 || is_reference_v<iter_reference_t<_It>>
1858 || constructible_from<iter_value_t<_It>, iter_reference_t<_It>>);
1860 template<
typename _It>
1861 concept __common_iter_use_postfix_proxy
1862 = (!requires (_It& __i) { { *__i++ } -> __can_reference; })
1863 && constructible_from<iter_value_t<_It>, iter_reference_t<_It>>
1864 && move_constructible<iter_value_t<_It>>;
1869 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
1870 requires (!same_as<_It, _Sent>) && copyable<_It>
1871 class common_iterator
1873 template<
typename _Tp,
typename _Up>
1874 static constexpr
bool
1877 if constexpr (is_trivially_default_constructible_v<_Tp>)
1878 return is_nothrow_assignable_v<_Tp&, _Up>;
1880 return is_nothrow_constructible_v<_Tp, _Up>;
1883 template<
typename _It2,
typename _Sent2>
1884 static constexpr
bool
1886 {
return _S_noexcept1<_It, _It2>() && _S_noexcept1<_Sent, _Sent2>(); }
1890 iter_value_t<_It> _M_keep;
1893 __arrow_proxy(iter_reference_t<_It>&& __x)
1896 friend class common_iterator;
1899 constexpr
const iter_value_t<_It>*
1900 operator->()
const noexcept
1904 class __postfix_proxy
1906 iter_value_t<_It> _M_keep;
1909 __postfix_proxy(iter_reference_t<_It>&& __x)
1910 : _M_keep(
std::forward<iter_reference_t<_It>>(__x)) { }
1912 friend class common_iterator;
1915 constexpr
const iter_value_t<_It>&
1923 noexcept(is_nothrow_default_constructible_v<_It>)
1924 requires default_initializable<_It>
1925 : _M_it(), _M_index(0)
1929 common_iterator(_It __i)
1930 noexcept(is_nothrow_move_constructible_v<_It>)
1935 common_iterator(_Sent __s)
1936 noexcept(is_nothrow_move_constructible_v<_Sent>)
1940 template<
typename _It2,
typename _Sent2>
1941 requires convertible_to<const _It2&, _It>
1942 && convertible_to<const _Sent2&, _Sent>
1944 common_iterator(
const common_iterator<_It2, _Sent2>& __x)
1945 noexcept(_S_noexcept<const _It2&, const _Sent2&>())
1946 : _M_valueless(), _M_index(__x._M_index)
1948 __glibcxx_assert(__x._M_has_value());
1951 if constexpr (is_trivially_default_constructible_v<_It>)
1956 else if (_M_index == 1)
1958 if constexpr (is_trivially_default_constructible_v<_Sent>)
1965 common_iterator(
const common_iterator&) =
default;
1968 common_iterator(
const common_iterator& __x)
1969 noexcept(_S_noexcept<const _It&, const _Sent&>())
1970 requires (!is_trivially_copyable_v<_It> || !is_trivially_copyable_v<_Sent>)
1971 : _M_valueless(), _M_index(__x._M_index)
1975 if constexpr (is_trivially_default_constructible_v<_It>)
1980 else if (_M_index == 1)
1982 if constexpr (is_trivially_default_constructible_v<_Sent>)
1983 _M_sent = __x._M_sent;
1989 common_iterator(common_iterator&&) =
default;
1992 common_iterator(common_iterator&& __x)
1993 noexcept(_S_noexcept<_It, _Sent>())
1994 requires (!is_trivially_copyable_v<_It> || !is_trivially_copyable_v<_Sent>)
1995 : _M_valueless(), _M_index(__x._M_index)
1999 if constexpr (is_trivially_default_constructible_v<_It>)
2004 else if (_M_index == 1)
2006 if constexpr (is_trivially_default_constructible_v<_Sent>)
2014 constexpr common_iterator&
2015 operator=(
const common_iterator&) =
default;
2017 constexpr common_iterator&
2018 operator=(
const common_iterator& __x)
2019 noexcept(is_nothrow_copy_assignable_v<_It>
2020 && is_nothrow_copy_assignable_v<_Sent>
2021 && is_nothrow_copy_constructible_v<_It>
2022 && is_nothrow_copy_constructible_v<_Sent>)
2023 requires (!is_trivially_copy_assignable_v<_It>
2024 || !is_trivially_copy_assignable_v<_Sent>)
2030 constexpr common_iterator&
2031 operator=(common_iterator&&) =
default;
2033 constexpr common_iterator&
2034 operator=(common_iterator&& __x)
2035 noexcept(is_nothrow_move_assignable_v<_It>
2036 && is_nothrow_move_assignable_v<_Sent>
2037 && is_nothrow_move_constructible_v<_It>
2038 && is_nothrow_move_constructible_v<_Sent>)
2039 requires (!is_trivially_move_assignable_v<_It>
2040 || !is_trivially_move_assignable_v<_Sent>)
2046 template<
typename _It2,
typename _Sent2>
2047 requires convertible_to<const _It2&, _It>
2048 && convertible_to<const _Sent2&, _Sent>
2049 && assignable_from<_It&, const _It2&>
2050 && assignable_from<_Sent&, const _Sent2&>
2051 constexpr common_iterator&
2052 operator=(
const common_iterator<_It2, _Sent2>& __x)
2053 noexcept(is_nothrow_constructible_v<_It, const _It2&>
2054 && is_nothrow_constructible_v<_Sent, const _Sent2&>
2055 && is_nothrow_assignable_v<_It&, const _It2&>
2056 && is_nothrow_assignable_v<_Sent&, const _Sent2&>)
2058 __glibcxx_assert(__x._M_has_value());
2063 #if __cpp_concepts >= 202002L
2064 ~common_iterator() =
default;
2068 requires (!is_trivially_destructible_v<_It>
2069 || !is_trivially_destructible_v<_Sent>)
2077 else if (_M_index == 1)
2082 constexpr decltype(
auto)
2085 __glibcxx_assert(_M_index == 0);
2090 constexpr decltype(
auto)
2093 __glibcxx_assert(_M_index == 0);
2099 operator->()
const requires __detail::__common_iter_has_arrow<_It>
2101 __glibcxx_assert(_M_index == 0);
2102 if constexpr (is_pointer_v<_It> ||
requires { _M_it.operator->(); })
2104 else if constexpr (is_reference_v<iter_reference_t<_It>>)
2106 auto&& __tmp = *_M_it;
2110 return __arrow_proxy{*_M_it};
2113 constexpr common_iterator&
2116 __glibcxx_assert(_M_index == 0);
2121 constexpr decltype(
auto)
2124 __glibcxx_assert(_M_index == 0);
2125 if constexpr (forward_iterator<_It>)
2127 common_iterator __tmp = *
this;
2131 else if constexpr (!__detail::__common_iter_use_postfix_proxy<_It>)
2135 __postfix_proxy __p(**
this);
2141 template<
typename _It2, sentinel_for<_It> _Sent2>
2143 friend constexpr
bool
2144 operator== [[nodiscard]] (
const common_iterator& __x,
2145 const common_iterator<_It2, _Sent2>& __y)
2147 switch(__x._M_index << 2 | __y._M_index)
2153 return __x._M_it == __y._M_sent;
2155 return __x._M_sent == __y._M_it;
2157 __glibcxx_assert(__x._M_has_value());
2158 __glibcxx_assert(__y._M_has_value());
2159 __builtin_unreachable();
2163 template<
typename _It2, sentinel_for<_It> _Sent2>
2164 requires sentinel_for<_Sent, _It2> && equality_comparable_with<_It, _It2>
2165 friend constexpr
bool
2166 operator== [[nodiscard]] (
const common_iterator& __x,
2167 const common_iterator<_It2, _Sent2>& __y)
2169 switch(__x._M_index << 2 | __y._M_index)
2174 return __x._M_it == __y._M_it;
2176 return __x._M_it == __y._M_sent;
2178 return __x._M_sent == __y._M_it;
2180 __glibcxx_assert(__x._M_has_value());
2181 __glibcxx_assert(__y._M_has_value());
2182 __builtin_unreachable();
2186 template<sized_sentinel_for<_It> _It2, sized_sentinel_for<_It> _Sent2>
2187 requires sized_sentinel_for<_Sent, _It2>
2188 friend constexpr iter_difference_t<_It2>
2189 operator- [[nodiscard]] (
const common_iterator& __x,
2190 const common_iterator<_It2, _Sent2>& __y)
2192 switch(__x._M_index << 2 | __y._M_index)
2197 return __x._M_it - __y._M_it;
2199 return __x._M_it - __y._M_sent;
2201 return __x._M_sent - __y._M_it;
2203 __glibcxx_assert(__x._M_has_value());
2204 __glibcxx_assert(__y._M_has_value());
2205 __builtin_unreachable();
2210 friend constexpr iter_rvalue_reference_t<_It>
2211 iter_move(
const common_iterator& __i)
2212 noexcept(noexcept(ranges::iter_move(std::declval<const _It&>())))
2215 __glibcxx_assert(__i._M_index == 0);
2216 return ranges::iter_move(__i._M_it);
2219 template<indirectly_swappable<_It> _It2,
typename _Sent2>
2220 friend constexpr
void
2221 iter_swap(
const common_iterator& __x,
2222 const common_iterator<_It2, _Sent2>& __y)
2223 noexcept(noexcept(ranges::iter_swap(std::declval<const _It&>(),
2224 std::declval<const _It2&>())))
2226 __glibcxx_assert(__x._M_index == 0);
2227 __glibcxx_assert(__y._M_index == 0);
2228 return ranges::iter_swap(__x._M_it, __y._M_it);
2232 template<input_or_output_iterator _It2, sentinel_for<_It2> _Sent2>
2233 requires (!same_as<_It2, _Sent2>) && copyable<_It2>
2234 friend class common_iterator;
2237 _M_has_value()
const noexcept {
return _M_index != _S_valueless; }
2239 template<
typename _CIt>
2241 _M_assign(_CIt&& __x)
2243 if (_M_index == __x._M_index)
2246 _M_it = std::forward<_CIt>(__x)._M_it;
2247 else if (_M_index == 1)
2248 _M_sent = std::forward<_CIt>(__x)._M_sent;
2254 else if (_M_index == 1)
2256 _M_index = _S_valueless;
2258 if (__x._M_index == 0)
2260 std::forward<_CIt>(__x)._M_it);
2261 else if (__x._M_index == 1)
2263 std::forward<_CIt>(__x)._M_sent);
2264 _M_index = __x._M_index;
2272 unsigned char _M_valueless;
2274 unsigned char _M_index;
2276 static constexpr
unsigned char _S_valueless{2};
2279 template<
typename _It,
typename _Sent>
2280 struct incrementable_traits<common_iterator<_It, _Sent>>
2282 using difference_type = iter_difference_t<_It>;
2285 template<input_iterator _It,
typename _Sent>
2286 struct iterator_traits<common_iterator<_It, _Sent>>
2289 template<
typename _Iter>
2295 template<
typename _Iter>
2296 requires __detail::__common_iter_has_arrow<_Iter>
2299 using _CIter = common_iterator<_Iter, _Sent>;
2300 using type = decltype(std::declval<const _CIter&>().operator->());
2306 if constexpr (requires { requires derived_from<__iter_category_t<_It>,
2307 forward_iterator_tag>; })
2308 return forward_iterator_tag{};
2310 return input_iterator_tag{};
2314 using iterator_concept = __conditional_t<forward_iterator<_It>,
2315 forward_iterator_tag,
2316 input_iterator_tag>;
2317 using iterator_category = decltype(_S_iter_cat());
2318 using value_type = iter_value_t<_It>;
2319 using difference_type = iter_difference_t<_It>;
2320 using pointer =
typename __ptr<_It>::type;
2321 using reference = iter_reference_t<_It>;
2329 template<
typename _It>
2330 struct __counted_iter_value_type
2333 template<indirectly_readable _It>
2334 struct __counted_iter_value_type<_It>
2335 {
using value_type = iter_value_t<_It>; };
2337 template<
typename _It>
2338 struct __counted_iter_concept
2341 template<
typename _It>
2342 requires requires {
typename _It::iterator_concept; }
2343 struct __counted_iter_concept<_It>
2344 {
using iterator_concept =
typename _It::iterator_concept; };
2346 template<
typename _It>
2347 struct __counted_iter_cat
2350 template<
typename _It>
2351 requires requires {
typename _It::iterator_category; }
2352 struct __counted_iter_cat<_It>
2353 {
using iterator_category =
typename _It::iterator_category; };
2358 template<input_or_output_iterator _It>
2360 :
public __detail::__counted_iter_value_type<_It>,
2361 public __detail::__counted_iter_concept<_It>,
2362 public __detail::__counted_iter_cat<_It>
2365 using iterator_type = _It;
2367 using difference_type = iter_difference_t<_It>;
2371 constexpr
counted_iterator() requires default_initializable<_It> =
default;
2375 : _M_current(
std::move(__i)), _M_length(__n)
2376 { __glibcxx_assert(__n >= 0); }
2378 template<
typename _It2>
2379 requires convertible_to<const _It2&, _It>
2382 : _M_current(__x._M_current), _M_length(__x._M_length)
2385 template<
typename _It2>
2386 requires assignable_from<_It&, const _It2&>
2390 _M_current = __x._M_current;
2391 _M_length = __x._M_length;
2396 constexpr
const _It&
2397 base()
const & noexcept
2398 {
return _M_current; }
2403 noexcept(is_nothrow_move_constructible_v<_It>)
2407 constexpr iter_difference_t<_It>
2408 count()
const noexcept {
return _M_length; }
2411 constexpr decltype(
auto)
2413 noexcept(noexcept(*_M_current))
2415 __glibcxx_assert( _M_length > 0 );
2420 constexpr decltype(
auto)
2422 noexcept(noexcept(*_M_current))
2423 requires __detail::__dereferenceable<const _It>
2425 __glibcxx_assert( _M_length > 0 );
2431 operator->()
const noexcept
2432 requires contiguous_iterator<_It>
2438 __glibcxx_assert(_M_length > 0);
2444 constexpr decltype(
auto)
2447 __glibcxx_assert(_M_length > 0);
2451 return _M_current++;
2454 __throw_exception_again;
2459 operator++(
int) requires forward_iterator<_It>
2467 operator--() requires bidirectional_iterator<_It>
2475 operator--(
int) requires bidirectional_iterator<_It>
2484 operator+(iter_difference_t<_It> __n)
const
2485 requires random_access_iterator<_It>
2491 requires random_access_iterator<_It>
2492 {
return __x + __n; }
2495 operator+=(iter_difference_t<_It> __n)
2496 requires random_access_iterator<_It>
2498 __glibcxx_assert(__n <= _M_length);
2506 operator-(iter_difference_t<_It> __n)
const
2507 requires random_access_iterator<_It>
2510 template<common_with<_It> _It2>
2512 friend constexpr iter_difference_t<_It2>
2515 {
return __y._M_length - __x._M_length; }
2518 friend constexpr iter_difference_t<_It>
2520 {
return -__x._M_length; }
2523 friend constexpr iter_difference_t<_It>
2525 {
return __y._M_length; }
2528 operator-=(iter_difference_t<_It> __n)
2529 requires random_access_iterator<_It>
2531 __glibcxx_assert(-__n <= _M_length);
2538 constexpr decltype(
auto)
2539 operator[](iter_difference_t<_It> __n)
const
2540 noexcept(noexcept(_M_current[__n]))
2541 requires random_access_iterator<_It>
2543 __glibcxx_assert(__n < _M_length);
2544 return _M_current[__n];
2547 template<common_with<_It> _It2>
2549 friend constexpr
bool
2552 {
return __x._M_length == __y._M_length; }
2555 friend constexpr
bool
2557 {
return __x._M_length == 0; }
2559 template<common_with<_It> _It2>
2561 friend constexpr strong_ordering
2564 {
return __y._M_length <=> __x._M_length; }
2567 friend constexpr iter_rvalue_reference_t<_It>
2569 noexcept(noexcept(ranges::iter_move(__i._M_current)))
2570 requires input_iterator<_It>
2572 __glibcxx_assert( __i._M_length > 0 );
2573 return ranges::iter_move(__i._M_current);
2576 template<indirectly_swappable<_It> _It2>
2577 friend constexpr
void
2580 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
2582 __glibcxx_assert( __x._M_length > 0 && __y._M_length > 0 );
2583 ranges::iter_swap(__x._M_current, __y._M_current);
2589 _It _M_current = _It();
2590 iter_difference_t<_It> _M_length = 0;
2593 template<input_iterator _It>
2597 using pointer = __conditional_t<contiguous_iterator<_It>,
2602 #ifdef __glibcxx_ranges_as_const
2603 template<indirectly_readable _It>
2604 using iter_const_reference_t
2605 = common_reference_t<const iter_value_t<_It>&&, iter_reference_t<_It>>;
2607 template<input_iterator _It>
class basic_const_iterator;
2611 template<
typename _It>
2612 concept __constant_iterator = input_iterator<_It>
2613 && same_as<iter_const_reference_t<_It>, iter_reference_t<_It>>;
2615 template<
typename _Tp>
2616 inline constexpr
bool __is_const_iterator =
false;
2618 template<
typename _It>
2619 inline constexpr
bool __is_const_iterator<basic_const_iterator<_It>> =
true;
2621 template<
typename _Tp>
2622 concept __not_a_const_iterator = !__is_const_iterator<_Tp>;
2624 template<indirectly_readable _It>
2625 using __iter_const_rvalue_reference_t
2626 = common_reference_t<const iter_value_t<_It>&&, iter_rvalue_reference_t<_It>>;
2628 template<
typename _It>
2629 struct __basic_const_iterator_iter_cat
2632 template<forward_iterator _It>
2633 struct __basic_const_iterator_iter_cat<_It>
2634 {
using iterator_category = __iter_category_t<_It>; };
2637 template<input_iterator _It>
2638 using const_iterator
2639 = __conditional_t<__detail::__constant_iterator<_It>, _It, basic_const_iterator<_It>>;
2643 template<
typename _Sent>
2644 struct __const_sentinel
2645 {
using type = _Sent; };
2647 template<input_iterator _Sent>
2648 struct __const_sentinel<_Sent>
2649 {
using type = const_iterator<_Sent>; };
2652 template<semiregular _Sent>
2653 using const_sentinel =
typename __detail::__const_sentinel<_Sent>::type;
2655 template<input_iterator _It>
2656 class basic_const_iterator
2657 :
public __detail::__basic_const_iterator_iter_cat<_It>
2659 _It _M_current = _It();
2660 using __reference = iter_const_reference_t<_It>;
2661 using __rvalue_reference = __detail::__iter_const_rvalue_reference_t<_It>;
2666 if constexpr (contiguous_iterator<_It>)
2667 return contiguous_iterator_tag{};
2668 else if constexpr (random_access_iterator<_It>)
2669 return random_access_iterator_tag{};
2670 else if constexpr (bidirectional_iterator<_It>)
2671 return bidirectional_iterator_tag{};
2672 else if constexpr (forward_iterator<_It>)
2673 return forward_iterator_tag{};
2675 return input_iterator_tag{};
2678 template<input_iterator _It2>
friend class basic_const_iterator;
2681 using iterator_concept = decltype(_S_iter_concept());
2682 using value_type = iter_value_t<_It>;
2683 using difference_type = iter_difference_t<_It>;
2685 basic_const_iterator()
requires default_initializable<_It> = default;
2688 basic_const_iterator(_It __current)
2689 noexcept(is_nothrow_move_constructible_v<_It>)
2690 : _M_current(
std::
move(__current))
2693 template<convertible_to<_It> _It2>
2695 basic_const_iterator(basic_const_iterator<_It2> __current)
2696 noexcept(is_nothrow_constructible_v<_It, _It2>)
2697 : _M_current(
std::
move(__current._M_current))
2700 template<__detail::__different_from<basic_const_iterator> _Tp>
2703 basic_const_iterator(_Tp&& __current)
2704 noexcept(is_nothrow_constructible_v<_It, _Tp>)
2708 constexpr
const _It&
2709 base() const & noexcept
2710 {
return _M_current; }
2714 noexcept(is_nothrow_move_constructible_v<_It>)
2717 constexpr __reference
2719 noexcept(noexcept(static_cast<__reference>(*_M_current)))
2720 {
return static_cast<__reference
>(*_M_current); }
2722 constexpr
const auto*
2724 noexcept(contiguous_iterator<_It> || noexcept(*_M_current))
2725 requires is_lvalue_reference_v<iter_reference_t<_It>>
2726 && same_as<remove_cvref_t<iter_reference_t<_It>>, value_type>
2728 if constexpr (contiguous_iterator<_It>)
2734 constexpr basic_const_iterator&
2736 noexcept(noexcept(++_M_current))
2744 noexcept(noexcept(++_M_current))
2747 constexpr basic_const_iterator
2749 noexcept(noexcept(++*
this) && is_nothrow_copy_constructible_v<basic_const_iterator>)
2757 constexpr basic_const_iterator&
2759 noexcept(noexcept(--_M_current))
2760 requires bidirectional_iterator<_It>
2766 constexpr basic_const_iterator
2768 noexcept(noexcept(--*
this) && is_nothrow_copy_constructible_v<basic_const_iterator>)
2769 requires bidirectional_iterator<_It>
2776 constexpr basic_const_iterator&
2777 operator+=(difference_type __n)
2778 noexcept(noexcept(_M_current += __n))
2779 requires random_access_iterator<_It>
2785 constexpr basic_const_iterator&
2786 operator-=(difference_type __n)
2787 noexcept(noexcept(_M_current -= __n))
2788 requires random_access_iterator<_It>
2794 constexpr __reference
2795 operator[](difference_type __n)
const
2796 noexcept(noexcept(
static_cast<__reference
>(_M_current[__n])))
2797 requires random_access_iterator<_It>
2798 {
return static_cast<__reference
>(_M_current[__n]); }
2800 template<sentinel_for<_It> _Sent>
2802 operator==(
const _Sent& __s)
const
2803 noexcept(noexcept(_M_current == __s))
2804 {
return _M_current == __s; }
2806 template<__detail::__not_a_const_iterator _CIt>
2807 requires __detail::__constant_iterator<_CIt> && convertible_to<_It, _CIt>
2809 operator _CIt() const&
2810 {
return _M_current; }
2812 template<__detail::__not_a_const_iterator _CIt>
2813 requires __detail::__constant_iterator<_CIt> && convertible_to<_It, _CIt>
2819 operator<(
const basic_const_iterator& __y)
const
2820 noexcept(noexcept(_M_current < __y._M_current))
2821 requires random_access_iterator<_It>
2822 {
return _M_current < __y._M_current; }
2825 operator>(
const basic_const_iterator& __y)
const
2826 noexcept(noexcept(_M_current > __y._M_current))
2827 requires random_access_iterator<_It>
2828 {
return _M_current > __y._M_current; }
2831 operator<=(
const basic_const_iterator& __y)
const
2832 noexcept(noexcept(_M_current <= __y._M_current))
2833 requires random_access_iterator<_It>
2834 {
return _M_current <= __y._M_current; }
2837 operator>=(
const basic_const_iterator& __y)
const
2838 noexcept(noexcept(_M_current >= __y._M_current))
2839 requires random_access_iterator<_It>
2840 {
return _M_current >= __y._M_current; }
2843 operator<=>(
const basic_const_iterator& __y)
const
2844 noexcept(noexcept(_M_current <=> __y._M_current))
2845 requires random_access_iterator<_It> && three_way_comparable<_It>
2846 {
return _M_current <=> __y._M_current; }
2848 template<__detail::__different_from<basic_const_iterator> _It2>
2851 noexcept(noexcept(_M_current < __y))
2852 requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
2853 {
return _M_current < __y; }
2855 template<__detail::__different_from<basic_const_iterator> _It2>
2858 noexcept(noexcept(_M_current > __y))
2859 requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
2860 {
return _M_current > __y; }
2862 template<__detail::__different_from<basic_const_iterator> _It2>
2865 noexcept(noexcept(_M_current <= __y))
2866 requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
2867 {
return _M_current <= __y; }
2869 template<__detail::__different_from<basic_const_iterator> _It2>
2872 noexcept(noexcept(_M_current >= __y))
2873 requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
2874 {
return _M_current >= __y; }
2876 template<__detail::__different_from<basic_const_iterator> _It2>
2878 operator<=>(
const _It2& __y)
const
2879 noexcept(noexcept(_M_current <=> __y))
2880 requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
2881 && three_way_comparable_with<_It, _It2>
2882 {
return _M_current <=> __y; }
2884 template<__detail::__not_a_const_iterator _It2, same_as<_It> _It3>
2885 friend constexpr
bool
2886 operator<(
const _It2& __x,
const basic_const_iterator<_It3>& __y)
2887 noexcept(noexcept(__x < __y._M_current))
2888 requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
2889 {
return __x < __y._M_current; }
2891 template<__detail::__not_a_const_iterator _It2, same_as<_It> _It3>
2892 friend constexpr
bool
2893 operator>(
const _It2& __x,
const basic_const_iterator<_It3>& __y)
2894 noexcept(noexcept(__x > __y._M_current))
2895 requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
2896 {
return __x > __y._M_current; }
2898 template<__detail::__not_a_const_iterator _It2, same_as<_It> _It3>
2899 friend constexpr
bool
2900 operator<=(
const _It2& __x,
const basic_const_iterator<_It3>& __y)
2901 noexcept(noexcept(__x <= __y._M_current))
2902 requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
2903 {
return __x <= __y._M_current; }
2905 template<__detail::__not_a_const_iterator _It2, same_as<_It> _It3>
2906 friend constexpr
bool
2907 operator>=(
const _It2& __x,
const basic_const_iterator<_It3>& __y)
2908 noexcept(noexcept(__x >= __y._M_current))
2909 requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
2910 {
return __x >= __y._M_current; }
2912 friend constexpr basic_const_iterator
2913 operator+(
const basic_const_iterator& __i, difference_type __n)
2914 noexcept(noexcept(basic_const_iterator(__i._M_current + __n)))
2915 requires random_access_iterator<_It>
2916 {
return basic_const_iterator(__i._M_current + __n); }
2918 friend constexpr basic_const_iterator
2919 operator+(difference_type __n,
const basic_const_iterator& __i)
2920 noexcept(noexcept(basic_const_iterator(__i._M_current + __n)))
2921 requires random_access_iterator<_It>
2922 {
return basic_const_iterator(__i._M_current + __n); }
2924 friend constexpr basic_const_iterator
2925 operator-(
const basic_const_iterator& __i, difference_type __n)
2926 noexcept(noexcept(basic_const_iterator(__i._M_current - __n)))
2927 requires random_access_iterator<_It>
2928 {
return basic_const_iterator(__i._M_current - __n); }
2930 template<sized_sentinel_for<_It> _Sent>
2931 constexpr difference_type
2933 noexcept(noexcept(_M_current - __y))
2934 {
return _M_current - __y; }
2936 template<__detail::__not_a_const_iterator _Sent, same_as<_It> _It2>
2937 requires sized_sentinel_for<_Sent, _It>
2938 friend constexpr difference_type
2939 operator-(
const _Sent& __x,
const basic_const_iterator<_It2>& __y)
2940 noexcept(noexcept(__x - __y._M_current))
2941 {
return __x - __y._M_current; }
2943 friend constexpr __rvalue_reference
2944 iter_move(
const basic_const_iterator& __i)
2945 noexcept(noexcept(
static_cast<__rvalue_reference
>(ranges::iter_move(__i._M_current))))
2946 {
return static_cast<__rvalue_reference
>(ranges::iter_move(__i._M_current)); }
2949 template<
typename _Tp, common_with<_Tp> _Up>
2950 requires input_iterator<common_type_t<_Tp, _Up>>
2951 struct common_type<basic_const_iterator<_Tp>, _Up>
2952 {
using type = basic_const_iterator<common_type_t<_Tp, _Up>>; };
2954 template<
typename _Tp, common_with<_Tp> _Up>
2955 requires input_iterator<common_type_t<_Tp, _Up>>
2956 struct common_type<_Up, basic_const_iterator<_Tp>>
2957 {
using type = basic_const_iterator<common_type_t<_Tp, _Up>>; };
2959 template<
typename _Tp, common_with<_Tp> _Up>
2960 requires input_iterator<common_type_t<_Tp, _Up>>
2961 struct common_type<basic_const_iterator<_Tp>, basic_const_iterator<_Up>>
2962 {
using type = basic_const_iterator<common_type_t<_Tp, _Up>>; };
2964 template<input_iterator _It>
2965 constexpr const_iterator<_It>
2966 make_const_iterator(_It __it)
2967 noexcept(is_nothrow_convertible_v<_It, const_iterator<_It>>)
2970 template<semiregular _Sent>
2971 constexpr const_sentinel<_Sent>
2972 make_const_sentinel(_Sent __s)
2973 noexcept(is_nothrow_convertible_v<_Sent, const_sentinel<_Sent>>)
2980 _GLIBCXX_END_NAMESPACE_VERSION
2985 template<
typename _Iterator,
typename _Sequence,
typename _Category>
2986 class _Safe_iterator;
2989 namespace std _GLIBCXX_VISIBILITY(default)
2991 _GLIBCXX_BEGIN_NAMESPACE_VERSION
2996 template<
typename _Iterator,
typename _Container>
2997 _GLIBCXX_NODISCARD __attribute__((__always_inline__))
2998 _GLIBCXX20_CONSTEXPR
3000 __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it)
3002 {
return __it.base(); }
3005 template<
typename _Iterator>
3006 _GLIBCXX_NODISCARD __attribute__((__always_inline__))
3007 _GLIBCXX20_CONSTEXPR
3009 __niter_base(_Iterator __it)
3015 #if __cplusplus < 201103L
3016 template<
typename _Ite,
typename _Seq>
3018 __niter_base(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq,
3021 template<
typename _Ite,
typename _Cont,
typename _Seq>
3023 __niter_base(const ::__gnu_debug::_Safe_iterator<
3024 ::__gnu_cxx::__normal_iterator<_Ite, _Cont>, _Seq,
3027 template<
typename _Ite,
typename _Seq>
3028 _GLIBCXX20_CONSTEXPR
3029 decltype(std::__niter_base(std::declval<_Ite>()))
3030 __niter_base(const ::
__gnu_debug::_Safe_iterator<_Ite, _Seq,
3031 std::random_access_iterator_tag>&)
3032 noexcept(
std::is_nothrow_copy_constructible<_Ite>::value);
3035 #if __cplusplus >= 201103L
3036 template<
typename _Iterator>
3037 _GLIBCXX20_CONSTEXPR
3039 __niter_base(reverse_iterator<_Iterator> __it)
3040 -> decltype(__make_reverse_iterator(__niter_base(__it.base())))
3041 {
return __make_reverse_iterator(__niter_base(__it.base())); }
3043 template<
typename _Iterator>
3044 _GLIBCXX20_CONSTEXPR
3046 __niter_base(move_iterator<_Iterator> __it)
3047 -> decltype(make_move_iterator(__niter_base(__it.base())))
3048 {
return make_move_iterator(__niter_base(__it.base())); }
3050 template<
typename _Iterator>
3051 _GLIBCXX20_CONSTEXPR
3053 __miter_base(reverse_iterator<_Iterator> __it)
3054 -> decltype(__make_reverse_iterator(__miter_base(__it.base())))
3055 {
return __make_reverse_iterator(__miter_base(__it.base())); }
3057 template<
typename _Iterator>
3058 _GLIBCXX20_CONSTEXPR
3060 __miter_base(move_iterator<_Iterator> __it)
3061 -> decltype(__miter_base(__it.base()))
3062 {
return __miter_base(__it.base()); }
3069 template<
typename _From,
typename _To>
3071 _GLIBCXX20_CONSTEXPR
3073 __niter_wrap(_From __from, _To __res)
3074 {
return __from + (std::__niter_base(__res) - std::__niter_base(__from)); }
3077 template<
typename _Iterator>
3078 _GLIBCXX_NODISCARD __attribute__((__always_inline__))
3079 _GLIBCXX20_CONSTEXPR
3081 __niter_wrap(
const _Iterator&, _Iterator __res)
3086 #if __cpp_deduction_guides >= 201606
3089 template<
typename _InputIterator>
3090 using __iter_key_t = remove_const_t<
3091 #ifdef __glibcxx_tuple_like
3092 tuple_element_t<0, typename iterator_traits<_InputIterator>::value_type>>;
3094 typename iterator_traits<_InputIterator>::value_type::first_type>;
3097 template<
typename _InputIterator>
3099 #ifdef __glibcxx_tuple_like
3100 = tuple_element_t<1, typename iterator_traits<_InputIterator>::value_type>;
3102 =
typename iterator_traits<_InputIterator>::value_type::second_type;
3105 template<
typename _T1,
typename _T2>
3108 template<
typename _InputIterator>
3109 using __iter_to_alloc_t
3110 = pair<const __iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>>;
3113 _GLIBCXX_END_NAMESPACE_VERSION
3116 #ifdef _GLIBCXX_DEBUG
constexpr bool operator<=(const duration< _Rep1, _Period1 > &__lhs, const duration< _Rep2, _Period2 > &__rhs)
constexpr bool operator>=(const duration< _Rep1, _Period1 > &__lhs, const duration< _Rep2, _Period2 > &__rhs)
constexpr bool operator<(const duration< _Rep1, _Period1 > &__lhs, const duration< _Rep2, _Period2 > &__rhs)
constexpr bool operator>(const duration< _Rep1, _Period1 > &__lhs, const duration< _Rep2, _Period2 > &__rhs)
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.
constexpr _Tp * to_address(_Tp *__ptr) noexcept
Obtain address referenced by a pointer to an object.
typename add_pointer< _Tp >::type add_pointer_t
Alias template for add_pointer.
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.
requires(!same_as< _It, _Sent >) &©able< _It > class common_iterator
An iterator/sentinel adaptor for representing a non-common range.
constexpr front_insert_iterator< _Container > front_inserter(_Container &__x)
constexpr insert_iterator< _Container > inserter(_Container &__x, std::__detail::__range_iter_t< _Container > __i)
constexpr back_insert_iterator< _Container > back_inserter(_Container &__x)
ISO C++ entities toplevel namespace is std.
GNU extensions for public use.
GNU debug classes for public use.
is_nothrow_copy_constructible
requires constexpr __convertible< _Iter > reverse_iterator(const reverse_iterator< _Iter > &__x) noexcept(/*conditional */)
constexpr reverse_iterator operator+(difference_type __n) const
constexpr iterator_type base() const noexcept(/*conditional */)
constexpr pointer operator->() const requires is_pointer_v< _Iterator >||requires(const _Iterator __i)
constexpr reverse_iterator(const reverse_iterator &__x) noexcept(/*conditional */)
constexpr reverse_iterator & operator+=(difference_type __n)
constexpr reference operator[](difference_type __n) const
constexpr reverse_iterator() noexcept(/*conditional */)
constexpr reverse_iterator(iterator_type __x) noexcept(/*conditional */)
constexpr reverse_iterator & operator--()
constexpr reverse_iterator & operator-=(difference_type __n)
constexpr reverse_iterator operator--(int)
constexpr reference operator*() const
constexpr reverse_iterator operator-(difference_type __n) const
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.
A sentinel adaptor for use with std::move_iterator.
An iterator adaptor that yields an rvalue reference.
An iterator adaptor that keeps track of the distance to the end.
Forward iterators support a superset of input iterator operations.
Bidirectional iterators support a superset of forward iterator operations.
Random-access iterators support a superset of bidirectional iterator operations.
Traits class for iterators.