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 template<
integral _Tp>
351 constexpr make_unsigned_t<_Tp>
352 __to_unsigned_like(_Tp __t) noexcept
355 template<
typename _Tp,
bool _MaxDiff = same_as<_Tp, __max_diff_type>>
356 using __make_unsigned_like_t
357 = conditional_t<_MaxDiff, __max_size_type, make_unsigned_t<_Tp>>;
360 template<
typename _Tp>
361 concept __maybe_safe_range
362 = is_lvalue_reference_v<_Tp> || enable_safe_range<remove_cvref_t<_Tp>>;
366 namespace __cust_access
368 using std::ranges::__detail::__maybe_safe_range;
369 using std::__detail::__class_or_enum;
371 template<
typename _Tp>
372 constexpr decay_t<_Tp>
373 __decay_copy(_Tp&& __t)
374 noexcept(is_nothrow_convertible_v<_Tp, decay_t<_Tp>>)
375 {
return std::forward<_Tp>(__t); }
377 template<
typename _Tp>
378 concept __member_begin = requires(_Tp& __t)
380 { __decay_copy(__t.begin()) } -> input_or_output_iterator;
383 template<
typename _Tp>
void begin(_Tp&&) =
delete;
384 template<
typename _Tp>
void begin(initializer_list<_Tp>&&) =
delete;
386 template<
typename _Tp>
387 concept __adl_begin = __class_or_enum<remove_reference_t<_Tp>>
388 && requires(_Tp& __t)
390 { __decay_copy(
begin(__t)) } -> input_or_output_iterator;
396 template<
typename _Tp>
397 static constexpr
bool
400 if constexpr (is_array_v<remove_reference_t<_Tp>>)
402 else if constexpr (__member_begin<_Tp>)
403 return noexcept(__decay_copy(
std::declval<_Tp&>().
begin()));
405 return noexcept(__decay_copy(
begin(
std::declval<_Tp&>())));
409 template<__maybe_safe_range _Tp>
413 operator()(_Tp&& __t) const noexcept(_S_noexcept<_Tp>())
415 if constexpr (is_array_v<remove_reference_t<_Tp>>)
417 static_assert(is_lvalue_reference_v<_Tp>);
420 else if constexpr (__member_begin<_Tp>)
427 template<
typename _Tp>
428 concept __member_end = requires(_Tp& __t)
430 { __decay_copy(__t.end()) }
431 -> sentinel_for<decltype(_Begin{}(std::forward<_Tp>(__t)))>;
434 template<
typename _Tp>
void end(_Tp&&) =
delete;
435 template<
typename _Tp>
void end(initializer_list<_Tp>&&) =
delete;
437 template<
typename _Tp>
438 concept __adl_end = __class_or_enum<remove_reference_t<_Tp>>
439 && requires(_Tp& __t)
441 { __decay_copy(
end(__t)) }
442 -> sentinel_for<decltype(_Begin{}(std::forward<_Tp>(__t)))>;
448 template<
typename _Tp>
449 static constexpr
bool
452 if constexpr (is_array_v<remove_reference_t<_Tp>>)
454 else if constexpr (__member_end<_Tp>)
455 return noexcept(__decay_copy(
std::declval<_Tp&>().
end()));
457 return noexcept(__decay_copy(
end(
std::declval<_Tp&>())));
461 template<__maybe_safe_range _Tp>
465 operator()(_Tp&& __t) const noexcept(_S_noexcept<_Tp>())
467 if constexpr (is_array_v<remove_reference_t<_Tp>>)
469 static_assert(is_lvalue_reference_v<_Tp>);
470 static_assert(is_bounded_array_v<remove_reference_t<_Tp>>);
471 return __t + extent_v<remove_reference_t<_Tp>>;
473 else if constexpr (__member_end<_Tp>)
480 template<
typename _Tp>
481 constexpr decltype(
auto)
482 __as_const(_Tp&& __t) noexcept
484 if constexpr (is_lvalue_reference_v<_Tp>)
485 return static_cast<const remove_reference_t<_Tp>&
>(__t);
487 return static_cast<const _Tp&&
>(__t);
492 template<
typename _Tp>
494 operator()(_Tp&& __e)
const
495 noexcept(noexcept(_Begin{}(__cust_access::__as_const((_Tp&&)__e))))
496 requires requires { _Begin{}(__cust_access::__as_const((_Tp&&)__e)); }
498 return _Begin{}(__cust_access::__as_const(std::forward<_Tp>(__e)));
504 template<
typename _Tp>
506 operator()(_Tp&& __e)
const
507 noexcept(noexcept(_End{}(__cust_access::__as_const((_Tp&&)__e))))
508 requires requires { _End{}(__cust_access::__as_const((_Tp&&)__e)); }
510 return _End{}(__cust_access::__as_const(std::forward<_Tp>(__e)));
514 template<
typename _Tp>
515 concept __member_rbegin = requires(_Tp& __t)
517 { __decay_copy(__t.rbegin()) } -> input_or_output_iterator;
520 template<
typename _Tp>
void rbegin(_Tp&&) =
delete;
522 template<
typename _Tp>
523 concept __adl_rbegin = __class_or_enum<remove_reference_t<_Tp>>
524 && requires(_Tp& __t)
526 { __decay_copy(
rbegin(__t)) } -> input_or_output_iterator;
529 template<
typename _Tp>
530 concept __reversable = requires(_Tp& __t)
532 { _Begin{}(__t) } -> bidirectional_iterator;
533 { _End{}(__t) } -> same_as<decltype(_Begin{}(__t))>;
539 template<
typename _Tp>
540 static constexpr
bool
543 if constexpr (__member_rbegin<_Tp>)
544 return noexcept(__decay_copy(std::declval<_Tp&>().
rbegin()));
545 else if constexpr (__adl_rbegin<_Tp>)
546 return noexcept(__decay_copy(
rbegin(std::declval<_Tp&>())));
549 if constexpr (noexcept(_End{}(std::declval<_Tp&>())))
551 using _It = decltype(_End{}(std::declval<_Tp&>()));
553 return is_nothrow_copy_constructible_v<_It>;
561 template<__maybe_safe_range _Tp>
562 requires __member_rbegin<_Tp> || __adl_rbegin<_Tp> || __reversable<_Tp>
564 operator()(_Tp&& __t)
const
565 noexcept(_S_noexcept<_Tp>())
567 if constexpr (__member_rbegin<_Tp>)
569 else if constexpr (__adl_rbegin<_Tp>)
576 template<
typename _Tp>
577 concept __member_rend = requires(_Tp& __t)
579 { __decay_copy(__t.rend()) }
580 -> sentinel_for<decltype(_RBegin{}(__t))>;
583 template<
typename _Tp>
void rend(_Tp&&) =
delete;
585 template<
typename _Tp>
586 concept __adl_rend = __class_or_enum<remove_reference_t<_Tp>>
587 && requires(_Tp& __t)
589 { __decay_copy(
rend(__t)) }
590 -> sentinel_for<decltype(_RBegin{}(std::forward<_Tp>(__t)))>;
596 template<
typename _Tp>
597 static constexpr
bool
600 if constexpr (__member_rend<_Tp>)
601 return noexcept(__decay_copy(std::declval<_Tp&>().
rend()));
602 else if constexpr (__adl_rend<_Tp>)
603 return noexcept(__decay_copy(
rend(std::declval<_Tp&>())));
606 if constexpr (noexcept(_Begin{}(std::declval<_Tp&>())))
608 using _It = decltype(_Begin{}(std::declval<_Tp&>()));
610 return is_nothrow_copy_constructible_v<_It>;
618 template<__maybe_safe_range _Tp>
619 requires __member_rend<_Tp> || __adl_rend<_Tp> || __reversable<_Tp>
621 operator()(_Tp&& __t)
const
622 noexcept(_S_noexcept<_Tp>())
624 if constexpr (__member_rend<_Tp>)
626 else if constexpr (__adl_rend<_Tp>)
635 template<
typename _Tp>
637 operator()(_Tp&& __e)
const
638 noexcept(noexcept(_RBegin{}(__cust_access::__as_const((_Tp&&)__e))))
639 requires requires { _RBegin{}(__cust_access::__as_const((_Tp&&)__e)); }
641 return _RBegin{}(__cust_access::__as_const(std::forward<_Tp>(__e)));
647 template<
typename _Tp>
649 operator()(_Tp&& __e)
const
650 noexcept(noexcept(_REnd{}(__cust_access::__as_const((_Tp&&)__e))))
651 requires requires { _REnd{}(__cust_access::__as_const((_Tp&&)__e)); }
653 return _REnd{}(__cust_access::__as_const(std::forward<_Tp>(__e)));
657 template<
typename _Tp>
658 concept __member_size = !disable_sized_range<remove_cvref_t<_Tp>>
659 && requires(_Tp&& __t)
661 { __decay_copy(std::forward<_Tp>(__t).size()) }
662 -> __detail::__is_integer_like;
665 template<
typename _Tp>
void size(_Tp&&) =
delete;
667 template<
typename _Tp>
668 concept __adl_size = __class_or_enum<remove_reference_t<_Tp>>
669 && !disable_sized_range<remove_cvref_t<_Tp>>
670 && requires(_Tp&& __t)
672 { __decay_copy(size(std::forward<_Tp>(__t))) }
673 -> __detail::__is_integer_like;
676 template<
typename _Tp>
677 concept __sentinel_size = requires(_Tp&& __t)
679 { _Begin{}(std::forward<_Tp>(__t)) } -> forward_iterator;
681 { _End{}(std::forward<_Tp>(__t)) }
682 -> sized_sentinel_for<decltype(_Begin{}(std::forward<_Tp>(__t)))>;
688 template<
typename _Tp>
689 static constexpr
bool
692 if constexpr (is_array_v<remove_reference_t<_Tp>>)
694 else if constexpr (__member_size<_Tp>)
695 return noexcept(__decay_copy(
std::declval<_Tp>().size()));
696 else if constexpr (__adl_size<_Tp>)
697 return noexcept(__decay_copy(size(
std::declval<_Tp>())));
698 else if constexpr (__sentinel_size<_Tp>)
699 return noexcept(_End{}(std::declval<_Tp>())
700 - _Begin{}(std::declval<_Tp>()));
704 template<
typename _Tp>
705 requires is_array_v<remove_reference_t<_Tp>>
706 || __member_size<_Tp> || __adl_size<_Tp> || __sentinel_size<_Tp>
708 operator()(_Tp&& __e)
const noexcept(_S_noexcept<_Tp>())
710 if constexpr (is_array_v<remove_reference_t<_Tp>>)
712 static_assert(is_bounded_array_v<remove_reference_t<_Tp>>);
713 return extent_v<remove_reference_t<_Tp>>;
715 else if constexpr (__member_size<_Tp>)
716 return std::forward<_Tp>(__e).size();
717 else if constexpr (__adl_size<_Tp>)
718 return size(std::forward<_Tp>(__e));
719 else if constexpr (__sentinel_size<_Tp>)
720 return __detail::__to_unsigned_like(
721 _End{}(std::forward<_Tp>(__e))
722 - _Begin{}(std::forward<_Tp>(__e)));
726 template<
typename _Tp>
727 concept __member_empty = requires(_Tp&& __t)
728 { bool(std::forward<_Tp>(__t).empty()); };
730 template<
typename _Tp>
731 concept __size0_empty = requires(_Tp&& __t)
732 { _Size{}(std::forward<_Tp>(__t)) == 0; };
734 template<
typename _Tp>
735 concept __eq_iter_empty = requires(_Tp&& __t)
737 { _Begin{}(std::forward<_Tp>(__t)) } -> forward_iterator;
738 bool(_Begin{}(std::forward<_Tp>(__t))
739 == _End{}(std::forward<_Tp>(__t)));
745 template<
typename _Tp>
746 static constexpr
bool
749 if constexpr (__member_empty<_Tp>)
750 return noexcept(std::declval<_Tp>().empty());
751 else if constexpr (__size0_empty<_Tp>)
752 return noexcept(_Size{}(std::declval<_Tp>()) == 0);
754 return noexcept(
bool(_Begin{}(std::declval<_Tp>())
755 == _End{}(std::declval<_Tp>())));
759 template<
typename _Tp>
760 requires __member_empty<_Tp> || __size0_empty<_Tp>
761 || __eq_iter_empty<_Tp>
763 operator()(_Tp&& __e)
const noexcept(_S_noexcept<_Tp>())
765 if constexpr (__member_empty<_Tp>)
766 return bool(std::forward<_Tp>(__e).empty());
767 else if constexpr (__size0_empty<_Tp>)
768 return _Size{}(std::forward<_Tp>(__e)) == 0;
770 return bool(_Begin{}(std::forward<_Tp>(__e))
771 == _End{}(std::forward<_Tp>(__e)));
775 template<
typename _Tp>
776 concept __pointer_to_object = is_pointer_v<_Tp>
777 && is_object_v<remove_pointer_t<_Tp>>;
779 template<
typename _Tp>
780 concept __member_data = is_lvalue_reference_v<_Tp>
781 && requires(_Tp __t) { { __t.data() } -> __pointer_to_object; };
783 template<
typename _Tp>
784 concept __begin_data = requires(_Tp&& __t)
785 { { _Begin{}(std::forward<_Tp>(__t)) } -> contiguous_iterator; };
790 template<
typename _Tp>
791 static constexpr
bool
794 if constexpr (__member_data<_Tp>)
795 return noexcept(__decay_copy(std::declval<_Tp>().data()));
797 return noexcept(_Begin{}(std::declval<_Tp>()));
801 template<
typename _Tp> requires __member_data<_Tp> || __begin_data<_Tp>
803 operator()(_Tp&& __e)
const noexcept(_S_noexcept<_Tp>())
805 if constexpr (__member_data<_Tp>)
808 return std::to_address(_Begin{}(std::forward<_Tp>(__e)));
814 template<
typename _Tp>
816 operator()(_Tp&& __e)
const
817 noexcept(noexcept(_Data{}(__cust_access::__as_const((_Tp&&)__e))))
818 requires requires { _Data{}(__cust_access::__as_const((_Tp&&)__e)); }
820 return _Data{}(__cust_access::__as_const(std::forward<_Tp>(__e)));
826 inline namespace __cust
828 inline constexpr __cust_access::_Begin
begin{};
829 inline constexpr __cust_access::_End
end{};
830 inline constexpr __cust_access::_CBegin
cbegin{};
831 inline constexpr __cust_access::_CEnd
cend{};
832 inline constexpr __cust_access::_RBegin
rbegin{};
833 inline constexpr __cust_access::_REnd
rend{};
834 inline constexpr __cust_access::_CRBegin
crbegin{};
835 inline constexpr __cust_access::_CREnd
crend{};
836 inline constexpr __cust_access::_Size size{};
837 inline constexpr __cust_access::_Empty empty{};
838 inline constexpr __cust_access::_Data data{};
839 inline constexpr __cust_access::_CData cdata{};
843 template<
typename _Tp>
844 concept range = requires(_Tp& __t)
851 template<
typename _Tp>
852 concept safe_range = range<_Tp> && __detail::__maybe_safe_range<_Tp>;
854 template<range _Range>
855 using iterator_t = decltype(
ranges::begin(std::declval<_Range&>()));
857 template<range _Range>
858 using sentinel_t = decltype(
ranges::end(std::declval<_Range&>()));
860 template<range _Range>
861 using range_difference_t = iter_difference_t<iterator_t<_Range>>;
863 template<range _Range>
864 using range_value_t = iter_value_t<iterator_t<_Range>>;
866 template<range _Range>
867 using range_reference_t = iter_reference_t<iterator_t<_Range>>;
869 template<range _Range>
870 using range_rvalue_reference_t
871 = iter_rvalue_reference_t<iterator_t<_Range>>;
874 template<
typename _Tp>
875 concept sized_range = range<_Tp>
876 && requires(_Tp& __t) { ranges::size(__t); };
881 template<
typename _Range,
typename _Tp>
883 = range<_Range> && output_iterator<iterator_t<_Range>, _Tp>;
886 template<
typename _Tp>
887 concept input_range = range<_Tp> && input_iterator<iterator_t<_Tp>>;
890 template<
typename _Tp>
891 concept forward_range
892 = input_range<_Tp> && forward_iterator<iterator_t<_Tp>>;
895 template<
typename _Tp>
896 concept bidirectional_range
897 = forward_range<_Tp> && bidirectional_iterator<iterator_t<_Tp>>;
900 template<
typename _Tp>
901 concept random_access_range
902 = bidirectional_range<_Tp> && random_access_iterator<iterator_t<_Tp>>;
905 template<
typename _Tp>
906 concept contiguous_range
907 = random_access_range<_Tp> && contiguous_iterator<iterator_t<_Tp>>
908 && requires(_Tp& __t)
910 { ranges::data(__t) } -> same_as<add_pointer_t<range_reference_t<_Tp>>>;
914 template<
typename _Tp>
916 = range<_Tp> && same_as<iterator_t<_Tp>, sentinel_t<_Tp>>;
920 template<input_or_output_iterator _It>
922 advance(_It& __it, iter_difference_t<_It> __n)
924 if constexpr (random_access_iterator<_It>)
926 else if constexpr (bidirectional_iterator<_It>)
947 #ifdef __cpp_lib_is_constant_evaluated
948 if (std::is_constant_evaluated() && __n < 0)
949 throw "attempt to decrement a non-bidirectional iterator";
951 __glibcxx_assert(__n >= 0);
957 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
959 advance(_It& __it, _Sent __bound)
961 if constexpr (assignable_from<_It&, _Sent>)
963 else if constexpr (sized_sentinel_for<_Sent, _It>)
967 while (__it != __bound)
972 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
973 constexpr iter_difference_t<_It>
974 advance(_It& __it, iter_difference_t<_It> __n, _Sent __bound)
976 if constexpr (sized_sentinel_for<_Sent, _It>)
978 const auto __diff = __bound - __it;
979 #ifdef __cpp_lib_is_constant_evaluated
980 if (std::is_constant_evaluated()
981 && !(__n == 0 || __diff == 0 || (__n < 0 == __diff < 0)))
982 throw "inconsistent directions for distance and bound";
985 __glibcxx_assert(__n == 0 || __diff == 0 || (__n < 0 == __diff < 0));
986 const auto __absdiff = __diff < 0 ? -__diff : __diff;
987 const auto __absn = __n < 0 ? -__n : __n;;
988 if (__absn >= __absdiff)
999 else if (__it == __bound || __n == 0)
1000 return iter_difference_t<_It>(0);
1003 iter_difference_t<_It> __m = 0;
1009 while (__m != __n && __it != __bound);
1012 else if constexpr (bidirectional_iterator<_It> && same_as<_It, _Sent>)
1014 iter_difference_t<_It> __m = 0;
1020 while (__m != __n && __it != __bound);
1025 #ifdef __cpp_lib_is_constant_evaluated
1026 if (std::is_constant_evaluated() && __n < 0)
1027 throw "attempt to decrement a non-bidirectional iterator";
1029 __glibcxx_assert(__n >= 0);
1034 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
1035 constexpr iter_difference_t<_It>
1036 distance(_It __first, _Sent __last)
1038 if constexpr (sized_sentinel_for<_Sent, _It>)
1039 return __last - __first;
1042 iter_difference_t<_It> __n = 0;
1043 while (__first != __last)
1052 template<range _Range>
1053 constexpr range_difference_t<_Range>
1056 if constexpr (sized_range<_Range>)
1057 return static_cast<range_difference_t<_Range>
>(ranges::size(__r));
1062 template<input_or_output_iterator _It>
1070 template<input_or_output_iterator _It>
1072 next(_It __x, iter_difference_t<_It> __n)
1078 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
1080 next(_It __x, _Sent __bound)
1086 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
1088 next(_It __x, iter_difference_t<_It> __n, _Sent __bound)
1094 template<b
idirectional_iterator _It>
1102 template<b
idirectional_iterator _It>
1104 prev(_It __x, iter_difference_t<_It> __n)
1110 template<b
idirectional_iterator _It>
1112 prev(_It __x, iter_difference_t<_It> __n, _It __bound)
1119 #endif // library concepts
1121 _GLIBCXX_END_NAMESPACE_VERSION
1126 #endif // _GLIBCXX_RANGE_ACCESS_H