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 template<
typename _Container>
327 ssize(
const _Container& __cont)
328 noexcept(noexcept(__cont.size()))
332 return static_cast<common_type_t<ptrdiff_t, type>
>(__cont.size());
335 template<
typename _Tp, ptrdiff_t _Num>
337 ssize(
const _Tp (&)[_Num]) noexcept
340 #ifdef __cpp_lib_concepts
344 inline constexpr
bool disable_sized_range =
false;
346 template<
typename _Tp>
347 inline constexpr
bool enable_borrowed_range =
false;
349 template<
typename _Tp>
350 extern const bool enable_view;
354 template<
integral _Tp>
355 constexpr make_unsigned_t<_Tp>
356 __to_unsigned_like(_Tp __t) noexcept
359 template<
typename _Tp,
bool _MaxDiff = same_as<_Tp, __max_diff_type>>
360 using __make_unsigned_like_t
361 = conditional_t<_MaxDiff, __max_size_type, make_unsigned_t<_Tp>>;
364 template<
typename _Tp>
365 concept __maybe_borrowed_range
366 = is_lvalue_reference_v<_Tp>
367 || enable_borrowed_range<remove_cvref_t<_Tp>>;
371 namespace __cust_access
373 using std::ranges::__detail::__maybe_borrowed_range;
374 using std::__detail::__class_or_enum;
375 using std::__detail::__decay_copy;
376 using std::__detail::__member_begin;
377 using std::__detail::__adl_begin;
382 template<
typename _Tp>
383 static constexpr
bool
386 if constexpr (is_array_v<remove_reference_t<_Tp>>)
388 else if constexpr (__member_begin<_Tp>)
389 return noexcept(__decay_copy(
std::declval<_Tp&>().
begin()));
391 return noexcept(__decay_copy(
begin(
std::declval<_Tp&>())));
395 template<__maybe_borrowed_range _Tp>
399 operator()(_Tp&& __t) const noexcept(_S_noexcept<_Tp>())
401 if constexpr (is_array_v<remove_reference_t<_Tp>>)
403 static_assert(is_lvalue_reference_v<_Tp>);
404 using _Up = remove_all_extents_t<remove_reference_t<_Tp>>;
405 static_assert(
sizeof(_Up) != 0,
"not array of incomplete type");
408 else if constexpr (__member_begin<_Tp>)
415 template<
typename _Tp>
416 concept __member_end = requires(_Tp& __t)
418 { __decay_copy(__t.end()) }
419 -> sentinel_for<decltype(_Begin{}(std::forward<_Tp>(__t)))>;
422 void end(
auto&) =
delete;
423 void end(
const auto&) =
delete;
425 template<
typename _Tp>
426 concept __adl_end = __class_or_enum<remove_reference_t<_Tp>>
427 && requires(_Tp& __t)
429 { __decay_copy(
end(__t)) }
430 -> sentinel_for<decltype(_Begin{}(std::forward<_Tp>(__t)))>;
436 template<
typename _Tp>
437 static constexpr
bool
440 if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>)
442 else if constexpr (__member_end<_Tp>)
443 return noexcept(__decay_copy(
std::declval<_Tp&>().
end()));
445 return noexcept(__decay_copy(
end(
std::declval<_Tp&>())));
449 template<__maybe_borrowed_range _Tp>
453 operator()(_Tp&& __t) const noexcept(_S_noexcept<_Tp>())
455 if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>)
457 static_assert(is_lvalue_reference_v<_Tp>);
458 return __t + extent_v<remove_reference_t<_Tp>>;
460 else if constexpr (__member_end<_Tp>)
467 template<
typename _Tp>
468 constexpr decltype(
auto)
469 __as_const(_Tp&& __t) noexcept
471 if constexpr (is_lvalue_reference_v<_Tp>)
472 return static_cast<const remove_reference_t<_Tp>&
>(__t);
474 return static_cast<const _Tp&&>(__t);
479 template<
typename _Tp>
481 operator()(_Tp&& __e)
const
482 noexcept(noexcept(_Begin{}(__cust_access::__as_const((_Tp&&)__e))))
483 requires requires { _Begin{}(__cust_access::__as_const((_Tp&&)__e)); }
485 return _Begin{}(__cust_access::__as_const(std::forward<_Tp>(__e)));
491 template<
typename _Tp>
493 operator()(_Tp&& __e)
const
494 noexcept(noexcept(_End{}(__cust_access::__as_const((_Tp&&)__e))))
495 requires requires { _End{}(__cust_access::__as_const((_Tp&&)__e)); }
497 return _End{}(__cust_access::__as_const(std::forward<_Tp>(__e)));
501 template<
typename _Tp>
502 concept __member_rbegin = requires(_Tp& __t)
504 { __decay_copy(__t.rbegin()) } -> input_or_output_iterator;
507 void rbegin(
auto&) =
delete;
508 void rbegin(
const auto&) =
delete;
510 template<
typename _Tp>
511 concept __adl_rbegin = __class_or_enum<remove_reference_t<_Tp>>
512 && requires(_Tp& __t)
514 { __decay_copy(
rbegin(__t)) } -> input_or_output_iterator;
517 template<
typename _Tp>
518 concept __reversable = requires(_Tp& __t)
520 { _Begin{}(__t) } -> bidirectional_iterator;
521 { _End{}(__t) } -> same_as<decltype(_Begin{}(__t))>;
527 template<
typename _Tp>
528 static constexpr
bool
531 if constexpr (__member_rbegin<_Tp>)
532 return noexcept(__decay_copy(std::declval<_Tp&>().
rbegin()));
533 else if constexpr (__adl_rbegin<_Tp>)
534 return noexcept(__decay_copy(
rbegin(std::declval<_Tp&>())));
537 if constexpr (noexcept(_End{}(std::declval<_Tp&>())))
539 using _It = decltype(_End{}(std::declval<_Tp&>()));
541 return is_nothrow_copy_constructible_v<_It>;
549 template<__maybe_borrowed_range _Tp>
550 requires __member_rbegin<_Tp> || __adl_rbegin<_Tp> || __reversable<_Tp>
552 operator()(_Tp&& __t)
const
553 noexcept(_S_noexcept<_Tp>())
555 if constexpr (__member_rbegin<_Tp>)
557 else if constexpr (__adl_rbegin<_Tp>)
564 template<
typename _Tp>
565 concept __member_rend = requires(_Tp& __t)
567 { __decay_copy(__t.rend()) }
568 -> sentinel_for<decltype(_RBegin{}(__t))>;
571 void rend(
auto&) =
delete;
572 void rend(
const auto&) =
delete;
574 template<
typename _Tp>
575 concept __adl_rend = __class_or_enum<remove_reference_t<_Tp>>
576 && requires(_Tp& __t)
578 { __decay_copy(
rend(__t)) }
579 -> sentinel_for<decltype(_RBegin{}(std::forward<_Tp>(__t)))>;
585 template<
typename _Tp>
586 static constexpr
bool
589 if constexpr (__member_rend<_Tp>)
590 return noexcept(__decay_copy(std::declval<_Tp&>().
rend()));
591 else if constexpr (__adl_rend<_Tp>)
592 return noexcept(__decay_copy(
rend(std::declval<_Tp&>())));
595 if constexpr (noexcept(_Begin{}(std::declval<_Tp&>())))
597 using _It = decltype(_Begin{}(std::declval<_Tp&>()));
599 return is_nothrow_copy_constructible_v<_It>;
607 template<__maybe_borrowed_range _Tp>
608 requires __member_rend<_Tp> || __adl_rend<_Tp> || __reversable<_Tp>
610 operator()(_Tp&& __t)
const
611 noexcept(_S_noexcept<_Tp>())
613 if constexpr (__member_rend<_Tp>)
615 else if constexpr (__adl_rend<_Tp>)
624 template<
typename _Tp>
626 operator()(_Tp&& __e)
const
627 noexcept(noexcept(_RBegin{}(__cust_access::__as_const((_Tp&&)__e))))
628 requires requires { _RBegin{}(__cust_access::__as_const((_Tp&&)__e)); }
630 return _RBegin{}(__cust_access::__as_const(std::forward<_Tp>(__e)));
636 template<
typename _Tp>
638 operator()(_Tp&& __e)
const
639 noexcept(noexcept(_REnd{}(__cust_access::__as_const((_Tp&&)__e))))
640 requires requires { _REnd{}(__cust_access::__as_const((_Tp&&)__e)); }
642 return _REnd{}(__cust_access::__as_const(std::forward<_Tp>(__e)));
646 template<
typename _Tp>
647 concept __member_size = !disable_sized_range<remove_cvref_t<_Tp>>
648 && requires(_Tp&& __t)
650 { __decay_copy(std::forward<_Tp>(__t).size()) }
651 -> __detail::__is_integer_like;
654 void size(
auto&) =
delete;
655 void size(
const auto&) =
delete;
657 template<
typename _Tp>
658 concept __adl_size = __class_or_enum<remove_reference_t<_Tp>>
659 && !disable_sized_range<remove_cvref_t<_Tp>>
660 && requires(_Tp&& __t)
662 { __decay_copy(size(std::forward<_Tp>(__t))) }
663 -> __detail::__is_integer_like;
666 template<
typename _Tp>
667 concept __sentinel_size = requires(_Tp&& __t)
669 { _Begin{}(std::forward<_Tp>(__t)) } -> forward_iterator;
671 { _End{}(std::forward<_Tp>(__t)) }
672 -> sized_sentinel_for<decltype(_Begin{}(std::forward<_Tp>(__t)))>;
678 template<
typename _Tp>
679 static constexpr
bool
682 if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>)
684 else if constexpr (__member_size<_Tp>)
685 return noexcept(__decay_copy(
std::declval<_Tp>().size()));
686 else if constexpr (__adl_size<_Tp>)
687 return noexcept(__decay_copy(size(
std::declval<_Tp>())));
688 else if constexpr (__sentinel_size<_Tp>)
689 return noexcept(_End{}(std::declval<_Tp>())
690 - _Begin{}(std::declval<_Tp>()));
694 template<
typename _Tp>
695 requires is_bounded_array_v<remove_reference_t<_Tp>>
696 || __member_size<_Tp> || __adl_size<_Tp> || __sentinel_size<_Tp>
698 operator()(_Tp&& __e)
const noexcept(_S_noexcept<_Tp>())
700 if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>)
702 return extent_v<remove_reference_t<_Tp>>;
704 else if constexpr (__member_size<_Tp>)
705 return std::forward<_Tp>(__e).size();
706 else if constexpr (__adl_size<_Tp>)
707 return size(std::forward<_Tp>(__e));
708 else if constexpr (__sentinel_size<_Tp>)
709 return __detail::__to_unsigned_like(
710 _End{}(std::forward<_Tp>(__e))
711 - _Begin{}(std::forward<_Tp>(__e)));
717 template<
typename _Tp>
718 requires requires (_Tp&& __e)
720 _Begin{}(std::forward<_Tp>(__e));
721 _Size{}(std::forward<_Tp>(__e));
724 operator()(_Tp&& __e)
const
725 noexcept(noexcept(_Size{}(std::forward<_Tp>(__e))))
727 using __iter_type = decltype(_Begin{}(std::forward<_Tp>(__e)));
728 using __diff_type = iter_difference_t<__iter_type>;
729 using std::__detail::__int_limits;
730 auto __size = _Size{}(std::forward<_Tp>(__e));
731 if constexpr (integral<__diff_type>)
733 if constexpr (__int_limits<__diff_type>::digits
734 < __int_limits<ptrdiff_t>::digits)
735 return static_cast<ptrdiff_t>(__size);
737 return static_cast<__diff_type>(__size);
741 template<
typename _Tp>
742 concept __member_empty = requires(_Tp&& __t)
743 { bool(std::forward<_Tp>(__t).empty()); };
745 template<
typename _Tp>
746 concept __size0_empty = requires(_Tp&& __t)
747 { _Size{}(std::forward<_Tp>(__t)) == 0; };
749 template<
typename _Tp>
750 concept __eq_iter_empty = requires(_Tp&& __t)
752 { _Begin{}(std::forward<_Tp>(__t)) } -> forward_iterator;
753 bool(_Begin{}(std::forward<_Tp>(__t))
754 == _End{}(std::forward<_Tp>(__t)));
760 template<
typename _Tp>
761 static constexpr
bool
764 if constexpr (__member_empty<_Tp>)
765 return noexcept(std::declval<_Tp>().empty());
766 else if constexpr (__size0_empty<_Tp>)
767 return noexcept(_Size{}(std::declval<_Tp>()) == 0);
769 return noexcept(
bool(_Begin{}(std::declval<_Tp>())
770 == _End{}(std::declval<_Tp>())));
774 template<
typename _Tp>
775 requires __member_empty<_Tp> || __size0_empty<_Tp>
776 || __eq_iter_empty<_Tp>
778 operator()(_Tp&& __e)
const noexcept(_S_noexcept<_Tp>())
780 if constexpr (__member_empty<_Tp>)
781 return bool(std::forward<_Tp>(__e).empty());
782 else if constexpr (__size0_empty<_Tp>)
783 return _Size{}(std::forward<_Tp>(__e)) == 0;
785 return bool(_Begin{}(std::forward<_Tp>(__e))
786 == _End{}(std::forward<_Tp>(__e)));
790 template<
typename _Tp>
791 concept __pointer_to_object = is_pointer_v<_Tp>
792 && is_object_v<remove_pointer_t<_Tp>>;
794 template<
typename _Tp>
795 concept __member_data = is_lvalue_reference_v<_Tp>
796 && requires(_Tp __t) { { __t.data() } -> __pointer_to_object; };
798 template<
typename _Tp>
799 concept __begin_data = requires(_Tp&& __t)
800 { { _Begin{}(std::forward<_Tp>(__t)) } -> contiguous_iterator; };
805 template<
typename _Tp>
806 static constexpr
bool
809 if constexpr (__member_data<_Tp>)
810 return noexcept(__decay_copy(std::declval<_Tp>().data()));
812 return noexcept(_Begin{}(std::declval<_Tp>()));
816 template<__maybe_borrowed_range _Tp>
817 requires __member_data<_Tp> || __begin_data<_Tp>
819 operator()(_Tp&& __e)
const noexcept(_S_noexcept<_Tp>())
821 if constexpr (__member_data<_Tp>)
824 return std::to_address(_Begin{}(std::forward<_Tp>(__e)));
830 template<
typename _Tp>
832 operator()(_Tp&& __e)
const
833 noexcept(noexcept(_Data{}(__cust_access::__as_const((_Tp&&)__e))))
834 requires requires { _Data{}(__cust_access::__as_const((_Tp&&)__e)); }
836 return _Data{}(__cust_access::__as_const(std::forward<_Tp>(__e)));
842 inline namespace __cust
844 inline constexpr __cust_access::_Begin
begin{};
845 inline constexpr __cust_access::_End
end{};
846 inline constexpr __cust_access::_CBegin
cbegin{};
847 inline constexpr __cust_access::_CEnd
cend{};
848 inline constexpr __cust_access::_RBegin
rbegin{};
849 inline constexpr __cust_access::_REnd
rend{};
850 inline constexpr __cust_access::_CRBegin
crbegin{};
851 inline constexpr __cust_access::_CREnd
crend{};
852 inline constexpr __cust_access::_Size size{};
853 inline constexpr __cust_access::_SSize ssize{};
854 inline constexpr __cust_access::_Empty empty{};
855 inline constexpr __cust_access::_Data data{};
856 inline constexpr __cust_access::_CData cdata{};
860 template<
typename _Tp>
861 concept range = requires(_Tp& __t)
868 template<
typename _Tp>
869 concept borrowed_range
870 = range<_Tp> && __detail::__maybe_borrowed_range<_Tp>;
872 template<
typename _Tp>
873 using iterator_t = std::__detail::__range_iter_t<_Tp>;
875 template<range _Range>
876 using sentinel_t = decltype(
ranges::end(std::declval<_Range&>()));
878 template<range _Range>
879 using range_difference_t = iter_difference_t<iterator_t<_Range>>;
881 template<range _Range>
882 using range_value_t = iter_value_t<iterator_t<_Range>>;
884 template<range _Range>
885 using range_reference_t = iter_reference_t<iterator_t<_Range>>;
887 template<range _Range>
888 using range_rvalue_reference_t
889 = iter_rvalue_reference_t<iterator_t<_Range>>;
892 template<
typename _Tp>
893 concept sized_range = range<_Tp>
894 && requires(_Tp& __t) { ranges::size(__t); };
896 template<sized_range _Range>
897 using range_size_t = decltype(ranges::size(std::declval<_Range&>()));
902 template<
typename _Range,
typename _Tp>
904 = range<_Range> && output_iterator<iterator_t<_Range>, _Tp>;
907 template<
typename _Tp>
908 concept input_range = range<_Tp> && input_iterator<iterator_t<_Tp>>;
911 template<
typename _Tp>
912 concept forward_range
913 = input_range<_Tp> && forward_iterator<iterator_t<_Tp>>;
916 template<
typename _Tp>
917 concept bidirectional_range
918 = forward_range<_Tp> && bidirectional_iterator<iterator_t<_Tp>>;
921 template<
typename _Tp>
922 concept random_access_range
923 = bidirectional_range<_Tp> && random_access_iterator<iterator_t<_Tp>>;
926 template<
typename _Tp>
927 concept contiguous_range
928 = random_access_range<_Tp> && contiguous_iterator<iterator_t<_Tp>>
929 && requires(_Tp& __t)
931 { ranges::data(__t) } -> same_as<add_pointer_t<range_reference_t<_Tp>>>;
935 template<
typename _Tp>
937 = range<_Tp> && same_as<iterator_t<_Tp>, sentinel_t<_Tp>>;
941 template<input_or_output_iterator _It>
943 advance(_It& __it, iter_difference_t<_It> __n)
945 if constexpr (random_access_iterator<_It>)
947 else if constexpr (bidirectional_iterator<_It>)
968 #ifdef __cpp_lib_is_constant_evaluated
969 if (std::is_constant_evaluated() && __n < 0)
970 throw "attempt to decrement a non-bidirectional iterator";
972 __glibcxx_assert(__n >= 0);
978 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
980 advance(_It& __it, _Sent __bound)
982 if constexpr (assignable_from<_It&, _Sent>)
984 else if constexpr (sized_sentinel_for<_Sent, _It>)
988 while (__it != __bound)
993 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
994 constexpr iter_difference_t<_It>
995 advance(_It& __it, iter_difference_t<_It> __n, _Sent __bound)
997 if constexpr (sized_sentinel_for<_Sent, _It>)
999 const auto __diff = __bound - __it;
1000 #ifdef __cpp_lib_is_constant_evaluated
1001 if (std::is_constant_evaluated()
1002 && !(__n == 0 || __diff == 0 || (__n < 0 == __diff < 0)))
1003 throw "inconsistent directions for distance and bound";
1006 __glibcxx_assert(__n == 0 || __diff == 0 || (__n < 0 == __diff < 0));
1007 const auto __absdiff = __diff < 0 ? -__diff : __diff;
1008 const auto __absn = __n < 0 ? -__n : __n;;
1009 if (__absn >= __absdiff)
1012 return __n - __diff;
1020 else if (__it == __bound || __n == 0)
1021 return iter_difference_t<_It>(0);
1024 iter_difference_t<_It> __m = 0;
1030 while (__m != __n && __it != __bound);
1033 else if constexpr (bidirectional_iterator<_It> && same_as<_It, _Sent>)
1035 iter_difference_t<_It> __m = 0;
1041 while (__m != __n && __it != __bound);
1046 #ifdef __cpp_lib_is_constant_evaluated
1047 if (std::is_constant_evaluated() && __n < 0)
1048 throw "attempt to decrement a non-bidirectional iterator";
1050 __glibcxx_assert(__n >= 0);
1055 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
1056 constexpr iter_difference_t<_It>
1057 distance(_It __first, _Sent __last)
1059 if constexpr (sized_sentinel_for<_Sent, _It>)
1060 return __last - __first;
1063 iter_difference_t<_It> __n = 0;
1064 while (__first != __last)
1073 template<range _Range>
1074 constexpr range_difference_t<_Range>
1077 if constexpr (sized_range<_Range>)
1078 return static_cast<range_difference_t<_Range>
>(ranges::size(__r));
1083 template<input_or_output_iterator _It>
1091 template<input_or_output_iterator _It>
1093 next(_It __x, iter_difference_t<_It> __n)
1099 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
1101 next(_It __x, _Sent __bound)
1107 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
1109 next(_It __x, iter_difference_t<_It> __n, _Sent __bound)
1115 template<b
idirectional_iterator _It>
1123 template<b
idirectional_iterator _It>
1125 prev(_It __x, iter_difference_t<_It> __n)
1131 template<b
idirectional_iterator _It>
1133 prev(_It __x, iter_difference_t<_It> __n, _It __bound)
1140 #endif // library concepts
1142 _GLIBCXX_END_NAMESPACE_VERSION
1147 #endif // _GLIBCXX_RANGE_ACCESS_H