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); }
336 template<
typename _Tp>
337 static _GLIBCXX17_CONSTEXPR _Tp*
338 _S_to_pointer(_Tp* __p)
341 template<
typename _Tp>
342 static _GLIBCXX17_CONSTEXPR pointer
343 _S_to_pointer(_Tp __t)
344 {
return __t.operator->(); }
357 #if __cplusplus <= 201703L || ! defined __cpp_lib_concepts
358 template<
typename _Iterator>
359 inline _GLIBCXX17_CONSTEXPR
bool
362 {
return __x.
base() == __y.
base(); }
364 template<
typename _Iterator>
365 inline _GLIBCXX17_CONSTEXPR
bool
366 operator<(
const reverse_iterator<_Iterator>& __x,
367 const reverse_iterator<_Iterator>& __y)
368 {
return __y.base() < __x.base(); }
370 template<
typename _Iterator>
371 inline _GLIBCXX17_CONSTEXPR
bool
372 operator!=(
const reverse_iterator<_Iterator>& __x,
373 const reverse_iterator<_Iterator>& __y)
374 {
return !(__x == __y); }
376 template<
typename _Iterator>
377 inline _GLIBCXX17_CONSTEXPR
bool
378 operator>(
const reverse_iterator<_Iterator>& __x,
379 const reverse_iterator<_Iterator>& __y)
380 {
return __y < __x; }
382 template<
typename _Iterator>
383 inline _GLIBCXX17_CONSTEXPR
bool
384 operator<=(
const reverse_iterator<_Iterator>& __x,
385 const reverse_iterator<_Iterator>& __y)
386 {
return !(__y < __x); }
388 template<
typename _Iterator>
389 inline _GLIBCXX17_CONSTEXPR
bool
390 operator>=(
const reverse_iterator<_Iterator>& __x,
391 const reverse_iterator<_Iterator>& __y)
392 {
return !(__x < __y); }
396 template<
typename _IteratorL,
typename _IteratorR>
397 inline _GLIBCXX17_CONSTEXPR
bool
398 operator==(
const reverse_iterator<_IteratorL>& __x,
399 const reverse_iterator<_IteratorR>& __y)
400 {
return __x.base() == __y.base(); }
402 template<
typename _IteratorL,
typename _IteratorR>
403 inline _GLIBCXX17_CONSTEXPR
bool
404 operator<(
const reverse_iterator<_IteratorL>& __x,
405 const reverse_iterator<_IteratorR>& __y)
406 {
return __y.base() < __x.base(); }
408 template<
typename _IteratorL,
typename _IteratorR>
409 inline _GLIBCXX17_CONSTEXPR
bool
410 operator!=(
const reverse_iterator<_IteratorL>& __x,
411 const reverse_iterator<_IteratorR>& __y)
412 {
return !(__x == __y); }
414 template<
typename _IteratorL,
typename _IteratorR>
415 inline _GLIBCXX17_CONSTEXPR
bool
416 operator>(
const reverse_iterator<_IteratorL>& __x,
417 const reverse_iterator<_IteratorR>& __y)
418 {
return __y < __x; }
420 template<
typename _IteratorL,
typename _IteratorR>
421 inline _GLIBCXX17_CONSTEXPR
bool
422 operator<=(
const reverse_iterator<_IteratorL>& __x,
423 const reverse_iterator<_IteratorR>& __y)
424 {
return !(__y < __x); }
426 template<
typename _IteratorL,
typename _IteratorR>
427 inline _GLIBCXX17_CONSTEXPR
bool
428 operator>=(
const reverse_iterator<_IteratorL>& __x,
429 const reverse_iterator<_IteratorR>& __y)
430 {
return !(__x < __y); }
432 template<
typename _IteratorL,
typename _IteratorR>
434 operator==(
const reverse_iterator<_IteratorL>& __x,
435 const reverse_iterator<_IteratorR>& __y)
436 requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
437 {
return __x.base() == __y.base(); }
439 template<
typename _IteratorL,
typename _IteratorR>
441 operator!=(
const reverse_iterator<_IteratorL>& __x,
442 const reverse_iterator<_IteratorR>& __y)
443 requires requires { { __x.base() != __y.base() } -> convertible_to<bool>; }
444 {
return __x.base() != __y.base(); }
446 template<
typename _IteratorL,
typename _IteratorR>
448 operator<(
const reverse_iterator<_IteratorL>& __x,
449 const reverse_iterator<_IteratorR>& __y)
450 requires requires { { __x.base() > __y.base() } -> convertible_to<bool>; }
451 {
return __x.base() > __y.base(); }
453 template<
typename _IteratorL,
typename _IteratorR>
455 operator>(
const reverse_iterator<_IteratorL>& __x,
456 const reverse_iterator<_IteratorR>& __y)
457 requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
458 {
return __x.base() < __y.base(); }
460 template<
typename _IteratorL,
typename _IteratorR>
462 operator<=(
const reverse_iterator<_IteratorL>& __x,
463 const reverse_iterator<_IteratorR>& __y)
464 requires requires { { __x.base() >= __y.base() } -> convertible_to<bool>; }
465 {
return __x.base() >= __y.base(); }
467 template<
typename _IteratorL,
typename _IteratorR>
469 operator>=(
const reverse_iterator<_IteratorL>& __x,
470 const reverse_iterator<_IteratorR>& __y)
471 requires requires { { __x.base() <= __y.base() } -> convertible_to<bool>; }
472 {
return __x.base() <= __y.base(); }
474 template<
typename _IteratorL,
475 three_way_comparable_with<_IteratorL> _IteratorR>
476 constexpr compare_three_way_result_t<_IteratorL, _IteratorR>
477 operator<=>(
const reverse_iterator<_IteratorL>& __x,
478 const reverse_iterator<_IteratorR>& __y)
479 {
return __y.base() <=> __x.base(); }
483 #if __cplusplus < 201103L
484 template<
typename _Iterator>
485 inline typename reverse_iterator<_Iterator>::difference_type
486 operator-(
const reverse_iterator<_Iterator>& __x,
487 const reverse_iterator<_Iterator>& __y)
488 {
return __y.base() - __x.base(); }
490 template<
typename _IteratorL,
typename _IteratorR>
491 inline typename reverse_iterator<_IteratorL>::difference_type
492 operator-(
const reverse_iterator<_IteratorL>& __x,
493 const reverse_iterator<_IteratorR>& __y)
494 {
return __y.base() - __x.base(); }
498 template<
typename _IteratorL,
typename _IteratorR>
499 inline _GLIBCXX17_CONSTEXPR
auto
500 operator-(
const reverse_iterator<_IteratorL>& __x,
501 const reverse_iterator<_IteratorR>& __y)
502 -> decltype(__y.base() - __x.base())
503 {
return __y.base() - __x.base(); }
506 template<
typename _Iterator>
507 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
508 operator+(
typename reverse_iterator<_Iterator>::difference_type __n,
509 const reverse_iterator<_Iterator>& __x)
510 {
return reverse_iterator<_Iterator>(__x.base() - __n); }
512 #if __cplusplus >= 201103L
514 template<
typename _Iterator>
515 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
516 __make_reverse_iterator(_Iterator __i)
517 {
return reverse_iterator<_Iterator>(__i); }
519 # if __cplusplus >= 201402L
520 # define __cpp_lib_make_reverse_iterator 201402
525 template<
typename _Iterator>
526 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
530 # if __cplusplus > 201703L && defined __cpp_lib_concepts
531 template<
typename _Iterator1,
typename _Iterator2>
532 requires (!sized_sentinel_for<_Iterator1, _Iterator2>)
533 inline constexpr
bool
534 disable_sized_sentinel_for<reverse_iterator<_Iterator1>,
535 reverse_iterator<_Iterator2>> =
true;
539 template<
typename _Iterator>
542 __niter_base(reverse_iterator<_Iterator> __it)
543 -> decltype(__make_reverse_iterator(__niter_base(__it.base())))
544 {
return __make_reverse_iterator(__niter_base(__it.base())); }
546 template<
typename _Iterator>
547 struct __is_move_iterator<reverse_iterator<_Iterator> >
548 : __is_move_iterator<_Iterator>
551 template<
typename _Iterator>
554 __miter_base(reverse_iterator<_Iterator> __it)
555 -> decltype(__make_reverse_iterator(__miter_base(__it.base())))
556 {
return __make_reverse_iterator(__miter_base(__it.base())); }
570 template<
typename _Container>
572 :
public iterator<output_iterator_tag, void, void, void, void>
575 _Container* container;
580 #if __cplusplus > 201703L
587 explicit _GLIBCXX20_CONSTEXPR
602 #if __cplusplus < 201103L
604 operator=(
typename _Container::const_reference __value)
606 container->push_back(__value);
612 operator=(
const typename _Container::value_type& __value)
614 container->push_back(__value);
620 operator=(
typename _Container::value_type&& __value)
622 container->push_back(
std::move(__value));
657 template<
typename _Container>
659 inline back_insert_iterator<_Container>
673 template<
typename _Container>
675 :
public iterator<output_iterator_tag, void, void, void, void>
678 _Container* container;
683 #if __cplusplus > 201703L
690 explicit _GLIBCXX20_CONSTEXPR
705 #if __cplusplus < 201103L
707 operator=(
typename _Container::const_reference __value)
709 container->push_front(__value);
715 operator=(
const typename _Container::value_type& __value)
717 container->push_front(__value);
723 operator=(
typename _Container::value_type&& __value)
725 container->push_front(
std::move(__value));
760 template<
typename _Container>
762 inline front_insert_iterator<_Container>
780 template<
typename _Container>
782 :
public iterator<output_iterator_tag, void, void, void, void>
784 #if __cplusplus > 201703L && defined __cpp_lib_concepts
785 using _Iter = std::__detail::__range_iter_t<_Container>;
788 _Container* container =
nullptr;
789 _Iter iter = _Iter();
791 typedef typename _Container::iterator _Iter;
794 _Container* container;
802 #if __cplusplus > 201703L && defined __cpp_lib_concepts
839 #if __cplusplus < 201103L
841 operator=(
typename _Container::const_reference __value)
843 iter = container->insert(iter, __value);
850 operator=(
const typename _Container::value_type& __value)
852 iter = container->insert(iter, __value);
859 operator=(
typename _Container::value_type&& __value)
861 iter = container->insert(iter,
std::move(__value));
898 #if __cplusplus > 201703L && defined __cpp_lib_concepts
899 template<
typename _Container>
900 constexpr insert_iterator<_Container>
901 inserter(_Container& __x, std::__detail::__range_iter_t<_Container> __i)
902 {
return insert_iterator<_Container>(__x, __i); }
904 template<
typename _Container,
typename _Iterator>
905 inline insert_iterator<_Container>
909 typename _Container::iterator(__i));
915 _GLIBCXX_END_NAMESPACE_VERSION
918 namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
920 _GLIBCXX_BEGIN_NAMESPACE_VERSION
929 template<
typename _Iterator,
typename _Container>
930 class __normal_iterator
933 _Iterator _M_current;
938 typedef _Iterator iterator_type;
939 typedef typename __traits_type::iterator_category iterator_category;
940 typedef typename __traits_type::value_type value_type;
941 typedef typename __traits_type::difference_type difference_type;
942 typedef typename __traits_type::reference reference;
943 typedef typename __traits_type::pointer pointer;
945 #if __cplusplus > 201703L && __cpp_lib_concepts
946 using iterator_concept = std::__detail::__iter_concept<_Iterator>;
949 _GLIBCXX_CONSTEXPR __normal_iterator() _GLIBCXX_NOEXCEPT
950 : _M_current(_Iterator()) { }
952 explicit _GLIBCXX20_CONSTEXPR
953 __normal_iterator(
const _Iterator& __i) _GLIBCXX_NOEXCEPT
954 : _M_current(__i) { }
957 template<
typename _Iter>
959 __normal_iterator(
const __normal_iterator<_Iter,
960 typename __enable_if<
961 (std::__are_same<_Iter, typename _Container::pointer>::__value),
962 _Container>::__type>& __i) _GLIBCXX_NOEXCEPT
963 : _M_current(__i.base()) { }
969 {
return *_M_current; }
973 operator->() const _GLIBCXX_NOEXCEPT
974 {
return _M_current; }
978 operator++() _GLIBCXX_NOEXCEPT
986 operator++(
int) _GLIBCXX_NOEXCEPT
987 {
return __normal_iterator(_M_current++); }
992 operator--() _GLIBCXX_NOEXCEPT
1000 operator--(
int) _GLIBCXX_NOEXCEPT
1001 {
return __normal_iterator(_M_current--); }
1004 _GLIBCXX20_CONSTEXPR
1006 operator[](difference_type __n)
const _GLIBCXX_NOEXCEPT
1007 {
return _M_current[__n]; }
1009 _GLIBCXX20_CONSTEXPR
1011 operator+=(difference_type __n) _GLIBCXX_NOEXCEPT
1012 { _M_current += __n;
return *
this; }
1014 _GLIBCXX20_CONSTEXPR
1016 operator+(difference_type __n)
const _GLIBCXX_NOEXCEPT
1017 {
return __normal_iterator(_M_current + __n); }
1019 _GLIBCXX20_CONSTEXPR
1021 operator-=(difference_type __n) _GLIBCXX_NOEXCEPT
1022 { _M_current -= __n;
return *
this; }
1024 _GLIBCXX20_CONSTEXPR
1026 operator-(difference_type __n)
const _GLIBCXX_NOEXCEPT
1027 {
return __normal_iterator(_M_current - __n); }
1029 _GLIBCXX20_CONSTEXPR
1031 base() const _GLIBCXX_NOEXCEPT
1032 {
return _M_current; }
1043 #if __cpp_lib_three_way_comparison
1044 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1045 requires requires (_IteratorL __lhs, _IteratorR __rhs)
1046 { { __lhs == __rhs } -> std::convertible_to<bool>; }
1048 operator==(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1049 const __normal_iterator<_IteratorR, _Container>& __rhs)
1050 noexcept(noexcept(__lhs.base() == __rhs.base()))
1051 {
return __lhs.base() == __rhs.base(); }
1053 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1054 constexpr std::__detail::__synth3way_t<_IteratorR, _IteratorL>
1055 operator<=>(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1056 const __normal_iterator<_IteratorR, _Container>& __rhs)
1057 noexcept(noexcept(std::__detail::__synth3way(__lhs.base(), __rhs.base())))
1058 {
return std::__detail::__synth3way(__lhs.base(), __rhs.base()); }
1061 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1062 _GLIBCXX20_CONSTEXPR
1064 operator==(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1065 const __normal_iterator<_IteratorR, _Container>& __rhs)
1067 {
return __lhs.base() == __rhs.base(); }
1069 template<
typename _Iterator,
typename _Container>
1070 _GLIBCXX20_CONSTEXPR
1072 operator==(
const __normal_iterator<_Iterator, _Container>& __lhs,
1073 const __normal_iterator<_Iterator, _Container>& __rhs)
1075 {
return __lhs.base() == __rhs.base(); }
1077 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1078 _GLIBCXX20_CONSTEXPR
1080 operator!=(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1081 const __normal_iterator<_IteratorR, _Container>& __rhs)
1083 {
return __lhs.base() != __rhs.base(); }
1085 template<
typename _Iterator,
typename _Container>
1086 _GLIBCXX20_CONSTEXPR
1088 operator!=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1089 const __normal_iterator<_Iterator, _Container>& __rhs)
1091 {
return __lhs.base() != __rhs.base(); }
1094 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1096 operator<(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1097 const __normal_iterator<_IteratorR, _Container>& __rhs)
1099 {
return __lhs.base() < __rhs.base(); }
1101 template<
typename _Iterator,
typename _Container>
1102 _GLIBCXX20_CONSTEXPR
1104 operator<(
const __normal_iterator<_Iterator, _Container>& __lhs,
1105 const __normal_iterator<_Iterator, _Container>& __rhs)
1107 {
return __lhs.base() < __rhs.base(); }
1109 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1111 operator>(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1112 const __normal_iterator<_IteratorR, _Container>& __rhs)
1114 {
return __lhs.base() > __rhs.base(); }
1116 template<
typename _Iterator,
typename _Container>
1117 _GLIBCXX20_CONSTEXPR
1119 operator>(
const __normal_iterator<_Iterator, _Container>& __lhs,
1120 const __normal_iterator<_Iterator, _Container>& __rhs)
1122 {
return __lhs.base() > __rhs.base(); }
1124 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1126 operator<=(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1127 const __normal_iterator<_IteratorR, _Container>& __rhs)
1129 {
return __lhs.base() <= __rhs.base(); }
1131 template<
typename _Iterator,
typename _Container>
1132 _GLIBCXX20_CONSTEXPR
1134 operator<=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1135 const __normal_iterator<_Iterator, _Container>& __rhs)
1137 {
return __lhs.base() <= __rhs.base(); }
1139 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1141 operator>=(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1142 const __normal_iterator<_IteratorR, _Container>& __rhs)
1144 {
return __lhs.base() >= __rhs.base(); }
1146 template<
typename _Iterator,
typename _Container>
1147 _GLIBCXX20_CONSTEXPR
1149 operator>=(
const __normal_iterator<_Iterator, _Container>& __lhs,
1150 const __normal_iterator<_Iterator, _Container>& __rhs)
1152 {
return __lhs.base() >= __rhs.base(); }
1153 #endif // three-way comparison
1159 template<
typename _IteratorL,
typename _IteratorR,
typename _Container>
1160 #if __cplusplus >= 201103L
1162 _GLIBCXX20_CONSTEXPR
1164 operator-(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1165 const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept
1166 -> decltype(__lhs.base() - __rhs.base())
1168 inline typename __normal_iterator<_IteratorL, _Container>::difference_type
1169 operator-(
const __normal_iterator<_IteratorL, _Container>& __lhs,
1170 const __normal_iterator<_IteratorR, _Container>& __rhs)
1172 {
return __lhs.base() - __rhs.base(); }
1174 template<
typename _Iterator,
typename _Container>
1175 _GLIBCXX20_CONSTEXPR
1176 inline typename __normal_iterator<_Iterator, _Container>::difference_type
1177 operator-(
const __normal_iterator<_Iterator, _Container>& __lhs,
1178 const __normal_iterator<_Iterator, _Container>& __rhs)
1180 {
return __lhs.base() - __rhs.base(); }
1182 template<
typename _Iterator,
typename _Container>
1183 _GLIBCXX20_CONSTEXPR
1184 inline __normal_iterator<_Iterator, _Container>
1185 operator+(
typename __normal_iterator<_Iterator, _Container>::difference_type
1186 __n,
const __normal_iterator<_Iterator, _Container>& __i)
1188 {
return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
1190 _GLIBCXX_END_NAMESPACE_VERSION
1193 namespace std _GLIBCXX_VISIBILITY(default)
1195 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1197 template<
typename _Iterator,
typename _Container>
1198 _GLIBCXX20_CONSTEXPR
1200 __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it)
1202 {
return __it.base(); }
1204 #if __cplusplus >= 201103L
1210 #if __cplusplus > 201703L && __cpp_lib_concepts
1211 template<semiregular _Sent>
1217 noexcept(is_nothrow_default_constructible_v<_Sent>)
1221 move_sentinel(_Sent __s)
1222 noexcept(is_nothrow_move_constructible_v<_Sent>)
1225 template<
typename _S2> requires convertible_to<const _S2&, _Sent>
1227 move_sentinel(
const move_sentinel<_S2>& __s)
1228 noexcept(is_nothrow_constructible_v<_Sent, const _S2&>)
1229 : _M_last(__s.base())
1232 template<
typename _S2> requires assignable_from<_Sent&, const _S2&>
1233 constexpr move_sentinel&
1234 operator=(
const move_sentinel<_S2>& __s)
1235 noexcept(is_nothrow_assignable_v<_Sent, const _S2&>)
1237 _M_last = __s.base();
1243 noexcept(is_nothrow_copy_constructible_v<_Sent>)
1260 template<
typename _Iterator>
1263 _Iterator _M_current;
1266 #if __cplusplus > 201703L && __cpp_lib_concepts
1267 using __base_cat =
typename __traits_type::iterator_category;
1269 using __base_ref =
typename __traits_type::reference;
1273 using iterator_type = _Iterator;
1275 #if __cplusplus > 201703L && __cpp_lib_concepts
1277 using iterator_category
1278 = __detail::__clamp_iter_cat<__base_cat, random_access_iterator_tag>;
1279 using value_type = iter_value_t<_Iterator>;
1280 using difference_type = iter_difference_t<_Iterator>;
1281 using pointer = _Iterator;
1282 using reference = iter_rvalue_reference_t<_Iterator>;
1284 typedef typename __traits_type::iterator_category iterator_category;
1285 typedef typename __traits_type::value_type value_type;
1286 typedef typename __traits_type::difference_type difference_type;
1288 typedef _Iterator pointer;
1292 typename remove_reference<__base_ref>::type&&,
1293 __base_ref>::type reference;
1296 _GLIBCXX17_CONSTEXPR
1300 explicit _GLIBCXX17_CONSTEXPR
1304 template<
typename _Iter>
1305 _GLIBCXX17_CONSTEXPR
1307 : _M_current(__i.base()) { }
1309 #if __cplusplus <= 201703L
1310 _GLIBCXX17_CONSTEXPR iterator_type
1312 {
return _M_current; }
1314 constexpr iterator_type
1316 #if __cpp_lib_concepts
1317 requires copy_constructible<iterator_type>
1319 {
return _M_current; }
1321 constexpr iterator_type
1326 _GLIBCXX17_CONSTEXPR reference
1328 {
return static_cast<reference
>(*_M_current); }
1330 _GLIBCXX17_CONSTEXPR pointer
1332 {
return _M_current; }
1349 #if __cpp_lib_concepts
1351 operator++(
int) requires (!forward_iterator<_Iterator>)
1371 operator+(difference_type __n)
const
1375 operator+=(difference_type __n)
1382 operator-(difference_type __n)
const
1386 operator-=(difference_type __n)
1392 _GLIBCXX17_CONSTEXPR reference
1393 operator[](difference_type __n)
const
1396 #if __cplusplus > 201703L && __cpp_lib_concepts
1397 template<sentinel_for<_Iterator> _Sent>
1398 friend constexpr
bool
1399 operator==(
const move_iterator& __x,
const move_sentinel<_Sent>& __y)
1400 {
return __x.base() == __y.base(); }
1402 template<sized_sentinel_for<_Iterator> _Sent>
1403 friend constexpr iter_difference_t<_Iterator>
1404 operator-(
const move_sentinel<_Sent>& __x,
const move_iterator& __y)
1405 {
return __x.base() - __y.base(); }
1407 template<sized_sentinel_for<_Iterator> _Sent>
1408 friend constexpr iter_difference_t<_Iterator>
1409 operator-(
const move_iterator& __x,
const move_sentinel<_Sent>& __y)
1410 {
return __x.base() - __y.base(); }
1412 friend constexpr iter_rvalue_reference_t<_Iterator>
1414 noexcept(noexcept(ranges::iter_move(__i._M_current)))
1415 {
return ranges::iter_move(__i._M_current); }
1417 template<indirectly_swappable<_Iterator> _Iter2>
1418 friend constexpr
void
1420 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1421 {
return ranges::iter_swap(__x._M_current, __y._M_current); }
1425 template<
typename _IteratorL,
typename _IteratorR>
1426 inline _GLIBCXX17_CONSTEXPR
bool
1429 #if __cplusplus > 201703L && __cpp_lib_concepts
1430 requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
1432 {
return __x.base() == __y.base(); }
1434 #if __cpp_lib_three_way_comparison
1435 template<
typename _IteratorL,
1436 three_way_comparable_with<_IteratorL> _IteratorR>
1437 constexpr compare_three_way_result_t<_IteratorL, _IteratorR>
1438 operator<=>(
const move_iterator<_IteratorL>& __x,
1439 const move_iterator<_IteratorR>& __y)
1440 {
return __x.base() <=> __y.base(); }
1442 template<
typename _IteratorL,
typename _IteratorR>
1443 inline _GLIBCXX17_CONSTEXPR
bool
1444 operator!=(
const move_iterator<_IteratorL>& __x,
1445 const move_iterator<_IteratorR>& __y)
1446 {
return !(__x == __y); }
1449 template<
typename _IteratorL,
typename _IteratorR>
1450 inline _GLIBCXX17_CONSTEXPR
bool
1451 operator<(
const move_iterator<_IteratorL>& __x,
1452 const move_iterator<_IteratorR>& __y)
1453 #if __cplusplus > 201703L && __cpp_lib_concepts
1454 requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
1456 {
return __x.base() < __y.base(); }
1458 template<
typename _IteratorL,
typename _IteratorR>
1459 inline _GLIBCXX17_CONSTEXPR
bool
1460 operator<=(
const move_iterator<_IteratorL>& __x,
1461 const move_iterator<_IteratorR>& __y)
1462 #if __cplusplus > 201703L && __cpp_lib_concepts
1463 requires requires { { __y.base() < __x.base() } -> convertible_to<bool>; }
1465 {
return !(__y < __x); }
1467 template<
typename _IteratorL,
typename _IteratorR>
1468 inline _GLIBCXX17_CONSTEXPR
bool
1469 operator>(
const move_iterator<_IteratorL>& __x,
1470 const move_iterator<_IteratorR>& __y)
1471 #if __cplusplus > 201703L && __cpp_lib_concepts
1472 requires requires { { __y.base() < __x.base() } -> convertible_to<bool>; }
1474 {
return __y < __x; }
1476 template<
typename _IteratorL,
typename _IteratorR>
1477 inline _GLIBCXX17_CONSTEXPR
bool
1478 operator>=(
const move_iterator<_IteratorL>& __x,
1479 const move_iterator<_IteratorR>& __y)
1480 #if __cplusplus > 201703L && __cpp_lib_concepts
1481 requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
1483 {
return !(__x < __y); }
1485 #if ! (__cplusplus > 201703L && __cpp_lib_concepts)
1493 template<
typename _Iterator>
1494 inline _GLIBCXX17_CONSTEXPR
bool
1495 operator==(
const move_iterator<_Iterator>& __x,
1496 const move_iterator<_Iterator>& __y)
1497 {
return __x.base() == __y.base(); }
1499 template<
typename _Iterator>
1500 inline _GLIBCXX17_CONSTEXPR
bool
1501 operator!=(
const move_iterator<_Iterator>& __x,
1502 const move_iterator<_Iterator>& __y)
1503 {
return !(__x == __y); }
1505 template<
typename _Iterator>
1506 inline _GLIBCXX17_CONSTEXPR
bool
1507 operator<(
const move_iterator<_Iterator>& __x,
1508 const move_iterator<_Iterator>& __y)
1509 {
return __x.base() < __y.base(); }
1511 template<
typename _Iterator>
1512 inline _GLIBCXX17_CONSTEXPR
bool
1513 operator<=(
const move_iterator<_Iterator>& __x,
1514 const move_iterator<_Iterator>& __y)
1515 {
return !(__y < __x); }
1517 template<
typename _Iterator>
1518 inline _GLIBCXX17_CONSTEXPR
bool
1519 operator>(
const move_iterator<_Iterator>& __x,
1520 const move_iterator<_Iterator>& __y)
1521 {
return __y < __x; }
1523 template<
typename _Iterator>
1524 inline _GLIBCXX17_CONSTEXPR
bool
1525 operator>=(
const move_iterator<_Iterator>& __x,
1526 const move_iterator<_Iterator>& __y)
1527 {
return !(__x < __y); }
1531 template<
typename _IteratorL,
typename _IteratorR>
1532 inline _GLIBCXX17_CONSTEXPR
auto
1533 operator-(
const move_iterator<_IteratorL>& __x,
1534 const move_iterator<_IteratorR>& __y)
1535 -> decltype(__x.base() - __y.base())
1536 {
return __x.base() - __y.base(); }
1538 template<
typename _Iterator>
1539 inline _GLIBCXX17_CONSTEXPR move_iterator<_Iterator>
1540 operator+(
typename move_iterator<_Iterator>::difference_type __n,
1541 const move_iterator<_Iterator>& __x)
1542 {
return __x + __n; }
1544 template<
typename _Iterator>
1545 inline _GLIBCXX17_CONSTEXPR move_iterator<_Iterator>
1546 make_move_iterator(_Iterator __i)
1547 {
return move_iterator<_Iterator>(
std::move(__i)); }
1549 template<
typename _Iterator,
typename _ReturnType
1550 =
typename conditional<__move_if_noexcept_cond
1551 <
typename iterator_traits<_Iterator>::value_type>::value,
1552 _Iterator, move_iterator<_Iterator>>::type>
1553 inline _GLIBCXX17_CONSTEXPR _ReturnType
1554 __make_move_if_noexcept_iterator(_Iterator __i)
1555 {
return _ReturnType(__i); }
1559 template<
typename _Tp,
typename _ReturnType
1560 =
typename conditional<__move_if_noexcept_cond<_Tp>::value,
1561 const _Tp*, move_iterator<_Tp*>>::type>
1562 inline _GLIBCXX17_CONSTEXPR _ReturnType
1563 __make_move_if_noexcept_iterator(_Tp* __i)
1564 {
return _ReturnType(__i); }
1566 #if __cplusplus > 201703L && __cpp_lib_concepts
1571 template<input_or_output_iterator _It>
1572 class _Common_iter_proxy
1574 iter_value_t<_It> _M_keep;
1576 _Common_iter_proxy(iter_reference_t<_It>&& __x)
1579 template<
typename _Iter,
typename _Sent>
1580 friend class common_iterator;
1583 const iter_value_t<_It>*
1588 template<
typename _It>
1589 concept __common_iter_has_arrow = indirectly_readable<const _It>
1590 && (requires(
const _It& __it) { __it.operator->(); }
1591 || is_reference_v<iter_reference_t<_It>>
1592 || constructible_from<iter_value_t<_It>, iter_reference_t<_It>>);
1597 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
1598 requires (!same_as<_It, _Sent>) && copyable<_It>
1599 class common_iterator
1601 template<
typename _Tp,
typename _Up>
1602 static constexpr
bool
1605 if constexpr (is_trivially_default_constructible_v<_Tp>)
1606 return is_nothrow_assignable_v<_Tp, _Up>;
1608 return is_nothrow_constructible_v<_Tp, _Up>;
1611 template<
typename _It2,
typename _Sent2>
1612 static constexpr
bool
1614 {
return _S_noexcept1<_It, _It2>() && _S_noexcept1<_Sent, _Sent2>(); }
1619 noexcept(is_nothrow_default_constructible_v<_It>)
1620 : _M_it(), _M_index(0)
1624 common_iterator(_It __i)
1625 noexcept(is_nothrow_move_constructible_v<_It>)
1626 : _M_it(
std::
move(__i)), _M_index(0)
1630 common_iterator(_Sent __s)
1631 noexcept(is_nothrow_move_constructible_v<_Sent>)
1632 : _M_sent(
std::
move(__s)), _M_index(1)
1635 template<
typename _It2,
typename _Sent2>
1636 requires convertible_to<const _It2&, _It>
1637 && convertible_to<const _Sent2&, _Sent>
1639 common_iterator(
const common_iterator<_It2, _Sent2>& __x)
1640 noexcept(_S_noexcept<const _It2&, const _Sent2&>())
1641 : _M_valueless(), _M_index(__x._M_index)
1645 if constexpr (is_trivially_default_constructible_v<_It>)
1650 else if (_M_index == 1)
1652 if constexpr (is_trivially_default_constructible_v<_Sent>)
1660 common_iterator(
const common_iterator& __x)
1661 noexcept(_S_noexcept<const _It&, const _Sent&>())
1662 : _M_valueless(), _M_index(__x._M_index)
1666 if constexpr (is_trivially_default_constructible_v<_It>)
1671 else if (_M_index == 1)
1673 if constexpr (is_trivially_default_constructible_v<_Sent>)
1681 operator=(
const common_iterator& __x)
1682 noexcept(is_nothrow_copy_assignable_v<_It>
1683 && is_nothrow_copy_assignable_v<_Sent>
1684 && is_nothrow_copy_constructible_v<_It>
1685 && is_nothrow_copy_constructible_v<_Sent>)
1687 return this->
operator=<_It, _Sent>(__x);
1690 template<
typename _It2,
typename _Sent2>
1691 requires convertible_to<const _It2&, _It>
1692 && convertible_to<const _Sent2&, _Sent>
1693 && assignable_from<_It&, const _It2&>
1694 && assignable_from<_Sent&, const _Sent2&>
1696 operator=(
const common_iterator<_It2, _Sent2>& __x)
1697 noexcept(is_nothrow_constructible_v<_It, const _It2&>
1698 && is_nothrow_constructible_v<_Sent, const _Sent2&>
1699 && is_nothrow_assignable_v<_It, const _It2&>
1700 && is_nothrow_assignable_v<_Sent, const _Sent2&>)
1702 switch(_M_index << 2 | __x._M_index)
1708 _M_sent = __x._M_sent;
1727 __glibcxx_assert(__x._M_has_value());
1728 __builtin_unreachable();
1749 __glibcxx_assert(_M_index == 0);
1754 operator*() const requires __detail::__dereferenceable<const _It>
1756 __glibcxx_assert(_M_index == 0);
1761 operator->() const requires __detail::__common_iter_has_arrow<_It>
1763 __glibcxx_assert(_M_index == 0);
1764 if constexpr (is_pointer_v<_It> || requires { _M_it.operator->(); })
1766 else if constexpr (is_reference_v<iter_reference_t<_It>>)
1768 auto&& __tmp = *_M_it;
1772 return _Common_iter_proxy(*_M_it);
1778 __glibcxx_assert(_M_index == 0);
1786 __glibcxx_assert(_M_index == 0);
1787 if constexpr (forward_iterator<_It>)
1789 common_iterator __tmp = *
this;
1797 template<
typename _It2, sentinel_for<_It> _Sent2>
1798 requires sentinel_for<_Sent, _It2>
1800 operator==(
const common_iterator& __x,
1801 const common_iterator<_It2, _Sent2>& __y)
1803 switch(__x._M_index << 2 | __y._M_index)
1809 return __x._M_it == __y._M_sent;
1811 return __x._M_sent == __y._M_it;
1813 __glibcxx_assert(__x._M_has_value());
1814 __glibcxx_assert(__y._M_has_value());
1815 __builtin_unreachable();
1819 template<
typename _It2, sentinel_for<_It> _Sent2>
1820 requires sentinel_for<_Sent, _It2> && equality_comparable_with<_It, _It2>
1822 operator==(
const common_iterator& __x,
1823 const common_iterator<_It2, _Sent2>& __y)
1825 switch(__x._M_index << 2 | __y._M_index)
1830 return __x._M_it == __y._M_it;
1832 return __x._M_it == __y._M_sent;
1834 return __x._M_sent == __y._M_it;
1836 __glibcxx_assert(__x._M_has_value());
1837 __glibcxx_assert(__y._M_has_value());
1838 __builtin_unreachable();
1842 template<sized_sentinel_for<_It> _It2, sized_sentinel_for<_It> _Sent2>
1843 requires sized_sentinel_for<_Sent, _It2>
1844 friend iter_difference_t<_It2>
1846 const common_iterator<_It2, _Sent2>& __y)
1848 switch(__x._M_index << 2 | __y._M_index)
1853 return __x._M_it - __y._M_it;
1855 return __x._M_it - __y._M_sent;
1857 return __x._M_sent - __y._M_it;
1859 __glibcxx_assert(__x._M_has_value());
1860 __glibcxx_assert(__y._M_has_value());
1861 __builtin_unreachable();
1865 friend iter_rvalue_reference_t<_It>
1866 iter_move(
const common_iterator& __i)
1867 noexcept(noexcept(ranges::iter_move(std::declval<const _It&>())))
1868 requires input_iterator<_It>
1870 __glibcxx_assert(__i._M_index == 0);
1871 return ranges::iter_move(__i._M_it);
1874 template<indirectly_swappable<_It> _It2,
typename _Sent2>
1876 iter_swap(
const common_iterator& __x,
1877 const common_iterator<_It2, _Sent2>& __y)
1878 noexcept(noexcept(ranges::iter_swap(std::declval<const _It&>(),
1879 std::declval<const _It2&>())))
1881 __glibcxx_assert(__x._M_index == 0);
1882 __glibcxx_assert(__y._M_index == 0);
1883 return ranges::iter_swap(__x._M_it, __y._M_it);
1887 template<input_or_output_iterator _It2, sentinel_for<_It2> _Sent2>
1888 friend class common_iterator;
1890 bool _M_has_value() const noexcept {
return _M_index < 2; }
1896 unsigned char _M_valueless;
1898 unsigned char _M_index;
1901 template<
typename _It,
typename _Sent>
1902 struct incrementable_traits<common_iterator<_It, _Sent>>
1904 using difference_type = iter_difference_t<_It>;
1910 template<
typename _It,
typename _Sent>
1911 struct __common_iter_ptr
1916 template<
typename _It,
typename _Sent>
1917 requires __detail::__common_iter_has_arrow<_It>
1918 struct __common_iter_ptr<_It, _Sent>
1920 using common_iterator = std::common_iterator<_It, _Sent>;
1923 = decltype(std::declval<const common_iterator&>().operator->());
1927 template<input_iterator _It,
typename _Sent>
1928 struct iterator_traits<common_iterator<_It, _Sent>>
1930 using iterator_concept = conditional_t<forward_iterator<_It>,
1931 forward_iterator_tag, input_iterator_tag>;
1932 using iterator_category = __detail::__clamp_iter_cat<
1933 typename iterator_traits<_It>::iterator_category,
1934 forward_iterator_tag, input_iterator_tag>;
1935 using value_type = iter_value_t<_It>;
1936 using difference_type = iter_difference_t<_It>;
1937 using pointer =
typename __detail::__common_iter_ptr<_It, _Sent>::type;
1938 using reference = iter_reference_t<_It>;
1944 template<input_or_output_iterator _It>
1945 class counted_iterator
1948 using iterator_type = _It;
1950 constexpr counted_iterator() =
default;
1953 counted_iterator(_It __i, iter_difference_t<_It> __n)
1954 : _M_current(
std::
move(__i)), _M_length(__n)
1955 { __glibcxx_assert(__n >= 0); }
1957 template<
typename _It2>
1958 requires convertible_to<const _It2&, _It>
1960 counted_iterator(
const counted_iterator<_It2>& __x)
1961 : _M_current(__x._M_current), _M_length(__x._M_length)
1964 template<
typename _It2>
1965 requires assignable_from<_It&, const _It2&>
1966 constexpr counted_iterator&
1967 operator=(
const counted_iterator<_It2>& __x)
1969 _M_current = __x._M_current;
1970 _M_length = __x._M_length;
1976 noexcept(is_nothrow_copy_constructible_v<_It>)
1977 requires copy_constructible<_It>
1978 {
return _M_current; }
1982 noexcept(is_nothrow_move_constructible_v<_It>)
1985 constexpr iter_difference_t<_It>
1986 count() const noexcept {
return _M_length; }
1988 constexpr decltype(
auto)
1990 noexcept(noexcept(*_M_current))
1991 {
return *_M_current; }
1993 constexpr decltype(
auto)
1995 noexcept(noexcept(*_M_current))
1996 requires __detail::__dereferenceable<const _It>
1997 {
return *_M_current; }
1999 constexpr counted_iterator&
2002 __glibcxx_assert(_M_length > 0);
2011 __glibcxx_assert(_M_length > 0);
2015 return _M_current++;
2023 constexpr counted_iterator
2024 operator++(
int) requires forward_iterator<_It>
2031 constexpr counted_iterator&
2032 operator--() requires bidirectional_iterator<_It>
2039 constexpr counted_iterator
2040 operator--(
int) requires bidirectional_iterator<_It>
2047 constexpr counted_iterator
2048 operator+(iter_difference_t<_It> __n)
const
2049 requires random_access_iterator<_It>
2050 {
return counted_iterator(_M_current + __n, _M_length - __n); }
2052 friend constexpr counted_iterator
2053 operator+(iter_difference_t<_It> __n,
const counted_iterator& __x)
2054 requires random_access_iterator<_It>
2055 {
return __x + __n; }
2057 constexpr counted_iterator&
2058 operator+=(iter_difference_t<_It> __n)
2059 requires random_access_iterator<_It>
2061 __glibcxx_assert(__n <= _M_length);
2067 constexpr counted_iterator
2068 operator-(iter_difference_t<_It> __n)
const
2069 requires random_access_iterator<_It>
2070 {
return counted_iterator(_M_current - __n, _M_length + __n); }
2072 template<common_with<_It> _It2>
2073 friend constexpr iter_difference_t<_It2>
2075 const counted_iterator<_It2>& __y)
2076 {
return __y._M_length - __x._M_length; }
2078 friend constexpr iter_difference_t<_It>
2079 operator-(
const counted_iterator& __x, default_sentinel_t)
2080 {
return -__x._M_length; }
2082 friend constexpr iter_difference_t<_It>
2083 operator-(default_sentinel_t,
const counted_iterator& __y)
2084 {
return __y._M_length; }
2086 constexpr counted_iterator&
2087 operator-=(iter_difference_t<_It> __n)
2088 requires random_access_iterator<_It>
2090 __glibcxx_assert(-__n <= _M_length);
2096 constexpr decltype(
auto)
2097 operator[](iter_difference_t<_It> __n) const
2098 noexcept(noexcept(_M_current[__n]))
2099 requires random_access_iterator<_It>
2101 __glibcxx_assert(__n < _M_length);
2102 return _M_current[__n];
2105 template<common_with<_It> _It2>
2106 friend constexpr
bool
2107 operator==(
const counted_iterator& __x,
2108 const counted_iterator<_It2>& __y)
2109 {
return __x._M_length == __y._M_length; }
2111 friend constexpr
bool
2112 operator==(
const counted_iterator& __x, default_sentinel_t)
2113 {
return __x._M_length == 0; }
2115 template<common_with<_It> _It2>
2116 friend constexpr strong_ordering
2117 operator<=>(
const counted_iterator& __x,
2118 const counted_iterator<_It2>& __y)
2119 {
return __y._M_length <=> __x._M_length; }
2121 friend constexpr iter_rvalue_reference_t<_It>
2122 iter_move(
const counted_iterator& __i)
2123 noexcept(noexcept(ranges::iter_move(__i._M_current)))
2124 requires input_iterator<_It>
2125 {
return ranges::iter_move(__i._M_current); }
2127 template<indirectly_swappable<_It> _It2>
2128 friend constexpr
void
2129 iter_swap(
const counted_iterator& __x,
2130 const counted_iterator<_It2>& __y)
2131 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
2132 { ranges::iter_swap(__x._M_current, __y._M_current); }
2135 template<input_or_output_iterator _It2>
friend class counted_iterator;
2137 _It _M_current = _It();
2138 iter_difference_t<_It> _M_length = 0;
2141 template<
typename _It>
2142 struct incrementable_traits<counted_iterator<_It>>
2144 using difference_type = iter_difference_t<_It>;
2147 template<input_iterator _It>
2148 struct iterator_traits<counted_iterator<_It>> : iterator_traits<_It>
2150 using pointer = void;
2156 template<
typename _Iterator>
2158 __niter_base(move_iterator<_Iterator> __it)
2159 -> decltype(make_move_iterator(__niter_base(__it.base())))
2160 {
return make_move_iterator(__niter_base(__it.base())); }
2162 template<
typename _Iterator>
2163 struct __is_move_iterator<move_iterator<_Iterator> >
2165 enum { __value = 1 };
2166 typedef __true_type __type;
2169 template<
typename _Iterator>
2171 __miter_base(move_iterator<_Iterator> __it)
2172 -> decltype(__miter_base(__it.base()))
2173 {
return __miter_base(__it.base()); }
2175 #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) std::make_move_iterator(_Iter)
2176 #define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) \
2177 std::__make_move_if_noexcept_iterator(_Iter)
2179 #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) (_Iter)
2180 #define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) (_Iter)
2183 #if __cpp_deduction_guides >= 201606
2186 template<
typename _InputIterator>
2188 typename iterator_traits<_InputIterator>::value_type::first_type>;
2190 template<
typename _InputIterator>
2191 using __iter_val_t =
2192 typename iterator_traits<_InputIterator>::value_type::second_type;
2194 template<
typename _T1,
typename _T2>
2197 template<
typename _InputIterator>
2198 using __iter_to_alloc_t =
2199 pair<add_const_t<__iter_key_t<_InputIterator>>,
2200 __iter_val_t<_InputIterator>>;
2201 #endif // __cpp_deduction_guides
2203 _GLIBCXX_END_NAMESPACE_VERSION
2206 #ifdef _GLIBCXX_DEBUG