30#ifndef _GLIBCXX_RANGES_BASE_H
31#define _GLIBCXX_RANGES_BASE_H 1
34#pragma GCC system_header
37#if __cplusplus > 201703L
44#if __glibcxx_containers_ranges
48#pragma GCC diagnostic push
49#pragma GCC diagnostic ignored "-Wpedantic"
51#if __glibcxx_algorithm_default_value_type
52# define _GLIBCXX26_RANGE_ALGO_DEF_VAL_T(_I, _P) = projected_value_t<_I, _P>
54# define _GLIBCXX26_RANGE_ALGO_DEF_VAL_T(_I, _P)
57#ifdef __cpp_lib_concepts
58namespace std _GLIBCXX_VISIBILITY(default)
60_GLIBCXX_BEGIN_NAMESPACE_VERSION
64 inline constexpr bool disable_sized_range =
false;
66 template<
typename _Tp>
67 inline constexpr bool enable_borrowed_range =
false;
71 constexpr __max_size_type
72 __to_unsigned_like(__max_size_type __t)
noexcept
75 constexpr __max_size_type
76 __to_unsigned_like(__max_diff_type __t)
noexcept
77 {
return __max_size_type(__t); }
79 template<
integral _Tp>
81 __to_unsigned_like(_Tp __t)
noexcept
82 {
return static_cast<make_unsigned_t<_Tp>
>(__t); }
84#if defined __STRICT_ANSI__ && defined __SIZEOF_INT128__
85 constexpr unsigned __int128
86 __to_unsigned_like(__int128 __t)
noexcept
89 constexpr unsigned __int128
90 __to_unsigned_like(
unsigned __int128 __t)
noexcept
94 template<
typename _Tp>
95 using __make_unsigned_like_t
96 =
decltype(__detail::__to_unsigned_like(std::declval<_Tp>()));
99 template<
typename _Tp>
100 concept __maybe_borrowed_range
101 = is_lvalue_reference_v<_Tp>
102 || enable_borrowed_range<remove_cvref_t<_Tp>>;
109 using std::ranges::__detail::__maybe_borrowed_range;
110 using std::__detail::__range_iter_t;
115 template<
typename _Tp>
116 static constexpr bool
119 if constexpr (is_array_v<remove_reference_t<_Tp>>)
121 else if constexpr (__member_begin<_Tp>)
122 return noexcept(__decay_copy(std::declval<_Tp&>().begin()));
124 return noexcept(__decay_copy(
begin(std::declval<_Tp&>())));
128 template<__maybe_borrowed_range _Tp>
129 requires is_array_v<remove_reference_t<_Tp>> || __member_begin<_Tp>
132 operator()[[nodiscard]](_Tp&& __t)
const noexcept(_S_noexcept<_Tp&>())
134 if constexpr (is_array_v<remove_reference_t<_Tp>>)
136 static_assert(is_lvalue_reference_v<_Tp>);
139 else if constexpr (__member_begin<_Tp>)
146 template<
typename _Tp>
147 concept __member_end =
requires(_Tp& __t)
149 { __decay_copy(__t.end()) } -> sentinel_for<__range_iter_t<_Tp>>;
155 template<
typename _Tp>
156 concept __adl_end = __class_or_enum<remove_reference_t<_Tp>>
157 &&
requires(_Tp& __t)
159 { __decay_copy(
end(__t)) } -> sentinel_for<__range_iter_t<_Tp>>;
165 template<
typename _Tp>
166 static constexpr bool
169 if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>)
171 else if constexpr (__member_end<_Tp>)
172 return noexcept(__decay_copy(std::declval<_Tp&>().end()));
174 return noexcept(__decay_copy(
end(std::declval<_Tp&>())));
178 template<__maybe_borrowed_range _Tp>
179 requires is_bounded_array_v<remove_reference_t<_Tp>>
180 || __member_end<_Tp> || __adl_end<_Tp>
182 operator()[[nodiscard]](_Tp&& __t)
const noexcept(_S_noexcept<_Tp&>())
184 if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>)
186 static_assert(is_lvalue_reference_v<_Tp>);
187 return __t + extent_v<remove_reference_t<_Tp>>;
189 else if constexpr (__member_end<_Tp>)
196 template<
typename _Tp>
197 concept __member_rbegin =
requires(_Tp& __t)
199 { __decay_copy(__t.rbegin()) } -> input_or_output_iterator;
204 template<
typename _Tp>
205 concept __adl_rbegin = __class_or_enum<remove_reference_t<_Tp>>
206 &&
requires(_Tp& __t)
208 { __decay_copy(
rbegin(__t)) } -> input_or_output_iterator;
211 template<
typename _Tp>
212 concept __reversable =
requires(_Tp& __t)
214 { _Begin{}(__t) } -> bidirectional_iterator;
215 { _End{}(__t) } -> same_as<
decltype(_Begin{}(__t))>;
221 template<
typename _Tp>
222 static constexpr bool
225 if constexpr (__member_rbegin<_Tp>)
226 return noexcept(__decay_copy(std::declval<_Tp&>().
rbegin()));
227 else if constexpr (__adl_rbegin<_Tp>)
228 return noexcept(__decay_copy(
rbegin(std::declval<_Tp&>())));
231 if constexpr (
noexcept(_End{}(std::declval<_Tp&>())))
233 using _It =
decltype(_End{}(std::declval<_Tp&>()));
235 return is_nothrow_copy_constructible_v<_It>;
243 template<__maybe_borrowed_range _Tp>
244 requires __member_rbegin<_Tp> || __adl_rbegin<_Tp> || __reversable<_Tp>
246 operator()[[nodiscard]](_Tp&& __t)
const
247 noexcept(_S_noexcept<_Tp&>())
249 if constexpr (__member_rbegin<_Tp>)
251 else if constexpr (__adl_rbegin<_Tp>)
258 template<
typename _Tp>
259 concept __member_rend =
requires(_Tp& __t)
261 { __decay_copy(__t.rend()) }
262 -> sentinel_for<
decltype(_RBegin{}(std::forward<_Tp>(__t)))>;
265 void rend() =
delete;
267 template<
typename _Tp>
268 concept __adl_rend = __class_or_enum<remove_reference_t<_Tp>>
269 &&
requires(_Tp& __t)
271 { __decay_copy(
rend(__t)) }
272 -> sentinel_for<
decltype(_RBegin{}(std::forward<_Tp>(__t)))>;
278 template<
typename _Tp>
279 static constexpr bool
282 if constexpr (__member_rend<_Tp>)
283 return noexcept(__decay_copy(std::declval<_Tp&>().
rend()));
284 else if constexpr (__adl_rend<_Tp>)
285 return noexcept(__decay_copy(
rend(std::declval<_Tp&>())));
288 if constexpr (
noexcept(_Begin{}(std::declval<_Tp&>())))
290 using _It =
decltype(_Begin{}(std::declval<_Tp&>()));
292 return is_nothrow_copy_constructible_v<_It>;
300 template<__maybe_borrowed_range _Tp>
301 requires __member_rend<_Tp> || __adl_rend<_Tp> || __reversable<_Tp>
303 operator()[[nodiscard]](_Tp&& __t)
const
304 noexcept(_S_noexcept<_Tp&>())
306 if constexpr (__member_rend<_Tp>)
308 else if constexpr (__adl_rend<_Tp>)
315 template<
typename _Tp>
316 concept __member_size = !disable_sized_range<remove_cvref_t<_Tp>>
317 &&
requires(_Tp& __t)
319 { __decay_copy(__t.size()) } -> __detail::__is_integer_like;
322 void size() =
delete;
324 template<
typename _Tp>
325 concept __adl_size = __class_or_enum<remove_reference_t<_Tp>>
326 && !disable_sized_range<remove_cvref_t<_Tp>>
327 &&
requires(_Tp& __t)
329 { __decay_copy(
size(__t)) } -> __detail::__is_integer_like;
332 template<
typename _Tp>
333 concept __sentinel_size =
requires(_Tp& __t)
335 requires (!is_unbounded_array_v<remove_reference_t<_Tp>>);
337 { _Begin{}(__t) } -> forward_iterator;
339 { _End{}(__t) } -> sized_sentinel_for<
decltype(_Begin{}(__t))>;
341 __detail::__to_unsigned_like(_End{}(__t) - _Begin{}(__t));
347 template<
typename _Tp>
348 static constexpr bool
351 if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>)
353 else if constexpr (__member_size<_Tp>)
354 return noexcept(__decay_copy(std::declval<_Tp&>().size()));
355 else if constexpr (__adl_size<_Tp>)
356 return noexcept(__decay_copy(
size(std::declval<_Tp&>())));
357 else if constexpr (__sentinel_size<_Tp>)
358 return noexcept(_End{}(std::declval<_Tp&>())
359 - _Begin{}(std::declval<_Tp&>()));
363 template<
typename _Tp>
364 requires is_bounded_array_v<remove_reference_t<_Tp>>
365 || __member_size<_Tp> || __adl_size<_Tp> || __sentinel_size<_Tp>
367 operator()[[nodiscard]](_Tp&& __t)
const noexcept(_S_noexcept<_Tp&>())
369 if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>)
370 return extent_v<remove_reference_t<_Tp>>;
371 else if constexpr (__member_size<_Tp>)
373 else if constexpr (__adl_size<_Tp>)
375 else if constexpr (__sentinel_size<_Tp>)
376 return __detail::__to_unsigned_like(_End{}(__t) - _Begin{}(__t));
384 template<
typename _Tp>
385 requires requires (_Tp& __t) { _Size{}(__t); }
387 operator()[[nodiscard]](_Tp&& __t)
const noexcept(
noexcept(_Size{}(__t)))
389 auto __size = _Size{}(__t);
390 using __size_type =
decltype(__size);
392 if constexpr (integral<__size_type>)
395 if constexpr (__int_traits<__size_type>::__digits
396 < __int_traits<ptrdiff_t>::__digits)
397 return static_cast<ptrdiff_t
>(__size);
399 return static_cast<make_signed_t<__size_type>
>(__size);
401#if defined __STRICT_ANSI__ && defined __SIZEOF_INT128__
403 else if constexpr (__detail::__is_int128<__size_type>)
404 return static_cast<__int128
>(__size);
407 return __detail::__max_diff_type(__size);
411 template<
typename _Tp>
412 concept __member_empty =
requires(_Tp& __t) { bool(__t.empty()); };
414 template<
typename _Tp>
415 concept __size0_empty =
requires(_Tp& __t) { _Size{}(__t) == 0; };
417 template<
typename _Tp>
418 concept __eq_iter_empty =
requires(_Tp& __t)
420 requires (!is_unbounded_array_v<remove_reference_t<_Tp>>);
422 { _Begin{}(__t) } -> forward_iterator;
424 bool(_Begin{}(__t) == _End{}(__t));
430 template<
typename _Tp>
431 static constexpr bool
434 if constexpr (__member_empty<_Tp>)
435 return noexcept(
bool(std::declval<_Tp&>().
empty()));
436 else if constexpr (__size0_empty<_Tp>)
437 return noexcept(_Size{}(std::declval<_Tp&>()) == 0);
439 return noexcept(bool(_Begin{}(std::declval<_Tp&>())
440 == _End{}(std::declval<_Tp&>())));
444 template<
typename _Tp>
445 requires __member_empty<_Tp> || __size0_empty<_Tp>
446 || __eq_iter_empty<_Tp>
448 operator()[[nodiscard]](_Tp&& __t)
const noexcept(_S_noexcept<_Tp&>())
450 if constexpr (__member_empty<_Tp>)
451 return bool(__t.empty());
452 else if constexpr (__size0_empty<_Tp>)
453 return _Size{}(__t) == 0;
455 return bool(_Begin{}(__t) == _End{}(__t));
459 template<
typename _Tp>
460 concept __pointer_to_object = is_pointer_v<_Tp>
461 && is_object_v<remove_pointer_t<_Tp>>;
463 template<
typename _Tp>
464 concept __member_data =
requires(_Tp& __t)
466 { __decay_copy(__t.data()) } -> __pointer_to_object;
469 template<
typename _Tp>
470 concept __begin_data = contiguous_iterator<__range_iter_t<_Tp>>;
475 template<
typename _Tp>
476 static constexpr bool
479 if constexpr (__member_data<_Tp>)
480 return noexcept(__decay_copy(std::declval<_Tp&>().
data()));
482 return noexcept(_Begin{}(std::declval<_Tp&>()));
486 template<__maybe_borrowed_range _Tp>
487 requires __member_data<_Tp> || __begin_data<_Tp>
489 operator()[[nodiscard]](_Tp&& __t)
const noexcept(_S_noexcept<_Tp>())
491 if constexpr (__member_data<_Tp>)
500 inline namespace _Cpo
502 inline constexpr ranges::__access::_Begin
begin{};
503 inline constexpr ranges::__access::_End
end{};
504 inline constexpr ranges::__access::_RBegin
rbegin{};
505 inline constexpr ranges::__access::_REnd
rend{};
506 inline constexpr ranges::__access::_Size
size{};
507 inline constexpr ranges::__access::_SSize ssize{};
508 inline constexpr ranges::__access::_Empty
empty{};
509 inline constexpr ranges::__access::_Data
data{};
513 template<
typename _Tp>
514 concept range =
requires(_Tp& __t)
521 template<
typename _Tp>
522 concept borrowed_range
523 = range<_Tp> && __detail::__maybe_borrowed_range<_Tp>;
525 template<
typename _Tp>
526 using iterator_t = std::__detail::__range_iter_t<_Tp>;
528 template<range _Range>
529 using sentinel_t =
decltype(ranges::end(std::declval<_Range&>()));
531#if __glibcxx_ranges_as_const
532 template<range _Range>
533 using const_iterator_t = const_iterator<iterator_t<_Range>>;
535 template<range _Range>
536 using const_sentinel_t = const_sentinel<sentinel_t<_Range>>;
538 template<range _Range>
539 using range_const_reference_t = iter_const_reference_t<iterator_t<_Range>>;
542 template<range _Range>
543 using range_difference_t = iter_difference_t<iterator_t<_Range>>;
545 template<range _Range>
546 using range_value_t = iter_value_t<iterator_t<_Range>>;
548 template<range _Range>
549 using range_reference_t = iter_reference_t<iterator_t<_Range>>;
551 template<range _Range>
552 using range_rvalue_reference_t
553 = iter_rvalue_reference_t<iterator_t<_Range>>;
557 template<range _Range>
558 using range_common_reference_t
559 = iter_common_reference_t<iterator_t<_Range>>;
562 template<
typename _Tp>
563 concept sized_range = range<_Tp>
564 &&
requires(_Tp& __t) { ranges::size(__t); };
566 template<sized_range _Range>
567 using range_size_t =
decltype(ranges::size(std::declval<_Range&>()));
569 template<
typename _Derived>
570 requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
571 class view_interface;
575 template<
typename _Tp,
typename _Up>
576 requires (!same_as<_Tp, view_interface<_Up>>)
577 void __is_derived_from_view_interface_fn(
const _Tp&,
578 const view_interface<_Up>&);
582 template<
typename _Tp>
583 concept __is_derived_from_view_interface
584 =
requires (_Tp __t) { __is_derived_from_view_interface_fn(__t, __t); };
588 struct view_base { };
591 template<
typename _Tp>
592 inline constexpr bool enable_view = derived_from<_Tp, view_base>
593 || __detail::__is_derived_from_view_interface<_Tp>;
596 template<
typename _Tp>
598 = range<_Tp> && movable<_Tp> && enable_view<_Tp>;
603 template<
typename _Range,
typename _Tp>
605 = range<_Range> && output_iterator<iterator_t<_Range>, _Tp>;
608 template<
typename _Tp>
609 concept input_range = range<_Tp> && input_iterator<iterator_t<_Tp>>;
612 template<
typename _Tp>
613 concept forward_range
614 = input_range<_Tp> && forward_iterator<iterator_t<_Tp>>;
617 template<
typename _Tp>
618 concept bidirectional_range
619 = forward_range<_Tp> && bidirectional_iterator<iterator_t<_Tp>>;
622 template<
typename _Tp>
623 concept random_access_range
624 = bidirectional_range<_Tp> && random_access_iterator<iterator_t<_Tp>>;
627 template<
typename _Tp>
628 concept contiguous_range
629 = random_access_range<_Tp> && contiguous_iterator<iterator_t<_Tp>>
630 &&
requires(_Tp& __t)
632 { ranges::data(__t) } -> same_as<add_pointer_t<range_reference_t<_Tp>>>;
636 template<
typename _Tp>
638 = range<_Tp> && same_as<iterator_t<_Tp>, sentinel_t<_Tp>>;
640#if __glibcxx_ranges_as_const
641 template<
typename _Tp>
642 concept constant_range
643 = input_range<_Tp> && std::__detail::__constant_iterator<iterator_t<_Tp>>;
648#if __glibcxx_ranges_as_const
649 template<input_range _Range>
651 __possibly_const_range(_Range& __r)
noexcept
655 if constexpr (input_range<const _Range>)
656 return const_cast<const _Range&
>(__r);
662 template<
typename _To,
typename _Tp>
663 constexpr decltype(
auto)
664 __as_const(_Tp& __t)
noexcept
666 static_assert(std::is_same_v<_To&, _Tp&>);
668 if constexpr (is_lvalue_reference_v<_To>)
669 return const_cast<const _Tp&
>(__t);
671 return static_cast<const _Tp&&
>(__t);
677#if __glibcxx_ranges_as_const
678 template<__maybe_borrowed_range _Tp>
681 operator()(_Tp&& __t)
const
682 noexcept(
noexcept(std::make_const_iterator
683 (ranges::begin(__access::__possibly_const_range(__t)))))
684 requires requires { std::make_const_iterator
685 (ranges::begin(__access::__possibly_const_range(__t))); }
687 auto& __r = __access::__possibly_const_range(__t);
688 return const_iterator_t<decltype(__r)>(ranges::begin(__r));
691 template<
typename _Tp>
694 operator()(_Tp&& __e)
const
695 noexcept(
noexcept(_Begin{}(__access::__as_const<_Tp>(__e))))
696 requires requires { _Begin{}(__access::__as_const<_Tp>(__e)); }
698 return _Begin{}(__access::__as_const<_Tp>(__e));
705#if __glibcxx_ranges_as_const
706 template<__maybe_borrowed_range _Tp>
709 operator()(_Tp&& __t)
const
710 noexcept(
noexcept(std::make_const_sentinel
711 (ranges::end(__access::__possibly_const_range(__t)))))
712 requires requires { std::make_const_sentinel
713 (ranges::end(__access::__possibly_const_range(__t))); }
715 auto& __r = __access::__possibly_const_range(__t);
716 return const_sentinel_t<decltype(__r)>(ranges::end(__r));
719 template<
typename _Tp>
722 operator()(_Tp&& __e)
const
723 noexcept(
noexcept(_End{}(__access::__as_const<_Tp>(__e))))
724 requires requires { _End{}(__access::__as_const<_Tp>(__e)); }
726 return _End{}(__access::__as_const<_Tp>(__e));
733#if __glibcxx_ranges_as_const
734 template<__maybe_borrowed_range _Tp>
737 operator()(_Tp&& __t)
const
738 noexcept(
noexcept(std::make_const_iterator
739 (ranges::rbegin(__access::__possibly_const_range(__t)))))
740 requires requires { std::make_const_iterator
741 (ranges::rbegin(__access::__possibly_const_range(__t))); }
743 auto& __r = __access::__possibly_const_range(__t);
744 return const_iterator<decltype(ranges::rbegin(__r))>(ranges::rbegin(__r));
747 template<
typename _Tp>
750 operator()(_Tp&& __e)
const
751 noexcept(
noexcept(_RBegin{}(__access::__as_const<_Tp>(__e))))
752 requires requires { _RBegin{}(__access::__as_const<_Tp>(__e)); }
754 return _RBegin{}(__access::__as_const<_Tp>(__e));
761#if __glibcxx_ranges_as_const
762 template<__maybe_borrowed_range _Tp>
765 operator()(_Tp&& __t)
const
766 noexcept(
noexcept(std::make_const_sentinel
767 (ranges::rend(__access::__possibly_const_range(__t)))))
768 requires requires { std::make_const_sentinel
769 (ranges::rend(__access::__possibly_const_range(__t))); }
771 auto& __r = __access::__possibly_const_range(__t);
772 return const_sentinel<decltype(ranges::rend(__r))>(ranges::rend(__r));
775 template<
typename _Tp>
778 operator()(_Tp&& __e)
const
779 noexcept(
noexcept(_REnd{}(__access::__as_const<_Tp>(__e))))
780 requires requires { _REnd{}(__access::__as_const<_Tp>(__e)); }
782 return _REnd{}(__access::__as_const<_Tp>(__e));
789#if __glibcxx_ranges_as_const
790 template<__maybe_borrowed_range _Tp>
792 constexpr const auto*
793 operator()(_Tp&& __t)
const
794 noexcept(
noexcept(ranges::data(__access::__possibly_const_range(__t))))
795 requires requires { ranges::data(__access::__possibly_const_range(__t)); }
796 {
return ranges::data(__access::__possibly_const_range(__t)); }
798 template<
typename _Tp>
801 operator()(_Tp&& __e)
const
802 noexcept(
noexcept(_Data{}(__access::__as_const<_Tp>(__e))))
803 requires requires { _Data{}(__access::__as_const<_Tp>(__e)); }
805 return _Data{}(__access::__as_const<_Tp>(__e));
811 inline namespace _Cpo
813 inline constexpr ranges::__access::_CBegin
cbegin{};
814 inline constexpr ranges::__access::_CEnd
cend{};
815 inline constexpr ranges::__access::_CRBegin
crbegin{};
816 inline constexpr ranges::__access::_CREnd
crend{};
817 inline constexpr ranges::__access::_CData cdata{};
822 template<
typename _Tp>
823 inline constexpr bool __is_initializer_list =
false;
825 template<
typename _Tp>
826 inline constexpr bool __is_initializer_list<initializer_list<_Tp>> =
true;
830 template<
typename _Tp>
831 concept viewable_range = range<_Tp>
832 && ((view<remove_cvref_t<_Tp>> && constructible_from<remove_cvref_t<_Tp>, _Tp>)
833 || (!view<remove_cvref_t<_Tp>>
834 && (is_lvalue_reference_v<_Tp>
835 || (movable<remove_reference_t<_Tp>>
836 && !__detail::__is_initializer_list<remove_cvref_t<_Tp>>))));
840 struct __advance_fn final
842 template<input_or_output_iterator _It>
844 operator()(_It& __it, iter_difference_t<_It> __n)
const
846 if constexpr (random_access_iterator<_It>)
848 else if constexpr (bidirectional_iterator<_It>)
870 __glibcxx_assert(__n >= 0);
876 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
878 operator()(_It& __it, _Sent __bound)
const
880 if constexpr (assignable_from<_It&, _Sent>)
882 else if constexpr (sized_sentinel_for<_Sent, _It>)
883 (*
this)(__it, __bound - __it);
886 while (__it != __bound)
891 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
892 constexpr iter_difference_t<_It>
893 operator()(_It& __it, iter_difference_t<_It> __n, _Sent __bound)
const
895 if constexpr (sized_sentinel_for<_Sent, _It>)
897 const auto __diff = __bound - __it;
901 else if (__diff > 0 ? __n >= __diff : __n <= __diff)
903 (*this)(__it, __bound);
906 else if (__n != 0) [[likely]]
909 __glibcxx_assert((__n < 0) == (__diff < 0));
917 else if (__it == __bound || __n == 0)
921 iter_difference_t<_It> __m = 0;
927 while (__m != __n && __it != __bound);
930 else if constexpr (bidirectional_iterator<_It> && same_as<_It, _Sent>)
932 iter_difference_t<_It> __m = 0;
938 while (__m != __n && __it != __bound);
944 __glibcxx_assert(__n >= 0);
952 inline constexpr __advance_fn
advance{};
954 struct __distance_fn final
958 template<
typename _It, sentinel_for<_It> _Sent>
959 requires (!sized_sentinel_for<_Sent, _It>)
960 constexpr iter_difference_t<_It>
961 operator()[[nodiscard]](_It __first, _Sent __last)
const
963 iter_difference_t<_It> __n = 0;
964 while (__first != __last)
972 template<
typename _It, sized_sentinel_for<decay_t<_It>> _Sent>
974 constexpr iter_difference_t<decay_t<_It>>
975 operator()(_It&& __first, _Sent __last)
const
976 {
return __last -
static_cast<const decay_t<_It>&
>(__first); }
978 template<range _Range>
980 constexpr range_difference_t<_Range>
981 operator()(_Range&& __r)
const
983 if constexpr (sized_range<_Range>)
984 return static_cast<range_difference_t<_Range>
>(ranges::size(__r));
986 return (*
this)(ranges::begin(__r), ranges::end(__r));
992 inline constexpr __distance_fn
distance{};
994 struct __next_fn final
996 template<input_or_output_iterator _It>
999 operator()(_It __x)
const
1005 template<input_or_output_iterator _It>
1008 operator()(_It __x, iter_difference_t<_It> __n)
const
1010 ranges::advance(__x, __n);
1014 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
1017 operator()(_It __x, _Sent __bound)
const
1019 ranges::advance(__x, __bound);
1023 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
1026 operator()(_It __x, iter_difference_t<_It> __n, _Sent __bound)
const
1028 ranges::advance(__x, __n, __bound);
1035 inline constexpr __next_fn next{};
1037 struct __prev_fn final
1039 template<b
idirectional_iterator _It>
1042 operator()(_It __x)
const
1048 template<b
idirectional_iterator _It>
1051 operator()(_It __x, iter_difference_t<_It> __n)
const
1053 ranges::advance(__x, -__n);
1057 template<b
idirectional_iterator _It>
1060 operator()(_It __x, iter_difference_t<_It> __n, _It __bound)
const
1062 ranges::advance(__x, -__n, __bound);
1069 inline constexpr __prev_fn prev{};
1074 constexpr dangling() noexcept = default;
1075 template<typename... _Args>
1076 constexpr dangling(_Args&&...) noexcept { }
1079 template<range _Range>
1080 using borrowed_iterator_t = __conditional_t<borrowed_range<_Range>,
1085#if __glibcxx_ranges_to_container
1086 struct from_range_t {
explicit from_range_t() =
default; };
1087 inline constexpr from_range_t from_range{};
1090#if __glibcxx_containers_ranges
1092 template<typename _T1, typename _T2>
1097 template<
typename _Rg,
typename _Tp>
1098 concept __container_compatible_range
1099 = ranges::input_range<_Rg>
1100 && convertible_to<ranges::range_reference_t<_Rg>, _Tp>;
1104 template<ranges::input_range _Range>
1105 using __range_key_type
1106 = remove_const_t<tuple_element_t<0, ranges::range_value_t<_Range>>>;
1108 template<ranges::input_range _Range>
1109 using __range_mapped_type
1110 = tuple_element_t<1, ranges::range_value_t<_Range>>;
1113 template<ranges::input_range _Range>
1114 using __range_to_alloc_type
1115 = pair<const __range_key_type<_Range>, __range_mapped_type<_Range>>;
1120_GLIBCXX_END_NAMESPACE_VERSION
1123#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>.