30 #ifndef _GLIBCXX_RANGE_ACCESS_H
31 #define _GLIBCXX_RANGE_ACCESS_H 1
33 #pragma GCC system_header
35 #if __cplusplus >= 201103L
39 namespace std _GLIBCXX_VISIBILITY(default)
41 _GLIBCXX_BEGIN_NAMESPACE_VERSION
48 template<
typename _Container>
49 inline _GLIBCXX17_CONSTEXPR
auto
50 begin(_Container& __cont) -> decltype(__cont.begin())
51 {
return __cont.begin(); }
58 template<
typename _Container>
59 inline _GLIBCXX17_CONSTEXPR
auto
60 begin(
const _Container& __cont) -> decltype(__cont.begin())
61 {
return __cont.begin(); }
68 template<
typename _Container>
69 inline _GLIBCXX17_CONSTEXPR
auto
70 end(_Container& __cont) -> decltype(__cont.end())
71 {
return __cont.end(); }
78 template<
typename _Container>
79 inline _GLIBCXX17_CONSTEXPR
auto
80 end(
const _Container& __cont) -> decltype(__cont.end())
81 {
return __cont.end(); }
87 template<
typename _Tp,
size_t _Nm>
88 inline _GLIBCXX14_CONSTEXPR _Tp*
97 template<
typename _Tp,
size_t _Nm>
98 inline _GLIBCXX14_CONSTEXPR _Tp*
99 end(_Tp (&__arr)[_Nm])
100 {
return __arr + _Nm; }
102 #if __cplusplus >= 201402L
104 template<
typename _Tp>
class valarray;
106 template<
typename _Tp> _Tp*
begin(valarray<_Tp>&);
107 template<
typename _Tp>
const _Tp*
begin(
const valarray<_Tp>&);
108 template<
typename _Tp> _Tp*
end(valarray<_Tp>&);
109 template<
typename _Tp>
const _Tp*
end(
const valarray<_Tp>&);
116 template<
typename _Container>
117 inline constexpr
auto
127 template<
typename _Container>
128 inline constexpr
auto
138 template<
typename _Container>
139 inline _GLIBCXX17_CONSTEXPR
auto
140 rbegin(_Container& __cont) -> decltype(__cont.rbegin())
141 {
return __cont.rbegin(); }
148 template<
typename _Container>
149 inline _GLIBCXX17_CONSTEXPR
auto
150 rbegin(
const _Container& __cont) -> decltype(__cont.rbegin())
151 {
return __cont.rbegin(); }
158 template<
typename _Container>
159 inline _GLIBCXX17_CONSTEXPR
auto
160 rend(_Container& __cont) -> decltype(__cont.rend())
161 {
return __cont.rend(); }
168 template<
typename _Container>
169 inline _GLIBCXX17_CONSTEXPR
auto
170 rend(
const _Container& __cont) -> decltype(__cont.rend())
171 {
return __cont.rend(); }
178 template<
typename _Tp,
size_t _Nm>
179 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Tp*>
188 template<
typename _Tp,
size_t _Nm>
189 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Tp*>
198 template<
typename _Tp>
199 inline _GLIBCXX17_CONSTEXPR reverse_iterator<const _Tp*>
208 template<
typename _Tp>
209 inline _GLIBCXX17_CONSTEXPR reverse_iterator<const _Tp*>
218 template<
typename _Container>
219 inline _GLIBCXX17_CONSTEXPR
auto
228 template<
typename _Container>
229 inline _GLIBCXX17_CONSTEXPR
auto
235 #if __cplusplus >= 201703L
236 #define __cpp_lib_nonmember_container_access 201411
242 template <
typename _Container>
244 size(
const _Container& __cont) noexcept(noexcept(__cont.size()))
245 -> decltype(__cont.size())
246 {
return __cont.size(); }
251 template <
typename _Tp,
size_t _Nm>
253 size(
const _Tp (&)[_Nm]) noexcept
260 template <
typename _Container>
261 [[nodiscard]] constexpr
auto
262 empty(
const _Container& __cont) noexcept(noexcept(__cont.empty()))
263 -> decltype(__cont.empty())
264 {
return __cont.empty(); }
269 template <
typename _Tp,
size_t _Nm>
270 [[nodiscard]] constexpr
bool
271 empty(
const _Tp (&)[_Nm]) noexcept
278 template <
typename _Tp>
279 [[nodiscard]] constexpr
bool
280 empty(initializer_list<_Tp> __il) noexcept
281 {
return __il.size() == 0;}
287 template <
typename _Container>
289 data(_Container& __cont) noexcept(noexcept(__cont.data()))
290 -> decltype(__cont.data())
291 {
return __cont.data(); }
297 template <
typename _Container>
299 data(
const _Container& __cont) noexcept(noexcept(__cont.data()))
300 -> decltype(__cont.data())
301 {
return __cont.data(); }
307 template <
typename _Tp,
size_t _Nm>
309 data(_Tp (&__array)[_Nm]) noexcept
316 template <
typename _Tp>
318 data(initializer_list<_Tp> __il) noexcept
319 {
return __il.begin(); }
323 #if __cplusplus > 201703L
324 template<
typename _Container>
326 ssize(
const _Container& __cont)
327 noexcept(noexcept(__cont.size()))
331 return static_cast<common_type_t<ptrdiff_t, type>
>(__cont.size());
334 template<
typename _Tp, ptrdiff_t _Num>
336 ssize(
const _Tp (&)[_Num]) noexcept
339 #ifdef __cpp_lib_concepts
343 inline constexpr
bool disable_sized_range =
false;
345 template<
typename _Tp>
346 inline constexpr
bool enable_safe_range =
false;
350 using __max_diff_type =
long long;
351 using __max_size_type =
unsigned long long;
353 template<
typename _Tp>
354 concept __is_integer_like = integral<_Tp>
355 || same_as<_Tp, __max_diff_type> || same_as<_Tp, __max_size_type>;
357 template<
typename _Tp>
358 concept __is_signed_integer_like = signed_integral<_Tp>
359 || same_as<_Tp, __max_diff_type>;
361 template<
integral _Tp>
362 constexpr make_unsigned_t<_Tp>
363 __to_unsigned_like(_Tp __t) noexcept
367 template<
typename _Tp>
368 concept __maybe_safe_range
369 = is_lvalue_reference_v<_Tp> || enable_safe_range<remove_cvref_t<_Tp>>;
373 namespace __cust_access
375 using std::ranges::__detail::__maybe_safe_range;
376 using std::__detail::__class_or_enum;
378 template<
typename _Tp>
379 constexpr decay_t<_Tp>
380 __decay_copy(_Tp&& __t)
381 noexcept(is_nothrow_convertible_v<_Tp, decay_t<_Tp>>)
382 {
return std::forward<_Tp>(__t); }
384 template<
typename _Tp>
385 concept __member_begin = requires(_Tp& __t)
387 { __decay_copy(__t.begin()) } -> input_or_output_iterator;
390 template<
typename _Tp>
void begin(_Tp&&) =
delete;
391 template<
typename _Tp>
void begin(initializer_list<_Tp>&&) =
delete;
393 template<
typename _Tp>
394 concept __adl_begin = __class_or_enum<remove_reference_t<_Tp>>
395 && requires(_Tp& __t)
397 { __decay_copy(
begin(__t)) } -> input_or_output_iterator;
403 template<
typename _Tp>
404 static constexpr
bool
407 if constexpr (is_array_v<remove_reference_t<_Tp>>)
409 else if constexpr (__member_begin<_Tp>)
410 return noexcept(__decay_copy(
std::declval<_Tp&>().
begin()));
412 return noexcept(__decay_copy(
begin(
std::declval<_Tp&>())));
416 template<__maybe_safe_range _Tp>
420 operator()(_Tp&& __t) const noexcept(_S_noexcept<_Tp>())
422 if constexpr (is_array_v<remove_reference_t<_Tp>>)
424 static_assert(is_lvalue_reference_v<_Tp>);
427 else if constexpr (__member_begin<_Tp>)
434 template<
typename _Tp>
435 concept __member_end = requires(_Tp& __t)
437 { __decay_copy(__t.end()) }
438 -> sentinel_for<decltype(_Begin{}(std::forward<_Tp>(__t)))>;
441 template<
typename _Tp>
void end(_Tp&&) =
delete;
442 template<
typename _Tp>
void end(initializer_list<_Tp>&&) =
delete;
444 template<
typename _Tp>
445 concept __adl_end = __class_or_enum<remove_reference_t<_Tp>>
446 && requires(_Tp& __t)
448 { __decay_copy(
end(__t)) }
449 -> sentinel_for<decltype(_Begin{}(std::forward<_Tp>(__t)))>;
455 template<
typename _Tp>
456 static constexpr
bool
459 if constexpr (is_array_v<remove_reference_t<_Tp>>)
461 else if constexpr (__member_end<_Tp>)
462 return noexcept(__decay_copy(
std::declval<_Tp&>().
end()));
464 return noexcept(__decay_copy(
end(
std::declval<_Tp&>())));
468 template<__maybe_safe_range _Tp>
472 operator()(_Tp&& __t) const noexcept(_S_noexcept<_Tp>())
474 if constexpr (is_array_v<remove_reference_t<_Tp>>)
476 static_assert(is_lvalue_reference_v<_Tp>);
477 static_assert(is_bounded_array_v<remove_reference_t<_Tp>>);
478 return __t + extent_v<remove_reference_t<_Tp>>;
480 else if constexpr (__member_end<_Tp>)
487 template<
typename _Tp>
488 constexpr decltype(
auto)
489 __as_const(_Tp&& __t) noexcept
491 if constexpr (is_lvalue_reference_v<_Tp>)
492 return static_cast<const remove_reference_t<_Tp>&
>(__t);
494 return static_cast<const _Tp&&>(__t);
499 template<
typename _Tp>
501 operator()(_Tp&& __e)
const
502 noexcept(noexcept(_Begin{}(__cust_access::__as_const((_Tp&&)__e))))
503 requires requires { _Begin{}(__cust_access::__as_const((_Tp&&)__e)); }
505 return _Begin{}(__cust_access::__as_const(std::forward<_Tp>(__e)));
511 template<
typename _Tp>
513 operator()(_Tp&& __e)
const
514 noexcept(noexcept(_End{}(__cust_access::__as_const((_Tp&&)__e))))
515 requires requires { _End{}(__cust_access::__as_const((_Tp&&)__e)); }
517 return _End{}(__cust_access::__as_const(std::forward<_Tp>(__e)));
521 template<
typename _Tp>
522 concept __member_rbegin = requires(_Tp& __t)
524 { __decay_copy(__t.rbegin()) } -> input_or_output_iterator;
527 template<
typename _Tp>
void rbegin(_Tp&&) =
delete;
529 template<
typename _Tp>
530 concept __adl_rbegin = __class_or_enum<remove_reference_t<_Tp>>
531 && requires(_Tp& __t)
533 { __decay_copy(
rbegin(__t)) } -> input_or_output_iterator;
536 template<
typename _Tp>
537 concept __reversable = requires(_Tp& __t)
539 { _Begin{}(__t) } -> bidirectional_iterator;
540 { _End{}(__t) } -> same_as<decltype(_Begin{}(__t))>;
546 template<
typename _Tp>
547 static constexpr
bool
550 if constexpr (__member_rbegin<_Tp>)
551 return noexcept(__decay_copy(std::declval<_Tp&>().
rbegin()));
552 else if constexpr (__adl_rbegin<_Tp>)
553 return noexcept(__decay_copy(
rbegin(std::declval<_Tp&>())));
556 if constexpr (noexcept(_End{}(std::declval<_Tp&>())))
558 using _It = decltype(_End{}(std::declval<_Tp&>()));
560 return is_nothrow_copy_constructible_v<_It>;
568 template<__maybe_safe_range _Tp>
569 requires __member_rbegin<_Tp> || __adl_rbegin<_Tp> || __reversable<_Tp>
571 operator()(_Tp&& __t)
const
572 noexcept(_S_noexcept<_Tp>())
574 if constexpr (__member_rbegin<_Tp>)
576 else if constexpr (__adl_rbegin<_Tp>)
583 template<
typename _Tp>
584 concept __member_rend = requires(_Tp& __t)
586 { __decay_copy(__t.rend()) }
587 -> sentinel_for<decltype(_RBegin{}(__t))>;
590 template<
typename _Tp>
void rend(_Tp&&) =
delete;
592 template<
typename _Tp>
593 concept __adl_rend = __class_or_enum<remove_reference_t<_Tp>>
594 && requires(_Tp& __t)
596 { __decay_copy(
rend(__t)) }
597 -> sentinel_for<decltype(_RBegin{}(std::forward<_Tp>(__t)))>;
603 template<
typename _Tp>
604 static constexpr
bool
607 if constexpr (__member_rend<_Tp>)
608 return noexcept(__decay_copy(std::declval<_Tp&>().
rend()));
609 else if constexpr (__adl_rend<_Tp>)
610 return noexcept(__decay_copy(
rend(std::declval<_Tp&>())));
613 if constexpr (noexcept(_Begin{}(std::declval<_Tp&>())))
615 using _It = decltype(_Begin{}(std::declval<_Tp&>()));
617 return is_nothrow_copy_constructible_v<_It>;
625 template<__maybe_safe_range _Tp>
626 requires __member_rend<_Tp> || __adl_rend<_Tp> || __reversable<_Tp>
628 operator()(_Tp&& __t)
const
629 noexcept(_S_noexcept<_Tp>())
631 if constexpr (__member_rend<_Tp>)
633 else if constexpr (__adl_rend<_Tp>)
642 template<
typename _Tp>
644 operator()(_Tp&& __e)
const
645 noexcept(noexcept(_RBegin{}(__cust_access::__as_const((_Tp&&)__e))))
646 requires requires { _RBegin{}(__cust_access::__as_const((_Tp&&)__e)); }
648 return _RBegin{}(__cust_access::__as_const(std::forward<_Tp>(__e)));
654 template<
typename _Tp>
656 operator()(_Tp&& __e)
const
657 noexcept(noexcept(_REnd{}(__cust_access::__as_const((_Tp&&)__e))))
658 requires requires { _REnd{}(__cust_access::__as_const((_Tp&&)__e)); }
660 return _REnd{}(__cust_access::__as_const(std::forward<_Tp>(__e)));
664 template<
typename _Tp>
665 concept __member_size = !disable_sized_range<remove_cvref_t<_Tp>>
666 && requires(_Tp&& __t)
668 { __decay_copy(std::forward<_Tp>(__t).size()) }
669 -> __detail::__is_integer_like;
672 template<
typename _Tp>
void size(_Tp&&) =
delete;
674 template<
typename _Tp>
675 concept __adl_size = __class_or_enum<remove_reference_t<_Tp>>
676 && !disable_sized_range<remove_cvref_t<_Tp>>
677 && requires(_Tp&& __t)
679 { __decay_copy(size(std::forward<_Tp>(__t))) }
680 -> __detail::__is_integer_like;
683 template<
typename _Tp>
684 concept __sentinel_size = requires(_Tp&& __t)
686 { _Begin{}(std::forward<_Tp>(__t)) } -> forward_iterator;
688 { _End{}(std::forward<_Tp>(__t)) }
689 -> sized_sentinel_for<decltype(_Begin{}(std::forward<_Tp>(__t)))>;
695 template<
typename _Tp>
696 static constexpr
bool
699 if constexpr (is_array_v<remove_reference_t<_Tp>>)
701 else if constexpr (__member_size<_Tp>)
702 return noexcept(__decay_copy(
std::declval<_Tp>().size()));
703 else if constexpr (__adl_size<_Tp>)
704 return noexcept(__decay_copy(size(
std::declval<_Tp>())));
705 else if constexpr (__sentinel_size<_Tp>)
706 return noexcept(_End{}(std::declval<_Tp>())
707 - _Begin{}(std::declval<_Tp>()));
711 template<
typename _Tp>
712 requires is_array_v<remove_reference_t<_Tp>>
713 || __member_size<_Tp> || __adl_size<_Tp> || __sentinel_size<_Tp>
715 operator()(_Tp&& __e)
const noexcept(_S_noexcept<_Tp>())
717 if constexpr (is_array_v<remove_reference_t<_Tp>>)
719 static_assert(is_bounded_array_v<remove_reference_t<_Tp>>);
720 return extent_v<remove_reference_t<_Tp>>;
722 else if constexpr (__member_size<_Tp>)
723 return std::forward<_Tp>(__e).size();
724 else if constexpr (__adl_size<_Tp>)
725 return size(std::forward<_Tp>(__e));
726 else if constexpr (__sentinel_size<_Tp>)
727 return __detail::__to_unsigned_like(
728 _End{}(std::forward<_Tp>(__e))
729 - _Begin{}(std::forward<_Tp>(__e)));
733 template<
typename _Tp>
734 concept __member_empty = requires(_Tp&& __t)
735 { bool(std::forward<_Tp>(__t).empty()); };
737 template<
typename _Tp>
738 concept __size0_empty = requires(_Tp&& __t)
739 { _Size{}(std::forward<_Tp>(__t)) == 0; };
741 template<
typename _Tp>
742 concept __eq_iter_empty = requires(_Tp&& __t)
744 { _Begin{}(std::forward<_Tp>(__t)) } -> forward_iterator;
745 bool(_Begin{}(std::forward<_Tp>(__t))
746 == _End{}(std::forward<_Tp>(__t)));
752 template<
typename _Tp>
753 static constexpr
bool
756 if constexpr (__member_empty<_Tp>)
757 return noexcept(std::declval<_Tp>().empty());
758 else if constexpr (__size0_empty<_Tp>)
759 return noexcept(_Size{}(std::declval<_Tp>()) == 0);
761 return noexcept(
bool(_Begin{}(std::declval<_Tp>())
762 == _End{}(std::declval<_Tp>())));
766 template<
typename _Tp>
767 requires __member_empty<_Tp> || __size0_empty<_Tp>
768 || __eq_iter_empty<_Tp>
770 operator()(_Tp&& __e)
const noexcept(_S_noexcept<_Tp>())
772 if constexpr (__member_empty<_Tp>)
773 return bool(std::forward<_Tp>(__e).empty());
774 else if constexpr (__size0_empty<_Tp>)
775 return _Size{}(std::forward<_Tp>(__e)) == 0;
777 return bool(_Begin{}(std::forward<_Tp>(__e))
778 == _End{}(std::forward<_Tp>(__e)));
782 template<
typename _Tp>
783 concept __pointer_to_object = is_pointer_v<_Tp>
784 && is_object_v<remove_pointer_t<_Tp>>;
786 template<
typename _Tp>
787 concept __member_data = is_lvalue_reference_v<_Tp>
788 && requires(_Tp __t) { { __t.data() } -> __pointer_to_object; };
790 template<
typename _Tp>
791 concept __begin_data = requires(_Tp&& __t)
792 { { _Begin{}(std::forward<_Tp>(__t)) } -> contiguous_iterator; };
797 template<
typename _Tp>
798 static constexpr
bool
801 if constexpr (__member_data<_Tp>)
802 return noexcept(__decay_copy(std::declval<_Tp>().data()));
804 return noexcept(_Begin{}(std::declval<_Tp>()));
808 template<
typename _Tp> requires __member_data<_Tp> || __begin_data<_Tp>
810 operator()(_Tp&& __e)
const noexcept(_S_noexcept<_Tp>())
812 if constexpr (__member_data<_Tp>)
815 return std::to_address(_Begin{}(std::forward<_Tp>(__e)));
821 template<
typename _Tp>
823 operator()(_Tp&& __e)
const
824 noexcept(noexcept(_Data{}(__cust_access::__as_const((_Tp&&)__e))))
825 requires requires { _Data{}(__cust_access::__as_const((_Tp&&)__e)); }
827 return _Data{}(__cust_access::__as_const(std::forward<_Tp>(__e)));
833 inline namespace __cust
835 inline constexpr __cust_access::_Begin
begin{};
836 inline constexpr __cust_access::_End
end{};
837 inline constexpr __cust_access::_CBegin
cbegin{};
838 inline constexpr __cust_access::_CEnd
cend{};
839 inline constexpr __cust_access::_RBegin
rbegin{};
840 inline constexpr __cust_access::_REnd
rend{};
841 inline constexpr __cust_access::_CRBegin
crbegin{};
842 inline constexpr __cust_access::_CREnd
crend{};
843 inline constexpr __cust_access::_Size size{};
844 inline constexpr __cust_access::_Empty empty{};
845 inline constexpr __cust_access::_Data data{};
846 inline constexpr __cust_access::_CData cdata{};
850 template<
typename _Tp>
851 concept range = requires(_Tp& __t)
858 template<
typename _Tp>
859 concept safe_range = range<_Tp> && __detail::__maybe_safe_range<_Tp>;
861 template<range _Range>
862 using iterator_t = decltype(
ranges::begin(std::declval<_Range&>()));
864 template<range _Range>
865 using sentinel_t = decltype(
ranges::end(std::declval<_Range&>()));
867 template<range _Range>
868 using range_difference_t = iter_difference_t<iterator_t<_Range>>;
870 template<range _Range>
871 using range_value_t = iter_value_t<iterator_t<_Range>>;
873 template<range _Range>
874 using range_reference_t = iter_reference_t<iterator_t<_Range>>;
876 template<range _Range>
877 using range_rvalue_reference_t
878 = iter_rvalue_reference_t<iterator_t<_Range>>;
881 template<
typename _Tp>
882 concept sized_range = range<_Tp>
883 && requires(_Tp& __t) { ranges::size(__t); };
888 template<
typename _Range,
typename _Tp>
890 = range<_Range> && output_iterator<iterator_t<_Range>, _Tp>;
893 template<
typename _Tp>
894 concept input_range = range<_Tp> && input_iterator<iterator_t<_Tp>>;
897 template<
typename _Tp>
898 concept forward_range
899 = input_range<_Tp> && forward_iterator<iterator_t<_Tp>>;
902 template<
typename _Tp>
903 concept bidirectional_range
904 = forward_range<_Tp> && bidirectional_iterator<iterator_t<_Tp>>;
907 template<
typename _Tp>
908 concept random_access_range
909 = bidirectional_range<_Tp> && random_access_iterator<iterator_t<_Tp>>;
912 template<
typename _Tp>
913 concept contiguous_range
914 = random_access_range<_Tp> && contiguous_iterator<iterator_t<_Tp>>
915 && requires(_Tp& __t)
917 { ranges::data(__t) } -> same_as<add_pointer_t<range_reference_t<_Tp>>>;
921 template<
typename _Tp>
923 = range<_Tp> && same_as<iterator_t<_Tp>, sentinel_t<_Tp>>;
927 template<input_or_output_iterator _It>
929 advance(_It& __it, iter_difference_t<_It> __n)
931 if constexpr (random_access_iterator<_It>)
933 else if constexpr (bidirectional_iterator<_It>)
954 #ifdef __cpp_lib_is_constant_evaluated
955 if (std::is_constant_evaluated() && __n < 0)
956 throw "attempt to decrement a non-bidirectional iterator";
958 __glibcxx_assert(__n >= 0);
964 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
966 advance(_It& __it, _Sent __bound)
968 if constexpr (assignable_from<_It&, _Sent>)
970 else if constexpr (sized_sentinel_for<_Sent, _It>)
974 while (__it != __bound)
979 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
980 constexpr iter_difference_t<_It>
981 advance(_It& __it, iter_difference_t<_It> __n, _Sent __bound)
983 if constexpr (sized_sentinel_for<_Sent, _It>)
985 const auto __diff = __bound - __it;
986 #ifdef __cpp_lib_is_constant_evaluated
987 if (std::is_constant_evaluated()
988 && !(__n == 0 || __diff == 0 || (__n < 0 == __diff < 0)))
989 throw "inconsistent directions for distance and bound";
992 __glibcxx_assert(__n == 0 || __diff == 0 || (__n < 0 == __diff < 0));
993 const auto __absdiff = __diff < 0 ? -__diff : __diff;
994 const auto __absn = __n < 0 ? -__n : __n;;
995 if (__absn >= __absdiff)
1006 else if (__it == __bound || __n == 0)
1007 return iter_difference_t<_It>(0);
1010 iter_difference_t<_It> __m = 0;
1016 while (__m != __n && __it != __bound);
1019 else if constexpr (bidirectional_iterator<_It> && same_as<_It, _Sent>)
1021 iter_difference_t<_It> __m = 0;
1027 while (__m != __n && __it != __bound);
1032 #ifdef __cpp_lib_is_constant_evaluated
1033 if (std::is_constant_evaluated() && __n < 0)
1034 throw "attempt to decrement a non-bidirectional iterator";
1036 __glibcxx_assert(__n >= 0);
1041 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
1042 constexpr iter_difference_t<_It>
1043 distance(_It __first, _Sent __last)
1045 if constexpr (sized_sentinel_for<_Sent, _It>)
1046 return __last - __first;
1049 iter_difference_t<_It> __n = 0;
1050 while (__first != __last)
1059 template<range _Range>
1060 constexpr range_difference_t<_Range>
1063 if constexpr (sized_range<_Range>)
1064 return static_cast<range_difference_t<_Range>
>(ranges::size(__r));
1069 template<input_or_output_iterator _It>
1077 template<input_or_output_iterator _It>
1079 next(_It __x, iter_difference_t<_It> __n)
1085 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
1087 next(_It __x, _Sent __bound)
1093 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
1095 next(_It __x, iter_difference_t<_It> __n, _Sent __bound)
1101 template<b
idirectional_iterator _It>
1109 template<b
idirectional_iterator _It>
1111 prev(_It __x, iter_difference_t<_It> __n)
1117 template<b
idirectional_iterator _It>
1119 prev(_It __x, iter_difference_t<_It> __n, _It __bound)
1126 #endif // library concepts
1128 _GLIBCXX_END_NAMESPACE_VERSION
1133 #endif // _GLIBCXX_RANGE_ACCESS_H