30#ifndef _GLIBCXX_RANGES_BASE_H
31#define _GLIBCXX_RANGES_BASE_H 1
34#pragma GCC system_header
37#if __cplusplus > 201703L
44#pragma GCC diagnostic push
45#pragma GCC diagnostic ignored "-Wpedantic"
47#if __glibcxx_algorithm_default_value_type
48# define _GLIBCXX26_RANGE_ALGO_DEF_VAL_T(_I, _P) = projected_value_t<_I, _P>
50# define _GLIBCXX26_RANGE_ALGO_DEF_VAL_T(_I, _P)
53#ifdef __cpp_lib_concepts
54namespace std _GLIBCXX_VISIBILITY(default)
56_GLIBCXX_BEGIN_NAMESPACE_VERSION
60 inline constexpr bool disable_sized_range =
false;
62 template<
typename _Tp>
63 inline constexpr bool enable_borrowed_range =
false;
67 constexpr __max_size_type
68 __to_unsigned_like(__max_size_type __t)
noexcept
71 constexpr __max_size_type
72 __to_unsigned_like(__max_diff_type __t)
noexcept
73 {
return __max_size_type(__t); }
75 template<
integral _Tp>
77 __to_unsigned_like(_Tp __t)
noexcept
78 {
return static_cast<make_unsigned_t<_Tp>
>(__t); }
80#if defined __STRICT_ANSI__ && defined __SIZEOF_INT128__
81 constexpr unsigned __int128
82 __to_unsigned_like(__int128 __t)
noexcept
85 constexpr unsigned __int128
86 __to_unsigned_like(
unsigned __int128 __t)
noexcept
90 template<
typename _Tp>
91 using __make_unsigned_like_t
92 =
decltype(__detail::__to_unsigned_like(std::declval<_Tp>()));
95 template<
typename _Tp>
96 concept __maybe_borrowed_range
97 = is_lvalue_reference_v<_Tp>
98 || enable_borrowed_range<remove_cvref_t<_Tp>>;
105 using std::ranges::__detail::__maybe_borrowed_range;
106 using std::__detail::__range_iter_t;
111 template<
typename _Tp>
112 static constexpr bool
115 if constexpr (is_array_v<remove_reference_t<_Tp>>)
117 else if constexpr (__member_begin<_Tp>)
118 return noexcept(__decay_copy(std::declval<_Tp&>().begin()));
120 return noexcept(__decay_copy(
begin(std::declval<_Tp&>())));
124 template<__maybe_borrowed_range _Tp>
125 requires is_array_v<remove_reference_t<_Tp>> || __member_begin<_Tp>
128 operator()[[nodiscard]](_Tp&& __t)
const noexcept(_S_noexcept<_Tp&>())
130 if constexpr (is_array_v<remove_reference_t<_Tp>>)
132 static_assert(is_lvalue_reference_v<_Tp>);
135 else if constexpr (__member_begin<_Tp>)
142 template<
typename _Tp>
143 concept __member_end =
requires(_Tp& __t)
145 { __decay_copy(__t.end()) } -> sentinel_for<__range_iter_t<_Tp>>;
151 template<
typename _Tp>
152 concept __adl_end = __class_or_enum<remove_reference_t<_Tp>>
153 &&
requires(_Tp& __t)
155 { __decay_copy(
end(__t)) } -> sentinel_for<__range_iter_t<_Tp>>;
161 template<
typename _Tp>
162 static constexpr bool
165 if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>)
167 else if constexpr (__member_end<_Tp>)
168 return noexcept(__decay_copy(std::declval<_Tp&>().end()));
170 return noexcept(__decay_copy(
end(std::declval<_Tp&>())));
174 template<__maybe_borrowed_range _Tp>
175 requires is_bounded_array_v<remove_reference_t<_Tp>>
176 || __member_end<_Tp> || __adl_end<_Tp>
178 operator()[[nodiscard]](_Tp&& __t)
const noexcept(_S_noexcept<_Tp&>())
180 if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>)
182 static_assert(is_lvalue_reference_v<_Tp>);
183 return __t + extent_v<remove_reference_t<_Tp>>;
185 else if constexpr (__member_end<_Tp>)
192 template<
typename _Tp>
193 concept __member_rbegin =
requires(_Tp& __t)
195 { __decay_copy(__t.rbegin()) } -> input_or_output_iterator;
200 template<
typename _Tp>
201 concept __adl_rbegin = __class_or_enum<remove_reference_t<_Tp>>
202 &&
requires(_Tp& __t)
204 { __decay_copy(
rbegin(__t)) } -> input_or_output_iterator;
207 template<
typename _Tp>
208 concept __reversable =
requires(_Tp& __t)
210 { _Begin{}(__t) } -> bidirectional_iterator;
211 { _End{}(__t) } -> same_as<
decltype(_Begin{}(__t))>;
217 template<
typename _Tp>
218 static constexpr bool
221 if constexpr (__member_rbegin<_Tp>)
222 return noexcept(__decay_copy(std::declval<_Tp&>().
rbegin()));
223 else if constexpr (__adl_rbegin<_Tp>)
224 return noexcept(__decay_copy(
rbegin(std::declval<_Tp&>())));
227 if constexpr (
noexcept(_End{}(std::declval<_Tp&>())))
229 using _It =
decltype(_End{}(std::declval<_Tp&>()));
231 return is_nothrow_copy_constructible_v<_It>;
239 template<__maybe_borrowed_range _Tp>
240 requires __member_rbegin<_Tp> || __adl_rbegin<_Tp> || __reversable<_Tp>
242 operator()[[nodiscard]](_Tp&& __t)
const
243 noexcept(_S_noexcept<_Tp&>())
245 if constexpr (__member_rbegin<_Tp>)
247 else if constexpr (__adl_rbegin<_Tp>)
254 template<
typename _Tp>
255 concept __member_rend =
requires(_Tp& __t)
257 { __decay_copy(__t.rend()) }
258 -> sentinel_for<
decltype(_RBegin{}(std::forward<_Tp>(__t)))>;
261 void rend() =
delete;
263 template<
typename _Tp>
264 concept __adl_rend = __class_or_enum<remove_reference_t<_Tp>>
265 &&
requires(_Tp& __t)
267 { __decay_copy(
rend(__t)) }
268 -> sentinel_for<
decltype(_RBegin{}(std::forward<_Tp>(__t)))>;
274 template<
typename _Tp>
275 static constexpr bool
278 if constexpr (__member_rend<_Tp>)
279 return noexcept(__decay_copy(std::declval<_Tp&>().
rend()));
280 else if constexpr (__adl_rend<_Tp>)
281 return noexcept(__decay_copy(
rend(std::declval<_Tp&>())));
284 if constexpr (
noexcept(_Begin{}(std::declval<_Tp&>())))
286 using _It =
decltype(_Begin{}(std::declval<_Tp&>()));
288 return is_nothrow_copy_constructible_v<_It>;
296 template<__maybe_borrowed_range _Tp>
297 requires __member_rend<_Tp> || __adl_rend<_Tp> || __reversable<_Tp>
299 operator()[[nodiscard]](_Tp&& __t)
const
300 noexcept(_S_noexcept<_Tp&>())
302 if constexpr (__member_rend<_Tp>)
304 else if constexpr (__adl_rend<_Tp>)
311 template<
typename _Tp>
312 concept __member_size = !disable_sized_range<remove_cvref_t<_Tp>>
313 &&
requires(_Tp& __t)
315 { __decay_copy(__t.size()) } -> __detail::__is_integer_like;
318 void size() =
delete;
320 template<
typename _Tp>
321 concept __adl_size = __class_or_enum<remove_reference_t<_Tp>>
322 && !disable_sized_range<remove_cvref_t<_Tp>>
323 &&
requires(_Tp& __t)
325 { __decay_copy(
size(__t)) } -> __detail::__is_integer_like;
328 template<
typename _Tp>
329 concept __sentinel_size =
requires(_Tp& __t)
331 requires (!is_unbounded_array_v<remove_reference_t<_Tp>>);
333 { _Begin{}(__t) } -> forward_iterator;
335 { _End{}(__t) } -> sized_sentinel_for<
decltype(_Begin{}(__t))>;
337 __detail::__to_unsigned_like(_End{}(__t) - _Begin{}(__t));
343 template<
typename _Tp>
344 static constexpr bool
347 if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>)
349 else if constexpr (__member_size<_Tp>)
350 return noexcept(__decay_copy(std::declval<_Tp&>().size()));
351 else if constexpr (__adl_size<_Tp>)
352 return noexcept(__decay_copy(
size(std::declval<_Tp&>())));
353 else if constexpr (__sentinel_size<_Tp>)
354 return noexcept(_End{}(std::declval<_Tp&>())
355 - _Begin{}(std::declval<_Tp&>()));
359 template<
typename _Tp>
360 requires is_bounded_array_v<remove_reference_t<_Tp>>
361 || __member_size<_Tp> || __adl_size<_Tp> || __sentinel_size<_Tp>
363 operator()[[nodiscard]](_Tp&& __t)
const noexcept(_S_noexcept<_Tp&>())
365 if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>)
366 return extent_v<remove_reference_t<_Tp>>;
367 else if constexpr (__member_size<_Tp>)
369 else if constexpr (__adl_size<_Tp>)
371 else if constexpr (__sentinel_size<_Tp>)
372 return __detail::__to_unsigned_like(_End{}(__t) - _Begin{}(__t));
380 template<
typename _Tp>
381 requires requires (_Tp& __t) { _Size{}(__t); }
383 operator()[[nodiscard]](_Tp&& __t)
const noexcept(
noexcept(_Size{}(__t)))
385 auto __size = _Size{}(__t);
386 using __size_type =
decltype(__size);
388 if constexpr (integral<__size_type>)
391 if constexpr (__int_traits<__size_type>::__digits
392 < __int_traits<ptrdiff_t>::__digits)
393 return static_cast<ptrdiff_t
>(__size);
395 return static_cast<make_signed_t<__size_type>
>(__size);
397#if defined __STRICT_ANSI__ && defined __SIZEOF_INT128__
399 else if constexpr (__detail::__is_int128<__size_type>)
400 return static_cast<__int128
>(__size);
403 return __detail::__max_diff_type(__size);
407 template<
typename _Tp>
408 concept __member_empty =
requires(_Tp& __t) { bool(__t.empty()); };
410 template<
typename _Tp>
411 concept __size0_empty =
requires(_Tp& __t) { _Size{}(__t) == 0; };
413 template<
typename _Tp>
414 concept __eq_iter_empty =
requires(_Tp& __t)
416 requires (!is_unbounded_array_v<remove_reference_t<_Tp>>);
418 { _Begin{}(__t) } -> forward_iterator;
420 bool(_Begin{}(__t) == _End{}(__t));
426 template<
typename _Tp>
427 static constexpr bool
430 if constexpr (__member_empty<_Tp>)
431 return noexcept(
bool(std::declval<_Tp&>().
empty()));
432 else if constexpr (__size0_empty<_Tp>)
433 return noexcept(_Size{}(std::declval<_Tp&>()) == 0);
435 return noexcept(bool(_Begin{}(std::declval<_Tp&>())
436 == _End{}(std::declval<_Tp&>())));
440 template<
typename _Tp>
441 requires __member_empty<_Tp> || __size0_empty<_Tp>
442 || __eq_iter_empty<_Tp>
444 operator()[[nodiscard]](_Tp&& __t)
const noexcept(_S_noexcept<_Tp&>())
446 if constexpr (__member_empty<_Tp>)
447 return bool(__t.empty());
448 else if constexpr (__size0_empty<_Tp>)
449 return _Size{}(__t) == 0;
451 return bool(_Begin{}(__t) == _End{}(__t));
455 template<
typename _Tp>
456 concept __pointer_to_object = is_pointer_v<_Tp>
457 && is_object_v<remove_pointer_t<_Tp>>;
459 template<
typename _Tp>
460 concept __member_data =
requires(_Tp& __t)
462 { __decay_copy(__t.data()) } -> __pointer_to_object;
465 template<
typename _Tp>
466 concept __begin_data = contiguous_iterator<__range_iter_t<_Tp>>;
471 template<
typename _Tp>
472 static constexpr bool
475 if constexpr (__member_data<_Tp>)
476 return noexcept(__decay_copy(std::declval<_Tp&>().
data()));
478 return noexcept(_Begin{}(std::declval<_Tp&>()));
482 template<__maybe_borrowed_range _Tp>
483 requires __member_data<_Tp> || __begin_data<_Tp>
485 operator()[[nodiscard]](_Tp&& __t)
const noexcept(_S_noexcept<_Tp>())
487 if constexpr (__member_data<_Tp>)
496 inline namespace _Cpo
498 inline constexpr ranges::__access::_Begin
begin{};
499 inline constexpr ranges::__access::_End
end{};
500 inline constexpr ranges::__access::_RBegin
rbegin{};
501 inline constexpr ranges::__access::_REnd
rend{};
502 inline constexpr ranges::__access::_Size
size{};
503 inline constexpr ranges::__access::_SSize ssize{};
504 inline constexpr ranges::__access::_Empty
empty{};
505 inline constexpr ranges::__access::_Data
data{};
509 template<
typename _Tp>
510 concept range =
requires(_Tp& __t)
517 template<
typename _Tp>
518 concept borrowed_range
519 = range<_Tp> && __detail::__maybe_borrowed_range<_Tp>;
521 template<
typename _Tp>
522 using iterator_t = std::__detail::__range_iter_t<_Tp>;
524 template<range _Range>
525 using sentinel_t =
decltype(ranges::end(std::declval<_Range&>()));
527#if __glibcxx_ranges_as_const
528 template<range _Range>
529 using const_iterator_t = const_iterator<iterator_t<_Range>>;
531 template<range _Range>
532 using const_sentinel_t = const_sentinel<sentinel_t<_Range>>;
534 template<range _Range>
535 using range_const_reference_t = iter_const_reference_t<iterator_t<_Range>>;
538 template<range _Range>
539 using range_difference_t = iter_difference_t<iterator_t<_Range>>;
541 template<range _Range>
542 using range_value_t = iter_value_t<iterator_t<_Range>>;
544 template<range _Range>
545 using range_reference_t = iter_reference_t<iterator_t<_Range>>;
547 template<range _Range>
548 using range_rvalue_reference_t
549 = iter_rvalue_reference_t<iterator_t<_Range>>;
553 template<range _Range>
554 using range_common_reference_t
555 = iter_common_reference_t<iterator_t<_Range>>;
558 template<
typename _Tp>
559 concept sized_range = range<_Tp>
560 &&
requires(_Tp& __t) { ranges::size(__t); };
562 template<sized_range _Range>
563 using range_size_t =
decltype(ranges::size(std::declval<_Range&>()));
565 template<
typename _Derived>
566 requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
567 class view_interface;
571 template<
typename _Tp,
typename _Up>
572 requires (!same_as<_Tp, view_interface<_Up>>)
573 void __is_derived_from_view_interface_fn(
const _Tp&,
574 const view_interface<_Up>&);
578 template<
typename _Tp>
579 concept __is_derived_from_view_interface
580 =
requires (_Tp __t) { __is_derived_from_view_interface_fn(__t, __t); };
584 struct view_base { };
587 template<
typename _Tp>
588 inline constexpr bool enable_view = derived_from<_Tp, view_base>
589 || __detail::__is_derived_from_view_interface<_Tp>;
592 template<
typename _Tp>
594 = range<_Tp> && movable<_Tp> && enable_view<_Tp>;
599 template<
typename _Range,
typename _Tp>
601 = range<_Range> && output_iterator<iterator_t<_Range>, _Tp>;
604 template<
typename _Tp>
605 concept input_range = range<_Tp> && input_iterator<iterator_t<_Tp>>;
608 template<
typename _Tp>
609 concept forward_range
610 = input_range<_Tp> && forward_iterator<iterator_t<_Tp>>;
613 template<
typename _Tp>
614 concept bidirectional_range
615 = forward_range<_Tp> && bidirectional_iterator<iterator_t<_Tp>>;
618 template<
typename _Tp>
619 concept random_access_range
620 = bidirectional_range<_Tp> && random_access_iterator<iterator_t<_Tp>>;
623 template<
typename _Tp>
624 concept contiguous_range
625 = random_access_range<_Tp> && contiguous_iterator<iterator_t<_Tp>>
626 &&
requires(_Tp& __t)
628 { ranges::data(__t) } -> same_as<add_pointer_t<range_reference_t<_Tp>>>;
632 template<
typename _Tp>
634 = range<_Tp> && same_as<iterator_t<_Tp>, sentinel_t<_Tp>>;
636#if __glibcxx_ranges_as_const
637 template<
typename _Tp>
638 concept constant_range
639 = input_range<_Tp> && std::__detail::__constant_iterator<iterator_t<_Tp>>;
644#if __glibcxx_ranges_as_const
645 template<input_range _Range>
647 __possibly_const_range(_Range& __r)
noexcept
651 if constexpr (input_range<const _Range>)
652 return const_cast<const _Range&
>(__r);
658 template<
typename _To,
typename _Tp>
659 constexpr decltype(
auto)
660 __as_const(_Tp& __t)
noexcept
662 static_assert(std::is_same_v<_To&, _Tp&>);
664 if constexpr (is_lvalue_reference_v<_To>)
665 return const_cast<const _Tp&
>(__t);
667 return static_cast<const _Tp&&
>(__t);
673#if __glibcxx_ranges_as_const
674 template<__maybe_borrowed_range _Tp>
677 operator()(_Tp&& __t)
const
678 noexcept(
noexcept(std::make_const_iterator
679 (ranges::begin(__access::__possibly_const_range(__t)))))
680 requires requires { std::make_const_iterator
681 (ranges::begin(__access::__possibly_const_range(__t))); }
683 auto& __r = __access::__possibly_const_range(__t);
684 return const_iterator_t<decltype(__r)>(ranges::begin(__r));
687 template<
typename _Tp>
690 operator()(_Tp&& __e)
const
691 noexcept(
noexcept(_Begin{}(__access::__as_const<_Tp>(__e))))
692 requires requires { _Begin{}(__access::__as_const<_Tp>(__e)); }
694 return _Begin{}(__access::__as_const<_Tp>(__e));
701#if __glibcxx_ranges_as_const
702 template<__maybe_borrowed_range _Tp>
705 operator()(_Tp&& __t)
const
706 noexcept(
noexcept(std::make_const_sentinel
707 (ranges::end(__access::__possibly_const_range(__t)))))
708 requires requires { std::make_const_sentinel
709 (ranges::end(__access::__possibly_const_range(__t))); }
711 auto& __r = __access::__possibly_const_range(__t);
712 return const_sentinel_t<decltype(__r)>(ranges::end(__r));
715 template<
typename _Tp>
718 operator()(_Tp&& __e)
const
719 noexcept(
noexcept(_End{}(__access::__as_const<_Tp>(__e))))
720 requires requires { _End{}(__access::__as_const<_Tp>(__e)); }
722 return _End{}(__access::__as_const<_Tp>(__e));
729#if __glibcxx_ranges_as_const
730 template<__maybe_borrowed_range _Tp>
733 operator()(_Tp&& __t)
const
734 noexcept(
noexcept(std::make_const_iterator
735 (ranges::rbegin(__access::__possibly_const_range(__t)))))
736 requires requires { std::make_const_iterator
737 (ranges::rbegin(__access::__possibly_const_range(__t))); }
739 auto& __r = __access::__possibly_const_range(__t);
740 return const_iterator<decltype(ranges::rbegin(__r))>(ranges::rbegin(__r));
743 template<
typename _Tp>
746 operator()(_Tp&& __e)
const
747 noexcept(
noexcept(_RBegin{}(__access::__as_const<_Tp>(__e))))
748 requires requires { _RBegin{}(__access::__as_const<_Tp>(__e)); }
750 return _RBegin{}(__access::__as_const<_Tp>(__e));
757#if __glibcxx_ranges_as_const
758 template<__maybe_borrowed_range _Tp>
761 operator()(_Tp&& __t)
const
762 noexcept(
noexcept(std::make_const_sentinel
763 (ranges::rend(__access::__possibly_const_range(__t)))))
764 requires requires { std::make_const_sentinel
765 (ranges::rend(__access::__possibly_const_range(__t))); }
767 auto& __r = __access::__possibly_const_range(__t);
768 return const_sentinel<decltype(ranges::rend(__r))>(ranges::rend(__r));
771 template<
typename _Tp>
774 operator()(_Tp&& __e)
const
775 noexcept(
noexcept(_REnd{}(__access::__as_const<_Tp>(__e))))
776 requires requires { _REnd{}(__access::__as_const<_Tp>(__e)); }
778 return _REnd{}(__access::__as_const<_Tp>(__e));
785#if __glibcxx_ranges_as_const
786 template<__maybe_borrowed_range _Tp>
788 constexpr const auto*
789 operator()(_Tp&& __t)
const
790 noexcept(
noexcept(ranges::data(__access::__possibly_const_range(__t))))
791 requires requires { ranges::data(__access::__possibly_const_range(__t)); }
792 {
return ranges::data(__access::__possibly_const_range(__t)); }
794 template<
typename _Tp>
797 operator()(_Tp&& __e)
const
798 noexcept(
noexcept(_Data{}(__access::__as_const<_Tp>(__e))))
799 requires requires { _Data{}(__access::__as_const<_Tp>(__e)); }
801 return _Data{}(__access::__as_const<_Tp>(__e));
807 inline namespace _Cpo
809 inline constexpr ranges::__access::_CBegin
cbegin{};
810 inline constexpr ranges::__access::_CEnd
cend{};
811 inline constexpr ranges::__access::_CRBegin
crbegin{};
812 inline constexpr ranges::__access::_CREnd
crend{};
813 inline constexpr ranges::__access::_CData cdata{};
818 template<
typename _Tp>
819 inline constexpr bool __is_initializer_list =
false;
821 template<
typename _Tp>
822 inline constexpr bool __is_initializer_list<initializer_list<_Tp>> =
true;
826 template<
typename _Tp>
827 concept viewable_range = range<_Tp>
828 && ((view<remove_cvref_t<_Tp>> && constructible_from<remove_cvref_t<_Tp>, _Tp>)
829 || (!view<remove_cvref_t<_Tp>>
830 && (is_lvalue_reference_v<_Tp>
831 || (movable<remove_reference_t<_Tp>>
832 && !__detail::__is_initializer_list<remove_cvref_t<_Tp>>))));
836 struct __advance_fn final
838 template<input_or_output_iterator _It>
840 operator()(_It& __it, iter_difference_t<_It> __n)
const
842 if constexpr (random_access_iterator<_It>)
844 else if constexpr (bidirectional_iterator<_It>)
866 __glibcxx_assert(__n >= 0);
872 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
874 operator()(_It& __it, _Sent __bound)
const
876 if constexpr (assignable_from<_It&, _Sent>)
878 else if constexpr (sized_sentinel_for<_Sent, _It>)
879 (*
this)(__it, __bound - __it);
882 while (__it != __bound)
887 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
888 constexpr iter_difference_t<_It>
889 operator()(_It& __it, iter_difference_t<_It> __n, _Sent __bound)
const
891 if constexpr (sized_sentinel_for<_Sent, _It>)
893 const auto __diff = __bound - __it;
897 else if (__diff > 0 ? __n >= __diff : __n <= __diff)
899 (*this)(__it, __bound);
902 else if (__n != 0) [[likely]]
905 __glibcxx_assert((__n < 0) == (__diff < 0));
913 else if (__it == __bound || __n == 0)
917 iter_difference_t<_It> __m = 0;
923 while (__m != __n && __it != __bound);
926 else if constexpr (bidirectional_iterator<_It> && same_as<_It, _Sent>)
928 iter_difference_t<_It> __m = 0;
934 while (__m != __n && __it != __bound);
940 __glibcxx_assert(__n >= 0);
948 inline constexpr __advance_fn
advance{};
950 struct __distance_fn final
954 template<
typename _It, sentinel_for<_It> _Sent>
955 requires (!sized_sentinel_for<_Sent, _It>)
956 constexpr iter_difference_t<_It>
957 operator()[[nodiscard]](_It __first, _Sent __last)
const
959 iter_difference_t<_It> __n = 0;
960 while (__first != __last)
968 template<
typename _It, sized_sentinel_for<decay_t<_It>> _Sent>
970 constexpr iter_difference_t<decay_t<_It>>
971 operator()(_It&& __first, _Sent __last)
const
972 {
return __last -
static_cast<const decay_t<_It>&
>(__first); }
974 template<range _Range>
976 constexpr range_difference_t<_Range>
977 operator()(_Range&& __r)
const
979 if constexpr (sized_range<_Range>)
980 return static_cast<range_difference_t<_Range>
>(ranges::size(__r));
982 return (*
this)(ranges::begin(__r), ranges::end(__r));
988 inline constexpr __distance_fn
distance{};
990 struct __next_fn final
992 template<input_or_output_iterator _It>
995 operator()(_It __x)
const
1001 template<input_or_output_iterator _It>
1004 operator()(_It __x, iter_difference_t<_It> __n)
const
1006 ranges::advance(__x, __n);
1010 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
1013 operator()(_It __x, _Sent __bound)
const
1015 ranges::advance(__x, __bound);
1019 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
1022 operator()(_It __x, iter_difference_t<_It> __n, _Sent __bound)
const
1024 ranges::advance(__x, __n, __bound);
1031 inline constexpr __next_fn next{};
1033 struct __prev_fn final
1035 template<b
idirectional_iterator _It>
1038 operator()(_It __x)
const
1044 template<b
idirectional_iterator _It>
1047 operator()(_It __x, iter_difference_t<_It> __n)
const
1049 ranges::advance(__x, -__n);
1053 template<b
idirectional_iterator _It>
1056 operator()(_It __x, iter_difference_t<_It> __n, _It __bound)
const
1058 ranges::advance(__x, -__n, __bound);
1065 inline constexpr __prev_fn prev{};
1070 constexpr dangling() noexcept = default;
1071 template<typename... _Args>
1072 constexpr dangling(_Args&&...) noexcept { }
1075 template<range _Range>
1076 using borrowed_iterator_t = __conditional_t<borrowed_range<_Range>,
1081#if __glibcxx_ranges_to_container
1082 struct from_range_t {
explicit from_range_t() =
default; };
1083 inline constexpr from_range_t from_range{};
1088 template<
typename _Rg,
typename _Tp>
1089 concept __container_compatible_range
1090 = ranges::input_range<_Rg>
1091 && convertible_to<ranges::range_reference_t<_Rg>, _Tp>;
1093 template<ranges::input_range _Range>
1094 using __range_key_type
1095 = remove_const_t<typename ranges::range_value_t<_Range>::first_type>;
1097 template<ranges::input_range _Range>
1098 using __range_mapped_type
1099 =
typename ranges::range_value_t<_Range>::second_type;
1104_GLIBCXX_END_NAMESPACE_VERSION
1107#pragma GCC diagnostic pop
constexpr _Tp * to_address(_Tp *__ptr) noexcept
Obtain address referenced by a pointer to an object.
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
_Tp * end(valarray< _Tp > &__va) noexcept
Return an iterator pointing to one past the last element of the valarray.
_Tp * begin(valarray< _Tp > &__va) noexcept
Return an iterator pointing to the first element of the valarray.
constexpr reverse_iterator< _Iterator > make_reverse_iterator(_Iterator __i)
Generator function for reverse_iterator.
ISO C++ entities toplevel namespace is std.
constexpr auto rbegin(_Container &__cont) noexcept(noexcept(__cont.rbegin())) -> decltype(__cont.rbegin())
Return a reverse iterator pointing to the last element of the container.
constexpr iterator_traits< _InputIterator >::difference_type distance(_InputIterator __first, _InputIterator __last)
A generalization of pointer arithmetic.
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 auto empty(const _Container &__cont) noexcept(noexcept(__cont.empty())) -> decltype(__cont.empty())
Return whether a container is empty.
constexpr auto crbegin(const _Container &__cont) noexcept(noexcept(std::rbegin(__cont))) -> decltype(std::rbegin(__cont))
Return a reverse iterator pointing to the last element of the const container.
constexpr auto size(const _Container &__cont) noexcept(noexcept(__cont.size())) -> decltype(__cont.size())
Return the size of a container.
constexpr void advance(_InputIterator &__i, _Distance __n)
A generalization of pointer arithmetic.
constexpr auto data(_Container &__cont) noexcept(noexcept(__cont.data())) -> decltype(__cont.data())
Return the data pointer of a container.
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) noexcept(noexcept(__cont.rend())) -> decltype(__cont.rend())
Return a reverse iterator pointing one past the first element of the container.
constexpr bitset< _Nb > operator&(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
constexpr auto crend(const _Container &__cont) noexcept(noexcept(std::rend(__cont))) -> decltype(std::rend(__cont))
Return a reverse iterator pointing one past the first element of the const container.
__numeric_traits_integer< _Tp > __int_traits
Convenience alias for __numeric_traits<integer-type>.