60#ifndef _STL_ITERATOR_H
61#define _STL_ITERATOR_H 1
69#if __cplusplus >= 201103L
73#if __cplusplus >= 202002L
81#if __glibcxx_tuple_like
85namespace std _GLIBCXX_VISIBILITY(default)
87_GLIBCXX_BEGIN_NAMESPACE_VERSION
99 template<
typename _Cat,
typename _Limit,
typename _Otherwise = _Cat>
100 using __clamp_iter_cat
101 = __conditional_t<derived_from<_Cat, _Limit>, _Limit, _Otherwise>;
106#pragma GCC diagnostic push
107#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
128 template<
typename _Iterator>
129 class reverse_iterator
130 :
public iterator<typename iterator_traits<_Iterator>::iterator_category,
131 typename iterator_traits<_Iterator>::value_type,
132 typename iterator_traits<_Iterator>::difference_type,
133 typename iterator_traits<_Iterator>::pointer,
134 typename iterator_traits<_Iterator>::reference>
136 template<
typename _Iter>
137 friend class reverse_iterator;
139#if __glibcxx_concepts
142 template<
typename _Iter>
143 static constexpr bool __convertible = !is_same_v<_Iter, _Iterator>
144 && convertible_to<const _Iter&, _Iterator>;
150 typedef iterator_traits<_Iterator> __traits_type;
153 typedef _Iterator iterator_type;
154 typedef typename __traits_type::pointer pointer;
155#if ! __glibcxx_concepts
156 typedef typename __traits_type::difference_type difference_type;
157 typedef typename __traits_type::reference reference;
159 using iterator_concept
160 = __conditional_t<random_access_iterator<_Iterator>,
161 random_access_iterator_tag,
162 bidirectional_iterator_tag>;
163 using iterator_category
164 = __detail::__clamp_iter_cat<
typename __traits_type::iterator_category,
165 random_access_iterator_tag>;
166 using value_type = iter_value_t<_Iterator>;
167 using difference_type = iter_difference_t<_Iterator>;
168 using reference = iter_reference_t<_Iterator>;
180 _GLIBCXX_NOEXCEPT_IF(noexcept(_Iterator()))
187 explicit _GLIBCXX17_CONSTEXPR
189 _GLIBCXX_NOEXCEPT_IF(
noexcept(_Iterator(__x)))
198 _GLIBCXX_NOEXCEPT_IF(
noexcept(_Iterator(__x.current)))
199 : current(__x.current)
202#if __cplusplus >= 201103L
210 template<
typename _Iter>
211#if __glibcxx_concepts
212 requires __convertible<_Iter>
216 _GLIBCXX_NOEXCEPT_IF(
noexcept(_Iterator(__x.current)))
217 : current(__x.current)
220#if __cplusplus >= 201103L
221 template<
typename _Iter>
222#if __glibcxx_concepts
223 requires __convertible<_Iter>
224 && assignable_from<_Iterator&, const _Iter&>
229 _GLIBCXX_NOEXCEPT_IF(
noexcept(current = __x.current))
231 current = __x.current;
240 _GLIBCXX17_CONSTEXPR iterator_type
242 _GLIBCXX_NOEXCEPT_IF(noexcept(_Iterator(current)))
256 _GLIBCXX17_CONSTEXPR reference
259 _Iterator __tmp = current;
269 _GLIBCXX17_CONSTEXPR pointer
271#if __cplusplus > 201703L && __cpp_concepts >= 201907L
272 requires is_pointer_v<_Iterator>
273 ||
requires(
const _Iterator __i) { __i.operator->(); }
278 _Iterator __tmp = current;
280 return _S_to_pointer(__tmp);
385 _GLIBCXX17_CONSTEXPR reference
387 {
return *(*
this + __n); }
389#if __cplusplus > 201703L && __glibcxx_concepts
391 friend constexpr iter_rvalue_reference_t<_Iterator>
393 noexcept(is_nothrow_copy_constructible_v<_Iterator>
396 auto __tmp = __i.base();
397 return ranges::iter_move(--__tmp);
400 template<indirectly_swappable<_Iterator> _Iter2>
401 friend constexpr void
402 iter_swap(
const reverse_iterator& __x,
403 const reverse_iterator<_Iter2>& __y)
404 noexcept(is_nothrow_copy_constructible_v<_Iterator>
405 && is_nothrow_copy_constructible_v<_Iter2>
409 auto __xtmp = __x.base();
410 auto __ytmp = __y.base();
411 ranges::iter_swap(--__xtmp, --__ytmp);
416 template<
typename _Tp>
417 static _GLIBCXX17_CONSTEXPR _Tp*
418 _S_to_pointer(_Tp* __p)
421 template<
typename _Tp>
422 static _GLIBCXX17_CONSTEXPR pointer
423 _S_to_pointer(_Tp __t)
424 {
return __t.operator->(); }
437#if __cplusplus <= 201703L || ! defined __glibcxx_concepts
438 template<
typename _Iterator>
440 inline _GLIBCXX17_CONSTEXPR
bool
441 operator==(
const reverse_iterator<_Iterator>& __x,
442 const reverse_iterator<_Iterator>& __y)
443 {
return __x.base() == __y.base(); }
445 template<
typename _Iterator>
447 inline _GLIBCXX17_CONSTEXPR
bool
448 operator<(
const reverse_iterator<_Iterator>& __x,
449 const reverse_iterator<_Iterator>& __y)
450 {
return __y.base() < __x.base(); }
452 template<
typename _Iterator>
454 inline _GLIBCXX17_CONSTEXPR
bool
455 operator!=(
const reverse_iterator<_Iterator>& __x,
456 const reverse_iterator<_Iterator>& __y)
457 {
return !(__x == __y); }
459 template<
typename _Iterator>
461 inline _GLIBCXX17_CONSTEXPR
bool
462 operator>(
const reverse_iterator<_Iterator>& __x,
463 const reverse_iterator<_Iterator>& __y)
464 {
return __y < __x; }
466 template<
typename _Iterator>
468 inline _GLIBCXX17_CONSTEXPR
bool
469 operator<=(
const reverse_iterator<_Iterator>& __x,
470 const reverse_iterator<_Iterator>& __y)
471 {
return !(__y < __x); }
473 template<
typename _Iterator>
475 inline _GLIBCXX17_CONSTEXPR
bool
476 operator>=(
const reverse_iterator<_Iterator>& __x,
477 const reverse_iterator<_Iterator>& __y)
478 {
return !(__x < __y); }
483 template<
typename _IteratorL,
typename _IteratorR>
485 inline _GLIBCXX17_CONSTEXPR
bool
486 operator==(
const reverse_iterator<_IteratorL>& __x,
487 const reverse_iterator<_IteratorR>& __y)
488 {
return __x.base() == __y.base(); }
490 template<
typename _IteratorL,
typename _IteratorR>
492 inline _GLIBCXX17_CONSTEXPR
bool
493 operator<(
const reverse_iterator<_IteratorL>& __x,
494 const reverse_iterator<_IteratorR>& __y)
495 {
return __x.base() > __y.base(); }
497 template<
typename _IteratorL,
typename _IteratorR>
499 inline _GLIBCXX17_CONSTEXPR
bool
500 operator!=(
const reverse_iterator<_IteratorL>& __x,
501 const reverse_iterator<_IteratorR>& __y)
502 {
return __x.base() != __y.base(); }
504 template<
typename _IteratorL,
typename _IteratorR>
506 inline _GLIBCXX17_CONSTEXPR
bool
507 operator>(
const reverse_iterator<_IteratorL>& __x,
508 const reverse_iterator<_IteratorR>& __y)
509 {
return __x.base() < __y.base(); }
511 template<
typename _IteratorL,
typename _IteratorR>
512 inline _GLIBCXX17_CONSTEXPR
bool
513 operator<=(
const reverse_iterator<_IteratorL>& __x,
514 const reverse_iterator<_IteratorR>& __y)
515 {
return __x.base() >= __y.base(); }
517 template<
typename _IteratorL,
typename _IteratorR>
519 inline _GLIBCXX17_CONSTEXPR
bool
520 operator>=(
const reverse_iterator<_IteratorL>& __x,
521 const reverse_iterator<_IteratorR>& __y)
522 {
return __x.base() <= __y.base(); }
524 template<
typename _IteratorL,
typename _IteratorR>
529 requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
530 {
return __x.base() == __y.base(); }
532 template<
typename _IteratorL,
typename _IteratorR>
535 operator!=(
const reverse_iterator<_IteratorL>& __x,
536 const reverse_iterator<_IteratorR>& __y)
537 requires requires { { __x.base() != __y.base() } -> convertible_to<bool>; }
538 {
return __x.base() != __y.base(); }
540 template<
typename _IteratorL,
typename _IteratorR>
543 operator<(
const reverse_iterator<_IteratorL>& __x,
544 const reverse_iterator<_IteratorR>& __y)
545 requires requires { { __x.base() > __y.base() } -> convertible_to<bool>; }
546 {
return __x.base() > __y.base(); }
548 template<
typename _IteratorL,
typename _IteratorR>
551 operator>(
const reverse_iterator<_IteratorL>& __x,
552 const reverse_iterator<_IteratorR>& __y)
553 requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
554 {
return __x.base() < __y.base(); }
556 template<
typename _IteratorL,
typename _IteratorR>
559 operator<=(
const reverse_iterator<_IteratorL>& __x,
560 const reverse_iterator<_IteratorR>& __y)
561 requires requires { { __x.base() >= __y.base() } -> convertible_to<bool>; }
562 {
return __x.base() >= __y.base(); }
564 template<
typename _IteratorL,
typename _IteratorR>
567 operator>=(
const reverse_iterator<_IteratorL>& __x,
568 const reverse_iterator<_IteratorR>& __y)
569 requires requires { { __x.base() <= __y.base() } -> convertible_to<bool>; }
570 {
return __x.base() <= __y.base(); }
572 template<
typename _IteratorL,
573 three_way_comparable_with<_IteratorL> _IteratorR>
576 operator<=>(
const reverse_iterator<_IteratorL>& __x,
577 const reverse_iterator<_IteratorR>& __y)
578 {
return __y.base() <=> __x.base(); }
583 template<
typename _Iterator>
586 operator==(
const reverse_iterator<_Iterator>& __x,
587 const reverse_iterator<_Iterator>& __y)
588 requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
589 {
return __x.base() == __y.base(); }
591 template<three_way_comparable _Iterator>
594 operator<=>(
const reverse_iterator<_Iterator>& __x,
595 const reverse_iterator<_Iterator>& __y)
596 {
return __y.base() <=> __x.base(); }
600#if __cplusplus < 201103L
601 template<
typename _Iterator>
602 inline typename reverse_iterator<_Iterator>::difference_type
603 operator-(
const reverse_iterator<_Iterator>& __x,
604 const reverse_iterator<_Iterator>& __y)
605 {
return __y.base() - __x.base(); }
607 template<
typename _IteratorL,
typename _IteratorR>
608 inline typename reverse_iterator<_IteratorL>::difference_type
609 operator-(
const reverse_iterator<_IteratorL>& __x,
610 const reverse_iterator<_IteratorR>& __y)
611 {
return __y.base() - __x.base(); }
615 template<
typename _IteratorL,
typename _IteratorR>
617 inline _GLIBCXX17_CONSTEXPR
auto
618 operator-(
const reverse_iterator<_IteratorL>& __x,
619 const reverse_iterator<_IteratorR>& __y)
620 ->
decltype(__y.base() - __x.base())
621 {
return __y.base() - __x.base(); }
624 template<
typename _Iterator>
626 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
627 operator+(
typename reverse_iterator<_Iterator>::difference_type __n,
628 const reverse_iterator<_Iterator>& __x)
629 {
return reverse_iterator<_Iterator>(__x.base() - __n); }
631#if __cplusplus >= 201103L
633 template<
typename _Iterator>
634 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
635 __make_reverse_iterator(_Iterator __i)
636 {
return reverse_iterator<_Iterator>(__i); }
638# ifdef __glibcxx_make_reverse_iterator
642 template<
typename _Iterator>
644 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
648# if __cplusplus > 201703L && defined __glibcxx_concepts
649 template<
typename _Iterator1,
typename _Iterator2>
650 requires (!sized_sentinel_for<_Iterator1, _Iterator2>)
651 inline constexpr bool
652 disable_sized_sentinel_for<reverse_iterator<_Iterator1>,
653 reverse_iterator<_Iterator2>> =
true;
657 template<
typename _Iterator>
660 __niter_base(reverse_iterator<_Iterator> __it)
661 ->
decltype(__make_reverse_iterator(__niter_base(__it.base())))
662 {
return __make_reverse_iterator(__niter_base(__it.base())); }
664 template<
typename _Iterator>
665 struct __is_move_iterator<reverse_iterator<_Iterator> >
666 : __is_move_iterator<_Iterator>
669 template<
typename _Iterator>
672 __miter_base(reverse_iterator<_Iterator> __it)
673 ->
decltype(__make_reverse_iterator(__miter_base(__it.base())))
674 {
return __make_reverse_iterator(__miter_base(__it.base())); }
688 template<
typename _Container>
690 :
public iterator<output_iterator_tag, void, void, void, void>
693 _Container* container;
698#if __cplusplus > 201703L
699 using difference_type = ptrdiff_t;
703 explicit _GLIBCXX20_CONSTEXPR
718#if __cplusplus < 201103L
720 operator=(
typename _Container::const_reference __value)
722 container->push_back(__value);
728 operator=(
const typename _Container::value_type& __value)
730 container->push_back(__value);
736 operator=(
typename _Container::value_type&& __value)
738 container->push_back(
std::move(__value));
744 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
773 template<
typename _Container>
774 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
775 inline back_insert_iterator<_Container>
789 template<
typename _Container>
791 :
public iterator<output_iterator_tag, void, void, void, void>
794 _Container* container;
799#if __cplusplus > 201703L
800 using difference_type = ptrdiff_t;
804 explicit _GLIBCXX20_CONSTEXPR
819#if __cplusplus < 201103L
821 operator=(
typename _Container::const_reference __value)
823 container->push_front(__value);
829 operator=(
const typename _Container::value_type& __value)
831 container->push_front(__value);
837 operator=(
typename _Container::value_type&& __value)
839 container->push_front(
std::move(__value));
845 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
874 template<
typename _Container>
875 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
876 inline front_insert_iterator<_Container>
894 template<
typename _Container>
896 :
public iterator<output_iterator_tag, void, void, void, void>
898#if __cplusplus > 201703L && defined __glibcxx_concepts
899 using _Iter = std::__detail::__range_iter_t<_Container>;
901 typedef typename _Container::iterator _Iter;
904 _Container* container;
911#if __cplusplus > 201703L && defined __glibcxx_concepts
912 using difference_type = ptrdiff_t;
946#if __cplusplus < 201103L
948 operator=(
typename _Container::const_reference __value)
950 iter = container->insert(iter, __value);
957 operator=(
const typename _Container::value_type& __value)
959 iter = container->insert(iter, __value);
966 operator=(
typename _Container::value_type&& __value)
968 iter = container->insert(iter,
std::move(__value));
975 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
993#pragma GCC diagnostic pop
1007#if __cplusplus > 201703L && defined __glibcxx_concepts
1008 template<
typename _Container>
1010 constexpr insert_iterator<_Container>
1011 inserter(_Container& __x, std::__detail::__range_iter_t<_Container> __i)
1014 template<
typename _Container>
1016 inline insert_iterator<_Container>
1017 inserter(_Container& __x,
typename _Container::iterator __i)
1018 {
return insert_iterator<_Container>(__x, __i); }
1023_GLIBCXX_END_NAMESPACE_VERSION
1026namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
1028_GLIBCXX_BEGIN_NAMESPACE_VERSION
1037 template<
typename _Iterator,
typename _Container>
1038 class __normal_iterator
1041 _Iterator _M_current;
1045#if __cplusplus >= 201103L
1046 template<
typename _Iter>
1047 using __convertible_from
1048 = std::__enable_if_t<std::is_convertible<_Iter, _Iterator>::value>;
1052 typedef _Iterator iterator_type;
1053 typedef typename __traits_type::iterator_category iterator_category;
1054 typedef typename __traits_type::value_type value_type;
1055 typedef typename __traits_type::difference_type difference_type;
1056 typedef typename __traits_type::reference reference;
1057 typedef typename __traits_type::pointer pointer;
1059#if __cplusplus > 201703L && __glibcxx_concepts
1060 using iterator_concept = std::__detail::__iter_concept<_Iterator>;
1063 _GLIBCXX_CONSTEXPR __normal_iterator() _GLIBCXX_NOEXCEPT
1064 : _M_current(_Iterator()) { }
1066 explicit _GLIBCXX20_CONSTEXPR
1067 __normal_iterator(
const _Iterator& __i) _GLIBCXX_NOEXCEPT
1068 : _M_current(__i) { }
1071#if __cplusplus >= 201103L
1072 template<
typename _Iter,
typename = __convertible_from<_Iter>>
1073 _GLIBCXX20_CONSTEXPR
1074 __normal_iterator(
const __normal_iterator<_Iter, _Container>& __i)
1079 template<
typename _Iter>
1080 __normal_iterator(
const __normal_iterator<_Iter,
1081 typename __enable_if<
1082 (std::__are_same<_Iter, typename _Container::pointer>::__value),
1083 _Container>::__type>& __i)
1085 : _M_current(__i.base()) { }
1088 _GLIBCXX20_CONSTEXPR
1090 operator*() const _GLIBCXX_NOEXCEPT
1091 {
return *_M_current; }
1093 _GLIBCXX20_CONSTEXPR
1095 operator->() const _GLIBCXX_NOEXCEPT
1096 {
return _M_current; }
1098 _GLIBCXX20_CONSTEXPR
1100 operator++() _GLIBCXX_NOEXCEPT
1106 _GLIBCXX20_CONSTEXPR
1108 operator++(
int) _GLIBCXX_NOEXCEPT
1109 {
return __normal_iterator(_M_current++); }
1112 _GLIBCXX20_CONSTEXPR
1114 operator--() _GLIBCXX_NOEXCEPT
1120 _GLIBCXX20_CONSTEXPR
1122 operator--(
int) _GLIBCXX_NOEXCEPT
1123 {
return __normal_iterator(_M_current--); }
1126 _GLIBCXX20_CONSTEXPR
1128 operator[](difference_type __n)
const _GLIBCXX_NOEXCEPT
1129 {
return _M_current[__n]; }
1131 _GLIBCXX20_CONSTEXPR
1133 operator+=(difference_type __n) _GLIBCXX_NOEXCEPT
1134 { _M_current += __n;
return *
this; }
1136 _GLIBCXX20_CONSTEXPR
1138 operator+(difference_type __n)
const _GLIBCXX_NOEXCEPT
1139 {
return __normal_iterator(_M_current + __n); }
1141 _GLIBCXX20_CONSTEXPR
1143 operator-=(difference_type __n) _GLIBCXX_NOEXCEPT
1144 { _M_current -= __n;
return *
this; }
1146 _GLIBCXX20_CONSTEXPR
1148 operator-(difference_type __n)
const _GLIBCXX_NOEXCEPT
1149 {
return __normal_iterator(_M_current - __n); }
1151 _GLIBCXX20_CONSTEXPR
1153 base() const _GLIBCXX_NOEXCEPT
1154 {
return _M_current; }
1165#if __cpp_lib_three_way_comparison
1166 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1169 operator==(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1170 const __normal_iterator<_IteratorR, _Container>& __rhs)
1171 noexcept(
noexcept(__lhs.base() == __rhs.base()))
1173 { __lhs.base() == __rhs.base() } -> std::convertible_to<bool>;
1175 {
return __lhs.base() == __rhs.base(); }
1177 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1179 constexpr std::__detail::__synth3way_t<_IteratorR, _IteratorL>
1180 operator<=>(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1181 const __normal_iterator<_IteratorR, _Container>& __rhs)
1182 noexcept(
noexcept(std::__detail::__synth3way(__lhs.base(), __rhs.base())))
1183 {
return std::__detail::__synth3way(__lhs.base(), __rhs.base()); }
1185 template<
typename _Iterator,
typename _Container>
1188 operator==(
const __normal_iterator<_Iterator, _Container>& __lhs,
1189 const __normal_iterator<_Iterator, _Container>& __rhs)
1190 noexcept(
noexcept(__lhs.base() == __rhs.base()))
1192 { __lhs.base() == __rhs.base() } -> std::convertible_to<bool>;
1194 {
return __lhs.base() == __rhs.base(); }
1196 template<
typename _Iterator,
typename _Container>
1198 constexpr std::__detail::__synth3way_t<_Iterator>
1199 operator<=>(
const __normal_iterator<_Iterator, _Container>& __lhs,
1200 const __normal_iterator<_Iterator, _Container>& __rhs)
1201 noexcept(
noexcept(std::__detail::__synth3way(__lhs.base(), __rhs.base())))
1202 {
return std::__detail::__synth3way(__lhs.base(), __rhs.base()); }
1205 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1206 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1208 operator==(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1209 const __normal_iterator<_IteratorR, _Container>& __rhs)
1211 {
return __lhs.base() == __rhs.base(); }
1213 template<
typename _Iterator,
typename _Container>
1214 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1216 operator==(
const __normal_iterator<_Iterator, _Container>& __lhs,
1217 const __normal_iterator<_Iterator, _Container>& __rhs)
1219 {
return __lhs.base() == __rhs.base(); }
1221 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1222 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1224 operator!=(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1225 const __normal_iterator<_IteratorR, _Container>& __rhs)
1227 {
return __lhs.base() != __rhs.base(); }
1229 template<
typename _Iterator,
typename _Container>
1230 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1232 operator!=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1233 const __normal_iterator<_Iterator, _Container>& __rhs)
1235 {
return __lhs.base() != __rhs.base(); }
1238 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1241 operator<(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1242 const __normal_iterator<_IteratorR, _Container>& __rhs)
1244 {
return __lhs.base() < __rhs.base(); }
1246 template<
typename _Iterator,
typename _Container>
1247 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1249 operator<(
const __normal_iterator<_Iterator, _Container>& __lhs,
1250 const __normal_iterator<_Iterator, _Container>& __rhs)
1252 {
return __lhs.base() < __rhs.base(); }
1254 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1257 operator>(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1258 const __normal_iterator<_IteratorR, _Container>& __rhs)
1260 {
return __lhs.base() > __rhs.base(); }
1262 template<
typename _Iterator,
typename _Container>
1263 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1265 operator>(
const __normal_iterator<_Iterator, _Container>& __lhs,
1266 const __normal_iterator<_Iterator, _Container>& __rhs)
1268 {
return __lhs.base() > __rhs.base(); }
1270 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1273 operator<=(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1274 const __normal_iterator<_IteratorR, _Container>& __rhs)
1276 {
return __lhs.base() <= __rhs.base(); }
1278 template<
typename _Iterator,
typename _Container>
1279 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1281 operator<=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1282 const __normal_iterator<_Iterator, _Container>& __rhs)
1284 {
return __lhs.base() <= __rhs.base(); }
1286 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1289 operator>=(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1290 const __normal_iterator<_IteratorR, _Container>& __rhs)
1292 {
return __lhs.base() >= __rhs.base(); }
1294 template<
typename _Iterator,
typename _Container>
1295 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1297 operator>=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1298 const __normal_iterator<_Iterator, _Container>& __rhs)
1300 {
return __lhs.base() >= __rhs.base(); }
1307 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1308#if __cplusplus >= 201103L
1310 [[__nodiscard__]] _GLIBCXX20_CONSTEXPR
1312 operator-(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1313 const __normal_iterator<_IteratorR, _Container>& __rhs)
noexcept
1314 ->
decltype(__lhs.base() - __rhs.base())
1316 inline typename __normal_iterator<_IteratorL, _Container>::difference_type
1317 operator-(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1318 const __normal_iterator<_IteratorR, _Container>& __rhs)
1320 {
return __lhs.base() - __rhs.base(); }
1322 template<
typename _Iterator,
typename _Container>
1323 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1324 inline typename __normal_iterator<_Iterator, _Container>::difference_type
1325 operator-(
const __normal_iterator<_Iterator, _Container>& __lhs,
1326 const __normal_iterator<_Iterator, _Container>& __rhs)
1328 {
return __lhs.base() - __rhs.base(); }
1330 template<
typename _Iterator,
typename _Container>
1331 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1332 inline __normal_iterator<_Iterator, _Container>
1333 operator+(
typename __normal_iterator<_Iterator, _Container>::difference_type
1334 __n,
const __normal_iterator<_Iterator, _Container>& __i)
1336 {
return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
1338_GLIBCXX_END_NAMESPACE_VERSION
1341namespace std _GLIBCXX_VISIBILITY(default)
1343_GLIBCXX_BEGIN_NAMESPACE_VERSION
1345 template<
typename _Iterator,
typename _Container>
1346 _GLIBCXX20_CONSTEXPR
1348 __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it)
1350 {
return __it.base(); }
1352#if __cplusplus >= 201103L
1354#if __cplusplus <= 201703L
1357 template<
typename _Iterator,
typename _Container>
1359 __to_address(
const __gnu_cxx::__normal_iterator<_Iterator,
1360 _Container>& __it)
noexcept
1361 ->
decltype(std::__to_address(__it.base()))
1362 {
return std::__to_address(__it.base()); }
1370#if __cplusplus > 201703L && __glibcxx_concepts
1371 template<semiregular _Sent>
1377 noexcept(is_nothrow_default_constructible_v<_Sent>)
1381 move_sentinel(_Sent __s)
1382 noexcept(is_nothrow_move_constructible_v<_Sent>)
1385 template<
typename _S2>
requires convertible_to<const _S2&, _Sent>
1387 move_sentinel(
const move_sentinel<_S2>& __s)
1388 noexcept(is_nothrow_constructible_v<_Sent, const _S2&>)
1389 : _M_last(__s.base())
1392 template<
typename _S2>
requires assignable_from<_Sent&, const _S2&>
1393 constexpr move_sentinel&
1394 operator=(
const move_sentinel<_S2>& __s)
1395 noexcept(is_nothrow_assignable_v<_Sent, const _S2&>)
1397 _M_last = __s.base();
1404 noexcept(is_nothrow_copy_constructible_v<_Sent>)
1414#if __cplusplus > 201703L && __glibcxx_concepts
1415 template<
typename _Iterator>
1416 struct __move_iter_cat
1419 template<
typename _Iterator>
1420 requires requires {
typename __iter_category_t<_Iterator>; }
1421 struct __move_iter_cat<_Iterator>
1423 using iterator_category
1424 = __clamp_iter_cat<__iter_category_t<_Iterator>,
1425 random_access_iterator_tag>;
1439 template<
typename _Iterator>
1441#if __cplusplus > 201703L && __glibcxx_concepts
1442 :
public __detail::__move_iter_cat<_Iterator>
1445 _Iterator _M_current;
1447 using __traits_type = iterator_traits<_Iterator>;
1448#if ! (__cplusplus > 201703L && __glibcxx_concepts)
1449 using __base_ref =
typename __traits_type::reference;
1452 template<
typename _Iter2>
1453 friend class move_iterator;
1455#if __glibcxx_concepts
1458 template<
typename _Iter2>
1459 static constexpr bool __convertible = !is_same_v<_Iter2, _Iterator>
1460 && convertible_to<const _Iter2&, _Iterator>;
1463#if __cplusplus > 201703L && __glibcxx_concepts
1467 if constexpr (random_access_iterator<_Iterator>)
1468 return random_access_iterator_tag{};
1469 else if constexpr (bidirectional_iterator<_Iterator>)
1470 return bidirectional_iterator_tag{};
1471 else if constexpr (forward_iterator<_Iterator>)
1472 return forward_iterator_tag{};
1474 return input_iterator_tag{};
1479 using iterator_type = _Iterator;
1481#ifdef __glibcxx_move_iterator_concept
1482 using iterator_concept =
decltype(_S_iter_concept());
1485 using value_type = iter_value_t<_Iterator>;
1486 using difference_type = iter_difference_t<_Iterator>;
1487 using pointer = _Iterator;
1488 using reference = iter_rvalue_reference_t<_Iterator>;
1490 typedef typename __traits_type::iterator_category iterator_category;
1491 typedef typename __traits_type::value_type value_type;
1492 typedef typename __traits_type::difference_type difference_type;
1494 typedef _Iterator pointer;
1498 = __conditional_t<is_reference<__base_ref>::value,
1499 typename remove_reference<__base_ref>::type&&,
1503 _GLIBCXX17_CONSTEXPR
1507 explicit _GLIBCXX17_CONSTEXPR
1508 move_iterator(iterator_type __i)
1509 : _M_current(
std::
move(__i)) { }
1511 template<
typename _Iter>
1512#if __glibcxx_concepts
1513 requires __convertible<_Iter>
1515 _GLIBCXX17_CONSTEXPR
1516 move_iterator(
const move_iterator<_Iter>& __i)
1517 : _M_current(__i._M_current) { }
1519 template<
typename _Iter>
1520#if __glibcxx_concepts
1521 requires __convertible<_Iter>
1522 && assignable_from<_Iterator&, const _Iter&>
1524 _GLIBCXX17_CONSTEXPR
1525 move_iterator& operator=(
const move_iterator<_Iter>& __i)
1527 _M_current = __i._M_current;
1531#if __cplusplus <= 201703L
1533 _GLIBCXX17_CONSTEXPR iterator_type
1535 {
return _M_current; }
1538 constexpr const iterator_type&
1539 base() const & noexcept
1540 {
return _M_current; }
1543 constexpr iterator_type
1549 _GLIBCXX17_CONSTEXPR reference
1551#if __cplusplus > 201703L && __glibcxx_concepts
1552 {
return ranges::iter_move(_M_current); }
1554 {
return static_cast<reference
>(*_M_current); }
1558 _GLIBCXX17_CONSTEXPR pointer
1560 {
return _M_current; }
1562 _GLIBCXX17_CONSTEXPR move_iterator&
1569 _GLIBCXX17_CONSTEXPR move_iterator
1572 move_iterator __tmp = *
this;
1577#if __glibcxx_concepts
1579 operator++(
int)
requires (!forward_iterator<_Iterator>)
1583 _GLIBCXX17_CONSTEXPR move_iterator&
1590 _GLIBCXX17_CONSTEXPR move_iterator
1593 move_iterator __tmp = *
this;
1599 _GLIBCXX17_CONSTEXPR move_iterator
1601 {
return move_iterator(_M_current + __n); }
1603 _GLIBCXX17_CONSTEXPR move_iterator&
1604 operator+=(difference_type __n)
1611 _GLIBCXX17_CONSTEXPR move_iterator
1613 {
return move_iterator(_M_current - __n); }
1615 _GLIBCXX17_CONSTEXPR move_iterator&
1616 operator-=(difference_type __n)
1623 _GLIBCXX17_CONSTEXPR reference
1624 operator[](difference_type __n)
const
1625#if __cplusplus > 201703L && __glibcxx_concepts
1626 {
return ranges::iter_move(_M_current + __n); }
1631#if __cplusplus > 201703L && __glibcxx_concepts
1632 template<sentinel_for<_Iterator> _Sent>
1634 friend constexpr bool
1635 operator==(
const move_iterator& __x,
const move_sentinel<_Sent>& __y)
1636 {
return __x.base() == __y.base(); }
1638 template<sized_sentinel_for<_Iterator> _Sent>
1640 friend constexpr iter_difference_t<_Iterator>
1641 operator-(
const move_sentinel<_Sent>& __x,
const move_iterator& __y)
1642 {
return __x.base() - __y.base(); }
1644 template<sized_sentinel_for<_Iterator> _Sent>
1646 friend constexpr iter_difference_t<_Iterator>
1647 operator-(
const move_iterator& __x,
const move_sentinel<_Sent>& __y)
1648 {
return __x.base() - __y.base(); }
1651 friend constexpr iter_rvalue_reference_t<_Iterator>
1652 iter_move(
const move_iterator& __i)
1653 noexcept(
noexcept(ranges::iter_move(__i._M_current)))
1654 {
return ranges::iter_move(__i._M_current); }
1656 template<indirectly_swappable<_Iterator> _Iter2>
1657 friend constexpr void
1658 iter_swap(
const move_iterator& __x,
const move_iterator<_Iter2>& __y)
1659 noexcept(
noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1660 {
return ranges::iter_swap(__x._M_current, __y._M_current); }
1664 template<
typename _IteratorL,
typename _IteratorR>
1666 inline _GLIBCXX17_CONSTEXPR
bool
1667 operator==(
const move_iterator<_IteratorL>& __x,
1668 const move_iterator<_IteratorR>& __y)
1669#if __cplusplus > 201703L && __glibcxx_concepts
1670 requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
1672 {
return __x.base() == __y.base(); }
1674#if __cpp_lib_three_way_comparison
1675 template<
typename _IteratorL,
1676 three_way_comparable_with<_IteratorL> _IteratorR>
1679 operator<=>(
const move_iterator<_IteratorL>& __x,
1680 const move_iterator<_IteratorR>& __y)
1681 {
return __x.base() <=> __y.base(); }
1683 template<
typename _IteratorL,
typename _IteratorR>
1685 inline _GLIBCXX17_CONSTEXPR
bool
1686 operator!=(
const move_iterator<_IteratorL>& __x,
1687 const move_iterator<_IteratorR>& __y)
1688 {
return !(__x == __y); }
1691 template<
typename _IteratorL,
typename _IteratorR>
1693 inline _GLIBCXX17_CONSTEXPR
bool
1694 operator<(
const move_iterator<_IteratorL>& __x,
1695 const move_iterator<_IteratorR>& __y)
1696#if __cplusplus > 201703L && __glibcxx_concepts
1697 requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
1699 {
return __x.base() < __y.base(); }
1701 template<
typename _IteratorL,
typename _IteratorR>
1703 inline _GLIBCXX17_CONSTEXPR
bool
1704 operator<=(
const move_iterator<_IteratorL>& __x,
1705 const move_iterator<_IteratorR>& __y)
1706#if __cplusplus > 201703L && __glibcxx_concepts
1707 requires requires { { __y.base() < __x.base() } -> convertible_to<bool>; }
1709 {
return !(__y < __x); }
1711 template<
typename _IteratorL,
typename _IteratorR>
1713 inline _GLIBCXX17_CONSTEXPR
bool
1714 operator>(
const move_iterator<_IteratorL>& __x,
1715 const move_iterator<_IteratorR>& __y)
1716#if __cplusplus > 201703L && __glibcxx_concepts
1717 requires requires { { __y.base() < __x.base() } -> convertible_to<bool>; }
1719 {
return __y < __x; }
1721 template<
typename _IteratorL,
typename _IteratorR>
1723 inline _GLIBCXX17_CONSTEXPR
bool
1724 operator>=(
const move_iterator<_IteratorL>& __x,
1725 const move_iterator<_IteratorR>& __y)
1726#if __cplusplus > 201703L && __glibcxx_concepts
1727 requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
1729 {
return !(__x < __y); }
1734 template<
typename _Iterator>
1736 inline _GLIBCXX17_CONSTEXPR
bool
1737 operator==(
const move_iterator<_Iterator>& __x,
1738 const move_iterator<_Iterator>& __y)
1740 {
return __x.base() == __y.base(); }
1742#if __cpp_lib_three_way_comparison
1743 template<three_way_comparable _Iterator>
1746 operator<=>(
const move_iterator<_Iterator>& __x,
1747 const move_iterator<_Iterator>& __y)
1748 {
return __x.base() <=> __y.base(); }
1750 template<
typename _Iterator>
1752 inline _GLIBCXX17_CONSTEXPR
bool
1753 operator!=(
const move_iterator<_Iterator>& __x,
1754 const move_iterator<_Iterator>& __y)
1755 {
return !(__x == __y); }
1757 template<
typename _Iterator>
1759 inline _GLIBCXX17_CONSTEXPR
bool
1760 operator<(
const move_iterator<_Iterator>& __x,
1761 const move_iterator<_Iterator>& __y)
1762 {
return __x.base() < __y.base(); }
1764 template<
typename _Iterator>
1766 inline _GLIBCXX17_CONSTEXPR
bool
1767 operator<=(
const move_iterator<_Iterator>& __x,
1768 const move_iterator<_Iterator>& __y)
1769 {
return !(__y < __x); }
1771 template<
typename _Iterator>
1773 inline _GLIBCXX17_CONSTEXPR
bool
1774 operator>(
const move_iterator<_Iterator>& __x,
1775 const move_iterator<_Iterator>& __y)
1776 {
return __y < __x; }
1778 template<
typename _Iterator>
1780 inline _GLIBCXX17_CONSTEXPR
bool
1781 operator>=(
const move_iterator<_Iterator>& __x,
1782 const move_iterator<_Iterator>& __y)
1783 {
return !(__x < __y); }
1787 template<
typename _IteratorL,
typename _IteratorR>
1789 inline _GLIBCXX17_CONSTEXPR
auto
1790 operator-(
const move_iterator<_IteratorL>& __x,
1791 const move_iterator<_IteratorR>& __y)
1792 ->
decltype(__x.base() - __y.base())
1793 {
return __x.base() - __y.base(); }
1795 template<
typename _Iterator>
1797 inline _GLIBCXX17_CONSTEXPR move_iterator<_Iterator>
1798 operator+(
typename move_iterator<_Iterator>::difference_type __n,
1799 const move_iterator<_Iterator>& __x)
1800#ifdef __glibcxx_concepts
1801 requires requires { { __x.base() + __n } -> same_as<_Iterator>; }
1803 {
return __x + __n; }
1805 template<
typename _Iterator>
1807 inline _GLIBCXX17_CONSTEXPR move_iterator<_Iterator>
1808 make_move_iterator(_Iterator __i)
1809 {
return move_iterator<_Iterator>(
std::move(__i)); }
1811 template<
typename _Iterator,
typename _ReturnType
1812 = __conditional_t<__move_if_noexcept_cond
1813 <
typename iterator_traits<_Iterator>::value_type>::value,
1814 _Iterator, move_iterator<_Iterator>>>
1815 inline _GLIBCXX17_CONSTEXPR _ReturnType
1816 __make_move_if_noexcept_iterator(_Iterator __i)
1817 {
return _ReturnType(__i); }
1821 template<
typename _Tp,
typename _ReturnType
1822 = __conditional_t<__move_if_noexcept_cond<_Tp>::value,
1823 const _Tp*, move_iterator<_Tp*>>>
1824 inline _GLIBCXX17_CONSTEXPR _ReturnType
1825 __make_move_if_noexcept_iterator(_Tp* __i)
1826 {
return _ReturnType(__i); }
1828#if __cplusplus > 201703L && __glibcxx_concepts
1831 template<
typename _Iterator1,
typename _Iterator2>
1832 requires (!sized_sentinel_for<_Iterator1, _Iterator2>)
1833 inline constexpr bool
1834 disable_sized_sentinel_for<move_iterator<_Iterator1>,
1835 move_iterator<_Iterator2>> =
true;
1841 template<
typename _It>
1842 concept __common_iter_has_arrow = indirectly_readable<const _It>
1843 && (
requires(
const _It& __it) { __it.operator->(); }
1844 || is_reference_v<iter_reference_t<_It>>
1845 || constructible_from<iter_value_t<_It>, iter_reference_t<_It>>);
1847 template<
typename _It>
1848 concept __common_iter_use_postfix_proxy
1849 = (!
requires (_It& __i) { { *__i++ } -> __can_reference; })
1850 && constructible_from<iter_value_t<_It>, iter_reference_t<_It>>
1851 && move_constructible<iter_value_t<_It>>;
1855 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
1856 requires (!same_as<_It, _Sent>) && copyable<_It>
1859 template<
typename _Tp,
typename _Up>
1860 static constexpr bool
1863 if constexpr (is_trivially_default_constructible_v<_Tp>)
1864 return is_nothrow_assignable_v<_Tp&, _Up>;
1866 return is_nothrow_constructible_v<_Tp, _Up>;
1869 template<
typename _It2,
typename _Sent2>
1870 static constexpr bool
1872 {
return _S_noexcept1<_It, _It2>() && _S_noexcept1<_Sent, _Sent2>(); }
1876 iter_value_t<_It> _M_keep;
1879 __arrow_proxy(iter_reference_t<_It>&& __x)
1885 constexpr const iter_value_t<_It>*
1886 operator->()
const noexcept
1890 class __postfix_proxy
1892 iter_value_t<_It> _M_keep;
1895 __postfix_proxy(iter_reference_t<_It>&& __x)
1896 : _M_keep(
std::forward<iter_reference_t<_It>>(__x)) { }
1901 constexpr const iter_value_t<_It>&
1909 noexcept(is_nothrow_default_constructible_v<_It>)
1910 requires default_initializable<_It>
1911 : _M_it(), _M_index(0)
1916 noexcept(is_nothrow_move_constructible_v<_It>)
1922 noexcept(is_nothrow_move_constructible_v<_Sent>)
1926 template<
typename _It2,
typename _Sent2>
1927 requires convertible_to<const _It2&, _It>
1928 && convertible_to<const _Sent2&, _Sent>
1931 noexcept(_S_noexcept<const _It2&, const _Sent2&>())
1932 : _M_valueless(), _M_index(__x._M_index)
1934 __glibcxx_assert(__x._M_has_value());
1937 if constexpr (is_trivially_default_constructible_v<_It>)
1942 else if (_M_index == 1)
1944 if constexpr (is_trivially_default_constructible_v<_Sent>)
1955 noexcept(_S_noexcept<const _It&, const _Sent&>())
1956 requires (!is_trivially_copyable_v<_It> || !is_trivially_copyable_v<_Sent>)
1957 : _M_valueless(), _M_index(__x._M_index)
1961 if constexpr (is_trivially_default_constructible_v<_It>)
1966 else if (_M_index == 1)
1968 if constexpr (is_trivially_default_constructible_v<_Sent>)
1969 _M_sent = __x._M_sent;
1979 noexcept(_S_noexcept<_It, _Sent>())
1980 requires (!is_trivially_copyable_v<_It> || !is_trivially_copyable_v<_Sent>)
1981 : _M_valueless(), _M_index(__x._M_index)
1985 if constexpr (is_trivially_default_constructible_v<_It>)
1990 else if (_M_index == 1)
1992 if constexpr (is_trivially_default_constructible_v<_Sent>)
2005 noexcept(is_nothrow_copy_assignable_v<_It>
2006 && is_nothrow_copy_assignable_v<_Sent>
2007 && is_nothrow_copy_constructible_v<_It>
2008 && is_nothrow_copy_constructible_v<_Sent>)
2009 requires (!is_trivially_copy_assignable_v<_It>
2010 || !is_trivially_copy_assignable_v<_Sent>)
2021 noexcept(is_nothrow_move_assignable_v<_It>
2022 && is_nothrow_move_assignable_v<_Sent>
2023 && is_nothrow_move_constructible_v<_It>
2024 && is_nothrow_move_constructible_v<_Sent>)
2025 requires (!is_trivially_move_assignable_v<_It>
2026 || !is_trivially_move_assignable_v<_Sent>)
2032 template<
typename _It2,
typename _Sent2>
2033 requires convertible_to<const _It2&, _It>
2034 && convertible_to<const _Sent2&, _Sent>
2035 && assignable_from<_It&, const _It2&>
2036 && assignable_from<_Sent&, const _Sent2&>
2039 noexcept(is_nothrow_constructible_v<_It, const _It2&>
2040 && is_nothrow_constructible_v<_Sent, const _Sent2&>
2041 && is_nothrow_assignable_v<_It&, const _It2&>
2042 && is_nothrow_assignable_v<_Sent&, const _Sent2&>)
2044 __glibcxx_assert(__x._M_has_value());
2049#if __cpp_concepts >= 202002L
2054 requires (!is_trivially_destructible_v<_It>
2055 || !is_trivially_destructible_v<_Sent>)
2063 else if (_M_index == 1)
2068 constexpr decltype(
auto)
2071 __glibcxx_assert(_M_index == 0);
2076 constexpr decltype(
auto)
2077 operator*()
const requires __detail::__dereferenceable<const _It>
2079 __glibcxx_assert(_M_index == 0);
2085 operator->()
const requires __detail::__common_iter_has_arrow<_It>
2087 __glibcxx_assert(_M_index == 0);
2088 if constexpr (is_pointer_v<_It> ||
requires { _M_it.operator->(); })
2090 else if constexpr (is_reference_v<iter_reference_t<_It>>)
2092 auto&& __tmp = *_M_it;
2096 return __arrow_proxy{*_M_it};
2102 __glibcxx_assert(_M_index == 0);
2107 constexpr decltype(
auto)
2110 __glibcxx_assert(_M_index == 0);
2111 if constexpr (forward_iterator<_It>)
2117 else if constexpr (!__detail::__common_iter_use_postfix_proxy<_It>)
2121 __postfix_proxy __p(**
this);
2127 template<
typename _It2, sentinel_for<_It> _Sent2>
2128 requires sentinel_for<_Sent, _It2>
2129 friend constexpr bool
2133 switch(__x._M_index << 2 | __y._M_index)
2139 return __x._M_it == __y._M_sent;
2141 return __x._M_sent == __y._M_it;
2143 __glibcxx_assert(__x._M_has_value());
2144 __glibcxx_assert(__y._M_has_value());
2145 __builtin_unreachable();
2149 template<
typename _It2, sentinel_for<_It> _Sent2>
2150 requires sentinel_for<_Sent, _It2> && equality_comparable_with<_It, _It2>
2151 friend constexpr bool
2155 switch(__x._M_index << 2 | __y._M_index)
2160 return __x._M_it == __y._M_it;
2162 return __x._M_it == __y._M_sent;
2164 return __x._M_sent == __y._M_it;
2166 __glibcxx_assert(__x._M_has_value());
2167 __glibcxx_assert(__y._M_has_value());
2168 __builtin_unreachable();
2172 template<sized_sentinel_for<_It> _It2, sized_sentinel_for<_It> _Sent2>
2173 requires sized_sentinel_for<_Sent, _It2>
2174 friend constexpr iter_difference_t<_It2>
2178 switch(__x._M_index << 2 | __y._M_index)
2183 return __x._M_it - __y._M_it;
2185 return __x._M_it - __y._M_sent;
2187 return __x._M_sent - __y._M_it;
2189 __glibcxx_assert(__x._M_has_value());
2190 __glibcxx_assert(__y._M_has_value());
2191 __builtin_unreachable();
2196 friend constexpr iter_rvalue_reference_t<_It>
2199 requires input_iterator<_It>
2201 __glibcxx_assert(__i._M_index == 0);
2202 return ranges::iter_move(__i._M_it);
2205 template<indirectly_swappable<_It> _It2,
typename _Sent2>
2206 friend constexpr void
2212 __glibcxx_assert(__x._M_index == 0);
2213 __glibcxx_assert(__y._M_index == 0);
2214 return ranges::iter_swap(__x._M_it, __y._M_it);
2218 template<input_or_output_iterator _It2, sentinel_for<_It2> _Sent2>
2219 requires (!same_as<_It2, _Sent2>) && copyable<_It2>
2223 _M_has_value()
const noexcept {
return _M_index != _S_valueless; }
2225 template<
typename _CIt>
2227 _M_assign(_CIt&& __x)
2229 if (_M_index == __x._M_index)
2233 else if (_M_index == 1)
2240 else if (_M_index == 1)
2242 _M_index = _S_valueless;
2244 if (__x._M_index == 0)
2247 else if (__x._M_index == 1)
2250 _M_index = __x._M_index;
2258 unsigned char _M_valueless;
2260 unsigned char _M_index;
2262 static constexpr unsigned char _S_valueless{2};
2265 template<
typename _It,
typename _Sent>
2268 using difference_type = iter_difference_t<_It>;
2271 template<input_iterator _It,
typename _Sent>
2272 struct iterator_traits<common_iterator<_It, _Sent>>
2275 template<
typename _Iter>
2281 template<
typename _Iter>
2282 requires __detail::__common_iter_has_arrow<_Iter>
2285 using _CIter = common_iterator<_Iter, _Sent>;
2292 if constexpr (
requires {
requires derived_from<__iter_category_t<_It>,
2293 forward_iterator_tag>; })
2294 return forward_iterator_tag{};
2296 return input_iterator_tag{};
2300 using iterator_concept = __conditional_t<forward_iterator<_It>,
2301 forward_iterator_tag,
2302 input_iterator_tag>;
2303 using iterator_category =
decltype(_S_iter_cat());
2304 using value_type = iter_value_t<_It>;
2305 using difference_type = iter_difference_t<_It>;
2306 using pointer =
typename __ptr<_It>::type;
2307 using reference = iter_reference_t<_It>;
2314 template<
typename _It>
2315 struct __counted_iter_value_type
2318 template<indirectly_readable _It>
2319 struct __counted_iter_value_type<_It>
2320 {
using value_type = iter_value_t<_It>; };
2322 template<
typename _It>
2323 struct __counted_iter_concept
2326 template<
typename _It>
2327 requires requires {
typename _It::iterator_concept; }
2328 struct __counted_iter_concept<_It>
2329 {
using iterator_concept =
typename _It::iterator_concept; };
2331 template<
typename _It>
2332 struct __counted_iter_cat
2335 template<
typename _It>
2336 requires requires {
typename _It::iterator_category; }
2337 struct __counted_iter_cat<_It>
2338 {
using iterator_category =
typename _It::iterator_category; };
2342 template<input_or_output_iterator _It>
2344 :
public __detail::__counted_iter_value_type<_It>,
2345 public __detail::__counted_iter_concept<_It>,
2346 public __detail::__counted_iter_cat<_It>
2349 using iterator_type = _It;
2351 using difference_type = iter_difference_t<_It>;
2355 constexpr counted_iterator()
requires default_initializable<_It> =
default;
2359 : _M_current(
std::move(__i)), _M_length(__n)
2360 { __glibcxx_assert(__n >= 0); }
2362 template<
typename _It2>
2363 requires convertible_to<const _It2&, _It>
2366 : _M_current(__x._M_current), _M_length(__x._M_length)
2369 template<
typename _It2>
2370 requires assignable_from<_It&, const _It2&>
2374 _M_current = __x._M_current;
2375 _M_length = __x._M_length;
2380 constexpr const _It&
2381 base()
const &
noexcept
2382 {
return _M_current; }
2387 noexcept(is_nothrow_move_constructible_v<_It>)
2391 constexpr iter_difference_t<_It>
2392 count()
const noexcept {
return _M_length; }
2395 constexpr decltype(
auto)
2397 noexcept(
noexcept(*_M_current))
2399 __glibcxx_assert( _M_length > 0 );
2404 constexpr decltype(
auto)
2406 noexcept(
noexcept(*_M_current))
2407 requires __detail::__dereferenceable<const _It>
2409 __glibcxx_assert( _M_length > 0 );
2415 operator->()
const noexcept
2416 requires contiguous_iterator<_It>
2422 __glibcxx_assert(_M_length > 0);
2428 constexpr decltype(
auto)
2431 __glibcxx_assert(_M_length > 0);
2435 return _M_current++;
2438 __throw_exception_again;
2443 operator++(
int)
requires forward_iterator<_It>
2451 operator--()
requires bidirectional_iterator<_It>
2459 operator--(
int)
requires bidirectional_iterator<_It>
2468 operator+(iter_difference_t<_It> __n)
const
2469 requires random_access_iterator<_It>
2475 requires random_access_iterator<_It>
2476 {
return __x + __n; }
2479 operator+=(iter_difference_t<_It> __n)
2480 requires random_access_iterator<_It>
2482 __glibcxx_assert(__n <= _M_length);
2490 operator-(iter_difference_t<_It> __n)
const
2491 requires random_access_iterator<_It>
2494 template<common_with<_It> _It2>
2496 friend constexpr iter_difference_t<_It2>
2499 {
return __y._M_length - __x._M_length; }
2502 friend constexpr iter_difference_t<_It>
2504 {
return -__x._M_length; }
2507 friend constexpr iter_difference_t<_It>
2509 {
return __y._M_length; }
2512 operator-=(iter_difference_t<_It> __n)
2513 requires random_access_iterator<_It>
2515 __glibcxx_assert(-__n <= _M_length);
2522 constexpr decltype(
auto)
2523 operator[](iter_difference_t<_It> __n)
const
2524 noexcept(
noexcept(_M_current[__n]))
2525 requires random_access_iterator<_It>
2527 __glibcxx_assert(__n < _M_length);
2528 return _M_current[__n];
2531 template<common_with<_It> _It2>
2533 friend constexpr bool
2536 {
return __x._M_length == __y._M_length; }
2539 friend constexpr bool
2541 {
return __x._M_length == 0; }
2543 template<common_with<_It> _It2>
2545 friend constexpr strong_ordering
2548 {
return __y._M_length <=> __x._M_length; }
2551 friend constexpr iter_rvalue_reference_t<_It>
2553 noexcept(
noexcept(ranges::iter_move(__i._M_current)))
2554 requires input_iterator<_It>
2556 __glibcxx_assert( __i._M_length > 0 );
2557 return ranges::iter_move(__i._M_current);
2560 template<indirectly_swappable<_It> _It2>
2561 friend constexpr void
2564 noexcept(
noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
2566 __glibcxx_assert( __x._M_length > 0 && __y._M_length > 0 );
2567 ranges::iter_swap(__x._M_current, __y._M_current);
2573 _It _M_current = _It();
2574 iter_difference_t<_It> _M_length = 0;
2577 template<input_iterator _It>
2581 using pointer = __conditional_t<contiguous_iterator<_It>,
2586#if __glibcxx_ranges_as_const
2587 template<indirectly_readable _It>
2588 using iter_const_reference_t
2591 template<input_iterator _It>
class basic_const_iterator;
2595 template<
typename _It>
2596 concept __constant_iterator = input_iterator<_It>
2597 && same_as<iter_const_reference_t<_It>, iter_reference_t<_It>>;
2599 template<
typename _Tp>
2600 inline constexpr bool __is_const_iterator =
false;
2602 template<
typename _It>
2603 inline constexpr bool __is_const_iterator<basic_const_iterator<_It>> =
true;
2605 template<
typename _Tp>
2606 concept __not_a_const_iterator = !__is_const_iterator<_Tp>;
2608 template<indirectly_readable _It>
2609 using __iter_const_rvalue_reference_t
2612 template<
typename _It>
2613 struct __basic_const_iterator_iter_cat
2616 template<forward_iterator _It>
2617 struct __basic_const_iterator_iter_cat<_It>
2618 {
using iterator_category = __iter_category_t<_It>; };
2621 template<input_iterator _It>
2622 using const_iterator
2623 = __conditional_t<__detail::__constant_iterator<_It>, _It, basic_const_iterator<_It>>;
2627 template<
typename _Sent>
2628 struct __const_sentinel
2629 {
using type = _Sent; };
2631 template<input_iterator _Sent>
2632 struct __const_sentinel<_Sent>
2633 {
using type = const_iterator<_Sent>; };
2636 template<semiregular _Sent>
2637 using const_sentinel =
typename __detail::__const_sentinel<_Sent>::type;
2639 template<input_iterator _It>
2640 class basic_const_iterator
2641 :
public __detail::__basic_const_iterator_iter_cat<_It>
2643 _It _M_current = _It();
2644 using __reference = iter_const_reference_t<_It>;
2645 using __rvalue_reference = __detail::__iter_const_rvalue_reference_t<_It>;
2650 if constexpr (contiguous_iterator<_It>)
2651 return contiguous_iterator_tag{};
2652 else if constexpr (random_access_iterator<_It>)
2653 return random_access_iterator_tag{};
2654 else if constexpr (bidirectional_iterator<_It>)
2655 return bidirectional_iterator_tag{};
2656 else if constexpr (forward_iterator<_It>)
2657 return forward_iterator_tag{};
2659 return input_iterator_tag{};
2662 template<input_iterator _It2>
friend class basic_const_iterator;
2665 using iterator_concept =
decltype(_S_iter_concept());
2666 using value_type = iter_value_t<_It>;
2667 using difference_type = iter_difference_t<_It>;
2669 basic_const_iterator()
requires default_initializable<_It> = default;
2672 basic_const_iterator(_It __current)
2673 noexcept(is_nothrow_move_constructible_v<_It>)
2674 : _M_current(
std::move(__current))
2677 template<convertible_to<_It> _It2>
2679 basic_const_iterator(basic_const_iterator<_It2> __current)
2680 noexcept(is_nothrow_constructible_v<_It, _It2>)
2681 : _M_current(
std::
move(__current._M_current))
2684 template<__detail::__different_from<basic_const_iterator> _Tp>
2685 requires convertible_to<_Tp, _It>
2687 basic_const_iterator(_Tp&& __current)
2688 noexcept(is_nothrow_constructible_v<_It, _Tp>)
2692 constexpr const _It&
2693 base() const & noexcept
2694 {
return _M_current; }
2698 noexcept(is_nothrow_move_constructible_v<_It>)
2701 constexpr __reference
2703 noexcept(noexcept(static_cast<__reference>(*_M_current)))
2704 {
return static_cast<__reference
>(*_M_current); }
2706 constexpr const auto*
2708 noexcept(contiguous_iterator<_It> || noexcept(*_M_current))
2709 requires is_lvalue_reference_v<iter_reference_t<_It>>
2710 && same_as<remove_cvref_t<iter_reference_t<_It>>, value_type>
2712 if constexpr (contiguous_iterator<_It>)
2718 constexpr basic_const_iterator&
2720 noexcept(noexcept(++_M_current))
2728 noexcept(
noexcept(++_M_current))
2731 constexpr basic_const_iterator
2733 noexcept(
noexcept(++*
this) && is_nothrow_copy_constructible_v<basic_const_iterator>)
2734 requires forward_iterator<_It>
2741 constexpr basic_const_iterator&
2743 noexcept(noexcept(--_M_current))
2744 requires bidirectional_iterator<_It>
2750 constexpr basic_const_iterator
2752 noexcept(
noexcept(--*
this) && is_nothrow_copy_constructible_v<basic_const_iterator>)
2753 requires bidirectional_iterator<_It>
2760 constexpr basic_const_iterator&
2761 operator+=(difference_type __n)
2762 noexcept(
noexcept(_M_current += __n))
2763 requires random_access_iterator<_It>
2769 constexpr basic_const_iterator&
2770 operator-=(difference_type __n)
2771 noexcept(
noexcept(_M_current -= __n))
2772 requires random_access_iterator<_It>
2778 constexpr __reference
2779 operator[](difference_type __n)
const
2780 noexcept(
noexcept(
static_cast<__reference
>(_M_current[__n])))
2781 requires random_access_iterator<_It>
2782 {
return static_cast<__reference
>(_M_current[__n]); }
2784 template<sentinel_for<_It> _Sent>
2786 operator==(
const _Sent& __s)
const
2787 noexcept(
noexcept(_M_current == __s))
2788 {
return _M_current == __s; }
2790 template<__detail::__not_a_const_iterator _CIt>
2791 requires __detail::__constant_iterator<_CIt> && convertible_to<_It, _CIt>
2793 operator _CIt() const&
2794 {
return _M_current; }
2796 template<__detail::__not_a_const_iterator _CIt>
2797 requires __detail::__constant_iterator<_CIt> && convertible_to<_It, _CIt>
2803 operator<(
const basic_const_iterator& __y)
const
2804 noexcept(
noexcept(_M_current < __y._M_current))
2805 requires random_access_iterator<_It>
2806 {
return _M_current < __y._M_current; }
2809 operator>(
const basic_const_iterator& __y)
const
2810 noexcept(
noexcept(_M_current > __y._M_current))
2811 requires random_access_iterator<_It>
2812 {
return _M_current > __y._M_current; }
2815 operator<=(
const basic_const_iterator& __y)
const
2816 noexcept(
noexcept(_M_current <= __y._M_current))
2817 requires random_access_iterator<_It>
2818 {
return _M_current <= __y._M_current; }
2821 operator>=(
const basic_const_iterator& __y)
const
2822 noexcept(
noexcept(_M_current >= __y._M_current))
2823 requires random_access_iterator<_It>
2824 {
return _M_current >= __y._M_current; }
2827 operator<=>(
const basic_const_iterator& __y)
const
2828 noexcept(
noexcept(_M_current <=> __y._M_current))
2829 requires random_access_iterator<_It> && three_way_comparable<_It>
2830 {
return _M_current <=> __y._M_current; }
2832 template<__detail::__different_from<basic_const_iterator> _It2>
2835 noexcept(
noexcept(_M_current < __y))
2836 requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
2837 {
return _M_current < __y; }
2839 template<__detail::__different_from<basic_const_iterator> _It2>
2842 noexcept(
noexcept(_M_current > __y))
2843 requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
2844 {
return _M_current > __y; }
2846 template<__detail::__different_from<basic_const_iterator> _It2>
2849 noexcept(
noexcept(_M_current <= __y))
2850 requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
2851 {
return _M_current <= __y; }
2853 template<__detail::__different_from<basic_const_iterator> _It2>
2856 noexcept(
noexcept(_M_current >= __y))
2857 requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
2858 {
return _M_current >= __y; }
2860 template<__detail::__different_from<basic_const_iterator> _It2>
2862 operator<=>(
const _It2& __y)
const
2863 noexcept(
noexcept(_M_current <=> __y))
2864 requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
2865 && three_way_comparable_with<_It, _It2>
2866 {
return _M_current <=> __y; }
2868 template<__detail::__not_a_const_iterator _It2, same_as<_It> _It3>
2869 friend constexpr bool
2870 operator<(
const _It2& __x,
const basic_const_iterator<_It3>& __y)
2871 noexcept(
noexcept(__x < __y._M_current))
2872 requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
2873 {
return __x < __y._M_current; }
2875 template<__detail::__not_a_const_iterator _It2, same_as<_It> _It3>
2876 friend constexpr bool
2877 operator>(
const _It2& __x,
const basic_const_iterator<_It3>& __y)
2878 noexcept(
noexcept(__x > __y._M_current))
2879 requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
2880 {
return __x > __y._M_current; }
2882 template<__detail::__not_a_const_iterator _It2, same_as<_It> _It3>
2883 friend constexpr bool
2884 operator<=(
const _It2& __x,
const basic_const_iterator<_It3>& __y)
2885 noexcept(
noexcept(__x <= __y._M_current))
2886 requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
2887 {
return __x <= __y._M_current; }
2889 template<__detail::__not_a_const_iterator _It2, same_as<_It> _It3>
2890 friend constexpr bool
2891 operator>=(
const _It2& __x,
const basic_const_iterator<_It3>& __y)
2892 noexcept(
noexcept(__x >= __y._M_current))
2893 requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
2894 {
return __x >= __y._M_current; }
2896 friend constexpr basic_const_iterator
2897 operator+(
const basic_const_iterator& __i, difference_type __n)
2898 noexcept(
noexcept(basic_const_iterator(__i._M_current + __n)))
2899 requires random_access_iterator<_It>
2900 {
return basic_const_iterator(__i._M_current + __n); }
2902 friend constexpr basic_const_iterator
2903 operator+(difference_type __n,
const basic_const_iterator& __i)
2904 noexcept(
noexcept(basic_const_iterator(__i._M_current + __n)))
2905 requires random_access_iterator<_It>
2906 {
return basic_const_iterator(__i._M_current + __n); }
2908 friend constexpr basic_const_iterator
2909 operator-(
const basic_const_iterator& __i, difference_type __n)
2910 noexcept(
noexcept(basic_const_iterator(__i._M_current - __n)))
2911 requires random_access_iterator<_It>
2912 {
return basic_const_iterator(__i._M_current - __n); }
2914 template<sized_sentinel_for<_It> _Sent>
2915 constexpr difference_type
2917 noexcept(
noexcept(_M_current - __y))
2918 {
return _M_current - __y; }
2920 template<__detail::__not_a_const_iterator _Sent, same_as<_It> _It2>
2921 requires sized_sentinel_for<_Sent, _It>
2922 friend constexpr difference_type
2923 operator-(
const _Sent& __x,
const basic_const_iterator<_It2>& __y)
2924 noexcept(
noexcept(__x - __y._M_current))
2925 {
return __x - __y._M_current; }
2927 friend constexpr __rvalue_reference
2928 iter_move(
const basic_const_iterator& __i)
2929 noexcept(
noexcept(
static_cast<__rvalue_reference
>(ranges::iter_move(__i._M_current))))
2930 {
return static_cast<__rvalue_reference
>(ranges::iter_move(__i._M_current)); }
2933 template<
typename _Tp, common_with<_Tp> _Up>
2934 requires input_iterator<common_type_t<_Tp, _Up>>
2935 struct common_type<basic_const_iterator<_Tp>, _Up>
2936 {
using type = basic_const_iterator<common_type_t<_Tp, _Up>>; };
2938 template<
typename _Tp, common_with<_Tp> _Up>
2939 requires input_iterator<common_type_t<_Tp, _Up>>
2940 struct common_type<_Up, basic_const_iterator<_Tp>>
2941 {
using type = basic_const_iterator<common_type_t<_Tp, _Up>>; };
2943 template<
typename _Tp, common_with<_Tp> _Up>
2944 requires input_iterator<common_type_t<_Tp, _Up>>
2945 struct common_type<basic_const_iterator<_Tp>, basic_const_iterator<_Up>>
2946 {
using type = basic_const_iterator<common_type_t<_Tp, _Up>>; };
2948 template<input_iterator _It>
2949 constexpr const_iterator<_It>
2950 make_const_iterator(_It __it)
2951 noexcept(is_nothrow_convertible_v<_It, const_iterator<_It>>)
2954 template<semiregular _Sent>
2955 constexpr const_sentinel<_Sent>
2956 make_const_sentinel(_Sent __s)
2957 noexcept(is_nothrow_convertible_v<_Sent, const_sentinel<_Sent>>)
2964 template<
typename _Iterator>
2965 _GLIBCXX20_CONSTEXPR
2967 __niter_base(move_iterator<_Iterator> __it)
2968 ->
decltype(make_move_iterator(__niter_base(__it.base())))
2969 {
return make_move_iterator(__niter_base(__it.base())); }
2971 template<
typename _Iterator>
2972 struct __is_move_iterator<move_iterator<_Iterator> >
2974 enum { __value = 1 };
2975 typedef __true_type __type;
2978 template<
typename _Iterator>
2979 _GLIBCXX20_CONSTEXPR
2981 __miter_base(move_iterator<_Iterator> __it)
2982 ->
decltype(__miter_base(__it.base()))
2983 {
return __miter_base(__it.base()); }
2985#define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) std::make_move_iterator(_Iter)
2986#define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) \
2987 std::__make_move_if_noexcept_iterator(_Iter)
2989#define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) (_Iter)
2990#define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) (_Iter)
2993#if __cpp_deduction_guides >= 201606
2996 template<
typename _InputIterator>
2997 using __iter_key_t = remove_const_t<
2998#if __glibcxx_tuple_like
2999 tuple_element_t<0, typename iterator_traits<_InputIterator>::value_type>>;
3001 typename iterator_traits<_InputIterator>::value_type::first_type>;
3004 template<
typename _InputIterator>
3006#if __glibcxx_tuple_like
3007 = tuple_element_t<1, typename iterator_traits<_InputIterator>::value_type>;
3009 =
typename iterator_traits<_InputIterator>::value_type::second_type;
3012 template<
typename _T1,
typename _T2>
3015 template<
typename _InputIterator>
3016 using __iter_to_alloc_t
3020_GLIBCXX_END_NAMESPACE_VERSION
3023#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 common_reference< _Tp... >::type common_reference_t
typename add_pointer< _Tp >::type add_pointer_t
Alias template for add_pointer.
pair(_T1, _T2) -> pair< _T1, _T2 >
Two pairs of the same type are equal iff their members are equal.
auto declval() noexcept -> decltype(__declval< _Tp >(0))
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
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.
constexpr insert_iterator< _Container > inserter(_Container &__x, std::__detail::__range_iter_t< _Container > __i)
constexpr front_insert_iterator< _Container > front_inserter(_Container &__x)
constexpr back_insert_iterator< _Container > back_inserter(_Container &__x)
ISO C++ entities toplevel namespace is std.
typename __detail::__cmp3way_res_impl< _Tp, _Up >::type compare_three_way_result_t
[cmp.result], result of three-way comparison
GNU extensions for public use.
is_nothrow_copy_constructible
Traits class for iterators.
constexpr reverse_iterator & operator-=(difference_type __n)
constexpr reverse_iterator & operator+=(difference_type __n)
constexpr reverse_iterator operator+(difference_type __n) const
constexpr iterator_type base() const noexcept(/*conditional */)
constexpr reference operator[](difference_type __n) const
constexpr reverse_iterator & operator--()
constexpr pointer operator->() const
constexpr reference operator*() const
constexpr reverse_iterator operator-(difference_type __n) const
constexpr reverse_iterator & operator++()
Turns assignment into insertion.
constexpr back_insert_iterator operator++(int)
Simply returns *this. (This iterator does not move.)
constexpr back_insert_iterator & operator++()
Simply returns *this. (This iterator does not move.)
constexpr back_insert_iterator & operator=(const typename _Container::value_type &__value)
_Container container_type
A nested typedef for the type of whatever container you used.
constexpr back_insert_iterator(_Container &__x)
The only way to create this iterator is with a container.
constexpr back_insert_iterator & operator*()
Simply returns *this.
Turns assignment into insertion.
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.
_Container container_type
A nested typedef for the type of whatever container you used.
constexpr front_insert_iterator & operator=(const typename _Container::value_type &__value)
Turns assignment into insertion.
constexpr 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 insert_iterator & operator*()
Simply returns *this.
constexpr insert_iterator & operator=(const typename _Container::value_type &__value)
constexpr insert_iterator & operator++()
Simply returns *this. (This iterator does not move.)
constexpr insert_iterator(_Container &__x, _Iter __i)
An iterator/sentinel adaptor for representing a non-common range.
An iterator adaptor that keeps track of the distance to the end.