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 >= 202002L
88namespace std _GLIBCXX_VISIBILITY(default)
90_GLIBCXX_BEGIN_NAMESPACE_VERSION
102 template<
typename _Cat,
typename _Limit,
typename _Otherwise = _Cat>
103 using __clamp_iter_cat
104 = __conditional_t<derived_from<_Cat, _Limit>, _Limit, _Otherwise>;
106 template<
typename _Tp,
typename _Up>
107 concept __different_from
108 = !same_as<remove_cvref_t<_Tp>, remove_cvref_t<_Up>>;
113#pragma GCC diagnostic push
114#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
135 template<
typename _Iterator>
137 :
public iterator<typename iterator_traits<_Iterator>::iterator_category,
138 typename iterator_traits<_Iterator>::value_type,
139 typename iterator_traits<_Iterator>::difference_type,
140 typename iterator_traits<_Iterator>::pointer,
141 typename iterator_traits<_Iterator>::reference>
143 template<
typename _Iter>
146#if __cpp_lib_concepts
149 template<
typename _Iter>
150 static constexpr bool __convertible = !is_same_v<_Iter, _Iterator>
160 typedef _Iterator iterator_type;
161 typedef typename __traits_type::pointer pointer;
162#if ! __cpp_lib_concepts
163 typedef typename __traits_type::difference_type difference_type;
164 typedef typename __traits_type::reference reference;
166 using iterator_concept
167 = __conditional_t<random_access_iterator<_Iterator>,
170 using iterator_category
171 = __detail::__clamp_iter_cat<
typename __traits_type::iterator_category,
173 using value_type = iter_value_t<_Iterator>;
174 using difference_type = iter_difference_t<_Iterator>;
175 using reference = iter_reference_t<_Iterator>;
187 _GLIBCXX_NOEXCEPT_IF(noexcept(_Iterator()))
194 explicit _GLIBCXX17_CONSTEXPR
196 _GLIBCXX_NOEXCEPT_IF(
noexcept(_Iterator(__x)))
205 _GLIBCXX_NOEXCEPT_IF(
noexcept(_Iterator(__x.current)))
206 : current(__x.current)
209#if __cplusplus >= 201103L
217 template<
typename _Iter>
218#if __cpp_lib_concepts
219 requires __convertible<_Iter>
223 _GLIBCXX_NOEXCEPT_IF(
noexcept(_Iterator(__x.current)))
224 : current(__x.current)
227#if __cplusplus >= 201103L
228 template<
typename _Iter>
229#if __cpp_lib_concepts
230 requires __convertible<_Iter>
236 _GLIBCXX_NOEXCEPT_IF(
noexcept(current = __x.current))
238 current = __x.current;
247 _GLIBCXX17_CONSTEXPR iterator_type
249 _GLIBCXX_NOEXCEPT_IF(noexcept(_Iterator(current)))
263 _GLIBCXX17_CONSTEXPR reference
266 _Iterator __tmp = current;
276 _GLIBCXX17_CONSTEXPR pointer
278#if __cplusplus > 201703L && __cpp_concepts >= 201907L
279 requires is_pointer_v<_Iterator>
280 ||
requires(
const _Iterator __i) { __i.operator->(); }
285 _Iterator __tmp = current;
287 return _S_to_pointer(__tmp);
295 _GLIBCXX17_CONSTEXPR reverse_iterator&
392 _GLIBCXX17_CONSTEXPR reference
394 {
return *(*
this + __n); }
396#if __cplusplus > 201703L && __cpp_lib_concepts
398 friend constexpr iter_rvalue_reference_t<_Iterator>
400 noexcept(is_nothrow_copy_constructible_v<_Iterator>
401 &&
noexcept(ranges::iter_move(--std::declval<_Iterator&>())))
403 auto __tmp = __i.base();
404 return ranges::iter_move(--__tmp);
407 template<indirectly_swappable<_Iterator> _Iter2>
408 friend constexpr void
409 iter_swap(
const reverse_iterator& __x,
410 const reverse_iterator<_Iter2>& __y)
411 noexcept(is_nothrow_copy_constructible_v<_Iterator>
412 && is_nothrow_copy_constructible_v<_Iter2>
413 &&
noexcept(ranges::iter_swap(--std::declval<_Iterator&>(),
414 --std::declval<_Iter2&>())))
416 auto __xtmp = __x.base();
417 auto __ytmp = __y.base();
418 ranges::iter_swap(--__xtmp, --__ytmp);
423 template<
typename _Tp>
424 static _GLIBCXX17_CONSTEXPR _Tp*
425 _S_to_pointer(_Tp* __p)
428 template<
typename _Tp>
429 static _GLIBCXX17_CONSTEXPR pointer
430 _S_to_pointer(_Tp __t)
431 {
return __t.operator->(); }
444#if __cplusplus <= 201703L || ! defined __cpp_lib_concepts
445 template<
typename _Iterator>
447 inline _GLIBCXX17_CONSTEXPR
bool
448 operator==(
const reverse_iterator<_Iterator>& __x,
449 const reverse_iterator<_Iterator>& __y)
450 {
return __x.base() == __y.base(); }
452 template<
typename _Iterator>
454 inline _GLIBCXX17_CONSTEXPR
bool
455 operator<(
const reverse_iterator<_Iterator>& __x,
456 const reverse_iterator<_Iterator>& __y)
457 {
return __y.base() < __x.base(); }
459 template<
typename _Iterator>
461 inline _GLIBCXX17_CONSTEXPR
bool
462 operator!=(
const reverse_iterator<_Iterator>& __x,
463 const reverse_iterator<_Iterator>& __y)
464 {
return !(__x == __y); }
466 template<
typename _Iterator>
468 inline _GLIBCXX17_CONSTEXPR
bool
469 operator>(
const reverse_iterator<_Iterator>& __x,
470 const reverse_iterator<_Iterator>& __y)
471 {
return __y < __x; }
473 template<
typename _Iterator>
475 inline _GLIBCXX17_CONSTEXPR
bool
476 operator<=(
const reverse_iterator<_Iterator>& __x,
477 const reverse_iterator<_Iterator>& __y)
478 {
return !(__y < __x); }
480 template<
typename _Iterator>
482 inline _GLIBCXX17_CONSTEXPR
bool
483 operator>=(
const reverse_iterator<_Iterator>& __x,
484 const reverse_iterator<_Iterator>& __y)
485 {
return !(__x < __y); }
490 template<
typename _IteratorL,
typename _IteratorR>
492 inline _GLIBCXX17_CONSTEXPR
bool
493 operator==(
const reverse_iterator<_IteratorL>& __x,
494 const reverse_iterator<_IteratorR>& __y)
495 {
return __x.base() == __y.base(); }
497 template<
typename _IteratorL,
typename _IteratorR>
499 inline _GLIBCXX17_CONSTEXPR
bool
500 operator<(
const reverse_iterator<_IteratorL>& __x,
501 const reverse_iterator<_IteratorR>& __y)
502 {
return __x.base() > __y.base(); }
504 template<
typename _IteratorL,
typename _IteratorR>
506 inline _GLIBCXX17_CONSTEXPR
bool
507 operator!=(
const reverse_iterator<_IteratorL>& __x,
508 const reverse_iterator<_IteratorR>& __y)
509 {
return __x.base() != __y.base(); }
511 template<
typename _IteratorL,
typename _IteratorR>
513 inline _GLIBCXX17_CONSTEXPR
bool
514 operator>(
const reverse_iterator<_IteratorL>& __x,
515 const reverse_iterator<_IteratorR>& __y)
516 {
return __x.base() < __y.base(); }
518 template<
typename _IteratorL,
typename _IteratorR>
519 inline _GLIBCXX17_CONSTEXPR
bool
520 operator<=(
const reverse_iterator<_IteratorL>& __x,
521 const reverse_iterator<_IteratorR>& __y)
522 {
return __x.base() >= __y.base(); }
524 template<
typename _IteratorL,
typename _IteratorR>
526 inline _GLIBCXX17_CONSTEXPR
bool
527 operator>=(
const reverse_iterator<_IteratorL>& __x,
528 const reverse_iterator<_IteratorR>& __y)
529 {
return __x.base() <= __y.base(); }
531 template<
typename _IteratorL,
typename _IteratorR>
537 {
return __x.base() == __y.base(); }
539 template<
typename _IteratorL,
typename _IteratorR>
542 operator!=(
const reverse_iterator<_IteratorL>& __x,
543 const reverse_iterator<_IteratorR>& __y)
544 requires requires { { __x.base() != __y.base() } -> convertible_to<bool>; }
545 {
return __x.base() != __y.base(); }
547 template<
typename _IteratorL,
typename _IteratorR>
550 operator<(
const reverse_iterator<_IteratorL>& __x,
551 const reverse_iterator<_IteratorR>& __y)
552 requires requires { { __x.base() > __y.base() } -> convertible_to<bool>; }
553 {
return __x.base() > __y.base(); }
555 template<
typename _IteratorL,
typename _IteratorR>
558 operator>(
const reverse_iterator<_IteratorL>& __x,
559 const reverse_iterator<_IteratorR>& __y)
560 requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
561 {
return __x.base() < __y.base(); }
563 template<
typename _IteratorL,
typename _IteratorR>
566 operator<=(
const reverse_iterator<_IteratorL>& __x,
567 const reverse_iterator<_IteratorR>& __y)
568 requires requires { { __x.base() >= __y.base() } -> convertible_to<bool>; }
569 {
return __x.base() >= __y.base(); }
571 template<
typename _IteratorL,
typename _IteratorR>
574 operator>=(
const reverse_iterator<_IteratorL>& __x,
575 const reverse_iterator<_IteratorR>& __y)
576 requires requires { { __x.base() <= __y.base() } -> convertible_to<bool>; }
577 {
return __x.base() <= __y.base(); }
579 template<
typename _IteratorL,
580 three_way_comparable_with<_IteratorL> _IteratorR>
582 constexpr compare_three_way_result_t<_IteratorL, _IteratorR>
583 operator<=>(
const reverse_iterator<_IteratorL>& __x,
584 const reverse_iterator<_IteratorR>& __y)
585 {
return __y.base() <=> __x.base(); }
590 template<
typename _Iterator>
593 operator==(
const reverse_iterator<_Iterator>& __x,
594 const reverse_iterator<_Iterator>& __y)
595 requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
596 {
return __x.base() == __y.base(); }
598 template<three_way_comparable _Iterator>
600 constexpr compare_three_way_result_t<_Iterator, _Iterator>
601 operator<=>(
const reverse_iterator<_Iterator>& __x,
602 const reverse_iterator<_Iterator>& __y)
603 {
return __y.base() <=> __x.base(); }
607#if __cplusplus < 201103L
608 template<
typename _Iterator>
609 inline typename reverse_iterator<_Iterator>::difference_type
610 operator-(
const reverse_iterator<_Iterator>& __x,
611 const reverse_iterator<_Iterator>& __y)
612 {
return __y.base() - __x.base(); }
614 template<
typename _IteratorL,
typename _IteratorR>
615 inline typename reverse_iterator<_IteratorL>::difference_type
616 operator-(
const reverse_iterator<_IteratorL>& __x,
617 const reverse_iterator<_IteratorR>& __y)
618 {
return __y.base() - __x.base(); }
622 template<
typename _IteratorL,
typename _IteratorR>
624 inline _GLIBCXX17_CONSTEXPR
auto
625 operator-(
const reverse_iterator<_IteratorL>& __x,
626 const reverse_iterator<_IteratorR>& __y)
627 ->
decltype(__y.base() - __x.base())
628 {
return __y.base() - __x.base(); }
631 template<
typename _Iterator>
633 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
634 operator+(
typename reverse_iterator<_Iterator>::difference_type __n,
635 const reverse_iterator<_Iterator>& __x)
636 {
return reverse_iterator<_Iterator>(__x.base() - __n); }
638#if __cplusplus >= 201103L
640 template<
typename _Iterator>
641 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
642 __make_reverse_iterator(_Iterator __i)
643 {
return reverse_iterator<_Iterator>(__i); }
645# if __cplusplus >= 201402L
646# define __cpp_lib_make_reverse_iterator 201402L
651 template<
typename _Iterator>
653 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
657# if __cplusplus > 201703L && defined __cpp_lib_concepts
658 template<
typename _Iterator1,
typename _Iterator2>
659 requires (!sized_sentinel_for<_Iterator1, _Iterator2>)
660 inline constexpr bool
661 disable_sized_sentinel_for<reverse_iterator<_Iterator1>,
662 reverse_iterator<_Iterator2>> =
true;
666 template<
typename _Iterator>
669 __niter_base(reverse_iterator<_Iterator> __it)
670 ->
decltype(__make_reverse_iterator(__niter_base(__it.base())))
671 {
return __make_reverse_iterator(__niter_base(__it.base())); }
673 template<
typename _Iterator>
674 struct __is_move_iterator<reverse_iterator<_Iterator> >
675 : __is_move_iterator<_Iterator>
678 template<
typename _Iterator>
681 __miter_base(reverse_iterator<_Iterator> __it)
682 ->
decltype(__make_reverse_iterator(__miter_base(__it.base())))
683 {
return __make_reverse_iterator(__miter_base(__it.base())); }
697 template<
typename _Container>
699 :
public iterator<output_iterator_tag, void, void, void, void>
702 _Container* container;
707#if __cplusplus > 201703L
708 using difference_type = ptrdiff_t;
712 explicit _GLIBCXX20_CONSTEXPR
727#if __cplusplus < 201103L
729 operator=(
typename _Container::const_reference __value)
731 container->push_back(__value);
736 back_insert_iterator&
737 operator=(
const typename _Container::value_type& __value)
739 container->push_back(__value);
745 operator=(
typename _Container::value_type&& __value)
747 container->push_back(
std::move(__value));
753 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
754 back_insert_iterator&
782 template<
typename _Container>
783 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
784 inline back_insert_iterator<_Container>
798 template<
typename _Container>
800 :
public iterator<output_iterator_tag, void, void, void, void>
803 _Container* container;
808#if __cplusplus > 201703L
809 using difference_type = ptrdiff_t;
813 explicit _GLIBCXX20_CONSTEXPR
828#if __cplusplus < 201103L
830 operator=(
typename _Container::const_reference __value)
832 container->push_front(__value);
837 front_insert_iterator&
838 operator=(
const typename _Container::value_type& __value)
840 container->push_front(__value);
846 operator=(
typename _Container::value_type&& __value)
848 container->push_front(
std::move(__value));
854 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
855 front_insert_iterator&
883 template<
typename _Container>
884 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
885 inline front_insert_iterator<_Container>
903 template<
typename _Container>
905 :
public iterator<output_iterator_tag, void, void, void, void>
907#if __cplusplus > 201703L && defined __cpp_lib_concepts
908 using _Iter = std::__detail::__range_iter_t<_Container>;
910 typedef typename _Container::iterator _Iter;
913 _Container* container;
920#if __cplusplus > 201703L && defined __cpp_lib_concepts
921 using difference_type = ptrdiff_t;
955#if __cplusplus < 201103L
957 operator=(
typename _Container::const_reference __value)
959 iter = container->insert(iter, __value);
966 operator=(
const typename _Container::value_type& __value)
968 iter = container->insert(iter, __value);
975 operator=(
typename _Container::value_type&& __value)
977 iter = container->insert(iter,
std::move(__value));
984 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1002#pragma GCC diagnostic pop
1016#if __cplusplus > 201703L && defined __cpp_lib_concepts
1017 template<
typename _Container>
1019 constexpr insert_iterator<_Container>
1020 inserter(_Container& __x, std::__detail::__range_iter_t<_Container> __i)
1023 template<
typename _Container>
1025 inline insert_iterator<_Container>
1026 inserter(_Container& __x,
typename _Container::iterator __i)
1027 {
return insert_iterator<_Container>(__x, __i); }
1032_GLIBCXX_END_NAMESPACE_VERSION
1035namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
1037_GLIBCXX_BEGIN_NAMESPACE_VERSION
1046 template<
typename _Iterator,
typename _Container>
1047 class __normal_iterator
1050 _Iterator _M_current;
1054#if __cplusplus >= 201103L
1055 template<
typename _Iter>
1056 using __convertible_from
1057 = std::__enable_if_t<std::is_convertible<_Iter, _Iterator>::value>;
1061 typedef _Iterator iterator_type;
1062 typedef typename __traits_type::iterator_category iterator_category;
1063 typedef typename __traits_type::value_type value_type;
1064 typedef typename __traits_type::difference_type difference_type;
1065 typedef typename __traits_type::reference reference;
1066 typedef typename __traits_type::pointer pointer;
1068#if __cplusplus > 201703L && __cpp_lib_concepts
1069 using iterator_concept = std::__detail::__iter_concept<_Iterator>;
1072 _GLIBCXX_CONSTEXPR __normal_iterator() _GLIBCXX_NOEXCEPT
1073 : _M_current(_Iterator()) { }
1075 explicit _GLIBCXX20_CONSTEXPR
1076 __normal_iterator(
const _Iterator& __i) _GLIBCXX_NOEXCEPT
1077 : _M_current(__i) { }
1080#if __cplusplus >= 201103L
1081 template<
typename _Iter,
typename = __convertible_from<_Iter>>
1082 _GLIBCXX20_CONSTEXPR
1083 __normal_iterator(
const __normal_iterator<_Iter, _Container>& __i)
1088 template<
typename _Iter>
1089 __normal_iterator(
const __normal_iterator<_Iter,
1090 typename __enable_if<
1091 (std::__are_same<_Iter, typename _Container::pointer>::__value),
1092 _Container>::__type>& __i)
1094 : _M_current(__i.base()) { }
1097 _GLIBCXX20_CONSTEXPR
1100 {
return *_M_current; }
1102 _GLIBCXX20_CONSTEXPR
1104 operator->() const _GLIBCXX_NOEXCEPT
1105 {
return _M_current; }
1107 _GLIBCXX20_CONSTEXPR
1109 operator++() _GLIBCXX_NOEXCEPT
1115 _GLIBCXX20_CONSTEXPR
1117 operator++(
int) _GLIBCXX_NOEXCEPT
1118 {
return __normal_iterator(_M_current++); }
1121 _GLIBCXX20_CONSTEXPR
1123 operator--() _GLIBCXX_NOEXCEPT
1129 _GLIBCXX20_CONSTEXPR
1131 operator--(
int) _GLIBCXX_NOEXCEPT
1132 {
return __normal_iterator(_M_current--); }
1135 _GLIBCXX20_CONSTEXPR
1137 operator[](difference_type __n)
const _GLIBCXX_NOEXCEPT
1138 {
return _M_current[__n]; }
1140 _GLIBCXX20_CONSTEXPR
1142 operator+=(difference_type __n) _GLIBCXX_NOEXCEPT
1143 { _M_current += __n;
return *
this; }
1145 _GLIBCXX20_CONSTEXPR
1147 operator+(difference_type __n)
const _GLIBCXX_NOEXCEPT
1148 {
return __normal_iterator(_M_current + __n); }
1150 _GLIBCXX20_CONSTEXPR
1152 operator-=(difference_type __n) _GLIBCXX_NOEXCEPT
1153 { _M_current -= __n;
return *
this; }
1155 _GLIBCXX20_CONSTEXPR
1157 operator-(difference_type __n)
const _GLIBCXX_NOEXCEPT
1158 {
return __normal_iterator(_M_current - __n); }
1160 _GLIBCXX20_CONSTEXPR
1162 base() const _GLIBCXX_NOEXCEPT
1163 {
return _M_current; }
1174#if __cpp_lib_three_way_comparison
1175 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1178 operator==(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1179 const __normal_iterator<_IteratorR, _Container>& __rhs)
1180 noexcept(
noexcept(__lhs.base() == __rhs.base()))
1184 {
return __lhs.base() == __rhs.base(); }
1186 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1188 constexpr std::__detail::__synth3way_t<_IteratorR, _IteratorL>
1189 operator<=>(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1190 const __normal_iterator<_IteratorR, _Container>& __rhs)
1191 noexcept(
noexcept(std::__detail::__synth3way(__lhs.base(), __rhs.base())))
1192 {
return std::__detail::__synth3way(__lhs.base(), __rhs.base()); }
1194 template<
typename _Iterator,
typename _Container>
1197 operator==(
const __normal_iterator<_Iterator, _Container>& __lhs,
1198 const __normal_iterator<_Iterator, _Container>& __rhs)
1199 noexcept(
noexcept(__lhs.base() == __rhs.base()))
1203 {
return __lhs.base() == __rhs.base(); }
1205 template<
typename _Iterator,
typename _Container>
1207 constexpr std::__detail::__synth3way_t<_Iterator>
1208 operator<=>(
const __normal_iterator<_Iterator, _Container>& __lhs,
1209 const __normal_iterator<_Iterator, _Container>& __rhs)
1210 noexcept(
noexcept(std::__detail::__synth3way(__lhs.base(), __rhs.base())))
1211 {
return std::__detail::__synth3way(__lhs.base(), __rhs.base()); }
1214 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1215 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1217 operator==(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1218 const __normal_iterator<_IteratorR, _Container>& __rhs)
1220 {
return __lhs.base() == __rhs.base(); }
1222 template<
typename _Iterator,
typename _Container>
1223 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1225 operator==(
const __normal_iterator<_Iterator, _Container>& __lhs,
1226 const __normal_iterator<_Iterator, _Container>& __rhs)
1228 {
return __lhs.base() == __rhs.base(); }
1230 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1231 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1233 operator!=(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1234 const __normal_iterator<_IteratorR, _Container>& __rhs)
1236 {
return __lhs.base() != __rhs.base(); }
1238 template<
typename _Iterator,
typename _Container>
1239 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1241 operator!=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1242 const __normal_iterator<_Iterator, _Container>& __rhs)
1244 {
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(); }
1263 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1266 operator>(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1267 const __normal_iterator<_IteratorR, _Container>& __rhs)
1269 {
return __lhs.base() > __rhs.base(); }
1271 template<
typename _Iterator,
typename _Container>
1272 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1274 operator>(
const __normal_iterator<_Iterator, _Container>& __lhs,
1275 const __normal_iterator<_Iterator, _Container>& __rhs)
1277 {
return __lhs.base() > __rhs.base(); }
1279 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1282 operator<=(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1283 const __normal_iterator<_IteratorR, _Container>& __rhs)
1285 {
return __lhs.base() <= __rhs.base(); }
1287 template<
typename _Iterator,
typename _Container>
1288 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1290 operator<=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1291 const __normal_iterator<_Iterator, _Container>& __rhs)
1293 {
return __lhs.base() <= __rhs.base(); }
1295 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1298 operator>=(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1299 const __normal_iterator<_IteratorR, _Container>& __rhs)
1301 {
return __lhs.base() >= __rhs.base(); }
1303 template<
typename _Iterator,
typename _Container>
1304 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1306 operator>=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1307 const __normal_iterator<_Iterator, _Container>& __rhs)
1309 {
return __lhs.base() >= __rhs.base(); }
1316 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1317#if __cplusplus >= 201103L
1319 [[__nodiscard__]] _GLIBCXX20_CONSTEXPR
1321 operator-(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1322 const __normal_iterator<_IteratorR, _Container>& __rhs)
noexcept
1323 ->
decltype(__lhs.base() - __rhs.base())
1325 inline typename __normal_iterator<_IteratorL, _Container>::difference_type
1326 operator-(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1327 const __normal_iterator<_IteratorR, _Container>& __rhs)
1329 {
return __lhs.base() - __rhs.base(); }
1331 template<
typename _Iterator,
typename _Container>
1332 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1333 inline typename __normal_iterator<_Iterator, _Container>::difference_type
1334 operator-(
const __normal_iterator<_Iterator, _Container>& __lhs,
1335 const __normal_iterator<_Iterator, _Container>& __rhs)
1337 {
return __lhs.base() - __rhs.base(); }
1339 template<
typename _Iterator,
typename _Container>
1340 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1341 inline __normal_iterator<_Iterator, _Container>
1342 operator+(
typename __normal_iterator<_Iterator, _Container>::difference_type
1343 __n,
const __normal_iterator<_Iterator, _Container>& __i)
1345 {
return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
1347_GLIBCXX_END_NAMESPACE_VERSION
1350namespace std _GLIBCXX_VISIBILITY(default)
1352_GLIBCXX_BEGIN_NAMESPACE_VERSION
1354 template<
typename _Iterator,
typename _Container>
1355 _GLIBCXX20_CONSTEXPR
1357 __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it)
1359 {
return __it.base(); }
1361#if __cplusplus >= 201103L
1363#if __cplusplus <= 201703L
1366 template<
typename _Iterator,
typename _Container>
1368 __to_address(
const __gnu_cxx::__normal_iterator<_Iterator,
1369 _Container>& __it)
noexcept
1370 ->
decltype(std::__to_address(__it.base()))
1371 {
return std::__to_address(__it.base()); }
1379#if __cplusplus > 201703L && __cpp_lib_concepts
1380 template<semiregular _Sent>
1386 noexcept(is_nothrow_default_constructible_v<_Sent>)
1390 move_sentinel(_Sent __s)
1391 noexcept(is_nothrow_move_constructible_v<_Sent>)
1394 template<
typename _S2>
requires convertible_to<const _S2&, _Sent>
1396 move_sentinel(
const move_sentinel<_S2>& __s)
1397 noexcept(is_nothrow_constructible_v<_Sent, const _S2&>)
1398 : _M_last(__s.base())
1401 template<
typename _S2>
requires assignable_from<_Sent&, const _S2&>
1402 constexpr move_sentinel&
1403 operator=(
const move_sentinel<_S2>& __s)
1404 noexcept(is_nothrow_assignable_v<_Sent, const _S2&>)
1406 _M_last = __s.base();
1413 noexcept(is_nothrow_copy_constructible_v<_Sent>)
1423#if __cplusplus > 201703L && __cpp_lib_concepts
1424 template<
typename _Iterator>
1425 struct __move_iter_cat
1428 template<
typename _Iterator>
1429 requires requires {
typename __iter_category_t<_Iterator>; }
1430 struct __move_iter_cat<_Iterator>
1432 using iterator_category
1433 = __clamp_iter_cat<__iter_category_t<_Iterator>,
1434 random_access_iterator_tag>;
1448 template<
typename _Iterator>
1450#if __cplusplus > 201703L && __cpp_lib_concepts
1451 :
public __detail::__move_iter_cat<_Iterator>
1454 _Iterator _M_current;
1457#if ! (__cplusplus > 201703L && __cpp_lib_concepts)
1458 using __base_ref =
typename __traits_type::reference;
1461 template<
typename _Iter2>
1464#if __cpp_lib_concepts
1467 template<
typename _Iter2>
1468 static constexpr bool __convertible = !is_same_v<_Iter2, _Iterator>
1472#if __cplusplus > 201703L && __cpp_lib_concepts
1476 if constexpr (random_access_iterator<_Iterator>)
1478 else if constexpr (bidirectional_iterator<_Iterator>)
1480 else if constexpr (forward_iterator<_Iterator>)
1488 using iterator_type = _Iterator;
1490#if __cplusplus > 201703L && __cpp_lib_concepts
1492# define __cpp_lib_move_iterator_concept 202207L
1493 using iterator_concept =
decltype(_S_iter_concept());
1496 using value_type = iter_value_t<_Iterator>;
1497 using difference_type = iter_difference_t<_Iterator>;
1498 using pointer = _Iterator;
1499 using reference = iter_rvalue_reference_t<_Iterator>;
1501 typedef typename __traits_type::iterator_category iterator_category;
1502 typedef typename __traits_type::value_type value_type;
1503 typedef typename __traits_type::difference_type difference_type;
1505 typedef _Iterator pointer;
1509 = __conditional_t<is_reference<__base_ref>::value,
1510 typename remove_reference<__base_ref>::type&&,
1514 _GLIBCXX17_CONSTEXPR
1518 explicit _GLIBCXX17_CONSTEXPR
1522 template<
typename _Iter>
1523#if __cpp_lib_concepts
1524 requires __convertible<_Iter>
1526 _GLIBCXX17_CONSTEXPR
1528 : _M_current(__i._M_current) { }
1530 template<
typename _Iter>
1531#if __cpp_lib_concepts
1532 requires __convertible<_Iter>
1535 _GLIBCXX17_CONSTEXPR
1538 _M_current = __i._M_current;
1542#if __cplusplus <= 201703L
1544 _GLIBCXX17_CONSTEXPR iterator_type
1546 {
return _M_current; }
1549 constexpr const iterator_type&
1550 base()
const &
noexcept
1551 {
return _M_current; }
1554 constexpr iterator_type
1560 _GLIBCXX17_CONSTEXPR reference
1562#if __cplusplus > 201703L && __cpp_lib_concepts
1563 {
return ranges::iter_move(_M_current); }
1565 {
return static_cast<reference
>(*_M_current); }
1569 _GLIBCXX17_CONSTEXPR pointer
1571 {
return _M_current; }
1588#if __cpp_lib_concepts
1590 operator++(
int)
requires (!forward_iterator<_Iterator>)
1615 operator+=(difference_type __n)
1627 operator-=(difference_type __n)
1634 _GLIBCXX17_CONSTEXPR reference
1635 operator[](difference_type __n)
const
1636#if __cplusplus > 201703L && __cpp_lib_concepts
1637 {
return ranges::iter_move(_M_current + __n); }
1642#if __cplusplus > 201703L && __cpp_lib_concepts
1643 template<sentinel_for<_Iterator> _Sent>
1645 friend constexpr bool
1646 operator==(
const move_iterator& __x,
const move_sentinel<_Sent>& __y)
1647 {
return __x.base() == __y.base(); }
1649 template<sized_sentinel_for<_Iterator> _Sent>
1651 friend constexpr iter_difference_t<_Iterator>
1653 {
return __x.base() - __y.base(); }
1655 template<sized_sentinel_for<_Iterator> _Sent>
1657 friend constexpr iter_difference_t<_Iterator>
1659 {
return __x.base() - __y.base(); }
1662 friend constexpr iter_rvalue_reference_t<_Iterator>
1664 noexcept(
noexcept(ranges::iter_move(__i._M_current)))
1665 {
return ranges::iter_move(__i._M_current); }
1667 template<indirectly_swappable<_Iterator> _Iter2>
1668 friend constexpr void
1670 noexcept(
noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1671 {
return ranges::iter_swap(__x._M_current, __y._M_current); }
1675 template<
typename _IteratorL,
typename _IteratorR>
1677 inline _GLIBCXX17_CONSTEXPR
bool
1680#if __cplusplus > 201703L && __cpp_lib_concepts
1681 requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
1683 {
return __x.base() == __y.base(); }
1685#if __cpp_lib_three_way_comparison
1686 template<
typename _IteratorL,
1687 three_way_comparable_with<_IteratorL> _IteratorR>
1689 constexpr compare_three_way_result_t<_IteratorL, _IteratorR>
1690 operator<=>(
const move_iterator<_IteratorL>& __x,
1691 const move_iterator<_IteratorR>& __y)
1692 {
return __x.base() <=> __y.base(); }
1694 template<
typename _IteratorL,
typename _IteratorR>
1696 inline _GLIBCXX17_CONSTEXPR
bool
1697 operator!=(
const move_iterator<_IteratorL>& __x,
1698 const move_iterator<_IteratorR>& __y)
1699 {
return !(__x == __y); }
1702 template<
typename _IteratorL,
typename _IteratorR>
1704 inline _GLIBCXX17_CONSTEXPR
bool
1705 operator<(
const move_iterator<_IteratorL>& __x,
1706 const move_iterator<_IteratorR>& __y)
1707#if __cplusplus > 201703L && __cpp_lib_concepts
1708 requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
1710 {
return __x.base() < __y.base(); }
1712 template<
typename _IteratorL,
typename _IteratorR>
1714 inline _GLIBCXX17_CONSTEXPR
bool
1715 operator<=(
const move_iterator<_IteratorL>& __x,
1716 const move_iterator<_IteratorR>& __y)
1717#if __cplusplus > 201703L && __cpp_lib_concepts
1718 requires requires { { __y.base() < __x.base() } -> convertible_to<bool>; }
1720 {
return !(__y < __x); }
1722 template<
typename _IteratorL,
typename _IteratorR>
1724 inline _GLIBCXX17_CONSTEXPR
bool
1725 operator>(
const move_iterator<_IteratorL>& __x,
1726 const move_iterator<_IteratorR>& __y)
1727#if __cplusplus > 201703L && __cpp_lib_concepts
1728 requires requires { { __y.base() < __x.base() } -> convertible_to<bool>; }
1730 {
return __y < __x; }
1732 template<
typename _IteratorL,
typename _IteratorR>
1734 inline _GLIBCXX17_CONSTEXPR
bool
1735 operator>=(
const move_iterator<_IteratorL>& __x,
1736 const move_iterator<_IteratorR>& __y)
1737#if __cplusplus > 201703L && __cpp_lib_concepts
1738 requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
1740 {
return !(__x < __y); }
1745 template<
typename _Iterator>
1747 inline _GLIBCXX17_CONSTEXPR
bool
1748 operator==(
const move_iterator<_Iterator>& __x,
1749 const move_iterator<_Iterator>& __y)
1750 {
return __x.base() == __y.base(); }
1752#if __cpp_lib_three_way_comparison
1753 template<three_way_comparable _Iterator>
1755 constexpr compare_three_way_result_t<_Iterator>
1756 operator<=>(
const move_iterator<_Iterator>& __x,
1757 const move_iterator<_Iterator>& __y)
1758 {
return __x.base() <=> __y.base(); }
1760 template<
typename _Iterator>
1762 inline _GLIBCXX17_CONSTEXPR
bool
1763 operator!=(
const move_iterator<_Iterator>& __x,
1764 const move_iterator<_Iterator>& __y)
1765 {
return !(__x == __y); }
1767 template<
typename _Iterator>
1769 inline _GLIBCXX17_CONSTEXPR
bool
1770 operator<(
const move_iterator<_Iterator>& __x,
1771 const move_iterator<_Iterator>& __y)
1772 {
return __x.base() < __y.base(); }
1774 template<
typename _Iterator>
1776 inline _GLIBCXX17_CONSTEXPR
bool
1777 operator<=(
const move_iterator<_Iterator>& __x,
1778 const move_iterator<_Iterator>& __y)
1779 {
return !(__y < __x); }
1781 template<
typename _Iterator>
1783 inline _GLIBCXX17_CONSTEXPR
bool
1784 operator>(
const move_iterator<_Iterator>& __x,
1785 const move_iterator<_Iterator>& __y)
1786 {
return __y < __x; }
1788 template<
typename _Iterator>
1790 inline _GLIBCXX17_CONSTEXPR
bool
1791 operator>=(
const move_iterator<_Iterator>& __x,
1792 const move_iterator<_Iterator>& __y)
1793 {
return !(__x < __y); }
1797 template<
typename _IteratorL,
typename _IteratorR>
1799 inline _GLIBCXX17_CONSTEXPR
auto
1800 operator-(
const move_iterator<_IteratorL>& __x,
1801 const move_iterator<_IteratorR>& __y)
1802 ->
decltype(__x.base() - __y.base())
1803 {
return __x.base() - __y.base(); }
1805 template<
typename _Iterator>
1807 inline _GLIBCXX17_CONSTEXPR move_iterator<_Iterator>
1808 operator+(
typename move_iterator<_Iterator>::difference_type __n,
1809 const move_iterator<_Iterator>& __x)
1810 {
return __x + __n; }
1812 template<
typename _Iterator>
1814 inline _GLIBCXX17_CONSTEXPR move_iterator<_Iterator>
1815 make_move_iterator(_Iterator __i)
1816 {
return move_iterator<_Iterator>(
std::move(__i)); }
1818 template<
typename _Iterator,
typename _ReturnType
1819 = __conditional_t<__move_if_noexcept_cond
1820 <
typename iterator_traits<_Iterator>::value_type>::value,
1821 _Iterator, move_iterator<_Iterator>>>
1822 inline _GLIBCXX17_CONSTEXPR _ReturnType
1823 __make_move_if_noexcept_iterator(_Iterator __i)
1824 {
return _ReturnType(__i); }
1828 template<
typename _Tp,
typename _ReturnType
1829 = __conditional_t<__move_if_noexcept_cond<_Tp>::value,
1830 const _Tp*, move_iterator<_Tp*>>>
1831 inline _GLIBCXX17_CONSTEXPR _ReturnType
1832 __make_move_if_noexcept_iterator(_Tp* __i)
1833 {
return _ReturnType(__i); }
1835#if __cplusplus > 201703L && __cpp_lib_concepts
1840 template<
typename _It>
1841 concept __common_iter_has_arrow = indirectly_readable<const _It>
1842 && (
requires(
const _It& __it) { __it.operator->(); }
1843 || is_reference_v<iter_reference_t<_It>>
1844 || constructible_from<iter_value_t<_It>, iter_reference_t<_It>>);
1846 template<
typename _It>
1847 concept __common_iter_use_postfix_proxy
1848 = (!
requires (_It& __i) { { *__i++ } -> __can_reference; })
1849 && constructible_from<iter_value_t<_It>, iter_reference_t<_It>>
1850 && move_constructible<iter_value_t<_It>>;
1854 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
1855 requires (!same_as<_It, _Sent>) && copyable<_It>
1858 template<
typename _Tp,
typename _Up>
1859 static constexpr bool
1862 if constexpr (is_trivially_default_constructible_v<_Tp>)
1863 return is_nothrow_assignable_v<_Tp&, _Up>;
1865 return is_nothrow_constructible_v<_Tp, _Up>;
1868 template<
typename _It2,
typename _Sent2>
1869 static constexpr bool
1871 {
return _S_noexcept1<_It, _It2>() && _S_noexcept1<_Sent, _Sent2>(); }
1875 iter_value_t<_It> _M_keep;
1878 __arrow_proxy(iter_reference_t<_It>&& __x)
1884 constexpr const iter_value_t<_It>*
1885 operator->()
const noexcept
1889 class __postfix_proxy
1891 iter_value_t<_It> _M_keep;
1894 __postfix_proxy(iter_reference_t<_It>&& __x)
1895 : _M_keep(
std::forward<iter_reference_t<_It>>(__x)) { }
1900 constexpr const iter_value_t<_It>&
1908 noexcept(is_nothrow_default_constructible_v<_It>)
1910 : _M_it(), _M_index(0)
1915 noexcept(is_nothrow_move_constructible_v<_It>)
1921 noexcept(is_nothrow_move_constructible_v<_Sent>)
1925 template<
typename _It2,
typename _Sent2>
1930 noexcept(_S_noexcept<const _It2&, const _Sent2&>())
1931 : _M_valueless(), _M_index(__x._M_index)
1933 __glibcxx_assert(__x._M_has_value());
1936 if constexpr (is_trivially_default_constructible_v<_It>)
1941 else if (_M_index == 1)
1943 if constexpr (is_trivially_default_constructible_v<_Sent>)
1954 noexcept(_S_noexcept<const _It&, const _Sent&>())
1955 requires (!is_trivially_copyable_v<_It> || !is_trivially_copyable_v<_Sent>)
1956 : _M_valueless(), _M_index(__x._M_index)
1960 if constexpr (is_trivially_default_constructible_v<_It>)
1965 else if (_M_index == 1)
1967 if constexpr (is_trivially_default_constructible_v<_Sent>)
1968 _M_sent = __x._M_sent;
1978 noexcept(_S_noexcept<_It, _Sent>())
1979 requires (!is_trivially_copyable_v<_It> || !is_trivially_copyable_v<_Sent>)
1980 : _M_valueless(), _M_index(__x._M_index)
1984 if constexpr (is_trivially_default_constructible_v<_It>)
1989 else if (_M_index == 1)
1991 if constexpr (is_trivially_default_constructible_v<_Sent>)
2004 noexcept(is_nothrow_copy_assignable_v<_It>
2005 && is_nothrow_copy_assignable_v<_Sent>
2006 && is_nothrow_copy_constructible_v<_It>
2007 && is_nothrow_copy_constructible_v<_Sent>)
2008 requires (!is_trivially_copy_assignable_v<_It>
2009 || !is_trivially_copy_assignable_v<_Sent>)
2020 noexcept(is_nothrow_move_assignable_v<_It>
2021 && is_nothrow_move_assignable_v<_Sent>
2022 && is_nothrow_move_constructible_v<_It>
2023 && is_nothrow_move_constructible_v<_Sent>)
2024 requires (!is_trivially_move_assignable_v<_It>
2025 || !is_trivially_move_assignable_v<_Sent>)
2031 template<
typename _It2,
typename _Sent2>
2038 noexcept(is_nothrow_constructible_v<_It, const _It2&>
2039 && is_nothrow_constructible_v<_Sent, const _Sent2&>
2040 && is_nothrow_assignable_v<_It&, const _It2&>
2041 && is_nothrow_assignable_v<_Sent&, const _Sent2&>)
2043 __glibcxx_assert(__x._M_has_value());
2048#if __cpp_concepts >= 202002L
2053 requires (!is_trivially_destructible_v<_It>
2054 || !is_trivially_destructible_v<_Sent>)
2062 else if (_M_index == 1)
2067 constexpr decltype(
auto)
2070 __glibcxx_assert(_M_index == 0);
2075 constexpr decltype(
auto)
2076 operator*()
const requires __detail::__dereferenceable<const _It>
2078 __glibcxx_assert(_M_index == 0);
2084 operator->()
const requires __detail::__common_iter_has_arrow<_It>
2086 __glibcxx_assert(_M_index == 0);
2087 if constexpr (is_pointer_v<_It> ||
requires { _M_it.operator->(); })
2089 else if constexpr (is_reference_v<iter_reference_t<_It>>)
2091 auto&& __tmp = *_M_it;
2095 return __arrow_proxy{*_M_it};
2101 __glibcxx_assert(_M_index == 0);
2106 constexpr decltype(
auto)
2109 __glibcxx_assert(_M_index == 0);
2110 if constexpr (forward_iterator<_It>)
2116 else if constexpr (!__detail::__common_iter_use_postfix_proxy<_It>)
2120 __postfix_proxy __p(**
this);
2126 template<
typename _It2, sentinel_for<_It> _Sent2>
2127 requires sentinel_for<_Sent, _It2>
2128 friend constexpr bool
2132 switch(__x._M_index << 2 | __y._M_index)
2138 return __x._M_it == __y._M_sent;
2140 return __x._M_sent == __y._M_it;
2142 __glibcxx_assert(__x._M_has_value());
2143 __glibcxx_assert(__y._M_has_value());
2144 __builtin_unreachable();
2148 template<
typename _It2, sentinel_for<_It> _Sent2>
2149 requires sentinel_for<_Sent, _It2> && equality_comparable_with<_It, _It2>
2150 friend constexpr bool
2154 switch(__x._M_index << 2 | __y._M_index)
2159 return __x._M_it == __y._M_it;
2161 return __x._M_it == __y._M_sent;
2163 return __x._M_sent == __y._M_it;
2165 __glibcxx_assert(__x._M_has_value());
2166 __glibcxx_assert(__y._M_has_value());
2167 __builtin_unreachable();
2171 template<sized_sentinel_for<_It> _It2, sized_sentinel_for<_It> _Sent2>
2172 requires sized_sentinel_for<_Sent, _It2>
2173 friend constexpr iter_difference_t<_It2>
2177 switch(__x._M_index << 2 | __y._M_index)
2182 return __x._M_it - __y._M_it;
2184 return __x._M_it - __y._M_sent;
2186 return __x._M_sent - __y._M_it;
2188 __glibcxx_assert(__x._M_has_value());
2189 __glibcxx_assert(__y._M_has_value());
2190 __builtin_unreachable();
2195 friend constexpr iter_rvalue_reference_t<_It>
2197 noexcept(
noexcept(ranges::iter_move(std::declval<const _It&>())))
2198 requires input_iterator<_It>
2200 __glibcxx_assert(__i._M_index == 0);
2201 return ranges::iter_move(__i._M_it);
2204 template<indirectly_swappable<_It> _It2,
typename _Sent2>
2205 friend constexpr void
2208 noexcept(
noexcept(ranges::iter_swap(std::declval<const _It&>(),
2209 std::declval<const _It2&>())))
2211 __glibcxx_assert(__x._M_index == 0);
2212 __glibcxx_assert(__y._M_index == 0);
2213 return ranges::iter_swap(__x._M_it, __y._M_it);
2217 template<input_or_output_iterator _It2, sentinel_for<_It2> _Sent2>
2222 _M_has_value()
const noexcept {
return _M_index != _S_valueless; }
2224 template<
typename _CIt>
2226 _M_assign(_CIt&& __x)
2228 if (_M_index == __x._M_index)
2231 _M_it = std::forward<_CIt>(__x)._M_it;
2232 else if (_M_index == 1)
2233 _M_sent = std::forward<_CIt>(__x)._M_sent;
2239 else if (_M_index == 1)
2241 _M_index = _S_valueless;
2243 if (__x._M_index == 0)
2245 std::forward<_CIt>(__x)._M_it);
2246 else if (__x._M_index == 1)
2248 std::forward<_CIt>(__x)._M_sent);
2249 _M_index = __x._M_index;
2257 unsigned char _M_valueless;
2259 unsigned char _M_index;
2261 static constexpr unsigned char _S_valueless{2};
2264 template<
typename _It,
typename _Sent>
2267 using difference_type = iter_difference_t<_It>;
2270 template<input_iterator _It,
typename _Sent>
2271 struct iterator_traits<common_iterator<_It, _Sent>>
2274 template<
typename _Iter>
2280 template<
typename _Iter>
2281 requires __detail::__common_iter_has_arrow<_Iter>
2284 using _CIter = common_iterator<_Iter, _Sent>;
2285 using type =
decltype(std::declval<const _CIter&>().operator->());
2291 if constexpr (
requires {
requires derived_from<__iter_category_t<_It>,
2292 forward_iterator_tag>; })
2293 return forward_iterator_tag{};
2295 return input_iterator_tag{};
2299 using iterator_concept = __conditional_t<forward_iterator<_It>,
2300 forward_iterator_tag,
2301 input_iterator_tag>;
2302 using iterator_category =
decltype(_S_iter_cat());
2303 using value_type = iter_value_t<_It>;
2304 using difference_type = iter_difference_t<_It>;
2305 using pointer =
typename __ptr<_It>::type;
2306 using reference = iter_reference_t<_It>;
2313 template<
typename _It>
2314 struct __counted_iter_value_type
2317 template<indirectly_readable _It>
2318 struct __counted_iter_value_type<_It>
2319 {
using value_type = iter_value_t<_It>; };
2321 template<
typename _It>
2322 struct __counted_iter_concept
2325 template<
typename _It>
2326 requires requires {
typename _It::iterator_concept; }
2327 struct __counted_iter_concept<_It>
2328 {
using iterator_concept =
typename _It::iterator_concept; };
2330 template<
typename _It>
2331 struct __counted_iter_cat
2334 template<
typename _It>
2335 requires requires {
typename _It::iterator_category; }
2336 struct __counted_iter_cat<_It>
2337 {
using iterator_category =
typename _It::iterator_category; };
2341 template<input_or_output_iterator _It>
2343 :
public __detail::__counted_iter_value_type<_It>,
2344 public __detail::__counted_iter_concept<_It>,
2345 public __detail::__counted_iter_cat<_It>
2348 using iterator_type = _It;
2350 using difference_type = iter_difference_t<_It>;
2358 : _M_current(
std::move(__i)), _M_length(__n)
2359 { __glibcxx_assert(__n >= 0); }
2361 template<
typename _It2>
2365 : _M_current(__x._M_current), _M_length(__x._M_length)
2368 template<
typename _It2>
2373 _M_current = __x._M_current;
2374 _M_length = __x._M_length;
2379 constexpr const _It&
2380 base()
const &
noexcept
2381 {
return _M_current; }
2386 noexcept(is_nothrow_move_constructible_v<_It>)
2390 constexpr iter_difference_t<_It>
2391 count()
const noexcept {
return _M_length; }
2394 constexpr decltype(
auto)
2396 noexcept(
noexcept(*_M_current))
2398 __glibcxx_assert( _M_length > 0 );
2403 constexpr decltype(
auto)
2405 noexcept(
noexcept(*_M_current))
2406 requires __detail::__dereferenceable<const _It>
2408 __glibcxx_assert( _M_length > 0 );
2414 operator->()
const noexcept
2415 requires contiguous_iterator<_It>
2421 __glibcxx_assert(_M_length > 0);
2427 constexpr decltype(
auto)
2430 __glibcxx_assert(_M_length > 0);
2434 return _M_current++;
2437 __throw_exception_again;
2442 operator++(
int)
requires forward_iterator<_It>
2450 operator--()
requires bidirectional_iterator<_It>
2458 operator--(
int)
requires bidirectional_iterator<_It>
2467 operator+(iter_difference_t<_It> __n)
const
2468 requires random_access_iterator<_It>
2474 requires random_access_iterator<_It>
2475 {
return __x + __n; }
2478 operator+=(iter_difference_t<_It> __n)
2479 requires random_access_iterator<_It>
2481 __glibcxx_assert(__n <= _M_length);
2489 operator-(iter_difference_t<_It> __n)
const
2490 requires random_access_iterator<_It>
2493 template<common_with<_It> _It2>
2495 friend constexpr iter_difference_t<_It2>
2498 {
return __y._M_length - __x._M_length; }
2501 friend constexpr iter_difference_t<_It>
2503 {
return -__x._M_length; }
2506 friend constexpr iter_difference_t<_It>
2508 {
return __y._M_length; }
2511 operator-=(iter_difference_t<_It> __n)
2512 requires random_access_iterator<_It>
2514 __glibcxx_assert(-__n <= _M_length);
2521 constexpr decltype(
auto)
2522 operator[](iter_difference_t<_It> __n)
const
2523 noexcept(
noexcept(_M_current[__n]))
2524 requires random_access_iterator<_It>
2526 __glibcxx_assert(__n < _M_length);
2527 return _M_current[__n];
2530 template<common_with<_It> _It2>
2532 friend constexpr bool
2535 {
return __x._M_length == __y._M_length; }
2538 friend constexpr bool
2540 {
return __x._M_length == 0; }
2542 template<common_with<_It> _It2>
2544 friend constexpr strong_ordering
2547 {
return __y._M_length <=> __x._M_length; }
2550 friend constexpr iter_rvalue_reference_t<_It>
2552 noexcept(
noexcept(ranges::iter_move(__i._M_current)))
2553 requires input_iterator<_It>
2555 __glibcxx_assert( __i._M_length > 0 );
2556 return ranges::iter_move(__i._M_current);
2559 template<indirectly_swappable<_It> _It2>
2560 friend constexpr void
2563 noexcept(
noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
2565 __glibcxx_assert( __x._M_length > 0 && __y._M_length > 0 );
2566 ranges::iter_swap(__x._M_current, __y._M_current);
2572 _It _M_current = _It();
2573 iter_difference_t<_It> _M_length = 0;
2576 template<input_iterator _It>
2580 using pointer = __conditional_t<contiguous_iterator<_It>,
2585#if __cplusplus > 202020L
2586 template<indirectly_readable _It>
2587 using iter_const_reference_t
2588 = common_reference_t<const iter_value_t<_It>&&, iter_reference_t<_It>>;
2590 template<input_iterator _It>
class basic_const_iterator;
2594 template<
typename _It>
2595 concept __constant_iterator = input_iterator<_It>
2596 && same_as<iter_const_reference_t<_It>, iter_reference_t<_It>>;
2598 template<
typename _Tp>
2599 inline constexpr bool __is_const_iterator =
false;
2601 template<
typename _It>
2602 inline constexpr bool __is_const_iterator<basic_const_iterator<_It>> =
true;
2604 template<
typename _Tp>
2605 concept __not_a_const_iterator = !__is_const_iterator<_Tp>;
2607 template<indirectly_readable _It>
2608 using __iter_const_rvalue_reference_t
2609 = common_reference_t<const iter_value_t<_It>&&, iter_rvalue_reference_t<_It>>;
2611 template<
typename _It>
2612 struct __basic_const_iterator_iter_cat
2615 template<forward_iterator _It>
2616 struct __basic_const_iterator_iter_cat<_It>
2617 {
using iterator_category = __iter_category_t<_It>; };
2620 template<input_iterator _It>
2621 using const_iterator
2622 = __conditional_t<__detail::__constant_iterator<_It>, _It, basic_const_iterator<_It>>;
2626 template<
typename _Sent>
2627 struct __const_sentinel
2628 {
using type = _Sent; };
2630 template<input_iterator _Sent>
2631 struct __const_sentinel<_Sent>
2632 {
using type = const_iterator<_Sent>; };
2635 template<semiregular _Sent>
2636 using const_sentinel =
typename __detail::__const_sentinel<_Sent>::type;
2638 template<input_iterator _It>
2639 class basic_const_iterator
2640 :
public __detail::__basic_const_iterator_iter_cat<_It>
2642 _It _M_current = _It();
2643 using __reference = iter_const_reference_t<_It>;
2644 using __rvalue_reference = __detail::__iter_const_rvalue_reference_t<_It>;
2649 if constexpr (contiguous_iterator<_It>)
2650 return contiguous_iterator_tag{};
2651 else if constexpr (random_access_iterator<_It>)
2652 return random_access_iterator_tag{};
2653 else if constexpr (bidirectional_iterator<_It>)
2654 return bidirectional_iterator_tag{};
2655 else if constexpr (forward_iterator<_It>)
2656 return forward_iterator_tag{};
2658 return input_iterator_tag{};
2661 template<input_iterator _It2>
friend class basic_const_iterator;
2664 using iterator_concept =
decltype(_S_iter_concept());
2665 using value_type = iter_value_t<_It>;
2666 using difference_type = iter_difference_t<_It>;
2668 basic_const_iterator()
requires default_initializable<_It> = default;
2671 basic_const_iterator(_It __current)
2672 noexcept(is_nothrow_move_constructible_v<_It>)
2673 : _M_current(
std::move(__current))
2676 template<convertible_to<_It> _It2>
2678 basic_const_iterator(basic_const_iterator<_It2> __current)
2679 noexcept(is_nothrow_constructible_v<_It, _It2>)
2680 : _M_current(
std::move(__current._M_current))
2683 template<__detail::__different_from<basic_const_iterator> _Tp>
2684 requires convertible_to<_Tp, _It>
2686 basic_const_iterator(_Tp&& __current)
2687 noexcept(is_nothrow_constructible_v<_It, _Tp>)
2688 : _M_current(std::forward<_Tp>(__current))
2691 constexpr const _It&
2692 base() const & noexcept
2693 {
return _M_current; }
2697 noexcept(is_nothrow_move_constructible_v<_It>)
2700 constexpr __reference
2702 noexcept(noexcept(static_cast<__reference>(*_M_current)))
2703 {
return static_cast<__reference
>(*_M_current); }
2705 constexpr const auto*
2707 noexcept(contiguous_iterator<_It> || noexcept(*_M_current))
2708 requires is_lvalue_reference_v<iter_reference_t<_It>>
2709 && same_as<remove_cvref_t<iter_reference_t<_It>>, value_type>
2711 if constexpr (contiguous_iterator<_It>)
2717 constexpr basic_const_iterator&
2719 noexcept(noexcept(++_M_current))
2727 noexcept(
noexcept(++_M_current))
2730 constexpr basic_const_iterator
2732 noexcept(
noexcept(++*
this) && is_nothrow_copy_constructible_v<basic_const_iterator>)
2733 requires forward_iterator<_It>
2740 constexpr basic_const_iterator&
2742 noexcept(noexcept(--_M_current))
2743 requires bidirectional_iterator<_It>
2749 constexpr basic_const_iterator
2751 noexcept(
noexcept(--*
this) && is_nothrow_copy_constructible_v<basic_const_iterator>)
2752 requires bidirectional_iterator<_It>
2759 constexpr basic_const_iterator&
2760 operator+=(difference_type __n)
2761 noexcept(
noexcept(_M_current += __n))
2762 requires random_access_iterator<_It>
2768 constexpr basic_const_iterator&
2769 operator-=(difference_type __n)
2770 noexcept(
noexcept(_M_current -= __n))
2771 requires random_access_iterator<_It>
2777 constexpr __reference
2778 operator[](difference_type __n)
const
2779 noexcept(
noexcept(
static_cast<__reference
>(_M_current[__n])))
2780 requires random_access_iterator<_It>
2781 {
return static_cast<__reference
>(_M_current[__n]); }
2783 template<sentinel_for<_It> _Sent>
2785 operator==(
const _Sent& __s)
const
2786 noexcept(
noexcept(_M_current == __s))
2787 {
return _M_current == __s; }
2790 operator<(
const basic_const_iterator& __y)
const
2791 noexcept(
noexcept(_M_current < __y._M_current))
2792 requires random_access_iterator<_It>
2793 {
return _M_current < __y._M_current; }
2796 operator>(
const basic_const_iterator& __y)
const
2797 noexcept(
noexcept(_M_current > __y._M_current))
2798 requires random_access_iterator<_It>
2799 {
return _M_current > __y._M_current; }
2802 operator<=(
const basic_const_iterator& __y)
const
2803 noexcept(
noexcept(_M_current <= __y._M_current))
2804 requires random_access_iterator<_It>
2805 {
return _M_current <= __y._M_current; }
2808 operator>=(
const basic_const_iterator& __y)
const
2809 noexcept(
noexcept(_M_current >= __y._M_current))
2810 requires random_access_iterator<_It>
2811 {
return _M_current >= __y._M_current; }
2814 operator<=>(
const basic_const_iterator& __y)
const
2815 noexcept(
noexcept(_M_current <=> __y._M_current))
2816 requires random_access_iterator<_It> && three_way_comparable<_It>
2817 {
return _M_current <=> __y._M_current; }
2819 template<__detail::__different_from<basic_const_iterator> _It2>
2821 operator<(
const _It2& __y)
const
2822 noexcept(
noexcept(_M_current < __y))
2823 requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
2824 {
return _M_current < __y; }
2826 template<__detail::__different_from<basic_const_iterator> _It2>
2828 operator>(
const _It2& __y)
const
2829 noexcept(
noexcept(_M_current > __y))
2830 requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
2831 {
return _M_current > __y; }
2833 template<__detail::__different_from<basic_const_iterator> _It2>
2835 operator<=(
const _It2& __y)
const
2836 noexcept(
noexcept(_M_current <= __y))
2837 requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
2838 {
return _M_current <= __y; }
2840 template<__detail::__different_from<basic_const_iterator> _It2>
2842 operator>=(
const _It2& __y)
const
2843 noexcept(
noexcept(_M_current >= __y))
2844 requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
2845 {
return _M_current >= __y; }
2847 template<__detail::__different_from<basic_const_iterator> _It2>
2849 operator<=>(
const _It2& __y)
const
2850 noexcept(
noexcept(_M_current <=> __y))
2851 requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
2852 && three_way_comparable_with<_It, _It2>
2853 {
return _M_current <=> __y; }
2855 template<__detail::__not_a_const_iterator _It2>
2856 friend constexpr bool
2857 operator<(
const _It2& __x,
const basic_const_iterator& __y)
2858 noexcept(
noexcept(__x < __y._M_current))
2859 requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
2860 {
return __x < __y._M_current; }
2862 template<__detail::__not_a_const_iterator _It2>
2863 friend constexpr bool
2864 operator>(
const _It2& __x,
const basic_const_iterator& __y)
2865 noexcept(
noexcept(__x > __y._M_current))
2866 requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
2867 {
return __x > __y._M_current; }
2869 template<__detail::__not_a_const_iterator _It2>
2870 friend constexpr bool
2871 operator<=(
const _It2& __x,
const basic_const_iterator& __y)
2872 noexcept(
noexcept(__x <= __y._M_current))
2873 requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
2874 {
return __x <= __y._M_current; }
2876 template<__detail::__not_a_const_iterator _It2>
2877 friend constexpr bool
2878 operator>=(
const _It2& __x,
const basic_const_iterator& __y)
2879 noexcept(
noexcept(__x >= __y._M_current))
2880 requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
2881 {
return __x >= __y._M_current; }
2883 friend constexpr basic_const_iterator
2884 operator+(
const basic_const_iterator& __i, difference_type __n)
2885 noexcept(
noexcept(basic_const_iterator(__i._M_current + __n)))
2886 requires random_access_iterator<_It>
2887 {
return basic_const_iterator(__i._M_current + __n); }
2889 friend constexpr basic_const_iterator
2890 operator+(difference_type __n,
const basic_const_iterator& __i)
2891 noexcept(
noexcept(basic_const_iterator(__i._M_current + __n)))
2892 requires random_access_iterator<_It>
2893 {
return basic_const_iterator(__i._M_current + __n); }
2895 friend constexpr basic_const_iterator
2896 operator-(
const basic_const_iterator& __i, difference_type __n)
2897 noexcept(
noexcept(basic_const_iterator(__i._M_current - __n)))
2898 requires random_access_iterator<_It>
2899 {
return basic_const_iterator(__i._M_current - __n); }
2901 template<sized_sentinel_for<_It> _Sent>
2902 constexpr difference_type
2904 noexcept(
noexcept(_M_current - __y))
2905 {
return _M_current - __y; }
2907 template<__detail::__not_a_const_iterator _Sent>
2908 requires sized_sentinel_for<_Sent, _It>
2909 friend constexpr difference_type
2910 operator-(
const _Sent& __x,
const basic_const_iterator& __y)
2911 noexcept(
noexcept(__x - __y._M_current))
2912 {
return __x - __y._M_current; }
2914 friend constexpr __rvalue_reference
2915 iter_move(
const basic_const_iterator& __i)
2916 noexcept(
noexcept(
static_cast<__rvalue_reference
>(ranges::iter_move(__i._M_current))))
2917 {
return static_cast<__rvalue_reference
>(ranges::iter_move(__i._M_current)); }
2920 template<
typename _Tp, common_with<_Tp> _Up>
2921 requires input_iterator<common_type_t<_Tp, _Up>>
2922 struct common_type<basic_const_iterator<_Tp>, _Up>
2923 {
using type = basic_const_iterator<common_type_t<_Tp, _Up>>; };
2925 template<
typename _Tp, common_with<_Tp> _Up>
2926 requires input_iterator<common_type_t<_Tp, _Up>>
2927 struct common_type<_Up, basic_const_iterator<_Tp>>
2928 {
using type = basic_const_iterator<common_type_t<_Tp, _Up>>; };
2930 template<
typename _Tp, common_with<_Tp> _Up>
2931 requires input_iterator<common_type_t<_Tp, _Up>>
2932 struct common_type<basic_const_iterator<_Tp>, basic_const_iterator<_Up>>
2933 {
using type = basic_const_iterator<common_type_t<_Tp, _Up>>; };
2935 template<input_iterator _It>
2936 constexpr const_iterator<_It>
2937 make_const_iterator(_It __it)
2938 noexcept(is_nothrow_convertible_v<_It, const_iterator<_It>>)
2941 template<semiregular _Sent>
2942 constexpr const_sentinel<_Sent>
2943 make_const_sentinel(_Sent __s)
2944 noexcept(is_nothrow_convertible_v<_Sent, const_sentinel<_Sent>>)
2951 template<
typename _Iterator>
2952 _GLIBCXX20_CONSTEXPR
2954 __niter_base(move_iterator<_Iterator> __it)
2955 ->
decltype(make_move_iterator(__niter_base(__it.base())))
2956 {
return make_move_iterator(__niter_base(__it.base())); }
2958 template<
typename _Iterator>
2959 struct __is_move_iterator<move_iterator<_Iterator> >
2961 enum { __value = 1 };
2962 typedef __true_type __type;
2965 template<
typename _Iterator>
2966 _GLIBCXX20_CONSTEXPR
2968 __miter_base(move_iterator<_Iterator> __it)
2969 ->
decltype(__miter_base(__it.base()))
2970 {
return __miter_base(__it.base()); }
2972#define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) std::make_move_iterator(_Iter)
2973#define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) \
2974 std::__make_move_if_noexcept_iterator(_Iter)
2976#define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) (_Iter)
2977#define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) (_Iter)
2980#if __cpp_deduction_guides >= 201606
2983 template<
typename _InputIterator>
2985 typename iterator_traits<_InputIterator>::value_type::first_type>;
2987 template<
typename _InputIterator>
2989 =
typename iterator_traits<_InputIterator>::value_type::second_type;
2991 template<
typename _T1,
typename _T2>
2994 template<
typename _InputIterator>
2995 using __iter_to_alloc_t
2996 = pair<const __iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>>;
2999_GLIBCXX_END_NAMESPACE_VERSION
3002#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 std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
constexpr _Tp && forward(typename std::remove_reference< _Tp >::type &__t) noexcept
Forward an lvalue.
constexpr reverse_iterator< _Iterator > make_reverse_iterator(_Iterator __i)
Generator function for reverse_iterator.
constexpr insert_iterator< _Container > inserter(_Container &__x, std::__detail::__range_iter_t< _Container > __i)
constexpr front_insert_iterator< _Container > front_inserter(_Container &__x)
constexpr back_insert_iterator< _Container > back_inserter(_Container &__x)
ISO C++ entities toplevel namespace is std.
GNU extensions for public use.
is_nothrow_copy_constructible
Traits class for iterators.
constexpr reverse_iterator(const reverse_iterator< _Iter > &__x) noexcept(/*conditional */)
constexpr reverse_iterator & operator-=(difference_type __n)
constexpr reverse_iterator & operator+=(difference_type __n)
constexpr reverse_iterator operator+(difference_type __n) const
constexpr iterator_type base() const noexcept(/*conditional */)
constexpr reverse_iterator(const reverse_iterator &__x) noexcept(/*conditional */)
constexpr reference operator[](difference_type __n) const
constexpr reverse_iterator & operator--()
constexpr reverse_iterator() noexcept(/*conditional */)
constexpr pointer operator->() const
constexpr reverse_iterator(iterator_type __x) noexcept(/*conditional */)
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. (This iterator does not move.)
constexpr back_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 back_insert_iterator & operator*()
Simply returns *this.
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++(int)
Simply returns *this. (This iterator does not move.)
constexpr insert_iterator & operator*()
Simply returns *this.
_Container container_type
A nested typedef for the type of whatever container you used.
constexpr insert_iterator & operator=(const typename _Container::value_type &__value)
constexpr insert_iterator & operator++()
Simply returns *this. (This iterator does not move.)
constexpr insert_iterator(_Container &__x, _Iter __i)
An iterator/sentinel adaptor for representing a non-common range.
An iterator adaptor that keeps track of the distance to the end.
Forward iterators support a superset of input iterator operations.
Bidirectional iterators support a superset of forward iterator operations.
Random-access iterators support a superset of bidirectional iterator operations.
[concept.same], concept same_as
[concept.convertible], concept convertible_to
[concept.assignable], concept assignable_from
[concept.defaultinitializable], concept default_initializable