30 #ifndef _GLIBCXX_RANGE_ACCESS_H 31 #define _GLIBCXX_RANGE_ACCESS_H 1 33 #pragma GCC system_header 35 #if __cplusplus >= 201103L 40 namespace std _GLIBCXX_VISIBILITY(default)
42 _GLIBCXX_BEGIN_NAMESPACE_VERSION
49 template<
typename _Container>
50 inline _GLIBCXX17_CONSTEXPR
auto 51 begin(_Container& __cont) -> decltype(__cont.begin())
52 {
return __cont.begin(); }
59 template<
typename _Container>
60 inline _GLIBCXX17_CONSTEXPR
auto 61 begin(
const _Container& __cont) -> decltype(__cont.begin())
62 {
return __cont.begin(); }
69 template<
typename _Container>
70 inline _GLIBCXX17_CONSTEXPR
auto 71 end(_Container& __cont) -> decltype(__cont.end())
72 {
return __cont.end(); }
79 template<
typename _Container>
80 inline _GLIBCXX17_CONSTEXPR
auto 81 end(
const _Container& __cont) -> decltype(__cont.end())
82 {
return __cont.end(); }
88 template<
typename _Tp,
size_t _Nm>
89 inline _GLIBCXX14_CONSTEXPR _Tp*
98 template<
typename _Tp,
size_t _Nm>
99 inline _GLIBCXX14_CONSTEXPR _Tp*
101 {
return __arr + _Nm; }
103 #if __cplusplus >= 201402L 105 template<
typename _Tp>
class valarray;
107 template<
typename _Tp> _Tp*
begin(valarray<_Tp>&);
108 template<
typename _Tp>
const _Tp*
begin(
const valarray<_Tp>&);
109 template<
typename _Tp> _Tp*
end(valarray<_Tp>&);
110 template<
typename _Tp>
const _Tp*
end(
const valarray<_Tp>&);
117 template<
typename _Container>
118 inline constexpr
auto 128 template<
typename _Container>
129 inline constexpr
auto 139 template<
typename _Container>
140 inline _GLIBCXX17_CONSTEXPR
auto 141 rbegin(_Container& __cont) -> decltype(__cont.rbegin())
142 {
return __cont.rbegin(); }
149 template<
typename _Container>
150 inline _GLIBCXX17_CONSTEXPR
auto 151 rbegin(
const _Container& __cont) -> decltype(__cont.rbegin())
152 {
return __cont.rbegin(); }
159 template<
typename _Container>
160 inline _GLIBCXX17_CONSTEXPR
auto 161 rend(_Container& __cont) -> decltype(__cont.rend())
162 {
return __cont.rend(); }
169 template<
typename _Container>
170 inline _GLIBCXX17_CONSTEXPR
auto 171 rend(
const _Container& __cont) -> decltype(__cont.rend())
172 {
return __cont.rend(); }
179 template<
typename _Tp,
size_t _Nm>
180 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Tp*>
189 template<
typename _Tp,
size_t _Nm>
190 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Tp*>
199 template<
typename _Tp>
200 inline _GLIBCXX17_CONSTEXPR reverse_iterator<const _Tp*>
209 template<
typename _Tp>
210 inline _GLIBCXX17_CONSTEXPR reverse_iterator<const _Tp*>
219 template<
typename _Container>
220 inline _GLIBCXX17_CONSTEXPR
auto 229 template<
typename _Container>
230 inline _GLIBCXX17_CONSTEXPR
auto 236 #if __cplusplus >= 201703L 237 #define __cpp_lib_nonmember_container_access 201411 243 template <
typename _Container>
245 size(
const _Container& __cont) noexcept(noexcept(__cont.size()))
246 -> decltype(__cont.size())
247 {
return __cont.size(); }
252 template <
typename _Tp,
size_t _Nm>
254 size(
const _Tp (&)[_Nm]) noexcept
261 template <
typename _Container>
262 [[nodiscard]] constexpr
auto 263 empty(
const _Container& __cont) noexcept(noexcept(__cont.empty()))
264 -> decltype(__cont.empty())
265 {
return __cont.empty(); }
270 template <
typename _Tp,
size_t _Nm>
271 [[nodiscard]] constexpr
bool 272 empty(
const _Tp (&)[_Nm]) noexcept
279 template <
typename _Tp>
280 [[nodiscard]] constexpr
bool 281 empty(initializer_list<_Tp> __il) noexcept
282 {
return __il.size() == 0;}
288 template <
typename _Container>
290 data(_Container& __cont) noexcept(noexcept(__cont.data()))
291 -> decltype(__cont.data())
292 {
return __cont.data(); }
298 template <
typename _Container>
300 data(
const _Container& __cont) noexcept(noexcept(__cont.data()))
301 -> decltype(__cont.data())
302 {
return __cont.data(); }
308 template <
typename _Tp,
size_t _Nm>
310 data(_Tp (&__array)[_Nm]) noexcept
317 template <
typename _Tp>
319 data(initializer_list<_Tp> __il) noexcept
320 {
return __il.begin(); }
324 #if __cplusplus > 201703L 325 #define __cpp_lib_ssize 201902L 326 template<
typename _Container>
328 ssize(
const _Container& __cont)
329 noexcept(noexcept(__cont.size()))
333 return static_cast<common_type_t<ptrdiff_t, type>
>(__cont.size());
336 template<
typename _Tp, ptrdiff_t _Num>
338 ssize(
const _Tp (&)[_Num]) noexcept
341 #ifdef __cpp_lib_concepts 345 inline constexpr
bool disable_sized_range =
false;
347 template<
typename _Tp>
348 inline constexpr
bool enable_borrowed_range =
false;
350 template<
typename _Tp>
351 extern const bool enable_view;
355 template<
integral _Tp>
356 constexpr make_unsigned_t<_Tp>
357 __to_unsigned_like(_Tp __t) noexcept
360 template<
typename _Tp,
bool _MaxDiff = same_as<_Tp, __max_diff_type>>
361 using __make_unsigned_like_t
362 = conditional_t<_MaxDiff, __max_size_type, make_unsigned_t<_Tp>>;
365 template<
typename _Tp>
366 concept __maybe_borrowed_range
367 = is_lvalue_reference_v<_Tp>
368 || enable_borrowed_range<remove_cvref_t<_Tp>>;
372 namespace __cust_access
374 using std::ranges::__detail::__maybe_borrowed_range;
375 using std::__detail::__class_or_enum;
376 using std::__detail::__decay_copy;
377 using std::__detail::__member_begin;
378 using std::__detail::__adl_begin;
383 template<
typename _Tp>
384 static constexpr
bool 387 if constexpr (is_array_v<remove_reference_t<_Tp>>)
389 else if constexpr (__member_begin<_Tp>)
390 return noexcept(__decay_copy(
std::declval<_Tp&>().
begin()));
392 return noexcept(__decay_copy(
begin(
std::declval<_Tp&>())));
396 template<__maybe_borrowed_range _Tp>
400 operator()(_Tp&& __t) const noexcept(_S_noexcept<_Tp>())
402 if constexpr (is_array_v<remove_reference_t<_Tp>>)
404 static_assert(is_lvalue_reference_v<_Tp>);
405 using _Up = remove_all_extents_t<remove_reference_t<_Tp>>;
406 static_assert(
sizeof(_Up) != 0,
"not array of incomplete type");
409 else if constexpr (__member_begin<_Tp>)
416 template<
typename _Tp>
417 concept __member_end = requires(_Tp& __t)
419 { __decay_copy(__t.end()) }
420 -> sentinel_for<decltype(_Begin{}(std::forward<_Tp>(__t)))>;
423 void end(
auto&) =
delete;
424 void end(
const auto&) =
delete;
426 template<
typename _Tp>
427 concept __adl_end = __class_or_enum<remove_reference_t<_Tp>>
428 && requires(_Tp& __t)
430 { __decay_copy(
end(__t)) }
431 -> sentinel_for<decltype(_Begin{}(std::forward<_Tp>(__t)))>;
437 template<
typename _Tp>
438 static constexpr
bool 441 if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>)
443 else if constexpr (__member_end<_Tp>)
444 return noexcept(__decay_copy(
std::declval<_Tp&>().
end()));
446 return noexcept(__decay_copy(
end(
std::declval<_Tp&>())));
450 template<__maybe_borrowed_range _Tp>
454 operator()(_Tp&& __t) const noexcept(_S_noexcept<_Tp>())
456 if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>)
458 static_assert(is_lvalue_reference_v<_Tp>);
459 return __t + extent_v<remove_reference_t<_Tp>>;
461 else if constexpr (__member_end<_Tp>)
468 template<
typename _Tp>
469 constexpr decltype(
auto)
470 __as_const(_Tp&& __t) noexcept
472 if constexpr (is_lvalue_reference_v<_Tp>)
473 return static_cast<const remove_reference_t<_Tp>&
>(__t);
475 return static_cast<const _Tp&&
>(__t);
480 template<
typename _Tp>
482 operator()(_Tp&& __e)
const 483 noexcept(noexcept(_Begin{}(__cust_access::__as_const((_Tp&&)__e))))
484 requires requires { _Begin{}(__cust_access::__as_const((_Tp&&)__e)); }
486 return _Begin{}(__cust_access::__as_const(std::forward<_Tp>(__e)));
492 template<
typename _Tp>
494 operator()(_Tp&& __e)
const 495 noexcept(noexcept(_End{}(__cust_access::__as_const((_Tp&&)__e))))
496 requires requires { _End{}(__cust_access::__as_const((_Tp&&)__e)); }
498 return _End{}(__cust_access::__as_const(std::forward<_Tp>(__e)));
502 template<
typename _Tp>
503 concept __member_rbegin = requires(_Tp& __t)
505 { __decay_copy(__t.rbegin()) } -> input_or_output_iterator;
508 void rbegin(
auto&) =
delete;
509 void rbegin(
const auto&) =
delete;
511 template<
typename _Tp>
512 concept __adl_rbegin = __class_or_enum<remove_reference_t<_Tp>>
513 && requires(_Tp& __t)
515 { __decay_copy(
rbegin(__t)) } -> input_or_output_iterator;
518 template<
typename _Tp>
519 concept __reversable = requires(_Tp& __t)
521 { _Begin{}(__t) } -> bidirectional_iterator;
522 { _End{}(__t) } -> same_as<decltype(_Begin{}(__t))>;
528 template<
typename _Tp>
529 static constexpr
bool 532 if constexpr (__member_rbegin<_Tp>)
533 return noexcept(__decay_copy(std::declval<_Tp&>().
rbegin()));
534 else if constexpr (__adl_rbegin<_Tp>)
535 return noexcept(__decay_copy(
rbegin(std::declval<_Tp&>())));
538 if constexpr (noexcept(_End{}(std::declval<_Tp&>())))
540 using _It = decltype(_End{}(std::declval<_Tp&>()));
542 return is_nothrow_copy_constructible_v<_It>;
550 template<__maybe_borrowed_range _Tp>
551 requires __member_rbegin<_Tp> || __adl_rbegin<_Tp> || __reversable<_Tp>
553 operator()(_Tp&& __t)
const 554 noexcept(_S_noexcept<_Tp>())
556 if constexpr (__member_rbegin<_Tp>)
558 else if constexpr (__adl_rbegin<_Tp>)
565 template<
typename _Tp>
566 concept __member_rend = requires(_Tp& __t)
568 { __decay_copy(__t.rend()) }
569 -> sentinel_for<decltype(_RBegin{}(__t))>;
572 void rend(
auto&) =
delete;
573 void rend(
const auto&) =
delete;
575 template<
typename _Tp>
576 concept __adl_rend = __class_or_enum<remove_reference_t<_Tp>>
577 && requires(_Tp& __t)
579 { __decay_copy(
rend(__t)) }
580 -> sentinel_for<decltype(_RBegin{}(std::forward<_Tp>(__t)))>;
586 template<
typename _Tp>
587 static constexpr
bool 590 if constexpr (__member_rend<_Tp>)
591 return noexcept(__decay_copy(std::declval<_Tp&>().
rend()));
592 else if constexpr (__adl_rend<_Tp>)
593 return noexcept(__decay_copy(
rend(std::declval<_Tp&>())));
596 if constexpr (noexcept(_Begin{}(std::declval<_Tp&>())))
598 using _It = decltype(_Begin{}(std::declval<_Tp&>()));
600 return is_nothrow_copy_constructible_v<_It>;
608 template<__maybe_borrowed_range _Tp>
609 requires __member_rend<_Tp> || __adl_rend<_Tp> || __reversable<_Tp>
611 operator()(_Tp&& __t)
const 612 noexcept(_S_noexcept<_Tp>())
614 if constexpr (__member_rend<_Tp>)
616 else if constexpr (__adl_rend<_Tp>)
625 template<
typename _Tp>
627 operator()(_Tp&& __e)
const 628 noexcept(noexcept(_RBegin{}(__cust_access::__as_const((_Tp&&)__e))))
629 requires requires { _RBegin{}(__cust_access::__as_const((_Tp&&)__e)); }
631 return _RBegin{}(__cust_access::__as_const(std::forward<_Tp>(__e)));
637 template<
typename _Tp>
639 operator()(_Tp&& __e)
const 640 noexcept(noexcept(_REnd{}(__cust_access::__as_const((_Tp&&)__e))))
641 requires requires { _REnd{}(__cust_access::__as_const((_Tp&&)__e)); }
643 return _REnd{}(__cust_access::__as_const(std::forward<_Tp>(__e)));
647 template<
typename _Tp>
648 concept __member_size = !disable_sized_range<remove_cvref_t<_Tp>>
649 && requires(_Tp&& __t)
651 { __decay_copy(std::forward<_Tp>(__t).size()) }
652 -> __detail::__is_integer_like;
655 void size(
auto&) =
delete;
656 void size(
const auto&) =
delete;
658 template<
typename _Tp>
659 concept __adl_size = __class_or_enum<remove_reference_t<_Tp>>
660 && !disable_sized_range<remove_cvref_t<_Tp>>
661 && requires(_Tp&& __t)
663 { __decay_copy(size(std::forward<_Tp>(__t))) }
664 -> __detail::__is_integer_like;
667 template<
typename _Tp>
668 concept __sentinel_size = requires(_Tp&& __t)
670 { _Begin{}(std::forward<_Tp>(__t)) } -> forward_iterator;
672 { _End{}(std::forward<_Tp>(__t)) }
673 -> sized_sentinel_for<decltype(_Begin{}(std::forward<_Tp>(__t)))>;
679 template<
typename _Tp>
680 static constexpr
bool 683 if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>)
685 else if constexpr (__member_size<_Tp>)
686 return noexcept(__decay_copy(
std::declval<_Tp>().size()));
687 else if constexpr (__adl_size<_Tp>)
688 return noexcept(__decay_copy(size(
std::declval<_Tp>())));
689 else if constexpr (__sentinel_size<_Tp>)
690 return noexcept(_End{}(std::declval<_Tp>())
691 - _Begin{}(std::declval<_Tp>()));
695 template<
typename _Tp>
696 requires is_bounded_array_v<remove_reference_t<_Tp>>
697 || __member_size<_Tp> || __adl_size<_Tp> || __sentinel_size<_Tp>
699 operator()(_Tp&& __e)
const noexcept(_S_noexcept<_Tp>())
701 if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>)
703 return extent_v<remove_reference_t<_Tp>>;
705 else if constexpr (__member_size<_Tp>)
706 return std::forward<_Tp>(__e).size();
707 else if constexpr (__adl_size<_Tp>)
708 return size(std::forward<_Tp>(__e));
709 else if constexpr (__sentinel_size<_Tp>)
710 return __detail::__to_unsigned_like(
711 _End{}(std::forward<_Tp>(__e))
712 - _Begin{}(std::forward<_Tp>(__e)));
718 template<
typename _Tp>
719 requires requires (_Tp&& __e)
721 _Begin{}(std::forward<_Tp>(__e));
722 _Size{}(std::forward<_Tp>(__e));
725 operator()(_Tp&& __e)
const 726 noexcept(noexcept(_Size{}(std::forward<_Tp>(__e))))
728 using __iter_type = decltype(_Begin{}(std::forward<_Tp>(__e)));
729 using __diff_type = iter_difference_t<__iter_type>;
730 using __gnu_cxx::__int_traits;
731 auto __size = _Size{}(std::forward<_Tp>(__e));
732 if constexpr (integral<__diff_type>)
734 if constexpr (__int_traits<__diff_type>::__digits
735 < __int_traits<ptrdiff_t>::__digits)
736 return static_cast<ptrdiff_t
>(__size);
738 return static_cast<__diff_type
>(__size);
742 template<
typename _Tp>
743 concept __member_empty = requires(_Tp&& __t)
744 { bool(std::forward<_Tp>(__t).empty()); };
746 template<
typename _Tp>
747 concept __size0_empty = requires(_Tp&& __t)
748 { _Size{}(std::forward<_Tp>(__t)) == 0; };
750 template<
typename _Tp>
751 concept __eq_iter_empty = requires(_Tp&& __t)
753 { _Begin{}(std::forward<_Tp>(__t)) } -> forward_iterator;
754 bool(_Begin{}(std::forward<_Tp>(__t))
755 == _End{}(std::forward<_Tp>(__t)));
761 template<
typename _Tp>
762 static constexpr
bool 765 if constexpr (__member_empty<_Tp>)
766 return noexcept(std::declval<_Tp>().empty());
767 else if constexpr (__size0_empty<_Tp>)
768 return noexcept(_Size{}(std::declval<_Tp>()) == 0);
770 return noexcept(
bool(_Begin{}(std::declval<_Tp>())
771 == _End{}(std::declval<_Tp>())));
775 template<
typename _Tp>
776 requires __member_empty<_Tp> || __size0_empty<_Tp>
777 || __eq_iter_empty<_Tp>
779 operator()(_Tp&& __e)
const noexcept(_S_noexcept<_Tp>())
781 if constexpr (__member_empty<_Tp>)
782 return bool(std::forward<_Tp>(__e).empty());
783 else if constexpr (__size0_empty<_Tp>)
784 return _Size{}(std::forward<_Tp>(__e)) == 0;
786 return bool(_Begin{}(std::forward<_Tp>(__e))
787 == _End{}(std::forward<_Tp>(__e)));
791 template<
typename _Tp>
792 concept __pointer_to_object = is_pointer_v<_Tp>
793 && is_object_v<remove_pointer_t<_Tp>>;
795 template<
typename _Tp>
796 concept __member_data = is_lvalue_reference_v<_Tp>
797 && requires(_Tp __t) { { __t.data() } -> __pointer_to_object; };
799 template<
typename _Tp>
800 concept __begin_data = requires(_Tp&& __t)
801 { { _Begin{}(std::forward<_Tp>(__t)) } -> contiguous_iterator; };
806 template<
typename _Tp>
807 static constexpr
bool 810 if constexpr (__member_data<_Tp>)
811 return noexcept(__decay_copy(std::declval<_Tp>().data()));
813 return noexcept(_Begin{}(std::declval<_Tp>()));
817 template<__maybe_borrowed_range _Tp>
818 requires __member_data<_Tp> || __begin_data<_Tp>
820 operator()(_Tp&& __e)
const noexcept(_S_noexcept<_Tp>())
822 if constexpr (__member_data<_Tp>)
825 return std::to_address(_Begin{}(std::forward<_Tp>(__e)));
831 template<
typename _Tp>
833 operator()(_Tp&& __e)
const 834 noexcept(noexcept(_Data{}(__cust_access::__as_const((_Tp&&)__e))))
835 requires requires { _Data{}(__cust_access::__as_const((_Tp&&)__e)); }
837 return _Data{}(__cust_access::__as_const(std::forward<_Tp>(__e)));
843 inline namespace __cust
845 inline constexpr __cust_access::_Begin
begin{};
846 inline constexpr __cust_access::_End
end{};
847 inline constexpr __cust_access::_CBegin
cbegin{};
848 inline constexpr __cust_access::_CEnd
cend{};
849 inline constexpr __cust_access::_RBegin
rbegin{};
850 inline constexpr __cust_access::_REnd
rend{};
851 inline constexpr __cust_access::_CRBegin
crbegin{};
852 inline constexpr __cust_access::_CREnd
crend{};
853 inline constexpr __cust_access::_Size size{};
854 inline constexpr __cust_access::_SSize ssize{};
855 inline constexpr __cust_access::_Empty empty{};
856 inline constexpr __cust_access::_Data data{};
857 inline constexpr __cust_access::_CData cdata{};
861 template<
typename _Tp>
862 concept range = requires(_Tp& __t)
869 template<
typename _Tp>
870 concept borrowed_range
871 = range<_Tp> && __detail::__maybe_borrowed_range<_Tp>;
873 template<
typename _Tp>
874 using iterator_t = std::__detail::__range_iter_t<_Tp>;
876 template<range _Range>
877 using sentinel_t = decltype(
ranges::end(std::declval<_Range&>()));
879 template<range _Range>
880 using range_difference_t = iter_difference_t<iterator_t<_Range>>;
882 template<range _Range>
883 using range_value_t = iter_value_t<iterator_t<_Range>>;
885 template<range _Range>
886 using range_reference_t = iter_reference_t<iterator_t<_Range>>;
888 template<range _Range>
889 using range_rvalue_reference_t
890 = iter_rvalue_reference_t<iterator_t<_Range>>;
893 template<
typename _Tp>
894 concept sized_range = range<_Tp>
895 && requires(_Tp& __t) { ranges::size(__t); };
897 template<sized_range _Range>
898 using range_size_t = decltype(ranges::size(std::declval<_Range&>()));
903 template<
typename _Range,
typename _Tp>
905 = range<_Range> && output_iterator<iterator_t<_Range>, _Tp>;
908 template<
typename _Tp>
909 concept input_range = range<_Tp> && input_iterator<iterator_t<_Tp>>;
912 template<
typename _Tp>
913 concept forward_range
914 = input_range<_Tp> && forward_iterator<iterator_t<_Tp>>;
917 template<
typename _Tp>
918 concept bidirectional_range
919 = forward_range<_Tp> && bidirectional_iterator<iterator_t<_Tp>>;
922 template<
typename _Tp>
923 concept random_access_range
924 = bidirectional_range<_Tp> && random_access_iterator<iterator_t<_Tp>>;
927 template<
typename _Tp>
928 concept contiguous_range
929 = random_access_range<_Tp> && contiguous_iterator<iterator_t<_Tp>>
930 && requires(_Tp& __t)
932 { ranges::data(__t) } -> same_as<add_pointer_t<range_reference_t<_Tp>>>;
936 template<
typename _Tp>
938 = range<_Tp> && same_as<iterator_t<_Tp>, sentinel_t<_Tp>>;
942 template<input_or_output_iterator _It>
944 advance(_It& __it, iter_difference_t<_It> __n)
946 if constexpr (random_access_iterator<_It>)
948 else if constexpr (bidirectional_iterator<_It>)
969 #ifdef __cpp_lib_is_constant_evaluated 970 if (std::is_constant_evaluated() && __n < 0)
971 throw "attempt to decrement a non-bidirectional iterator";
973 __glibcxx_assert(__n >= 0);
979 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
981 advance(_It& __it, _Sent __bound)
983 if constexpr (assignable_from<_It&, _Sent>)
985 else if constexpr (sized_sentinel_for<_Sent, _It>)
989 while (__it != __bound)
994 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
995 constexpr iter_difference_t<_It>
996 advance(_It& __it, iter_difference_t<_It> __n, _Sent __bound)
998 if constexpr (sized_sentinel_for<_Sent, _It>)
1000 const auto __diff = __bound - __it;
1001 #ifdef __cpp_lib_is_constant_evaluated 1002 if (std::is_constant_evaluated()
1003 && !(__n == 0 || __diff == 0 || (__n < 0 == __diff < 0)))
1004 throw "inconsistent directions for distance and bound";
1007 __glibcxx_assert(__n == 0 || __diff == 0 || (__n < 0 == __diff < 0));
1008 const auto __absdiff = __diff < 0 ? -__diff : __diff;
1009 const auto __absn = __n < 0 ? -__n : __n;;
1010 if (__absn >= __absdiff)
1013 return __n - __diff;
1021 else if (__it == __bound || __n == 0)
1022 return iter_difference_t<_It>(0);
1025 iter_difference_t<_It> __m = 0;
1031 while (__m != __n && __it != __bound);
1034 else if constexpr (bidirectional_iterator<_It> && same_as<_It, _Sent>)
1036 iter_difference_t<_It> __m = 0;
1042 while (__m != __n && __it != __bound);
1047 #ifdef __cpp_lib_is_constant_evaluated 1048 if (std::is_constant_evaluated() && __n < 0)
1049 throw "attempt to decrement a non-bidirectional iterator";
1051 __glibcxx_assert(__n >= 0);
1056 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
1057 constexpr iter_difference_t<_It>
1058 distance(_It __first, _Sent __last)
1060 if constexpr (sized_sentinel_for<_Sent, _It>)
1061 return __last - __first;
1064 iter_difference_t<_It> __n = 0;
1065 while (__first != __last)
1074 template<range _Range>
1075 constexpr range_difference_t<_Range>
1078 if constexpr (sized_range<_Range>)
1079 return static_cast<range_difference_t<_Range>
>(ranges::size(__r));
1084 template<input_or_output_iterator _It>
1092 template<input_or_output_iterator _It>
1094 next(_It __x, iter_difference_t<_It> __n)
1100 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
1102 next(_It __x, _Sent __bound)
1108 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
1110 next(_It __x, iter_difference_t<_It> __n, _Sent __bound)
1116 template<b
idirectional_iterator _It>
1124 template<b
idirectional_iterator _It>
1126 prev(_It __x, iter_difference_t<_It> __n)
1132 template<b
idirectional_iterator _It>
1134 prev(_It __x, iter_difference_t<_It> __n, _It __bound)
1141 #endif // library concepts 1143 _GLIBCXX_END_NAMESPACE_VERSION
1148 #endif // _GLIBCXX_RANGE_ACCESS_H constexpr auto crend(const _Container &__cont) -> decltype(std::rend(__cont))
Return a reverse iterator pointing one past the first element of the const container.
typename make_signed< _Tp >::type make_signed_t
Alias template for make_signed.
constexpr _Tp * begin(_Tp(&__arr)[_Nm])
Return an iterator pointing to the first element of the array.
constexpr auto crbegin(const _Container &__cont) -> decltype(std::rbegin(__cont))
Return a reverse iterator pointing to the last element of the const container.
typename remove_reference< _Tp >::type remove_reference_t
Alias template for remove_reference.
constexpr auto cbegin(const _Container &__cont) noexcept(noexcept(std::begin(__cont))) -> decltype(std::begin(__cont))
Return an iterator pointing to the first element of the const container.
constexpr auto rend(_Container &__cont) -> decltype(__cont.rend())
Return a reverse iterator pointing one past the first element of the container.
constexpr auto cend(const _Container &__cont) noexcept(noexcept(std::end(__cont))) -> decltype(std::end(__cont))
Return an iterator pointing to one past the last element of the const container.
constexpr _Tp * end(_Tp(&__arr)[_Nm])
Return an iterator pointing to one past the last element of the array.
constexpr void advance(_InputIterator &__i, _Distance __n)
A generalization of pointer arithmetic.
_Tp * begin(valarray< _Tp > &__va)
Return an iterator pointing to the first element of the valarray.
ISO C++ entities toplevel namespace is std.
constexpr iterator_traits< _InputIterator >::difference_type distance(_InputIterator __first, _InputIterator __last)
A generalization of pointer arithmetic.
_Tp * end(valarray< _Tp > &__va)
Return an iterator pointing to one past the last element of the valarray.
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
constexpr reverse_iterator< _Iterator > make_reverse_iterator(_Iterator __i)
Generator function for reverse_iterator.
constexpr auto rbegin(_Container &__cont) -> decltype(__cont.rbegin())
Return a reverse iterator pointing to the last element of the container.
typename common_type< _Tp... >::type common_type_t
Alias template for common_type.