60 #ifndef _STL_ITERATOR_H
61 #define _STL_ITERATOR_H 1
69 #if __cplusplus >= 201103L
73 #if __cplusplus > 201703L
74 # define __cpp_lib_array_constexpr 201811L
75 # define __cpp_lib_constexpr_iterator 201811L
76 #elif __cplusplus == 201703L
77 # define __cpp_lib_array_constexpr 201803L
80 #if __cplusplus > 201703L
87 namespace std _GLIBCXX_VISIBILITY(default)
89 _GLIBCXX_BEGIN_NAMESPACE_VERSION
96 #if __cplusplus > 201703L && __cpp_lib_concepts
101 template<
typename _Cat,
typename _Limit,
typename _Otherwise = _Cat>
102 using __clamp_iter_cat
103 = __conditional_t<derived_from<_Cat, _Limit>, _Limit, _Otherwise>;
126 template<
typename _Iterator>
128 :
public iterator<typename iterator_traits<_Iterator>::iterator_category,
129 typename iterator_traits<_Iterator>::value_type,
130 typename iterator_traits<_Iterator>::difference_type,
131 typename iterator_traits<_Iterator>::pointer,
132 typename iterator_traits<_Iterator>::reference>
134 template<
typename _Iter>
137 #if __cpp_lib_concepts
140 template<
typename _Iter>
141 static constexpr
bool __convertible = !is_same_v<_Iter, _Iterator>
142 && convertible_to<const _Iter&, _Iterator>;
151 typedef _Iterator iterator_type;
152 typedef typename __traits_type::pointer pointer;
153 #if __cplusplus <= 201703L
154 typedef typename __traits_type::difference_type difference_type;
155 typedef typename __traits_type::reference reference;
157 using iterator_concept
158 = __conditional_t<random_access_iterator<_Iterator>,
161 using iterator_category
162 = __detail::__clamp_iter_cat<
typename __traits_type::iterator_category,
164 using value_type = iter_value_t<_Iterator>;
165 using difference_type = iter_difference_t<_Iterator>;
166 using reference = iter_reference_t<_Iterator>;
178 _GLIBCXX_NOEXCEPT_IF(noexcept(_Iterator()))
185 explicit _GLIBCXX17_CONSTEXPR
187 _GLIBCXX_NOEXCEPT_IF(noexcept(_Iterator(__x)))
196 _GLIBCXX_NOEXCEPT_IF(noexcept(_Iterator(__x.current)))
197 : current(__x.current)
200 #if __cplusplus >= 201103L
208 template<
typename _Iter>
209 #if __cpp_lib_concepts
214 _GLIBCXX_NOEXCEPT_IF(noexcept(_Iterator(__x.current)))
215 : current(__x.current)
218 #if __cplusplus >= 201103L
219 template<
typename _Iter>
220 #if __cpp_lib_concepts
222 && assignable_from<_Iterator&, const _Iter&>
227 _GLIBCXX_NOEXCEPT_IF(noexcept(current = __x.current))
229 current = __x.current;
238 _GLIBCXX17_CONSTEXPR iterator_type
240 _GLIBCXX_NOEXCEPT_IF(noexcept(_Iterator(current)))
254 _GLIBCXX17_CONSTEXPR reference
257 _Iterator __tmp = current;
267 _GLIBCXX17_CONSTEXPR pointer
269 #if __cplusplus > 201703L && __cpp_concepts >= 201907L
271 ||
requires(
const _Iterator __i) { __i.operator->(); }
276 _Iterator __tmp = current;
278 return _S_to_pointer(__tmp);
286 _GLIBCXX17_CONSTEXPR reverse_iterator&
383 _GLIBCXX17_CONSTEXPR reference
385 {
return *(*
this + __n); }
387 #if __cplusplus > 201703L && __cpp_lib_concepts
389 friend constexpr iter_rvalue_reference_t<_Iterator>
391 noexcept(is_nothrow_copy_constructible_v<_Iterator>
392 && noexcept(ranges::iter_move(--std::declval<_Iterator&>())))
394 auto __tmp = __i.base();
395 return ranges::iter_move(--__tmp);
398 template<indirectly_swappable<_Iterator> _Iter2>
399 friend constexpr
void
400 iter_swap(
const reverse_iterator& __x,
401 const reverse_iterator<_Iter2>& __y)
402 noexcept(is_nothrow_copy_constructible_v<_Iterator>
403 && is_nothrow_copy_constructible_v<_Iter2>
404 && noexcept(ranges::iter_swap(--std::declval<_Iterator&>(),
405 --std::declval<_Iter2&>())))
407 auto __xtmp = __x.base();
408 auto __ytmp = __y.base();
409 ranges::iter_swap(--__xtmp, --__ytmp);
414 template<
typename _Tp>
415 static _GLIBCXX17_CONSTEXPR _Tp*
416 _S_to_pointer(_Tp* __p)
419 template<
typename _Tp>
420 static _GLIBCXX17_CONSTEXPR pointer
421 _S_to_pointer(_Tp __t)
422 {
return __t.operator->(); }
435 #if __cplusplus <= 201703L || ! defined __cpp_lib_concepts
436 template<
typename _Iterator>
438 inline _GLIBCXX17_CONSTEXPR
bool
439 operator==(
const reverse_iterator<_Iterator>& __x,
440 const reverse_iterator<_Iterator>& __y)
441 {
return __x.base() == __y.base(); }
443 template<
typename _Iterator>
445 inline _GLIBCXX17_CONSTEXPR
bool
446 operator<(
const reverse_iterator<_Iterator>& __x,
447 const reverse_iterator<_Iterator>& __y)
448 {
return __y.base() < __x.base(); }
450 template<
typename _Iterator>
452 inline _GLIBCXX17_CONSTEXPR
bool
453 operator!=(
const reverse_iterator<_Iterator>& __x,
454 const reverse_iterator<_Iterator>& __y)
455 {
return !(__x == __y); }
457 template<
typename _Iterator>
459 inline _GLIBCXX17_CONSTEXPR
bool
460 operator>(
const reverse_iterator<_Iterator>& __x,
461 const reverse_iterator<_Iterator>& __y)
462 {
return __y < __x; }
464 template<
typename _Iterator>
466 inline _GLIBCXX17_CONSTEXPR
bool
467 operator<=(
const reverse_iterator<_Iterator>& __x,
468 const reverse_iterator<_Iterator>& __y)
469 {
return !(__y < __x); }
471 template<
typename _Iterator>
473 inline _GLIBCXX17_CONSTEXPR
bool
474 operator>=(
const reverse_iterator<_Iterator>& __x,
475 const reverse_iterator<_Iterator>& __y)
476 {
return !(__x < __y); }
481 template<
typename _IteratorL,
typename _IteratorR>
483 inline _GLIBCXX17_CONSTEXPR
bool
484 operator==(
const reverse_iterator<_IteratorL>& __x,
485 const reverse_iterator<_IteratorR>& __y)
486 {
return __x.base() == __y.base(); }
488 template<
typename _IteratorL,
typename _IteratorR>
490 inline _GLIBCXX17_CONSTEXPR
bool
491 operator<(
const reverse_iterator<_IteratorL>& __x,
492 const reverse_iterator<_IteratorR>& __y)
493 {
return __x.base() > __y.base(); }
495 template<
typename _IteratorL,
typename _IteratorR>
497 inline _GLIBCXX17_CONSTEXPR
bool
498 operator!=(
const reverse_iterator<_IteratorL>& __x,
499 const reverse_iterator<_IteratorR>& __y)
500 {
return __x.base() != __y.base(); }
502 template<
typename _IteratorL,
typename _IteratorR>
504 inline _GLIBCXX17_CONSTEXPR
bool
505 operator>(
const reverse_iterator<_IteratorL>& __x,
506 const reverse_iterator<_IteratorR>& __y)
507 {
return __x.base() < __y.base(); }
509 template<
typename _IteratorL,
typename _IteratorR>
510 inline _GLIBCXX17_CONSTEXPR
bool
511 operator<=(
const reverse_iterator<_IteratorL>& __x,
512 const reverse_iterator<_IteratorR>& __y)
513 {
return __x.base() >= __y.base(); }
515 template<
typename _IteratorL,
typename _IteratorR>
517 inline _GLIBCXX17_CONSTEXPR
bool
518 operator>=(
const reverse_iterator<_IteratorL>& __x,
519 const reverse_iterator<_IteratorR>& __y)
520 {
return __x.base() <= __y.base(); }
522 template<
typename _IteratorL,
typename _IteratorR>
528 {
return __x.base() == __y.base(); }
530 template<
typename _IteratorL,
typename _IteratorR>
533 operator!=(
const reverse_iterator<_IteratorL>& __x,
534 const reverse_iterator<_IteratorR>& __y)
536 {
return __x.base() != __y.base(); }
538 template<
typename _IteratorL,
typename _IteratorR>
541 operator<(
const reverse_iterator<_IteratorL>& __x,
542 const reverse_iterator<_IteratorR>& __y)
544 {
return __x.base() > __y.base(); }
546 template<
typename _IteratorL,
typename _IteratorR>
549 operator>(
const reverse_iterator<_IteratorL>& __x,
550 const reverse_iterator<_IteratorR>& __y)
552 {
return __x.base() < __y.base(); }
554 template<
typename _IteratorL,
typename _IteratorR>
557 operator<=(
const reverse_iterator<_IteratorL>& __x,
558 const reverse_iterator<_IteratorR>& __y)
560 {
return __x.base() >= __y.base(); }
562 template<
typename _IteratorL,
typename _IteratorR>
565 operator>=(
const reverse_iterator<_IteratorL>& __x,
566 const reverse_iterator<_IteratorR>& __y)
568 {
return __x.base() <= __y.base(); }
570 template<
typename _IteratorL,
571 three_way_comparable_with<_IteratorL> _IteratorR>
573 constexpr compare_three_way_result_t<_IteratorL, _IteratorR>
574 operator<=>(
const reverse_iterator<_IteratorL>& __x,
575 const reverse_iterator<_IteratorR>& __y)
576 {
return __y.base() <=> __x.base(); }
580 #if __cplusplus < 201103L
581 template<
typename _Iterator>
582 inline typename reverse_iterator<_Iterator>::difference_type
583 operator-(
const reverse_iterator<_Iterator>& __x,
584 const reverse_iterator<_Iterator>& __y)
585 {
return __y.base() - __x.base(); }
587 template<
typename _IteratorL,
typename _IteratorR>
588 inline typename reverse_iterator<_IteratorL>::difference_type
589 operator-(
const reverse_iterator<_IteratorL>& __x,
590 const reverse_iterator<_IteratorR>& __y)
591 {
return __y.base() - __x.base(); }
595 template<
typename _IteratorL,
typename _IteratorR>
597 inline _GLIBCXX17_CONSTEXPR
auto
598 operator-(
const reverse_iterator<_IteratorL>& __x,
599 const reverse_iterator<_IteratorR>& __y)
600 -> decltype(__y.base() - __x.base())
601 {
return __y.base() - __x.base(); }
604 template<
typename _Iterator>
606 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
607 operator+(
typename reverse_iterator<_Iterator>::difference_type __n,
608 const reverse_iterator<_Iterator>& __x)
609 {
return reverse_iterator<_Iterator>(__x.base() - __n); }
611 #if __cplusplus >= 201103L
613 template<
typename _Iterator>
614 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
615 __make_reverse_iterator(_Iterator __i)
616 {
return reverse_iterator<_Iterator>(__i); }
618 # if __cplusplus >= 201402L
619 # define __cpp_lib_make_reverse_iterator 201402
624 template<
typename _Iterator>
626 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
630 # if __cplusplus > 201703L && defined __cpp_lib_concepts
631 template<
typename _Iterator1,
typename _Iterator2>
632 requires (!sized_sentinel_for<_Iterator1, _Iterator2>)
633 inline constexpr
bool
634 disable_sized_sentinel_for<reverse_iterator<_Iterator1>,
635 reverse_iterator<_Iterator2>> =
true;
639 template<
typename _Iterator>
642 __niter_base(reverse_iterator<_Iterator> __it)
643 -> decltype(__make_reverse_iterator(__niter_base(__it.base())))
644 {
return __make_reverse_iterator(__niter_base(__it.base())); }
646 template<
typename _Iterator>
647 struct __is_move_iterator<reverse_iterator<_Iterator> >
648 : __is_move_iterator<_Iterator>
651 template<
typename _Iterator>
654 __miter_base(reverse_iterator<_Iterator> __it)
655 -> decltype(__make_reverse_iterator(__miter_base(__it.base())))
656 {
return __make_reverse_iterator(__miter_base(__it.base())); }
670 template<
typename _Container>
672 :
public iterator<output_iterator_tag, void, void, void, void>
675 _Container* container;
680 #if __cplusplus > 201703L
681 using difference_type = ptrdiff_t;
685 explicit _GLIBCXX20_CONSTEXPR
700 #if __cplusplus < 201103L
702 operator=(
typename _Container::const_reference __value)
704 container->push_back(__value);
710 operator=(
const typename _Container::value_type& __value)
712 container->push_back(__value);
718 operator=(
typename _Container::value_type&& __value)
720 container->push_back(
std::move(__value));
726 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
755 template<
typename _Container>
756 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
757 inline back_insert_iterator<_Container>
771 template<
typename _Container>
773 :
public iterator<output_iterator_tag, void, void, void, void>
776 _Container* container;
781 #if __cplusplus > 201703L
782 using difference_type = ptrdiff_t;
786 explicit _GLIBCXX20_CONSTEXPR
801 #if __cplusplus < 201103L
803 operator=(
typename _Container::const_reference __value)
805 container->push_front(__value);
811 operator=(
const typename _Container::value_type& __value)
813 container->push_front(__value);
819 operator=(
typename _Container::value_type&& __value)
821 container->push_front(
std::move(__value));
827 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
856 template<
typename _Container>
857 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
858 inline front_insert_iterator<_Container>
876 template<
typename _Container>
878 :
public iterator<output_iterator_tag, void, void, void, void>
880 #if __cplusplus > 201703L && defined __cpp_lib_concepts
881 using _Iter = std::__detail::__range_iter_t<_Container>;
883 typedef typename _Container::iterator _Iter;
886 _Container* container;
893 #if __cplusplus > 201703L && defined __cpp_lib_concepts
894 using difference_type = ptrdiff_t;
928 #if __cplusplus < 201103L
930 operator=(
typename _Container::const_reference __value)
932 iter = container->insert(iter, __value);
939 operator=(
const typename _Container::value_type& __value)
941 iter = container->insert(iter, __value);
948 operator=(
typename _Container::value_type&& __value)
950 iter = container->insert(iter,
std::move(__value));
957 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
987 #if __cplusplus > 201703L && defined __cpp_lib_concepts
988 template<
typename _Container>
990 constexpr insert_iterator<_Container>
991 inserter(_Container& __x, std::__detail::__range_iter_t<_Container> __i)
994 template<
typename _Container>
996 inline insert_iterator<_Container>
997 inserter(_Container& __x,
typename _Container::iterator __i)
998 {
return insert_iterator<_Container>(__x, __i); }
1003 _GLIBCXX_END_NAMESPACE_VERSION
1006 namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
1008 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1017 template<
typename _Iterator,
typename _Container>
1018 class __normal_iterator
1021 _Iterator _M_current;
1025 #if __cplusplus >= 201103L
1026 template<
typename _Iter>
1027 using __convertible_from
1028 = std::__enable_if_t<std::is_convertible<_Iter, _Iterator>::value>;
1032 typedef _Iterator iterator_type;
1033 typedef typename __traits_type::iterator_category iterator_category;
1034 typedef typename __traits_type::value_type value_type;
1035 typedef typename __traits_type::difference_type difference_type;
1036 typedef typename __traits_type::reference reference;
1037 typedef typename __traits_type::pointer pointer;
1039 #if __cplusplus > 201703L && __cpp_lib_concepts
1040 using iterator_concept = std::__detail::__iter_concept<_Iterator>;
1043 _GLIBCXX_CONSTEXPR __normal_iterator() _GLIBCXX_NOEXCEPT
1044 : _M_current(_Iterator()) { }
1046 explicit _GLIBCXX20_CONSTEXPR
1047 __normal_iterator(
const _Iterator& __i) _GLIBCXX_NOEXCEPT
1048 : _M_current(__i) { }
1051 #if __cplusplus >= 201103L
1052 template<
typename _Iter,
typename = __convertible_from<_Iter>>
1053 _GLIBCXX20_CONSTEXPR
1054 __normal_iterator(
const __normal_iterator<_Iter, _Container>& __i)
1059 template<
typename _Iter>
1060 __normal_iterator(
const __normal_iterator<_Iter,
1061 typename __enable_if<
1062 (std::__are_same<_Iter, typename _Container::pointer>::__value),
1063 _Container>::__type>& __i)
1065 : _M_current(__i.base()) { }
1068 _GLIBCXX20_CONSTEXPR
1071 {
return *_M_current; }
1073 _GLIBCXX20_CONSTEXPR
1075 operator->() const _GLIBCXX_NOEXCEPT
1076 {
return _M_current; }
1078 _GLIBCXX20_CONSTEXPR
1080 operator++() _GLIBCXX_NOEXCEPT
1086 _GLIBCXX20_CONSTEXPR
1088 operator++(
int) _GLIBCXX_NOEXCEPT
1089 {
return __normal_iterator(_M_current++); }
1092 _GLIBCXX20_CONSTEXPR
1094 operator--() _GLIBCXX_NOEXCEPT
1100 _GLIBCXX20_CONSTEXPR
1102 operator--(
int) _GLIBCXX_NOEXCEPT
1103 {
return __normal_iterator(_M_current--); }
1106 _GLIBCXX20_CONSTEXPR
1108 operator[](difference_type __n)
const _GLIBCXX_NOEXCEPT
1109 {
return _M_current[__n]; }
1111 _GLIBCXX20_CONSTEXPR
1113 operator+=(difference_type __n) _GLIBCXX_NOEXCEPT
1114 { _M_current += __n;
return *
this; }
1116 _GLIBCXX20_CONSTEXPR
1118 operator+(difference_type __n)
const _GLIBCXX_NOEXCEPT
1119 {
return __normal_iterator(_M_current + __n); }
1121 _GLIBCXX20_CONSTEXPR
1123 operator-=(difference_type __n) _GLIBCXX_NOEXCEPT
1124 { _M_current -= __n;
return *
this; }
1126 _GLIBCXX20_CONSTEXPR
1128 operator-(difference_type __n)
const _GLIBCXX_NOEXCEPT
1129 {
return __normal_iterator(_M_current - __n); }
1131 _GLIBCXX20_CONSTEXPR
1133 base() const _GLIBCXX_NOEXCEPT
1134 {
return _M_current; }
1145 #if __cpp_lib_three_way_comparison
1146 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1149 operator==(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1150 const __normal_iterator<_IteratorR, _Container>& __rhs)
1151 noexcept(noexcept(__lhs.base() == __rhs.base()))
1153 { __lhs.base() == __rhs.base() } -> std::convertible_to<bool>;
1155 {
return __lhs.base() == __rhs.base(); }
1157 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1159 constexpr std::__detail::__synth3way_t<_IteratorR, _IteratorL>
1160 operator<=>(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1161 const __normal_iterator<_IteratorR, _Container>& __rhs)
1162 noexcept(noexcept(std::__detail::__synth3way(__lhs.base(), __rhs.base())))
1163 {
return std::__detail::__synth3way(__lhs.base(), __rhs.base()); }
1166 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1167 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1169 operator==(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1170 const __normal_iterator<_IteratorR, _Container>& __rhs)
1172 {
return __lhs.base() == __rhs.base(); }
1174 template<
typename _Iterator,
typename _Container>
1175 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1177 operator==(
const __normal_iterator<_Iterator, _Container>& __lhs,
1178 const __normal_iterator<_Iterator, _Container>& __rhs)
1180 {
return __lhs.base() == __rhs.base(); }
1182 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1183 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1185 operator!=(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1186 const __normal_iterator<_IteratorR, _Container>& __rhs)
1188 {
return __lhs.base() != __rhs.base(); }
1190 template<
typename _Iterator,
typename _Container>
1191 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1193 operator!=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1194 const __normal_iterator<_Iterator, _Container>& __rhs)
1196 {
return __lhs.base() != __rhs.base(); }
1199 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1202 operator<(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1203 const __normal_iterator<_IteratorR, _Container>& __rhs)
1205 {
return __lhs.base() < __rhs.base(); }
1207 template<
typename _Iterator,
typename _Container>
1208 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1210 operator<(
const __normal_iterator<_Iterator, _Container>& __lhs,
1211 const __normal_iterator<_Iterator, _Container>& __rhs)
1213 {
return __lhs.base() < __rhs.base(); }
1215 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1218 operator>(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1219 const __normal_iterator<_IteratorR, _Container>& __rhs)
1221 {
return __lhs.base() > __rhs.base(); }
1223 template<
typename _Iterator,
typename _Container>
1224 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1226 operator>(
const __normal_iterator<_Iterator, _Container>& __lhs,
1227 const __normal_iterator<_Iterator, _Container>& __rhs)
1229 {
return __lhs.base() > __rhs.base(); }
1231 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1234 operator<=(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1235 const __normal_iterator<_IteratorR, _Container>& __rhs)
1237 {
return __lhs.base() <= __rhs.base(); }
1239 template<
typename _Iterator,
typename _Container>
1240 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1242 operator<=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1243 const __normal_iterator<_Iterator, _Container>& __rhs)
1245 {
return __lhs.base() <= __rhs.base(); }
1247 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1250 operator>=(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1251 const __normal_iterator<_IteratorR, _Container>& __rhs)
1253 {
return __lhs.base() >= __rhs.base(); }
1255 template<
typename _Iterator,
typename _Container>
1256 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1258 operator>=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1259 const __normal_iterator<_Iterator, _Container>& __rhs)
1261 {
return __lhs.base() >= __rhs.base(); }
1268 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1269 #if __cplusplus >= 201103L
1271 [[__nodiscard__]] _GLIBCXX20_CONSTEXPR
1273 operator-(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1274 const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept
1275 -> decltype(__lhs.base() - __rhs.base())
1277 inline typename __normal_iterator<_IteratorL, _Container>::difference_type
1278 operator-(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1279 const __normal_iterator<_IteratorR, _Container>& __rhs)
1281 {
return __lhs.base() - __rhs.base(); }
1283 template<
typename _Iterator,
typename _Container>
1284 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1285 inline typename __normal_iterator<_Iterator, _Container>::difference_type
1286 operator-(
const __normal_iterator<_Iterator, _Container>& __lhs,
1287 const __normal_iterator<_Iterator, _Container>& __rhs)
1289 {
return __lhs.base() - __rhs.base(); }
1291 template<
typename _Iterator,
typename _Container>
1292 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1293 inline __normal_iterator<_Iterator, _Container>
1294 operator+(
typename __normal_iterator<_Iterator, _Container>::difference_type
1295 __n,
const __normal_iterator<_Iterator, _Container>& __i)
1297 {
return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
1299 _GLIBCXX_END_NAMESPACE_VERSION
1302 namespace std _GLIBCXX_VISIBILITY(default)
1304 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1306 template<
typename _Iterator,
typename _Container>
1307 _GLIBCXX20_CONSTEXPR
1309 __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it)
1311 {
return __it.base(); }
1313 #if __cplusplus >= 201103L
1317 template<
typename _Iterator,
typename _Container>
1318 struct pointer_traits<
__gnu_cxx::__normal_iterator<_Iterator, _Container>>
1321 using _Base = pointer_traits<_Iterator>;
1324 using element_type =
typename _Base::element_type;
1325 using pointer = __gnu_cxx::__normal_iterator<_Iterator, _Container>;
1326 using difference_type =
typename _Base::difference_type;
1328 template<
typename _Tp>
1329 using rebind = __gnu_cxx::__normal_iterator<_Tp, _Container>;
1332 pointer_to(element_type& __e) noexcept
1333 {
return pointer(_Base::pointer_to(__e)); }
1335 #if __cplusplus >= 202002L
1336 static element_type*
1338 {
return __p.base(); }
1347 #if __cplusplus > 201703L && __cpp_lib_concepts
1348 template<semiregular _Sent>
1354 noexcept(is_nothrow_default_constructible_v<_Sent>)
1358 move_sentinel(_Sent __s)
1359 noexcept(is_nothrow_move_constructible_v<_Sent>)
1362 template<
typename _S2> requires convertible_to<const _S2&, _Sent>
1364 move_sentinel(
const move_sentinel<_S2>& __s)
1365 noexcept(is_nothrow_constructible_v<_Sent, const _S2&>)
1366 : _M_last(__s.base())
1369 template<
typename _S2> requires assignable_from<_Sent&, const _S2&>
1370 constexpr move_sentinel&
1371 operator=(
const move_sentinel<_S2>& __s)
1372 noexcept(is_nothrow_assignable_v<_Sent, const _S2&>)
1374 _M_last = __s.base();
1381 noexcept(is_nothrow_copy_constructible_v<_Sent>)
1391 #if __cplusplus > 201703L && __cpp_lib_concepts
1392 template<
typename _Iterator>
1393 struct __move_iter_cat
1396 template<
typename _Iterator>
1397 requires requires {
typename iterator_traits<_Iterator>::iterator_category; }
1398 struct __move_iter_cat<_Iterator>
1400 using iterator_category
1401 = __clamp_iter_cat<typename iterator_traits<_Iterator>::iterator_category,
1402 random_access_iterator_tag>;
1416 template<
typename _Iterator>
1418 #if __cplusplus > 201703L && __cpp_lib_concepts
1419 :
public __detail::__move_iter_cat<_Iterator>
1422 _Iterator _M_current;
1425 #if ! (__cplusplus > 201703L && __cpp_lib_concepts)
1426 using __base_ref =
typename __traits_type::reference;
1429 template<
typename _Iter2>
1432 #if __cpp_lib_concepts
1435 template<
typename _Iter2>
1436 static constexpr
bool __convertible = !is_same_v<_Iter2, _Iterator>
1437 && convertible_to<const _Iter2&, _Iterator>;
1441 using iterator_type = _Iterator;
1443 #if __cplusplus > 201703L && __cpp_lib_concepts
1446 using value_type = iter_value_t<_Iterator>;
1447 using difference_type = iter_difference_t<_Iterator>;
1448 using pointer = _Iterator;
1449 using reference = iter_rvalue_reference_t<_Iterator>;
1451 typedef typename __traits_type::iterator_category iterator_category;
1452 typedef typename __traits_type::value_type value_type;
1453 typedef typename __traits_type::difference_type difference_type;
1455 typedef _Iterator pointer;
1459 = __conditional_t<is_reference<__base_ref>::value,
1460 typename remove_reference<__base_ref>::type&&,
1464 _GLIBCXX17_CONSTEXPR
1468 explicit _GLIBCXX17_CONSTEXPR
1472 template<
typename _Iter>
1473 #if __cpp_lib_concepts
1476 _GLIBCXX17_CONSTEXPR
1478 : _M_current(__i._M_current) { }
1480 template<
typename _Iter>
1481 #if __cpp_lib_concepts
1483 && assignable_from<_Iterator&, const _Iter&>
1485 _GLIBCXX17_CONSTEXPR
1488 _M_current = __i._M_current;
1492 #if __cplusplus <= 201703L
1494 _GLIBCXX17_CONSTEXPR iterator_type
1496 {
return _M_current; }
1499 constexpr
const iterator_type&
1500 base()
const & noexcept
1501 {
return _M_current; }
1504 constexpr iterator_type
1510 _GLIBCXX17_CONSTEXPR reference
1512 #if __cplusplus > 201703L && __cpp_lib_concepts
1513 {
return ranges::iter_move(_M_current); }
1515 {
return static_cast<reference
>(*_M_current); }
1519 _GLIBCXX17_CONSTEXPR pointer
1521 {
return _M_current; }
1538 #if __cpp_lib_concepts
1540 operator++(
int)
requires (!forward_iterator<_Iterator>)
1565 operator+=(difference_type __n)
1577 operator-=(difference_type __n)
1584 _GLIBCXX17_CONSTEXPR reference
1585 operator[](difference_type __n)
const
1586 #if __cplusplus > 201703L && __cpp_lib_concepts
1587 {
return ranges::iter_move(_M_current + __n); }
1592 #if __cplusplus > 201703L && __cpp_lib_concepts
1593 template<sentinel_for<_Iterator> _Sent>
1595 friend constexpr
bool
1596 operator==(
const move_iterator& __x,
const move_sentinel<_Sent>& __y)
1597 {
return __x.base() == __y.base(); }
1599 template<sized_sentinel_for<_Iterator> _Sent>
1601 friend constexpr iter_difference_t<_Iterator>
1603 {
return __x.base() - __y.base(); }
1605 template<sized_sentinel_for<_Iterator> _Sent>
1607 friend constexpr iter_difference_t<_Iterator>
1609 {
return __x.base() - __y.base(); }
1612 friend constexpr iter_rvalue_reference_t<_Iterator>
1614 noexcept(noexcept(ranges::iter_move(__i._M_current)))
1615 {
return ranges::iter_move(__i._M_current); }
1617 template<indirectly_swappable<_Iterator> _Iter2>
1618 friend constexpr
void
1620 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1621 {
return ranges::iter_swap(__x._M_current, __y._M_current); }
1625 template<
typename _IteratorL,
typename _IteratorR>
1627 inline _GLIBCXX17_CONSTEXPR
bool
1630 #if __cplusplus > 201703L && __cpp_lib_concepts
1631 requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
1633 {
return __x.base() == __y.base(); }
1635 #if __cpp_lib_three_way_comparison
1636 template<
typename _IteratorL,
1637 three_way_comparable_with<_IteratorL> _IteratorR>
1639 constexpr compare_three_way_result_t<_IteratorL, _IteratorR>
1640 operator<=>(
const move_iterator<_IteratorL>& __x,
1641 const move_iterator<_IteratorR>& __y)
1642 {
return __x.base() <=> __y.base(); }
1644 template<
typename _IteratorL,
typename _IteratorR>
1646 inline _GLIBCXX17_CONSTEXPR
bool
1647 operator!=(
const move_iterator<_IteratorL>& __x,
1648 const move_iterator<_IteratorR>& __y)
1649 {
return !(__x == __y); }
1652 template<
typename _IteratorL,
typename _IteratorR>
1654 inline _GLIBCXX17_CONSTEXPR
bool
1655 operator<(
const move_iterator<_IteratorL>& __x,
1656 const move_iterator<_IteratorR>& __y)
1657 #if __cplusplus > 201703L && __cpp_lib_concepts
1660 {
return __x.base() < __y.base(); }
1662 template<
typename _IteratorL,
typename _IteratorR>
1664 inline _GLIBCXX17_CONSTEXPR
bool
1665 operator<=(
const move_iterator<_IteratorL>& __x,
1666 const move_iterator<_IteratorR>& __y)
1667 #if __cplusplus > 201703L && __cpp_lib_concepts
1670 {
return !(__y < __x); }
1672 template<
typename _IteratorL,
typename _IteratorR>
1674 inline _GLIBCXX17_CONSTEXPR
bool
1675 operator>(
const move_iterator<_IteratorL>& __x,
1676 const move_iterator<_IteratorR>& __y)
1677 #if __cplusplus > 201703L && __cpp_lib_concepts
1680 {
return __y < __x; }
1682 template<
typename _IteratorL,
typename _IteratorR>
1684 inline _GLIBCXX17_CONSTEXPR
bool
1685 operator>=(
const move_iterator<_IteratorL>& __x,
1686 const move_iterator<_IteratorR>& __y)
1687 #if __cplusplus > 201703L && __cpp_lib_concepts
1690 {
return !(__x < __y); }
1692 #if ! (__cplusplus > 201703L && __cpp_lib_concepts)
1700 template<
typename _Iterator>
1702 inline _GLIBCXX17_CONSTEXPR
bool
1703 operator==(
const move_iterator<_Iterator>& __x,
1704 const move_iterator<_Iterator>& __y)
1705 {
return __x.base() == __y.base(); }
1707 template<
typename _Iterator>
1709 inline _GLIBCXX17_CONSTEXPR
bool
1710 operator!=(
const move_iterator<_Iterator>& __x,
1711 const move_iterator<_Iterator>& __y)
1712 {
return !(__x == __y); }
1714 template<
typename _Iterator>
1716 inline _GLIBCXX17_CONSTEXPR
bool
1717 operator<(
const move_iterator<_Iterator>& __x,
1718 const move_iterator<_Iterator>& __y)
1719 {
return __x.base() < __y.base(); }
1721 template<
typename _Iterator>
1723 inline _GLIBCXX17_CONSTEXPR
bool
1724 operator<=(
const move_iterator<_Iterator>& __x,
1725 const move_iterator<_Iterator>& __y)
1726 {
return !(__y < __x); }
1728 template<
typename _Iterator>
1730 inline _GLIBCXX17_CONSTEXPR
bool
1731 operator>(
const move_iterator<_Iterator>& __x,
1732 const move_iterator<_Iterator>& __y)
1733 {
return __y < __x; }
1735 template<
typename _Iterator>
1737 inline _GLIBCXX17_CONSTEXPR
bool
1738 operator>=(
const move_iterator<_Iterator>& __x,
1739 const move_iterator<_Iterator>& __y)
1740 {
return !(__x < __y); }
1744 template<
typename _IteratorL,
typename _IteratorR>
1746 inline _GLIBCXX17_CONSTEXPR
auto
1747 operator-(
const move_iterator<_IteratorL>& __x,
1748 const move_iterator<_IteratorR>& __y)
1749 -> decltype(__x.base() - __y.base())
1750 {
return __x.base() - __y.base(); }
1752 template<
typename _Iterator>
1754 inline _GLIBCXX17_CONSTEXPR move_iterator<_Iterator>
1755 operator+(
typename move_iterator<_Iterator>::difference_type __n,
1756 const move_iterator<_Iterator>& __x)
1757 {
return __x + __n; }
1759 template<
typename _Iterator>
1761 inline _GLIBCXX17_CONSTEXPR move_iterator<_Iterator>
1762 make_move_iterator(_Iterator __i)
1763 {
return move_iterator<_Iterator>(
std::move(__i)); }
1765 template<
typename _Iterator,
typename _ReturnType
1766 = __conditional_t<__move_if_noexcept_cond
1767 <
typename iterator_traits<_Iterator>::value_type>::value,
1768 _Iterator, move_iterator<_Iterator>>>
1769 inline _GLIBCXX17_CONSTEXPR _ReturnType
1770 __make_move_if_noexcept_iterator(_Iterator __i)
1771 {
return _ReturnType(__i); }
1775 template<
typename _Tp,
typename _ReturnType
1776 = __conditional_t<__move_if_noexcept_cond<_Tp>::value,
1777 const _Tp*, move_iterator<_Tp*>>>
1778 inline _GLIBCXX17_CONSTEXPR _ReturnType
1779 __make_move_if_noexcept_iterator(_Tp* __i)
1780 {
return _ReturnType(__i); }
1782 #if __cplusplus > 201703L && __cpp_lib_concepts
1787 template<
typename _It>
1788 concept __common_iter_has_arrow = indirectly_readable<const _It>
1789 && (requires(
const _It& __it) { __it.operator->(); }
1790 || is_reference_v<iter_reference_t<_It>>
1791 || constructible_from<iter_value_t<_It>, iter_reference_t<_It>>);
1793 template<
typename _It>
1794 concept __common_iter_use_postfix_proxy
1795 = (!requires (_It& __i) { { *__i++ } -> __can_reference; })
1801 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
1802 requires (!same_as<_It, _Sent>) && copyable<_It>
1803 class common_iterator
1805 template<
typename _Tp,
typename _Up>
1806 static constexpr
bool
1809 if constexpr (is_trivially_default_constructible_v<_Tp>)
1810 return is_nothrow_assignable_v<_Tp, _Up>;
1812 return is_nothrow_constructible_v<_Tp, _Up>;
1815 template<
typename _It2,
typename _Sent2>
1816 static constexpr
bool
1818 {
return _S_noexcept1<_It, _It2>() && _S_noexcept1<_Sent, _Sent2>(); }
1822 iter_value_t<_It> _M_keep;
1825 __arrow_proxy(iter_reference_t<_It>&& __x)
1828 friend class common_iterator;
1831 constexpr
const iter_value_t<_It>*
1832 operator->()
const noexcept
1836 class __postfix_proxy
1838 iter_value_t<_It> _M_keep;
1841 __postfix_proxy(iter_reference_t<_It>&& __x)
1842 : _M_keep(
std::forward<iter_reference_t<_It>>(__x)) { }
1844 friend class common_iterator;
1847 constexpr
const iter_value_t<_It>&
1855 noexcept(is_nothrow_default_constructible_v<_It>)
1856 requires default_initializable<_It>
1857 : _M_it(), _M_index(0)
1861 common_iterator(_It __i)
1862 noexcept(is_nothrow_move_constructible_v<_It>)
1867 common_iterator(_Sent __s)
1868 noexcept(is_nothrow_move_constructible_v<_Sent>)
1872 template<
typename _It2,
typename _Sent2>
1873 requires convertible_to<const _It2&, _It>
1874 && convertible_to<const _Sent2&, _Sent>
1876 common_iterator(
const common_iterator<_It2, _Sent2>& __x)
1877 noexcept(_S_noexcept<const _It2&, const _Sent2&>())
1878 : _M_valueless(), _M_index(__x._M_index)
1882 if constexpr (is_trivially_default_constructible_v<_It>)
1887 else if (_M_index == 1)
1889 if constexpr (is_trivially_default_constructible_v<_Sent>)
1897 common_iterator(
const common_iterator& __x)
1898 noexcept(_S_noexcept<const _It&, const _Sent&>())
1899 : _M_valueless(), _M_index(__x._M_index)
1903 if constexpr (is_trivially_default_constructible_v<_It>)
1908 else if (_M_index == 1)
1910 if constexpr (is_trivially_default_constructible_v<_Sent>)
1918 operator=(
const common_iterator& __x)
1919 noexcept(is_nothrow_copy_assignable_v<_It>
1920 && is_nothrow_copy_assignable_v<_Sent>
1921 && is_nothrow_copy_constructible_v<_It>
1922 && is_nothrow_copy_constructible_v<_Sent>)
1924 return this->
operator=<_It, _Sent>(__x);
1927 template<
typename _It2,
typename _Sent2>
1928 requires convertible_to<const _It2&, _It>
1929 && convertible_to<const _Sent2&, _Sent>
1930 && assignable_from<_It&, const _It2&>
1931 && assignable_from<_Sent&, const _Sent2&>
1933 operator=(
const common_iterator<_It2, _Sent2>& __x)
1934 noexcept(is_nothrow_constructible_v<_It, const _It2&>
1935 && is_nothrow_constructible_v<_Sent, const _Sent2&>
1936 && is_nothrow_assignable_v<_It, const _It2&>
1937 && is_nothrow_assignable_v<_Sent, const _Sent2&>)
1939 switch(_M_index << 2 | __x._M_index)
1945 _M_sent = __x._M_sent;
1964 __glibcxx_assert(__x._M_has_value());
1965 __builtin_unreachable();
1987 __glibcxx_assert(_M_index == 0);
1995 __glibcxx_assert(_M_index == 0);
2001 operator->()
const requires __detail::__common_iter_has_arrow<_It>
2003 __glibcxx_assert(_M_index == 0);
2004 if constexpr (is_pointer_v<_It> ||
requires { _M_it.operator->(); })
2006 else if constexpr (is_reference_v<iter_reference_t<_It>>)
2008 auto&& __tmp = *_M_it;
2012 return __arrow_proxy{*_M_it};
2018 __glibcxx_assert(_M_index == 0);
2026 __glibcxx_assert(_M_index == 0);
2027 if constexpr (forward_iterator<_It>)
2029 common_iterator __tmp = *
this;
2033 else if constexpr (!__detail::__common_iter_use_postfix_proxy<_It>)
2037 __postfix_proxy __p(**
this);
2043 template<
typename _It2, sentinel_for<_It> _Sent2>
2046 operator== [[nodiscard]] (
const common_iterator& __x,
2047 const common_iterator<_It2, _Sent2>& __y)
2049 switch(__x._M_index << 2 | __y._M_index)
2055 return __x._M_it == __y._M_sent;
2057 return __x._M_sent == __y._M_it;
2059 __glibcxx_assert(__x._M_has_value());
2060 __glibcxx_assert(__y._M_has_value());
2061 __builtin_unreachable();
2065 template<
typename _It2, sentinel_for<_It> _Sent2>
2066 requires sentinel_for<_Sent, _It2> && equality_comparable_with<_It, _It2>
2068 operator== [[nodiscard]] (
const common_iterator& __x,
2069 const common_iterator<_It2, _Sent2>& __y)
2071 switch(__x._M_index << 2 | __y._M_index)
2076 return __x._M_it == __y._M_it;
2078 return __x._M_it == __y._M_sent;
2080 return __x._M_sent == __y._M_it;
2082 __glibcxx_assert(__x._M_has_value());
2083 __glibcxx_assert(__y._M_has_value());
2084 __builtin_unreachable();
2088 template<sized_sentinel_for<_It> _It2, sized_sentinel_for<_It> _Sent2>
2089 requires sized_sentinel_for<_Sent, _It2>
2090 friend iter_difference_t<_It2>
2091 operator- [[nodiscard]] (
const common_iterator& __x,
2092 const common_iterator<_It2, _Sent2>& __y)
2094 switch(__x._M_index << 2 | __y._M_index)
2099 return __x._M_it - __y._M_it;
2101 return __x._M_it - __y._M_sent;
2103 return __x._M_sent - __y._M_it;
2105 __glibcxx_assert(__x._M_has_value());
2106 __glibcxx_assert(__y._M_has_value());
2107 __builtin_unreachable();
2112 friend iter_rvalue_reference_t<_It>
2113 iter_move(
const common_iterator& __i)
2114 noexcept(noexcept(ranges::iter_move(std::declval<const _It&>())))
2117 __glibcxx_assert(__i._M_index == 0);
2118 return ranges::iter_move(__i._M_it);
2121 template<indirectly_swappable<_It> _It2,
typename _Sent2>
2123 iter_swap(
const common_iterator& __x,
2124 const common_iterator<_It2, _Sent2>& __y)
2125 noexcept(noexcept(ranges::iter_swap(std::declval<const _It&>(),
2126 std::declval<const _It2&>())))
2128 __glibcxx_assert(__x._M_index == 0);
2129 __glibcxx_assert(__y._M_index == 0);
2130 return ranges::iter_swap(__x._M_it, __y._M_it);
2134 template<input_or_output_iterator _It2, sentinel_for<_It2> _Sent2>
2135 friend class common_iterator;
2137 bool _M_has_value()
const noexcept {
return _M_index < 2; }
2143 unsigned char _M_valueless;
2145 unsigned char _M_index;
2148 template<
typename _It,
typename _Sent>
2149 struct incrementable_traits<common_iterator<_It, _Sent>>
2151 using difference_type = iter_difference_t<_It>;
2154 template<input_iterator _It,
typename _Sent>
2155 struct iterator_traits<common_iterator<_It, _Sent>>
2158 template<
typename _Iter>
2164 template<
typename _Iter>
2165 requires __detail::__common_iter_has_arrow<_Iter>
2168 using _CIter = common_iterator<_Iter, _Sent>;
2169 using type = decltype(std::declval<const _CIter&>().operator->());
2175 using _Traits = iterator_traits<_It>;
2176 if constexpr (requires { requires
derived_from<
typename _Traits::iterator_category,
2177 forward_iterator_tag>; })
2178 return forward_iterator_tag{};
2180 return input_iterator_tag{};
2184 using iterator_concept = __conditional_t<forward_iterator<_It>,
2185 forward_iterator_tag,
2186 input_iterator_tag>;
2187 using iterator_category = decltype(_S_iter_cat());
2188 using value_type = iter_value_t<_It>;
2189 using difference_type = iter_difference_t<_It>;
2190 using pointer =
typename __ptr<_It>::type;
2191 using reference = iter_reference_t<_It>;
2198 template<
typename _It>
2199 struct __counted_iter_value_type
2202 template<indirectly_readable _It>
2203 struct __counted_iter_value_type<_It>
2204 {
using value_type = iter_value_t<_It>; };
2206 template<
typename _It>
2207 struct __counted_iter_concept
2210 template<
typename _It>
2211 requires requires {
typename _It::iterator_concept; }
2212 struct __counted_iter_concept<_It>
2213 {
using iterator_concept =
typename _It::iterator_concept; };
2215 template<
typename _It>
2216 struct __counted_iter_cat
2219 template<
typename _It>
2220 requires requires {
typename _It::iterator_category; }
2221 struct __counted_iter_cat<_It>
2222 {
using iterator_category =
typename _It::iterator_category; };
2226 template<input_or_output_iterator _It>
2228 :
public __detail::__counted_iter_value_type<_It>,
2229 public __detail::__counted_iter_concept<_It>,
2230 public __detail::__counted_iter_cat<_It>
2233 using iterator_type = _It;
2235 using difference_type = iter_difference_t<_It>;
2239 constexpr
counted_iterator() requires default_initializable<_It> =
default;
2243 : _M_current(
std::move(__i)), _M_length(__n)
2244 { __glibcxx_assert(__n >= 0); }
2246 template<
typename _It2>
2247 requires convertible_to<const _It2&, _It>
2250 : _M_current(__x._M_current), _M_length(__x._M_length)
2253 template<
typename _It2>
2254 requires assignable_from<_It&, const _It2&>
2258 _M_current = __x._M_current;
2259 _M_length = __x._M_length;
2264 constexpr
const _It&
2265 base()
const & noexcept
2266 {
return _M_current; }
2271 noexcept(is_nothrow_move_constructible_v<_It>)
2275 constexpr iter_difference_t<_It>
2276 count()
const noexcept {
return _M_length; }
2279 constexpr decltype(
auto)
2281 noexcept(noexcept(*_M_current))
2283 __glibcxx_assert( _M_length > 0 );
2288 constexpr decltype(
auto)
2290 noexcept(noexcept(*_M_current))
2291 requires __detail::__dereferenceable<const _It>
2293 __glibcxx_assert( _M_length > 0 );
2299 operator->()
const noexcept
2300 requires contiguous_iterator<_It>
2306 __glibcxx_assert(_M_length > 0);
2315 __glibcxx_assert(_M_length > 0);
2319 return _M_current++;
2322 __throw_exception_again;
2328 operator++(
int) requires forward_iterator<_It>
2336 operator--() requires bidirectional_iterator<_It>
2344 operator--(
int) requires bidirectional_iterator<_It>
2353 operator+(iter_difference_t<_It> __n)
const
2354 requires random_access_iterator<_It>
2360 requires random_access_iterator<_It>
2361 {
return __x + __n; }
2364 operator+=(iter_difference_t<_It> __n)
2365 requires random_access_iterator<_It>
2367 __glibcxx_assert(__n <= _M_length);
2375 operator-(iter_difference_t<_It> __n)
const
2376 requires random_access_iterator<_It>
2379 template<common_with<_It> _It2>
2381 friend constexpr iter_difference_t<_It2>
2384 {
return __y._M_length - __x._M_length; }
2387 friend constexpr iter_difference_t<_It>
2389 {
return -__x._M_length; }
2392 friend constexpr iter_difference_t<_It>
2394 {
return __y._M_length; }
2397 operator-=(iter_difference_t<_It> __n)
2398 requires random_access_iterator<_It>
2400 __glibcxx_assert(-__n <= _M_length);
2407 constexpr decltype(
auto)
2408 operator[](iter_difference_t<_It> __n)
const
2409 noexcept(noexcept(_M_current[__n]))
2410 requires random_access_iterator<_It>
2412 __glibcxx_assert(__n < _M_length);
2413 return _M_current[__n];
2416 template<common_with<_It> _It2>
2418 friend constexpr
bool
2421 {
return __x._M_length == __y._M_length; }
2424 friend constexpr
bool
2426 {
return __x._M_length == 0; }
2428 template<common_with<_It> _It2>
2430 friend constexpr strong_ordering
2433 {
return __y._M_length <=> __x._M_length; }
2436 friend constexpr iter_rvalue_reference_t<_It>
2438 noexcept(noexcept(ranges::iter_move(__i._M_current)))
2439 requires input_iterator<_It>
2441 __glibcxx_assert( __i._M_length > 0 );
2442 return ranges::iter_move(__i._M_current);
2445 template<indirectly_swappable<_It> _It2>
2446 friend constexpr
void
2449 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
2451 __glibcxx_assert( __x._M_length > 0 && __y._M_length > 0 );
2452 ranges::iter_swap(__x._M_current, __y._M_current);
2458 _It _M_current = _It();
2459 iter_difference_t<_It> _M_length = 0;
2462 template<input_iterator _It>
2466 using pointer = __conditional_t<contiguous_iterator<_It>,
2474 template<
typename _Iterator>
2475 _GLIBCXX20_CONSTEXPR
2477 __niter_base(move_iterator<_Iterator> __it)
2478 -> decltype(make_move_iterator(__niter_base(__it.base())))
2479 {
return make_move_iterator(__niter_base(__it.base())); }
2481 template<
typename _Iterator>
2482 struct __is_move_iterator<move_iterator<_Iterator> >
2484 enum { __value = 1 };
2485 typedef __true_type __type;
2488 template<
typename _Iterator>
2489 _GLIBCXX20_CONSTEXPR
2491 __miter_base(move_iterator<_Iterator> __it)
2492 -> decltype(__miter_base(__it.base()))
2493 {
return __miter_base(__it.base()); }
2495 #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) std::make_move_iterator(_Iter)
2496 #define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) \
2497 std::__make_move_if_noexcept_iterator(_Iter)
2499 #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) (_Iter)
2500 #define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) (_Iter)
2503 #if __cpp_deduction_guides >= 201606
2506 template<
typename _InputIterator>
2508 typename iterator_traits<_InputIterator>::value_type::first_type>;
2510 template<
typename _InputIterator>
2511 using __iter_val_t =
2512 typename iterator_traits<_InputIterator>::value_type::second_type;
2514 template<
typename _T1,
typename _T2>
2517 template<
typename _InputIterator>
2518 using __iter_to_alloc_t =
2519 pair<add_const_t<__iter_key_t<_InputIterator>>,
2520 __iter_val_t<_InputIterator>>;
2523 _GLIBCXX_END_NAMESPACE_VERSION
2526 #ifdef _GLIBCXX_DEBUG
constexpr complex< _Tp > operator*(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x times y.
constexpr complex< _Tp > operator-(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x minus y.
constexpr complex< _Tp > operator+(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x plus y.
constexpr _Tp * to_address(_Tp *__ptr) noexcept
Obtain address referenced by a pointer to an object.
typename remove_const< _Tp >::type remove_const_t
Alias template for remove_const.
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.
concept derived_from
[concept.derived], concept derived_from
concept move_constructible
[concept.moveconstructible], concept move_constructible
concept constructible_from
[concept.constructible], concept constructible_from
GNU extensions for public use.
is_nothrow_copy_constructible
Traits class for iterators.
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.
An iterator adaptor that keeps track of the distance to the end.
Bidirectional iterators support a superset of forward iterator operations.
Random-access iterators support a superset of bidirectional iterator operations.