60 #ifndef _STL_ITERATOR_H
61 #define _STL_ITERATOR_H 1
68 #if __cplusplus >= 201103L
72 #if __cplusplus > 201703L
73 # define __cpp_lib_array_constexpr 201811L
74 # define __cpp_lib_constexpr_iterator 201811L
75 #elif __cplusplus == 201703L
76 # define __cpp_lib_array_constexpr 201803L
79 #if __cplusplus > 201703L
85 namespace std _GLIBCXX_VISIBILITY(default)
87 _GLIBCXX_BEGIN_NAMESPACE_VERSION
94 #if __cplusplus > 201703L && __cpp_lib_concepts
99 template<
typename _Cat,
typename _Limit,
typename _Otherwise = _Cat>
100 using __clamp_iter_cat
101 = conditional_t<derived_from<_Cat, _Limit>, _Limit, _Otherwise>;
124 template<
typename _Iterator>
126 :
public iterator<typename iterator_traits<_Iterator>::iterator_category,
127 typename iterator_traits<_Iterator>::value_type,
128 typename iterator_traits<_Iterator>::difference_type,
129 typename iterator_traits<_Iterator>::pointer,
130 typename iterator_traits<_Iterator>::reference>
138 typedef _Iterator iterator_type;
139 typedef typename __traits_type::difference_type difference_type;
140 typedef typename __traits_type::pointer pointer;
141 typedef typename __traits_type::reference reference;
143 #if __cplusplus > 201703L && __cpp_lib_concepts
144 using iterator_concept
149 = __detail::__clamp_iter_cat<
typename __traits_type::iterator_category,
166 explicit _GLIBCXX17_CONSTEXPR
174 : current(__x.current) { }
176 #if __cplusplus >= 201103L
184 template<
typename _Iter>
187 : current(__x.
base()) { }
192 _GLIBCXX17_CONSTEXPR iterator_type
206 _GLIBCXX17_CONSTEXPR reference
209 _Iterator __tmp = current;
218 _GLIBCXX17_CONSTEXPR pointer
220 #if __cplusplus > 201703L && __cpp_concepts >= 201907L
221 requires is_pointer_v<_Iterator>
222 || requires(
const _Iterator __i) { __i.operator->(); }
227 _Iterator __tmp = current;
229 return _S_to_pointer(__tmp);
331 _GLIBCXX17_CONSTEXPR reference
333 {
return *(*
this + __n); }
335 #if __cplusplus > 201703L && __cpp_lib_concepts
336 friend constexpr iter_rvalue_reference_t<_Iterator>
338 noexcept(is_nothrow_copy_constructible_v<_Iterator>
339 && noexcept(ranges::iter_move(--std::declval<_Iterator&>())))
341 auto __tmp = __i.base();
342 return ranges::iter_move(--__tmp);
345 template<indirectly_swappable<_Iterator> _Iter2>
346 friend constexpr
void
348 const reverse_iterator<_Iter2>& __y)
349 noexcept(is_nothrow_copy_constructible_v<_Iterator>
350 && is_nothrow_copy_constructible_v<_Iter2>
351 && noexcept(ranges::iter_swap(--std::declval<_Iterator&>(),
352 --std::declval<_Iter2&>())))
354 auto __xtmp = __x.base();
355 auto __ytmp = __y.base();
356 ranges::iter_swap(--__xtmp, --__ytmp);
361 template<
typename _Tp>
362 static _GLIBCXX17_CONSTEXPR _Tp*
363 _S_to_pointer(_Tp* __p)
366 template<
typename _Tp>
367 static _GLIBCXX17_CONSTEXPR pointer
368 _S_to_pointer(_Tp __t)
369 {
return __t.operator->(); }
382 #if __cplusplus <= 201703L || ! defined __cpp_lib_concepts
383 template<
typename _Iterator>
384 inline _GLIBCXX17_CONSTEXPR
bool
387 {
return __x.
base() == __y.
base(); }
389 template<
typename _Iterator>
390 inline _GLIBCXX17_CONSTEXPR
bool
391 operator<(
const reverse_iterator<_Iterator>& __x,
392 const reverse_iterator<_Iterator>& __y)
393 {
return __y.base() < __x.base(); }
395 template<
typename _Iterator>
396 inline _GLIBCXX17_CONSTEXPR
bool
397 operator!=(
const reverse_iterator<_Iterator>& __x,
398 const reverse_iterator<_Iterator>& __y)
399 {
return !(__x == __y); }
401 template<
typename _Iterator>
402 inline _GLIBCXX17_CONSTEXPR
bool
403 operator>(
const reverse_iterator<_Iterator>& __x,
404 const reverse_iterator<_Iterator>& __y)
405 {
return __y < __x; }
407 template<
typename _Iterator>
408 inline _GLIBCXX17_CONSTEXPR
bool
409 operator<=(
const reverse_iterator<_Iterator>& __x,
410 const reverse_iterator<_Iterator>& __y)
411 {
return !(__y < __x); }
413 template<
typename _Iterator>
414 inline _GLIBCXX17_CONSTEXPR
bool
415 operator>=(
const reverse_iterator<_Iterator>& __x,
416 const reverse_iterator<_Iterator>& __y)
417 {
return !(__x < __y); }
421 template<
typename _IteratorL,
typename _IteratorR>
422 inline _GLIBCXX17_CONSTEXPR
bool
423 operator==(
const reverse_iterator<_IteratorL>& __x,
424 const reverse_iterator<_IteratorR>& __y)
425 {
return __x.base() == __y.base(); }
427 template<
typename _IteratorL,
typename _IteratorR>
428 inline _GLIBCXX17_CONSTEXPR
bool
429 operator<(
const reverse_iterator<_IteratorL>& __x,
430 const reverse_iterator<_IteratorR>& __y)
431 {
return __y.base() < __x.base(); }
433 template<
typename _IteratorL,
typename _IteratorR>
434 inline _GLIBCXX17_CONSTEXPR
bool
435 operator!=(
const reverse_iterator<_IteratorL>& __x,
436 const reverse_iterator<_IteratorR>& __y)
437 {
return !(__x == __y); }
439 template<
typename _IteratorL,
typename _IteratorR>
440 inline _GLIBCXX17_CONSTEXPR
bool
441 operator>(
const reverse_iterator<_IteratorL>& __x,
442 const reverse_iterator<_IteratorR>& __y)
443 {
return __y < __x; }
445 template<
typename _IteratorL,
typename _IteratorR>
446 inline _GLIBCXX17_CONSTEXPR
bool
447 operator<=(
const reverse_iterator<_IteratorL>& __x,
448 const reverse_iterator<_IteratorR>& __y)
449 {
return !(__y < __x); }
451 template<
typename _IteratorL,
typename _IteratorR>
452 inline _GLIBCXX17_CONSTEXPR
bool
453 operator>=(
const reverse_iterator<_IteratorL>& __x,
454 const reverse_iterator<_IteratorR>& __y)
455 {
return !(__x < __y); }
457 template<
typename _IteratorL,
typename _IteratorR>
459 operator==(
const reverse_iterator<_IteratorL>& __x,
460 const reverse_iterator<_IteratorR>& __y)
461 requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
462 {
return __x.base() == __y.base(); }
464 template<
typename _IteratorL,
typename _IteratorR>
466 operator!=(
const reverse_iterator<_IteratorL>& __x,
467 const reverse_iterator<_IteratorR>& __y)
468 requires requires { { __x.base() != __y.base() } -> convertible_to<bool>; }
469 {
return __x.base() != __y.base(); }
471 template<
typename _IteratorL,
typename _IteratorR>
473 operator<(
const reverse_iterator<_IteratorL>& __x,
474 const reverse_iterator<_IteratorR>& __y)
475 requires requires { { __x.base() > __y.base() } -> convertible_to<bool>; }
476 {
return __x.base() > __y.base(); }
478 template<
typename _IteratorL,
typename _IteratorR>
480 operator>(
const reverse_iterator<_IteratorL>& __x,
481 const reverse_iterator<_IteratorR>& __y)
482 requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
483 {
return __x.base() < __y.base(); }
485 template<
typename _IteratorL,
typename _IteratorR>
487 operator<=(
const reverse_iterator<_IteratorL>& __x,
488 const reverse_iterator<_IteratorR>& __y)
489 requires requires { { __x.base() >= __y.base() } -> convertible_to<bool>; }
490 {
return __x.base() >= __y.base(); }
492 template<
typename _IteratorL,
typename _IteratorR>
494 operator>=(
const reverse_iterator<_IteratorL>& __x,
495 const reverse_iterator<_IteratorR>& __y)
496 requires requires { { __x.base() <= __y.base() } -> convertible_to<bool>; }
497 {
return __x.base() <= __y.base(); }
499 template<
typename _IteratorL,
500 three_way_comparable_with<_IteratorL> _IteratorR>
501 constexpr compare_three_way_result_t<_IteratorL, _IteratorR>
502 operator<=>(
const reverse_iterator<_IteratorL>& __x,
503 const reverse_iterator<_IteratorR>& __y)
504 {
return __y.base() <=> __x.base(); }
508 #if __cplusplus < 201103L
509 template<
typename _Iterator>
510 inline typename reverse_iterator<_Iterator>::difference_type
511 operator-(
const reverse_iterator<_Iterator>& __x,
512 const reverse_iterator<_Iterator>& __y)
513 {
return __y.base() - __x.base(); }
515 template<
typename _IteratorL,
typename _IteratorR>
516 inline typename reverse_iterator<_IteratorL>::difference_type
517 operator-(
const reverse_iterator<_IteratorL>& __x,
518 const reverse_iterator<_IteratorR>& __y)
519 {
return __y.base() - __x.base(); }
523 template<
typename _IteratorL,
typename _IteratorR>
524 inline _GLIBCXX17_CONSTEXPR
auto
525 operator-(
const reverse_iterator<_IteratorL>& __x,
526 const reverse_iterator<_IteratorR>& __y)
527 -> decltype(__y.base() - __x.base())
528 {
return __y.base() - __x.base(); }
531 template<
typename _Iterator>
532 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
533 operator+(
typename reverse_iterator<_Iterator>::difference_type __n,
534 const reverse_iterator<_Iterator>& __x)
535 {
return reverse_iterator<_Iterator>(__x.base() - __n); }
537 #if __cplusplus >= 201103L
539 template<
typename _Iterator>
540 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
541 __make_reverse_iterator(_Iterator __i)
542 {
return reverse_iterator<_Iterator>(__i); }
544 # if __cplusplus >= 201402L
545 # define __cpp_lib_make_reverse_iterator 201402
550 template<
typename _Iterator>
551 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
555 # if __cplusplus > 201703L && defined __cpp_lib_concepts
556 template<
typename _Iterator1,
typename _Iterator2>
557 requires (!sized_sentinel_for<_Iterator1, _Iterator2>)
558 inline constexpr
bool
559 disable_sized_sentinel_for<reverse_iterator<_Iterator1>,
560 reverse_iterator<_Iterator2>> =
true;
564 template<
typename _Iterator>
567 __niter_base(reverse_iterator<_Iterator> __it)
568 -> decltype(__make_reverse_iterator(__niter_base(__it.base())))
569 {
return __make_reverse_iterator(__niter_base(__it.base())); }
571 template<
typename _Iterator>
572 struct __is_move_iterator<reverse_iterator<_Iterator> >
573 : __is_move_iterator<_Iterator>
576 template<
typename _Iterator>
579 __miter_base(reverse_iterator<_Iterator> __it)
580 -> decltype(__make_reverse_iterator(__miter_base(__it.base())))
581 {
return __make_reverse_iterator(__miter_base(__it.base())); }
595 template<
typename _Container>
597 :
public iterator<output_iterator_tag, void, void, void, void>
600 _Container* container;
605 #if __cplusplus > 201703L
612 explicit _GLIBCXX20_CONSTEXPR
627 #if __cplusplus < 201103L
629 operator=(
typename _Container::const_reference __value)
631 container->push_back(__value);
637 operator=(
const typename _Container::value_type& __value)
639 container->push_back(__value);
645 operator=(
typename _Container::value_type&& __value)
647 container->push_back(
std::move(__value));
682 template<
typename _Container>
684 inline back_insert_iterator<_Container>
698 template<
typename _Container>
700 :
public iterator<output_iterator_tag, void, void, void, void>
703 _Container* container;
708 #if __cplusplus > 201703L
715 explicit _GLIBCXX20_CONSTEXPR
730 #if __cplusplus < 201103L
732 operator=(
typename _Container::const_reference __value)
734 container->push_front(__value);
740 operator=(
const typename _Container::value_type& __value)
742 container->push_front(__value);
748 operator=(
typename _Container::value_type&& __value)
750 container->push_front(
std::move(__value));
785 template<
typename _Container>
787 inline front_insert_iterator<_Container>
805 template<
typename _Container>
807 :
public iterator<output_iterator_tag, void, void, void, void>
809 #if __cplusplus > 201703L && defined __cpp_lib_concepts
810 using _Iter = std::__detail::__range_iter_t<_Container>;
813 _Container* container =
nullptr;
814 _Iter iter = _Iter();
816 typedef typename _Container::iterator _Iter;
819 _Container* container;
827 #if __cplusplus > 201703L && defined __cpp_lib_concepts
864 #if __cplusplus < 201103L
866 operator=(
typename _Container::const_reference __value)
868 iter = container->insert(iter, __value);
875 operator=(
const typename _Container::value_type& __value)
877 iter = container->insert(iter, __value);
884 operator=(
typename _Container::value_type&& __value)
886 iter = container->insert(iter,
std::move(__value));
923 #if __cplusplus > 201703L && defined __cpp_lib_concepts
924 template<
typename _Container>
925 constexpr insert_iterator<_Container>
926 inserter(_Container& __x, std::__detail::__range_iter_t<_Container> __i)
927 {
return insert_iterator<_Container>(__x, __i); }
929 template<
typename _Container>
930 inline insert_iterator<_Container>
931 inserter(_Container& __x,
typename _Container::iterator __i)
937 _GLIBCXX_END_NAMESPACE_VERSION
940 namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
942 _GLIBCXX_BEGIN_NAMESPACE_VERSION
951 template<
typename _Iterator,
typename _Container>
952 class __normal_iterator
955 _Iterator _M_current;
960 typedef _Iterator iterator_type;
961 typedef typename __traits_type::iterator_category iterator_category;
962 typedef typename __traits_type::value_type value_type;
963 typedef typename __traits_type::difference_type difference_type;
964 typedef typename __traits_type::reference reference;
965 typedef typename __traits_type::pointer pointer;
967 #if __cplusplus > 201703L && __cpp_lib_concepts
968 using iterator_concept = std::__detail::__iter_concept<_Iterator>;
971 _GLIBCXX_CONSTEXPR __normal_iterator() _GLIBCXX_NOEXCEPT
972 : _M_current(_Iterator()) { }
974 explicit _GLIBCXX20_CONSTEXPR
975 __normal_iterator(
const _Iterator& __i) _GLIBCXX_NOEXCEPT
976 : _M_current(__i) { }
979 template<
typename _Iter>
981 __normal_iterator(
const __normal_iterator<_Iter,
982 typename __enable_if<
983 (std::__are_same<_Iter, typename _Container::pointer>::__value),
984 _Container>::__type>& __i) _GLIBCXX_NOEXCEPT
985 : _M_current(__i.base()) { }
991 {
return *_M_current; }
995 operator->() const _GLIBCXX_NOEXCEPT
996 {
return _M_current; }
1000 operator++() _GLIBCXX_NOEXCEPT
1006 _GLIBCXX20_CONSTEXPR
1008 operator++(
int) _GLIBCXX_NOEXCEPT
1009 {
return __normal_iterator(_M_current++); }
1012 _GLIBCXX20_CONSTEXPR
1014 operator--() _GLIBCXX_NOEXCEPT
1020 _GLIBCXX20_CONSTEXPR
1022 operator--(
int) _GLIBCXX_NOEXCEPT
1023 {
return __normal_iterator(_M_current--); }
1026 _GLIBCXX20_CONSTEXPR
1028 operator[](difference_type __n)
const _GLIBCXX_NOEXCEPT
1029 {
return _M_current[__n]; }
1031 _GLIBCXX20_CONSTEXPR
1033 operator+=(difference_type __n) _GLIBCXX_NOEXCEPT
1034 { _M_current += __n;
return *
this; }
1036 _GLIBCXX20_CONSTEXPR
1038 operator+(difference_type __n)
const _GLIBCXX_NOEXCEPT
1039 {
return __normal_iterator(_M_current + __n); }
1041 _GLIBCXX20_CONSTEXPR
1043 operator-=(difference_type __n) _GLIBCXX_NOEXCEPT
1044 { _M_current -= __n;
return *
this; }
1046 _GLIBCXX20_CONSTEXPR
1048 operator-(difference_type __n)
const _GLIBCXX_NOEXCEPT
1049 {
return __normal_iterator(_M_current - __n); }
1051 _GLIBCXX20_CONSTEXPR
1053 base() const _GLIBCXX_NOEXCEPT
1054 {
return _M_current; }
1065 #if __cpp_lib_three_way_comparison
1066 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1067 requires requires (_IteratorL __lhs, _IteratorR __rhs)
1068 { { __lhs == __rhs } -> std::convertible_to<bool>; }
1070 operator==(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1071 const __normal_iterator<_IteratorR, _Container>& __rhs)
1072 noexcept(noexcept(__lhs.base() == __rhs.base()))
1073 {
return __lhs.base() == __rhs.base(); }
1075 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1076 constexpr std::__detail::__synth3way_t<_IteratorR, _IteratorL>
1077 operator<=>(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1078 const __normal_iterator<_IteratorR, _Container>& __rhs)
1079 noexcept(noexcept(std::__detail::__synth3way(__lhs.base(), __rhs.base())))
1080 {
return std::__detail::__synth3way(__lhs.base(), __rhs.base()); }
1083 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1084 _GLIBCXX20_CONSTEXPR
1086 operator==(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1087 const __normal_iterator<_IteratorR, _Container>& __rhs)
1089 {
return __lhs.base() == __rhs.base(); }
1091 template<
typename _Iterator,
typename _Container>
1092 _GLIBCXX20_CONSTEXPR
1094 operator==(
const __normal_iterator<_Iterator, _Container>& __lhs,
1095 const __normal_iterator<_Iterator, _Container>& __rhs)
1097 {
return __lhs.base() == __rhs.base(); }
1099 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1100 _GLIBCXX20_CONSTEXPR
1102 operator!=(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1103 const __normal_iterator<_IteratorR, _Container>& __rhs)
1105 {
return __lhs.base() != __rhs.base(); }
1107 template<
typename _Iterator,
typename _Container>
1108 _GLIBCXX20_CONSTEXPR
1110 operator!=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1111 const __normal_iterator<_Iterator, _Container>& __rhs)
1113 {
return __lhs.base() != __rhs.base(); }
1116 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1118 operator<(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1119 const __normal_iterator<_IteratorR, _Container>& __rhs)
1121 {
return __lhs.base() < __rhs.base(); }
1123 template<
typename _Iterator,
typename _Container>
1124 _GLIBCXX20_CONSTEXPR
1126 operator<(
const __normal_iterator<_Iterator, _Container>& __lhs,
1127 const __normal_iterator<_Iterator, _Container>& __rhs)
1129 {
return __lhs.base() < __rhs.base(); }
1131 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1133 operator>(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1134 const __normal_iterator<_IteratorR, _Container>& __rhs)
1136 {
return __lhs.base() > __rhs.base(); }
1138 template<
typename _Iterator,
typename _Container>
1139 _GLIBCXX20_CONSTEXPR
1141 operator>(
const __normal_iterator<_Iterator, _Container>& __lhs,
1142 const __normal_iterator<_Iterator, _Container>& __rhs)
1144 {
return __lhs.base() > __rhs.base(); }
1146 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1148 operator<=(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1149 const __normal_iterator<_IteratorR, _Container>& __rhs)
1151 {
return __lhs.base() <= __rhs.base(); }
1153 template<
typename _Iterator,
typename _Container>
1154 _GLIBCXX20_CONSTEXPR
1156 operator<=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1157 const __normal_iterator<_Iterator, _Container>& __rhs)
1159 {
return __lhs.base() <= __rhs.base(); }
1161 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1163 operator>=(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1164 const __normal_iterator<_IteratorR, _Container>& __rhs)
1166 {
return __lhs.base() >= __rhs.base(); }
1168 template<
typename _Iterator,
typename _Container>
1169 _GLIBCXX20_CONSTEXPR
1171 operator>=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1172 const __normal_iterator<_Iterator, _Container>& __rhs)
1174 {
return __lhs.base() >= __rhs.base(); }
1181 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1182 #if __cplusplus >= 201103L
1184 _GLIBCXX20_CONSTEXPR
1186 operator-(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1187 const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept
1188 -> decltype(__lhs.base() - __rhs.base())
1190 inline typename __normal_iterator<_IteratorL, _Container>::difference_type
1191 operator-(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1192 const __normal_iterator<_IteratorR, _Container>& __rhs)
1194 {
return __lhs.base() - __rhs.base(); }
1196 template<
typename _Iterator,
typename _Container>
1197 _GLIBCXX20_CONSTEXPR
1198 inline typename __normal_iterator<_Iterator, _Container>::difference_type
1199 operator-(
const __normal_iterator<_Iterator, _Container>& __lhs,
1200 const __normal_iterator<_Iterator, _Container>& __rhs)
1202 {
return __lhs.base() - __rhs.base(); }
1204 template<
typename _Iterator,
typename _Container>
1205 _GLIBCXX20_CONSTEXPR
1206 inline __normal_iterator<_Iterator, _Container>
1207 operator+(
typename __normal_iterator<_Iterator, _Container>::difference_type
1208 __n,
const __normal_iterator<_Iterator, _Container>& __i)
1210 {
return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
1212 _GLIBCXX_END_NAMESPACE_VERSION
1215 namespace std _GLIBCXX_VISIBILITY(default)
1217 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1219 template<
typename _Iterator,
typename _Container>
1220 _GLIBCXX20_CONSTEXPR
1222 __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it)
1224 {
return __it.base(); }
1226 #if __cplusplus >= 201103L
1232 #if __cplusplus > 201703L && __cpp_lib_concepts
1233 template<semiregular _Sent>
1239 noexcept(is_nothrow_default_constructible_v<_Sent>)
1243 move_sentinel(_Sent __s)
1244 noexcept(is_nothrow_move_constructible_v<_Sent>)
1247 template<
typename _S2> requires convertible_to<const _S2&, _Sent>
1249 move_sentinel(
const move_sentinel<_S2>& __s)
1250 noexcept(is_nothrow_constructible_v<_Sent, const _S2&>)
1251 : _M_last(__s.base())
1254 template<
typename _S2> requires assignable_from<_Sent&, const _S2&>
1255 constexpr move_sentinel&
1256 operator=(
const move_sentinel<_S2>& __s)
1257 noexcept(is_nothrow_assignable_v<_Sent, const _S2&>)
1259 _M_last = __s.base();
1265 noexcept(is_nothrow_copy_constructible_v<_Sent>)
1282 template<
typename _Iterator>
1285 _Iterator _M_current;
1288 #if __cplusplus > 201703L && __cpp_lib_concepts
1289 using __base_cat =
typename __traits_type::iterator_category;
1291 using __base_ref =
typename __traits_type::reference;
1295 using iterator_type = _Iterator;
1297 #if __cplusplus > 201703L && __cpp_lib_concepts
1299 using iterator_category
1300 = __detail::__clamp_iter_cat<__base_cat, random_access_iterator_tag>;
1301 using value_type = iter_value_t<_Iterator>;
1302 using difference_type = iter_difference_t<_Iterator>;
1303 using pointer = _Iterator;
1304 using reference = iter_rvalue_reference_t<_Iterator>;
1306 typedef typename __traits_type::iterator_category iterator_category;
1307 typedef typename __traits_type::value_type value_type;
1308 typedef typename __traits_type::difference_type difference_type;
1310 typedef _Iterator pointer;
1314 typename remove_reference<__base_ref>::type&&,
1315 __base_ref>::type reference;
1318 _GLIBCXX17_CONSTEXPR
1322 explicit _GLIBCXX17_CONSTEXPR
1326 template<
typename _Iter>
1327 _GLIBCXX17_CONSTEXPR
1329 : _M_current(__i.base()) { }
1331 template<
typename _Iter>
1332 _GLIBCXX17_CONSTEXPR
1335 _M_current = __i.base();
1339 #if __cplusplus <= 201703L
1340 _GLIBCXX17_CONSTEXPR iterator_type
1342 {
return _M_current; }
1344 constexpr iterator_type
1346 #if __cpp_lib_concepts
1347 requires copy_constructible<iterator_type>
1349 {
return _M_current; }
1351 constexpr iterator_type
1356 _GLIBCXX17_CONSTEXPR reference
1358 #if __cplusplus > 201703L && __cpp_lib_concepts
1359 {
return ranges::iter_move(_M_current); }
1361 {
return static_cast<reference
>(*_M_current); }
1364 _GLIBCXX17_CONSTEXPR pointer
1366 {
return _M_current; }
1383 #if __cpp_lib_concepts
1385 operator++(
int) requires (!forward_iterator<_Iterator>)
1405 operator+(difference_type __n)
const
1409 operator+=(difference_type __n)
1416 operator-(difference_type __n)
const
1420 operator-=(difference_type __n)
1426 _GLIBCXX17_CONSTEXPR reference
1427 operator[](difference_type __n)
const
1428 #if __cplusplus > 201703L && __cpp_lib_concepts
1429 {
return ranges::iter_move(_M_current + __n); }
1434 #if __cplusplus > 201703L && __cpp_lib_concepts
1435 template<sentinel_for<_Iterator> _Sent>
1436 friend constexpr
bool
1437 operator==(
const move_iterator& __x,
const move_sentinel<_Sent>& __y)
1438 {
return __x.base() == __y.base(); }
1440 template<sized_sentinel_for<_Iterator> _Sent>
1441 friend constexpr iter_difference_t<_Iterator>
1442 operator-(
const move_sentinel<_Sent>& __x,
const move_iterator& __y)
1443 {
return __x.base() - __y.base(); }
1445 template<sized_sentinel_for<_Iterator> _Sent>
1446 friend constexpr iter_difference_t<_Iterator>
1447 operator-(
const move_iterator& __x,
const move_sentinel<_Sent>& __y)
1448 {
return __x.base() - __y.base(); }
1450 friend constexpr iter_rvalue_reference_t<_Iterator>
1452 noexcept(noexcept(ranges::iter_move(__i._M_current)))
1453 {
return ranges::iter_move(__i._M_current); }
1455 template<indirectly_swappable<_Iterator> _Iter2>
1456 friend constexpr
void
1458 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1459 {
return ranges::iter_swap(__x._M_current, __y._M_current); }
1463 template<
typename _IteratorL,
typename _IteratorR>
1464 inline _GLIBCXX17_CONSTEXPR
bool
1467 #if __cplusplus > 201703L && __cpp_lib_concepts
1468 requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
1470 {
return __x.base() == __y.base(); }
1472 #if __cpp_lib_three_way_comparison
1473 template<
typename _IteratorL,
1474 three_way_comparable_with<_IteratorL> _IteratorR>
1475 constexpr compare_three_way_result_t<_IteratorL, _IteratorR>
1476 operator<=>(
const move_iterator<_IteratorL>& __x,
1477 const move_iterator<_IteratorR>& __y)
1478 {
return __x.base() <=> __y.base(); }
1480 template<
typename _IteratorL,
typename _IteratorR>
1481 inline _GLIBCXX17_CONSTEXPR
bool
1482 operator!=(
const move_iterator<_IteratorL>& __x,
1483 const move_iterator<_IteratorR>& __y)
1484 {
return !(__x == __y); }
1487 template<
typename _IteratorL,
typename _IteratorR>
1488 inline _GLIBCXX17_CONSTEXPR
bool
1489 operator<(
const move_iterator<_IteratorL>& __x,
1490 const move_iterator<_IteratorR>& __y)
1491 #if __cplusplus > 201703L && __cpp_lib_concepts
1492 requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
1494 {
return __x.base() < __y.base(); }
1496 template<
typename _IteratorL,
typename _IteratorR>
1497 inline _GLIBCXX17_CONSTEXPR
bool
1498 operator<=(
const move_iterator<_IteratorL>& __x,
1499 const move_iterator<_IteratorR>& __y)
1500 #if __cplusplus > 201703L && __cpp_lib_concepts
1501 requires requires { { __y.base() < __x.base() } -> convertible_to<bool>; }
1503 {
return !(__y < __x); }
1505 template<
typename _IteratorL,
typename _IteratorR>
1506 inline _GLIBCXX17_CONSTEXPR
bool
1507 operator>(
const move_iterator<_IteratorL>& __x,
1508 const move_iterator<_IteratorR>& __y)
1509 #if __cplusplus > 201703L && __cpp_lib_concepts
1510 requires requires { { __y.base() < __x.base() } -> convertible_to<bool>; }
1512 {
return __y < __x; }
1514 template<
typename _IteratorL,
typename _IteratorR>
1515 inline _GLIBCXX17_CONSTEXPR
bool
1516 operator>=(
const move_iterator<_IteratorL>& __x,
1517 const move_iterator<_IteratorR>& __y)
1518 #if __cplusplus > 201703L && __cpp_lib_concepts
1519 requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
1521 {
return !(__x < __y); }
1523 #if ! (__cplusplus > 201703L && __cpp_lib_concepts)
1531 template<
typename _Iterator>
1532 inline _GLIBCXX17_CONSTEXPR
bool
1533 operator==(
const move_iterator<_Iterator>& __x,
1534 const move_iterator<_Iterator>& __y)
1535 {
return __x.base() == __y.base(); }
1537 template<
typename _Iterator>
1538 inline _GLIBCXX17_CONSTEXPR
bool
1539 operator!=(
const move_iterator<_Iterator>& __x,
1540 const move_iterator<_Iterator>& __y)
1541 {
return !(__x == __y); }
1543 template<
typename _Iterator>
1544 inline _GLIBCXX17_CONSTEXPR
bool
1545 operator<(
const move_iterator<_Iterator>& __x,
1546 const move_iterator<_Iterator>& __y)
1547 {
return __x.base() < __y.base(); }
1549 template<
typename _Iterator>
1550 inline _GLIBCXX17_CONSTEXPR
bool
1551 operator<=(
const move_iterator<_Iterator>& __x,
1552 const move_iterator<_Iterator>& __y)
1553 {
return !(__y < __x); }
1555 template<
typename _Iterator>
1556 inline _GLIBCXX17_CONSTEXPR
bool
1557 operator>(
const move_iterator<_Iterator>& __x,
1558 const move_iterator<_Iterator>& __y)
1559 {
return __y < __x; }
1561 template<
typename _Iterator>
1562 inline _GLIBCXX17_CONSTEXPR
bool
1563 operator>=(
const move_iterator<_Iterator>& __x,
1564 const move_iterator<_Iterator>& __y)
1565 {
return !(__x < __y); }
1569 template<
typename _IteratorL,
typename _IteratorR>
1570 inline _GLIBCXX17_CONSTEXPR
auto
1571 operator-(
const move_iterator<_IteratorL>& __x,
1572 const move_iterator<_IteratorR>& __y)
1573 -> decltype(__x.base() - __y.base())
1574 {
return __x.base() - __y.base(); }
1576 template<
typename _Iterator>
1577 inline _GLIBCXX17_CONSTEXPR move_iterator<_Iterator>
1578 operator+(
typename move_iterator<_Iterator>::difference_type __n,
1579 const move_iterator<_Iterator>& __x)
1580 {
return __x + __n; }
1582 template<
typename _Iterator>
1583 inline _GLIBCXX17_CONSTEXPR move_iterator<_Iterator>
1584 make_move_iterator(_Iterator __i)
1585 {
return move_iterator<_Iterator>(
std::move(__i)); }
1587 template<
typename _Iterator,
typename _ReturnType
1588 =
typename conditional<__move_if_noexcept_cond
1589 <
typename iterator_traits<_Iterator>::value_type>::value,
1590 _Iterator, move_iterator<_Iterator>>::type>
1591 inline _GLIBCXX17_CONSTEXPR _ReturnType
1592 __make_move_if_noexcept_iterator(_Iterator __i)
1593 {
return _ReturnType(__i); }
1597 template<
typename _Tp,
typename _ReturnType
1598 =
typename conditional<__move_if_noexcept_cond<_Tp>::value,
1599 const _Tp*, move_iterator<_Tp*>>::type>
1600 inline _GLIBCXX17_CONSTEXPR _ReturnType
1601 __make_move_if_noexcept_iterator(_Tp* __i)
1602 {
return _ReturnType(__i); }
1604 #if __cplusplus > 201703L && __cpp_lib_concepts
1609 template<
typename _It>
1610 concept __common_iter_has_arrow = indirectly_readable<const _It>
1611 && (requires(
const _It& __it) { __it.operator->(); }
1612 || is_reference_v<iter_reference_t<_It>>
1613 || constructible_from<iter_value_t<_It>, iter_reference_t<_It>>);
1618 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
1619 requires (!same_as<_It, _Sent>) && copyable<_It>
1620 class common_iterator
1622 template<
typename _Tp,
typename _Up>
1623 static constexpr
bool
1626 if constexpr (is_trivially_default_constructible_v<_Tp>)
1627 return is_nothrow_assignable_v<_Tp, _Up>;
1629 return is_nothrow_constructible_v<_Tp, _Up>;
1632 template<
typename _It2,
typename _Sent2>
1633 static constexpr
bool
1635 {
return _S_noexcept1<_It, _It2>() && _S_noexcept1<_Sent, _Sent2>(); }
1639 iter_value_t<_It> _M_keep;
1641 _Proxy(iter_reference_t<_It>&& __x)
1644 friend class common_iterator;
1647 const iter_value_t<_It>*
1655 noexcept(is_nothrow_default_constructible_v<_It>)
1656 : _M_it(), _M_index(0)
1660 common_iterator(_It __i)
1661 noexcept(is_nothrow_move_constructible_v<_It>)
1662 : _M_it(
std::
move(__i)), _M_index(0)
1666 common_iterator(_Sent __s)
1667 noexcept(is_nothrow_move_constructible_v<_Sent>)
1668 : _M_sent(
std::
move(__s)), _M_index(1)
1671 template<
typename _It2,
typename _Sent2>
1672 requires convertible_to<const _It2&, _It>
1673 && convertible_to<const _Sent2&, _Sent>
1675 common_iterator(
const common_iterator<_It2, _Sent2>& __x)
1676 noexcept(_S_noexcept<const _It2&, const _Sent2&>())
1677 : _M_valueless(), _M_index(__x._M_index)
1681 if constexpr (is_trivially_default_constructible_v<_It>)
1686 else if (_M_index == 1)
1688 if constexpr (is_trivially_default_constructible_v<_Sent>)
1696 common_iterator(
const common_iterator& __x)
1697 noexcept(_S_noexcept<const _It&, const _Sent&>())
1698 : _M_valueless(), _M_index(__x._M_index)
1702 if constexpr (is_trivially_default_constructible_v<_It>)
1707 else if (_M_index == 1)
1709 if constexpr (is_trivially_default_constructible_v<_Sent>)
1717 operator=(
const common_iterator& __x)
1718 noexcept(is_nothrow_copy_assignable_v<_It>
1719 && is_nothrow_copy_assignable_v<_Sent>
1720 && is_nothrow_copy_constructible_v<_It>
1721 && is_nothrow_copy_constructible_v<_Sent>)
1723 return this->
operator=<_It, _Sent>(__x);
1726 template<
typename _It2,
typename _Sent2>
1727 requires convertible_to<const _It2&, _It>
1728 && convertible_to<const _Sent2&, _Sent>
1729 && assignable_from<_It&, const _It2&>
1730 && assignable_from<_Sent&, const _Sent2&>
1732 operator=(
const common_iterator<_It2, _Sent2>& __x)
1733 noexcept(is_nothrow_constructible_v<_It, const _It2&>
1734 && is_nothrow_constructible_v<_Sent, const _Sent2&>
1735 && is_nothrow_assignable_v<_It, const _It2&>
1736 && is_nothrow_assignable_v<_Sent, const _Sent2&>)
1738 switch(_M_index << 2 | __x._M_index)
1744 _M_sent = __x._M_sent;
1763 __glibcxx_assert(__x._M_has_value());
1764 __builtin_unreachable();
1785 __glibcxx_assert(_M_index == 0);
1790 operator*() const requires __detail::__dereferenceable<const _It>
1792 __glibcxx_assert(_M_index == 0);
1797 operator->() const requires __detail::__common_iter_has_arrow<_It>
1799 __glibcxx_assert(_M_index == 0);
1800 if constexpr (is_pointer_v<_It> || requires { _M_it.operator->(); })
1802 else if constexpr (is_reference_v<iter_reference_t<_It>>)
1804 auto&& __tmp = *_M_it;
1808 return _Proxy{*_M_it};
1814 __glibcxx_assert(_M_index == 0);
1822 __glibcxx_assert(_M_index == 0);
1823 if constexpr (forward_iterator<_It>)
1825 common_iterator __tmp = *
this;
1833 template<
typename _It2, sentinel_for<_It> _Sent2>
1834 requires sentinel_for<_Sent, _It2>
1836 operator==(
const common_iterator& __x,
1837 const common_iterator<_It2, _Sent2>& __y)
1839 switch(__x._M_index << 2 | __y._M_index)
1845 return __x._M_it == __y._M_sent;
1847 return __x._M_sent == __y._M_it;
1849 __glibcxx_assert(__x._M_has_value());
1850 __glibcxx_assert(__y._M_has_value());
1851 __builtin_unreachable();
1855 template<
typename _It2, sentinel_for<_It> _Sent2>
1856 requires sentinel_for<_Sent, _It2> && equality_comparable_with<_It, _It2>
1858 operator==(
const common_iterator& __x,
1859 const common_iterator<_It2, _Sent2>& __y)
1861 switch(__x._M_index << 2 | __y._M_index)
1866 return __x._M_it == __y._M_it;
1868 return __x._M_it == __y._M_sent;
1870 return __x._M_sent == __y._M_it;
1872 __glibcxx_assert(__x._M_has_value());
1873 __glibcxx_assert(__y._M_has_value());
1874 __builtin_unreachable();
1878 template<sized_sentinel_for<_It> _It2, sized_sentinel_for<_It> _Sent2>
1879 requires sized_sentinel_for<_Sent, _It2>
1880 friend iter_difference_t<_It2>
1882 const common_iterator<_It2, _Sent2>& __y)
1884 switch(__x._M_index << 2 | __y._M_index)
1889 return __x._M_it - __y._M_it;
1891 return __x._M_it - __y._M_sent;
1893 return __x._M_sent - __y._M_it;
1895 __glibcxx_assert(__x._M_has_value());
1896 __glibcxx_assert(__y._M_has_value());
1897 __builtin_unreachable();
1901 friend iter_rvalue_reference_t<_It>
1902 iter_move(
const common_iterator& __i)
1903 noexcept(noexcept(ranges::iter_move(std::declval<const _It&>())))
1904 requires input_iterator<_It>
1906 __glibcxx_assert(__i._M_index == 0);
1907 return ranges::iter_move(__i._M_it);
1910 template<indirectly_swappable<_It> _It2,
typename _Sent2>
1912 iter_swap(
const common_iterator& __x,
1913 const common_iterator<_It2, _Sent2>& __y)
1914 noexcept(noexcept(ranges::iter_swap(std::declval<const _It&>(),
1915 std::declval<const _It2&>())))
1917 __glibcxx_assert(__x._M_index == 0);
1918 __glibcxx_assert(__y._M_index == 0);
1919 return ranges::iter_swap(__x._M_it, __y._M_it);
1923 template<input_or_output_iterator _It2, sentinel_for<_It2> _Sent2>
1924 friend class common_iterator;
1926 bool _M_has_value() const noexcept {
return _M_index < 2; }
1932 unsigned char _M_valueless;
1934 unsigned char _M_index;
1937 template<
typename _It,
typename _Sent>
1938 struct incrementable_traits<common_iterator<_It, _Sent>>
1940 using difference_type = iter_difference_t<_It>;
1943 template<input_iterator _It,
typename _Sent>
1944 struct iterator_traits<common_iterator<_It, _Sent>>
1947 template<
typename _Iter>
1953 template<
typename _Iter>
1954 requires __detail::__common_iter_has_arrow<_Iter>
1957 using _CIter = common_iterator<_Iter, _Sent>;
1958 using type = decltype(std::declval<const _CIter&>().operator->());
1962 using iterator_concept = conditional_t<forward_iterator<_It>,
1963 forward_iterator_tag, input_iterator_tag>;
1964 using iterator_category = __detail::__clamp_iter_cat<
1965 typename iterator_traits<_It>::iterator_category,
1966 forward_iterator_tag, input_iterator_tag>;
1967 using value_type = iter_value_t<_It>;
1968 using difference_type = iter_difference_t<_It>;
1969 using pointer =
typename __ptr<_It>::type;
1970 using reference = iter_reference_t<_It>;
1976 template<input_or_output_iterator _It>
1977 class counted_iterator
1980 using iterator_type = _It;
1982 constexpr counted_iterator() =
default;
1985 counted_iterator(_It __i, iter_difference_t<_It> __n)
1986 : _M_current(
std::
move(__i)), _M_length(__n)
1987 { __glibcxx_assert(__n >= 0); }
1989 template<
typename _It2>
1990 requires convertible_to<const _It2&, _It>
1992 counted_iterator(
const counted_iterator<_It2>& __x)
1993 : _M_current(__x._M_current), _M_length(__x._M_length)
1996 template<
typename _It2>
1997 requires assignable_from<_It&, const _It2&>
1998 constexpr counted_iterator&
1999 operator=(
const counted_iterator<_It2>& __x)
2001 _M_current = __x._M_current;
2002 _M_length = __x._M_length;
2008 noexcept(is_nothrow_copy_constructible_v<_It>)
2009 requires copy_constructible<_It>
2010 {
return _M_current; }
2014 noexcept(is_nothrow_move_constructible_v<_It>)
2017 constexpr iter_difference_t<_It>
2018 count() const noexcept {
return _M_length; }
2020 constexpr decltype(
auto)
2022 noexcept(noexcept(*_M_current))
2023 {
return *_M_current; }
2025 constexpr decltype(
auto)
2027 noexcept(noexcept(*_M_current))
2028 requires __detail::__dereferenceable<const _It>
2029 {
return *_M_current; }
2031 constexpr counted_iterator&
2034 __glibcxx_assert(_M_length > 0);
2043 __glibcxx_assert(_M_length > 0);
2047 return _M_current++;
2050 __throw_exception_again;
2055 constexpr counted_iterator
2056 operator++(
int) requires forward_iterator<_It>
2063 constexpr counted_iterator&
2064 operator--() requires bidirectional_iterator<_It>
2071 constexpr counted_iterator
2072 operator--(
int) requires bidirectional_iterator<_It>
2079 constexpr counted_iterator
2080 operator+(iter_difference_t<_It> __n)
const
2081 requires random_access_iterator<_It>
2082 {
return counted_iterator(_M_current + __n, _M_length - __n); }
2084 friend constexpr counted_iterator
2085 operator+(iter_difference_t<_It> __n,
const counted_iterator& __x)
2086 requires random_access_iterator<_It>
2087 {
return __x + __n; }
2089 constexpr counted_iterator&
2090 operator+=(iter_difference_t<_It> __n)
2091 requires random_access_iterator<_It>
2093 __glibcxx_assert(__n <= _M_length);
2099 constexpr counted_iterator
2100 operator-(iter_difference_t<_It> __n)
const
2101 requires random_access_iterator<_It>
2102 {
return counted_iterator(_M_current - __n, _M_length + __n); }
2104 template<common_with<_It> _It2>
2105 friend constexpr iter_difference_t<_It2>
2107 const counted_iterator<_It2>& __y)
2108 {
return __y._M_length - __x._M_length; }
2110 friend constexpr iter_difference_t<_It>
2111 operator-(
const counted_iterator& __x, default_sentinel_t)
2112 {
return -__x._M_length; }
2114 friend constexpr iter_difference_t<_It>
2115 operator-(default_sentinel_t,
const counted_iterator& __y)
2116 {
return __y._M_length; }
2118 constexpr counted_iterator&
2119 operator-=(iter_difference_t<_It> __n)
2120 requires random_access_iterator<_It>
2122 __glibcxx_assert(-__n <= _M_length);
2128 constexpr decltype(
auto)
2129 operator[](iter_difference_t<_It> __n) const
2130 noexcept(noexcept(_M_current[__n]))
2131 requires random_access_iterator<_It>
2133 __glibcxx_assert(__n < _M_length);
2134 return _M_current[__n];
2137 template<common_with<_It> _It2>
2138 friend constexpr
bool
2139 operator==(
const counted_iterator& __x,
2140 const counted_iterator<_It2>& __y)
2141 {
return __x._M_length == __y._M_length; }
2143 friend constexpr
bool
2144 operator==(
const counted_iterator& __x, default_sentinel_t)
2145 {
return __x._M_length == 0; }
2147 template<common_with<_It> _It2>
2148 friend constexpr strong_ordering
2149 operator<=>(
const counted_iterator& __x,
2150 const counted_iterator<_It2>& __y)
2151 {
return __y._M_length <=> __x._M_length; }
2153 friend constexpr iter_rvalue_reference_t<_It>
2154 iter_move(
const counted_iterator& __i)
2155 noexcept(noexcept(ranges::iter_move(__i._M_current)))
2156 requires input_iterator<_It>
2157 {
return ranges::iter_move(__i._M_current); }
2159 template<indirectly_swappable<_It> _It2>
2160 friend constexpr
void
2161 iter_swap(
const counted_iterator& __x,
2162 const counted_iterator<_It2>& __y)
2163 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
2164 { ranges::iter_swap(__x._M_current, __y._M_current); }
2167 template<input_or_output_iterator _It2>
friend class counted_iterator;
2169 _It _M_current = _It();
2170 iter_difference_t<_It> _M_length = 0;
2173 template<
typename _It>
2174 struct incrementable_traits<counted_iterator<_It>>
2176 using difference_type = iter_difference_t<_It>;
2179 template<input_iterator _It>
2180 struct iterator_traits<counted_iterator<_It>> : iterator_traits<_It>
2182 using pointer = void;
2188 template<
typename _Iterator>
2190 __niter_base(move_iterator<_Iterator> __it)
2191 -> decltype(make_move_iterator(__niter_base(__it.base())))
2192 {
return make_move_iterator(__niter_base(__it.base())); }
2194 template<
typename _Iterator>
2195 struct __is_move_iterator<move_iterator<_Iterator> >
2197 enum { __value = 1 };
2198 typedef __true_type __type;
2201 template<
typename _Iterator>
2203 __miter_base(move_iterator<_Iterator> __it)
2204 -> decltype(__miter_base(__it.base()))
2205 {
return __miter_base(__it.base()); }
2207 #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) std::make_move_iterator(_Iter)
2208 #define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) \
2209 std::__make_move_if_noexcept_iterator(_Iter)
2211 #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) (_Iter)
2212 #define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) (_Iter)
2215 #if __cpp_deduction_guides >= 201606
2218 template<
typename _InputIterator>
2220 typename iterator_traits<_InputIterator>::value_type::first_type>;
2222 template<
typename _InputIterator>
2223 using __iter_val_t =
2224 typename iterator_traits<_InputIterator>::value_type::second_type;
2226 template<
typename _T1,
typename _T2>
2229 template<
typename _InputIterator>
2230 using __iter_to_alloc_t =
2231 pair<add_const_t<__iter_key_t<_InputIterator>>,
2232 __iter_val_t<_InputIterator>>;
2235 _GLIBCXX_END_NAMESPACE_VERSION
2238 #ifdef _GLIBCXX_DEBUG
constexpr complex< _Tp > operator*(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x times y.
constexpr complex< _Tp > operator-(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x minus y.
constexpr complex< _Tp > operator+(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x plus y.
typename conditional< _Cond, _Iftrue, _Iffalse >::type conditional_t
Alias template for conditional.
typename remove_const< _Tp >::type remove_const_t
Alias template for remove_const.
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
constexpr back_insert_iterator operator++(int)
Simply returns *this. (This iterator does not move.)
_Container container_type
A nested typedef for the type of whatever container you used.
constexpr reverse_iterator< _Iterator > make_reverse_iterator(_Iterator __i)
Generator function for reverse_iterator.
constexpr pointer operator->() const
constexpr iterator_type base() const
_Container container_type
A nested typedef for the type of whatever container you used.
constexpr back_insert_iterator & operator*()
Simply returns *this.
constexpr back_insert_iterator & operator=(const typename _Container::value_type &__value)
constexpr front_insert_iterator operator++(int)
Simply returns *this. (This iterator does not move.)
constexpr reverse_iterator operator+(difference_type __n) const
constexpr reverse_iterator(iterator_type __x)
constexpr front_insert_iterator(_Container &__x)
The only way to create this iterator is with a container.
constexpr back_insert_iterator & operator++()
Simply returns *this. (This iterator does not move.)
constexpr insert_iterator & operator++()
Simply returns *this. (This iterator does not move.)
insert_iterator< _Container > inserter(_Container &__x, typename _Container::iterator __i)
_Container container_type
A nested typedef for the type of whatever container you used.
constexpr reverse_iterator & operator+=(difference_type __n)
constexpr reference operator[](difference_type __n) const
constexpr front_insert_iterator & operator++()
Simply returns *this. (This iterator does not move.)
constexpr insert_iterator & operator++(int)
Simply returns *this. (This iterator does not move.)
constexpr front_insert_iterator< _Container > front_inserter(_Container &__x)
constexpr front_insert_iterator & operator*()
Simply returns *this.
constexpr front_insert_iterator & operator=(const typename _Container::value_type &__value)
constexpr back_insert_iterator(_Container &__x)
The only way to create this iterator is with a container.
constexpr reverse_iterator & operator--()
constexpr insert_iterator & operator=(const typename _Container::value_type &__value)
constexpr reverse_iterator(const reverse_iterator &__x)
constexpr reverse_iterator & operator-=(difference_type __n)
constexpr insert_iterator(_Container &__x, _Iter __i)
constexpr reverse_iterator(const reverse_iterator< _Iter > &__x)
constexpr reverse_iterator operator--(int)
constexpr reference operator*() const
constexpr reverse_iterator operator-(difference_type __n) const
constexpr reverse_iterator()
constexpr back_insert_iterator< _Container > back_inserter(_Container &__x)
constexpr reverse_iterator operator++(int)
constexpr insert_iterator & operator*()
Simply returns *this.
constexpr reverse_iterator & operator++()
ISO C++ entities toplevel namespace is std.
GNU extensions for public use.
Define a member typedef type to one of two argument types.
is_nothrow_copy_constructible
Traits class for iterators.
Turns assignment into insertion.
Turns assignment into insertion.
Turns assignment into insertion.
Bidirectional iterators support a superset of forward iterator operations.
Random-access iterators support a superset of bidirectional iterator operations.
iterator_traits< _Iterator >::iterator_category iterator_category
One of the tag types.
void difference_type
Distance between iterators is represented as this type.