30 #ifndef _GLIBCXX_RANGES
31 #define _GLIBCXX_RANGES 1
33 #if __cplusplus > 201703L
35 #pragma GCC system_header
39 #if __cpp_lib_concepts
56 namespace std _GLIBCXX_VISIBILITY(default)
58 _GLIBCXX_BEGIN_NAMESPACE_VERSION
73 template<
typename _Tp> requires is_object_v<_Tp>
78 static constexpr _Tp* begin() noexcept {
return nullptr; }
79 static constexpr _Tp* end() noexcept {
return nullptr; }
80 static constexpr _Tp* data() noexcept {
return nullptr; }
81 static constexpr
size_t size() noexcept {
return 0; }
82 static constexpr
bool empty() noexcept {
return true; }
85 template<
typename _Tp>
86 inline constexpr
bool enable_borrowed_range<empty_view<_Tp>> =
true;
90 template<
typename _Tp>
91 concept __boxable = copy_constructible<_Tp> && is_object_v<_Tp>;
93 template<__boxable _Tp>
100 noexcept(is_nothrow_default_constructible_v<_Tp>)
105 __box(
const __box&) =
default;
106 __box(__box&&) =
default;
114 operator=(
const __box& __that)
115 noexcept(is_nothrow_copy_constructible_v<_Tp>)
116 requires (!copyable<_Tp>)
121 this->emplace(*__that);
129 operator=(__box&& __that)
130 noexcept(is_nothrow_move_constructible_v<_Tp>)
131 requires (!movable<_Tp>)
148 template<__boxable _Tp>
149 requires copyable<_Tp> || (is_nothrow_move_constructible_v<_Tp>
150 && is_nothrow_copy_constructible_v<_Tp>)
154 [[no_unique_address]] _Tp _M_value = _Tp();
160 __box(const _Tp& __t)
161 noexcept(is_nothrow_copy_constructible_v<_Tp>)
167 noexcept(is_nothrow_move_constructible_v<_Tp>)
171 template<
typename... _Args>
174 __box(in_place_t, _Args&&... __args)
175 noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
179 __box(
const __box&) =
default;
180 __box(__box&&) =
default;
181 __box& operator=(
const __box&) requires copyable<_Tp> =
default;
182 __box& operator=(__box&&) requires copyable<_Tp> = default;
187 operator=(const __box& __that) noexcept
189 static_assert(is_nothrow_copy_constructible_v<_Tp>);
200 operator=(__box&& __that) noexcept
202 static_assert(is_nothrow_move_constructible_v<_Tp>);
212 has_value() const noexcept
224 operator->() noexcept
228 operator->() const noexcept
234 template<copy_constructible _Tp> requires is_object_v<_Tp>
238 single_view() requires default_initializable<_Tp> =
default;
242 noexcept(is_nothrow_copy_constructible_v<_Tp>)
248 noexcept(is_nothrow_move_constructible_v<_Tp>)
254 template<
typename... _Args>
258 noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
259 : _M_value{in_place, std::forward<_Args>(__args)...}
267 begin()
const noexcept
272 {
return data() + 1; }
276 {
return data() + 1; }
278 static constexpr
size_t
284 {
return _M_value.operator->(); }
287 data()
const noexcept
288 {
return _M_value.operator->(); }
291 [[no_unique_address]] __detail::__box<_Tp> _M_value;
294 template<
typename _Tp>
299 template<
typename _Wp>
300 constexpr
auto __to_signed_like(_Wp __w) noexcept
302 if constexpr (!integral<_Wp>)
303 return iter_difference_t<_Wp>();
304 else if constexpr (
sizeof(iter_difference_t<_Wp>) >
sizeof(_Wp))
305 return iter_difference_t<_Wp>(__w);
306 else if constexpr (
sizeof(ptrdiff_t) >
sizeof(_Wp))
307 return ptrdiff_t(__w);
308 else if constexpr (
sizeof(
long long) >
sizeof(_Wp))
309 return (
long long)(__w);
310 #ifdef __SIZEOF_INT128__
311 else if constexpr (__SIZEOF_INT128__ >
sizeof(_Wp))
312 return __int128(__w);
315 return __max_diff_type(__w);
318 template<
typename _Wp>
319 using __iota_diff_t = decltype(__to_signed_like(std::declval<_Wp>()));
321 template<
typename _It>
322 concept __decrementable = incrementable<_It>
325 { --__i } -> same_as<_It&>;
326 { __i-- } -> same_as<_It>;
329 template<
typename _It>
330 concept __advanceable = __decrementable<_It> && totally_ordered<_It>
331 && requires( _It __i,
const _It __j,
const __iota_diff_t<_It> __n)
333 { __i += __n } -> same_as<_It&>;
334 { __i -= __n } -> same_as<_It&>;
338 { __j - __j } -> convertible_to<__iota_diff_t<_It>>;
341 template<
typename _Winc>
342 struct __iota_view_iter_cat
345 template<incrementable _Winc>
346 struct __iota_view_iter_cat<_Winc>
347 {
using iterator_category = input_iterator_tag; };
351 semiregular _Bound = unreachable_sentinel_t>
352 requires std::__detail::__weakly_eq_cmp_with<_Winc, _Bound>
354 class iota_view :
public view_interface<iota_view<_Winc, _Bound>>
359 struct _Iterator : __detail::__iota_view_iter_cat<_Winc>
365 using namespace __detail;
366 if constexpr (__advanceable<_Winc>)
367 return random_access_iterator_tag{};
368 else if constexpr (__decrementable<_Winc>)
369 return bidirectional_iterator_tag{};
370 else if constexpr (incrementable<_Winc>)
371 return forward_iterator_tag{};
373 return input_iterator_tag{};
377 using iterator_concept = decltype(_S_iter_concept());
379 using value_type = _Winc;
380 using difference_type = __detail::__iota_diff_t<_Winc>;
385 _Iterator(_Winc __value)
386 : _M_value(__value) { }
389 operator*() const noexcept(is_nothrow_copy_constructible_v<_Winc>)
404 operator++(
int) requires incrementable<_Winc>
412 operator--() requires __detail::__decrementable<_Winc>
419 operator--(
int) requires __detail::__decrementable<_Winc>
427 operator+=(difference_type __n) requires __detail::__advanceable<_Winc>
429 using __detail::__is_integer_like;
430 using __detail::__is_signed_integer_like;
431 if constexpr (__is_integer_like<_Winc>
432 && !__is_signed_integer_like<_Winc>)
434 if (__n >= difference_type(0))
435 _M_value +=
static_cast<_Winc
>(__n);
437 _M_value -=
static_cast<_Winc
>(-__n);
445 operator-=(difference_type __n) requires __detail::__advanceable<_Winc>
447 using __detail::__is_integer_like;
448 using __detail::__is_signed_integer_like;
449 if constexpr (__is_integer_like<_Winc>
450 && !__is_signed_integer_like<_Winc>)
452 if (__n >= difference_type(0))
453 _M_value -=
static_cast<_Winc
>(__n);
455 _M_value +=
static_cast<_Winc
>(-__n);
463 operator[](difference_type __n)
const
464 requires __detail::__advanceable<_Winc>
465 {
return _Winc(_M_value + __n); }
467 friend constexpr
bool
468 operator==(
const _Iterator& __x,
const _Iterator& __y)
469 requires equality_comparable<_Winc>
470 {
return __x._M_value == __y._M_value; }
472 friend constexpr
bool
473 operator<(
const _Iterator& __x,
const _Iterator& __y)
474 requires totally_ordered<_Winc>
475 {
return __x._M_value < __y._M_value; }
477 friend constexpr
bool
478 operator>(
const _Iterator& __x,
const _Iterator& __y)
479 requires totally_ordered<_Winc>
480 {
return __y < __x; }
482 friend constexpr
bool
483 operator<=(
const _Iterator& __x,
const _Iterator& __y)
484 requires totally_ordered<_Winc>
485 {
return !(__y < __x); }
487 friend constexpr
bool
488 operator>=(
const _Iterator& __x,
const _Iterator& __y)
489 requires totally_ordered<_Winc>
490 {
return !(__x < __y); }
492 #ifdef __cpp_lib_three_way_comparison
493 friend constexpr
auto
494 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
495 requires totally_ordered<_Winc> && three_way_comparable<_Winc>
496 {
return __x._M_value <=> __y._M_value; }
499 friend constexpr _Iterator
500 operator+(_Iterator __i, difference_type __n)
501 requires __detail::__advanceable<_Winc>
507 friend constexpr _Iterator
508 operator+(difference_type __n, _Iterator __i)
509 requires __detail::__advanceable<_Winc>
510 {
return __i += __n; }
512 friend constexpr _Iterator
513 operator-(_Iterator __i, difference_type __n)
514 requires __detail::__advanceable<_Winc>
520 friend constexpr difference_type
521 operator-(
const _Iterator& __x,
const _Iterator& __y)
522 requires __detail::__advanceable<_Winc>
524 using __detail::__is_integer_like;
525 using __detail::__is_signed_integer_like;
526 using _Dt = difference_type;
527 if constexpr (__is_integer_like<_Winc>)
529 if constexpr (__is_signed_integer_like<_Winc>)
530 return _Dt(_Dt(__x._M_value) - _Dt(__y._M_value));
532 return (__y._M_value > __x._M_value)
533 ? _Dt(-_Dt(__y._M_value - __x._M_value))
534 : _Dt(__x._M_value - __y._M_value);
537 return __x._M_value - __y._M_value;
541 _Winc _M_value = _Winc();
551 _M_equal(
const _Iterator& __x)
const
552 {
return __x._M_value == _M_bound; }
555 _M_distance_from(
const _Iterator& __x)
const
556 {
return _M_bound - __x._M_value; }
558 _Bound _M_bound = _Bound();
561 _Sentinel() =
default;
564 _Sentinel(_Bound __bound)
565 : _M_bound(__bound) { }
567 friend constexpr
bool
568 operator==(
const _Iterator& __x,
const _Sentinel& __y)
569 {
return __y._M_equal(__x); }
571 friend constexpr iter_difference_t<_Winc>
572 operator-(
const _Iterator& __x,
const _Sentinel& __y)
573 requires sized_sentinel_for<_Bound, _Winc>
574 {
return -__y._M_distance_from(__x); }
576 friend constexpr iter_difference_t<_Winc>
577 operator-(
const _Sentinel& __x,
const _Iterator& __y)
578 requires sized_sentinel_for<_Bound, _Winc>
579 {
return __x._M_distance_from(__y); }
584 _Winc _M_value = _Winc();
585 [[no_unique_address]] _Bound _M_bound = _Bound();
591 iota_view(_Winc __value)
596 iota_view(type_identity_t<_Winc> __value,
597 type_identity_t<_Bound> __bound)
598 : _M_value(__value), _M_bound(__bound)
600 if constexpr (totally_ordered_with<_Winc, _Bound>)
601 __glibcxx_assert(
bool(__value <= __bound) );
605 iota_view(_Iterator __first, _Iterator __last)
606 requires same_as<_Winc, _Bound>
607 : iota_view(__first._M_value, __last._M_value)
611 iota_view(_Iterator __first, unreachable_sentinel_t __last)
612 requires same_as<_Bound, unreachable_sentinel_t>
613 : iota_view(__first._M_value, __last)
617 iota_view(_Iterator __first, _Sentinel __last)
618 requires (!same_as<_Winc, _Bound>) && (!same_as<_Bound, unreachable_sentinel_t>)
619 : iota_view(__first._M_value, __last._M_bound)
623 begin()
const {
return _Iterator{_M_value}; }
628 if constexpr (same_as<_Bound, unreachable_sentinel_t>)
629 return unreachable_sentinel;
631 return _Sentinel{_M_bound};
636 {
return _Iterator{_M_bound}; }
640 requires (
same_as<_Winc, _Bound> && __detail::__advanceable<_Winc>)
641 || (integral<_Winc> && integral<_Bound>)
642 || sized_sentinel_for<_Bound, _Winc>
644 using __detail::__is_integer_like;
645 using __detail::__to_unsigned_like;
646 if constexpr (integral<_Winc> && integral<_Bound>)
649 return _Up(_M_bound) - _Up(_M_value);
651 else if constexpr (__is_integer_like<_Winc>)
652 return __to_unsigned_like(_M_bound) - __to_unsigned_like(_M_value);
654 return __to_unsigned_like(_M_bound - _M_value);
658 template<
typename _Winc,
typename _Bound>
659 requires (!__detail::__is_integer_like<_Winc>
660 || !__detail::__is_integer_like<_Bound>
661 || (__detail::__is_signed_integer_like<_Winc>
662 == __detail::__is_signed_integer_like<_Bound>))
663 iota_view(_Winc, _Bound) -> iota_view<_Winc, _Bound>;
665 template<
typename _Winc,
typename _Bound>
666 inline constexpr
bool
667 enable_borrowed_range<iota_view<_Winc, _Bound>> =
true;
671 template<
typename _Tp>
672 inline constexpr empty_view<_Tp>
empty{};
676 template<
typename _Tp>
679 operator()(_Tp&& __e)
const
680 noexcept(noexcept(single_view<decay_t<_Tp>>(std::forward<_Tp>(__e))))
681 {
return single_view<decay_t<_Tp>>(std::forward<_Tp>(__e)); }
684 inline constexpr _Single single{};
688 template<
typename _Tp>
691 operator()(_Tp&& __e)
const
692 {
return iota_view(std::forward<_Tp>(__e)); }
694 template<
typename _Tp,
typename _Up>
697 operator()(_Tp&& __e, _Up&& __f)
const
698 {
return iota_view(std::forward<_Tp>(__e), std::forward<_Up>(__f)); }
701 inline constexpr _Iota
iota{};
706 template<
typename _Val,
typename _CharT,
typename _Traits>
707 concept __stream_extractable
708 = requires(basic_istream<_CharT, _Traits>& is, _Val& t) { is >> t; };
711 template<movable _Val,
typename _CharT,
712 typename _Traits = char_traits<_CharT>>
713 requires default_initializable<_Val>
714 && __detail::__stream_extractable<_Val, _CharT, _Traits>
715 class basic_istream_view
716 :
public view_interface<basic_istream_view<_Val, _CharT, _Traits>>
720 basic_istream_view(basic_istream<_CharT, _Traits>& __stream)
727 *_M_stream >> _M_object;
728 return _Iterator{
this};
731 constexpr default_sentinel_t
733 {
return default_sentinel; }
736 basic_istream<_CharT, _Traits>* _M_stream;
737 _Val _M_object = _Val();
742 using iterator_concept = input_iterator_tag;
743 using difference_type = ptrdiff_t;
744 using value_type = _Val;
747 _Iterator(basic_istream_view* __parent) noexcept
748 : _M_parent(__parent)
751 _Iterator(
const _Iterator&) =
delete;
752 _Iterator(_Iterator&&) =
default;
753 _Iterator& operator=(
const _Iterator&) =
delete;
754 _Iterator& operator=(_Iterator&&) =
default;
759 *_M_parent->_M_stream >> _M_parent->_M_object;
769 {
return _M_parent->_M_object; }
772 operator==(
const _Iterator& __x, default_sentinel_t)
773 {
return __x._M_at_end(); }
776 basic_istream_view* _M_parent;
780 {
return !*_M_parent->_M_stream; }
786 template<
typename _Val>
787 using istream_view = basic_istream_view<_Val, char>;
789 template<
typename _Val>
790 using wistream_view = basic_istream_view<_Val, wchar_t>;
794 template<
typename _Tp>
797 template<
typename _CharT,
typename _Traits>
800 operator()(basic_istream<_CharT, _Traits>& __e)
const
801 {
return basic_istream_view<_Tp, _CharT, _Traits>(__e); }
804 template<
typename _Tp>
805 inline constexpr _Istream<_Tp>
istream;
818 template<
bool _Present,
typename _Tp>
819 using __maybe_present_t = __conditional_t<_Present, _Tp, _Empty>;
822 template<
bool _Const,
typename _Tp>
823 using __maybe_const_t = __conditional_t<_Const, const _Tp, _Tp>;
827 namespace views::__adaptor
830 template<
typename _Adaptor,
typename... _Args>
831 concept __adaptor_invocable
832 = requires { std::declval<_Adaptor>()(declval<_Args>()...); };
836 template<
typename _Adaptor,
typename... _Args>
837 concept __adaptor_partial_app_viable = (_Adaptor::_S_arity > 1)
838 && (
sizeof...(_Args) == _Adaptor::_S_arity - 1)
841 template<
typename _Adaptor,
typename... _Args>
844 template<
typename _Lhs,
typename _Rhs>
852 struct _RangeAdaptorClosure
855 template<
typename _Self,
typename _Range>
856 requires derived_from<remove_cvref_t<_Self>, _RangeAdaptorClosure>
857 && __adaptor_invocable<_Self, _Range>
858 friend constexpr
auto
860 {
return std::forward<_Self>(__self)(std::forward<_Range>(__r)); }
864 template<
typename _Lhs,
typename _Rhs>
865 requires derived_from<_Lhs, _RangeAdaptorClosure>
866 && derived_from<_Rhs, _RangeAdaptorClosure>
867 friend constexpr
auto
883 template<
typename _Derived>
888 template<
typename... _Args>
889 requires __adaptor_partial_app_viable<_Derived, _Args...>
891 operator()(_Args&&... __args)
const
893 return _Partial<_Derived, decay_t<_Args>...>{std::forward<_Args>(__args)...};
900 template<
typename _Adaptor>
901 concept __closure_has_simple_call_op = _Adaptor::_S_has_simple_call_op;
905 template<
typename _Adaptor,
typename... _Args>
906 concept __adaptor_has_simple_extra_args = _Adaptor::_S_has_simple_extra_args
907 || _Adaptor::template _S_has_simple_extra_args<_Args...>;
911 template<
typename _Adaptor,
typename... _Args>
912 struct _Partial : _RangeAdaptorClosure
914 tuple<_Args...> _M_args;
917 _Partial(_Args... __args)
918 : _M_args(
std::
move(__args)...)
923 template<
typename _Range>
924 requires __adaptor_invocable<_Adaptor, _Range,
const _Args&...>
926 operator()(_Range&& __r)
const &
928 auto __forwarder = [&__r] (
const auto&... __args) {
929 return _Adaptor{}(std::forward<_Range>(__r), __args...);
931 return std::apply(__forwarder, _M_args);
934 template<
typename _Range>
935 requires __adaptor_invocable<_Adaptor, _Range, _Args...>
937 operator()(_Range&& __r) &&
939 auto __forwarder = [&__r] (
auto&... __args) {
940 return _Adaptor{}(std::forward<_Range>(__r),
std::move(__args)...);
942 return std::apply(__forwarder, _M_args);
945 template<
typename _Range>
947 operator()(_Range&& __r)
const && =
delete;
952 template<
typename _Adaptor,
typename _Arg>
953 struct _Partial<_Adaptor, _Arg> : _RangeAdaptorClosure
962 template<
typename _Range>
963 requires __adaptor_invocable<_Adaptor, _Range, const _Arg&>
965 operator()(_Range&& __r)
const &
966 {
return _Adaptor{}(std::forward<_Range>(__r), _M_arg); }
968 template<
typename _Range>
969 requires __adaptor_invocable<_Adaptor, _Range, _Arg>
971 operator()(_Range&& __r) &&
972 {
return _Adaptor{}(std::forward<_Range>(__r),
std::move(_M_arg)); }
974 template<
typename _Range>
976 operator()(_Range&& __r)
const && =
delete;
983 template<
typename _Adaptor,
typename... _Args>
984 requires __adaptor_has_simple_extra_args<_Adaptor, _Args...>
985 && (is_trivially_copyable_v<_Args> && ...)
986 struct _Partial<_Adaptor, _Args...> : _RangeAdaptorClosure
988 tuple<_Args...> _M_args;
991 _Partial(_Args... __args)
992 : _M_args(
std::
move(__args)...)
997 template<
typename _Range>
998 requires __adaptor_invocable<_Adaptor, _Range,
const _Args&...>
1000 operator()(_Range&& __r)
const
1002 auto __forwarder = [&__r] (
const auto&... __args) {
1003 return _Adaptor{}(std::forward<_Range>(__r), __args...);
1005 return std::apply(__forwarder, _M_args);
1008 static constexpr
bool _S_has_simple_call_op =
true;
1013 template<
typename _Adaptor,
typename _Arg>
1014 requires __adaptor_has_simple_extra_args<_Adaptor, _Arg>
1015 && is_trivially_copyable_v<_Arg>
1016 struct _Partial<_Adaptor, _Arg> : _RangeAdaptorClosure
1021 _Partial(_Arg __arg)
1025 template<
typename _Range>
1026 requires __adaptor_invocable<_Adaptor, _Range, const _Arg&>
1028 operator()(_Range&& __r)
const
1029 {
return _Adaptor{}(std::forward<_Range>(__r), _M_arg); }
1031 static constexpr
bool _S_has_simple_call_op =
true;
1034 template<
typename _Lhs,
typename _Rhs,
typename _Range>
1035 concept __pipe_invocable
1036 = requires { std::declval<_Rhs>()(std::declval<_Lhs>()(std::declval<_Range>())); };
1040 template<
typename _Lhs,
typename _Rhs>
1041 struct _Pipe : _RangeAdaptorClosure
1043 [[no_unique_address]] _Lhs _M_lhs;
1044 [[no_unique_address]] _Rhs _M_rhs;
1047 _Pipe(_Lhs __lhs, _Rhs __rhs)
1053 template<
typename _Range>
1054 requires __pipe_invocable<const _Lhs&, const _Rhs&, _Range>
1056 operator()(_Range&& __r)
const &
1057 {
return _M_rhs(_M_lhs(std::forward<_Range>(__r))); }
1059 template<
typename _Range>
1060 requires __pipe_invocable<_Lhs, _Rhs, _Range>
1062 operator()(_Range&& __r) &&
1065 template<
typename _Range>
1067 operator()(_Range&& __r)
const && =
delete;
1074 template<
typename _Lhs,
typename _Rhs>
1075 requires __closure_has_simple_call_op<_Lhs>
1076 && __closure_has_simple_call_op<_Rhs>
1077 struct _Pipe<_Lhs, _Rhs> : _RangeAdaptorClosure
1079 [[no_unique_address]] _Lhs _M_lhs;
1080 [[no_unique_address]] _Rhs _M_rhs;
1083 _Pipe(_Lhs __lhs, _Rhs __rhs)
1087 template<
typename _Range>
1088 requires __pipe_invocable<const _Lhs&, const _Rhs&, _Range>
1090 operator()(_Range&& __r)
const
1091 {
return _M_rhs(_M_lhs(std::forward<_Range>(__r))); }
1093 static constexpr
bool _S_has_simple_call_op =
true;
1097 template<range _Range> requires is_object_v<_Range>
1098 class ref_view :
public view_interface<ref_view<_Range>>
1103 static void _S_fun(_Range&);
1104 static void _S_fun(_Range&&) =
delete;
1107 template<__detail::__different_from<ref_view> _Tp>
1108 requires convertible_to<_Tp, _Range&>
1109 && requires { _S_fun(declval<_Tp>()); }
1112 noexcept(noexcept(
static_cast<_Range&
>(std::declval<_Tp>())))
1120 constexpr iterator_t<_Range>
1122 {
return ranges::begin(*_M_r); }
1124 constexpr sentinel_t<_Range>
1126 {
return ranges::end(*_M_r); }
1129 empty() const requires requires { ranges::empty(*_M_r); }
1130 {
return ranges::empty(*_M_r); }
1133 size() const requires sized_range<_Range>
1134 {
return ranges::size(*_M_r); }
1137 data() const requires contiguous_range<_Range>
1138 {
return ranges::data(*_M_r); }
1141 template<
typename _Range>
1142 ref_view(_Range&) -> ref_view<_Range>;
1144 template<
typename _Tp>
1145 inline constexpr
bool enable_borrowed_range<ref_view<_Tp>> =
true;
1151 template<
typename _Range>
1152 concept __can_ref_view = requires { ref_view{std::declval<_Range>()}; };
1154 template<
typename _Range>
1155 concept __can_subrange = requires {
subrange{std::declval<_Range>()}; };
1158 struct _All : __adaptor::_RangeAdaptorClosure
1160 template<
typename _Range>
1161 static constexpr
bool
1164 if constexpr (view<decay_t<_Range>>)
1165 return is_nothrow_constructible_v<
decay_t<_Range>, _Range>;
1166 else if constexpr (__detail::__can_ref_view<_Range>)
1169 return noexcept(subrange{std::declval<_Range>()});
1172 template<viewable_range _Range>
1173 requires view<decay_t<_Range>>
1174 || __detail::__can_ref_view<_Range>
1175 || __detail::__can_subrange<_Range>
1177 operator() [[nodiscard]] (_Range&& __r)
const
1178 noexcept(_S_noexcept<_Range>())
1180 if constexpr (view<decay_t<_Range>>)
1182 else if constexpr (__detail::__can_ref_view<_Range>)
1183 return ref_view{std::forward<_Range>(__r)};
1185 return subrange{std::forward<_Range>(__r)};
1188 static constexpr
bool _S_has_simple_call_op =
true;
1191 inline constexpr _All all;
1193 template<viewable_range _Range>
1194 using all_t = decltype(all(std::declval<_Range>()));
1199 template<
typename _Tp>
1200 struct __non_propagating_cache
1208 template<
typename _Tp>
1209 requires is_object_v<_Tp>
1210 struct __non_propagating_cache<_Tp>
1211 :
protected _Optional_base<_Tp>
1213 __non_propagating_cache() =
default;
1216 __non_propagating_cache(
const __non_propagating_cache&) noexcept
1220 __non_propagating_cache(__non_propagating_cache&& __other) noexcept
1221 { __other._M_reset(); }
1223 constexpr __non_propagating_cache&
1224 operator=(
const __non_propagating_cache& __other) noexcept
1231 constexpr __non_propagating_cache&
1232 operator=(__non_propagating_cache&& __other) noexcept
1239 constexpr __non_propagating_cache&
1240 operator=(_Tp __val)
1243 this->_M_payload._M_construct(
std::move(__val));
1248 operator bool() const noexcept
1249 {
return this->_M_is_engaged(); }
1253 {
return this->_M_get(); }
1255 constexpr
const _Tp&
1257 {
return this->_M_get(); }
1259 template<
typename _Iter>
1261 _M_emplace_deref(
const _Iter& __i)
1264 auto __f = [] (
auto& __x) {
return *__x; };
1265 this->_M_payload._M_apply(_Optional_func{__f}, __i);
1266 return this->_M_get();
1270 template<range _Range>
1271 struct _CachedPosition
1274 _M_has_value()
const
1277 constexpr iterator_t<_Range>
1278 _M_get(
const _Range&)
const
1280 __glibcxx_assert(
false);
1281 __builtin_unreachable();
1285 _M_set(
const _Range&,
const iterator_t<_Range>&)
const
1289 template<forward_range _Range>
1290 struct _CachedPosition<_Range>
1291 :
protected __non_propagating_cache<iterator_t<_Range>>
1294 _M_has_value()
const
1295 {
return this->_M_is_engaged(); }
1297 constexpr iterator_t<_Range>
1298 _M_get(
const _Range&)
const
1300 __glibcxx_assert(_M_has_value());
1305 _M_set(
const _Range&,
const iterator_t<_Range>& __it)
1307 __glibcxx_assert(!_M_has_value());
1310 this->_M_payload._M_engaged =
true;
1314 template<random_access_range _Range>
1315 requires (
sizeof(range_difference_t<_Range>)
1316 <=
sizeof(iterator_t<_Range>))
1317 struct _CachedPosition<_Range>
1320 range_difference_t<_Range> _M_offset = -1;
1323 _CachedPosition() =
default;
1326 _CachedPosition(
const _CachedPosition&) =
default;
1329 _CachedPosition(_CachedPosition&& __other) noexcept
1332 constexpr _CachedPosition&
1333 operator=(
const _CachedPosition&) =
default;
1335 constexpr _CachedPosition&
1336 operator=(_CachedPosition&& __other) noexcept
1339 _M_offset = __other._M_offset;
1340 __other._M_offset = -1;
1345 _M_has_value()
const
1346 {
return _M_offset >= 0; }
1348 constexpr iterator_t<_Range>
1349 _M_get(_Range& __r)
const
1351 __glibcxx_assert(_M_has_value());
1352 return ranges::begin(__r) + _M_offset;
1356 _M_set(_Range& __r,
const iterator_t<_Range>& __it)
1358 __glibcxx_assert(!_M_has_value());
1359 _M_offset = __it - ranges::begin(__r);
1366 template<
typename _Base>
1367 struct __filter_view_iter_cat
1370 template<forward_range _Base>
1371 struct __filter_view_iter_cat<_Base>
1377 using _Cat =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
1378 if constexpr (derived_from<_Cat, bidirectional_iterator_tag>)
1379 return bidirectional_iterator_tag{};
1380 else if constexpr (derived_from<_Cat, forward_iterator_tag>)
1381 return forward_iterator_tag{};
1386 using iterator_category = decltype(_S_iter_cat());
1391 indirect_unary_predicate<iterator_t<_Vp>> _Pred>
1392 requires view<_Vp> && is_object_v<_Pred>
1393 class filter_view :
public view_interface<filter_view<_Vp, _Pred>>
1398 struct _Iterator : __detail::__filter_view_iter_cat<_Vp>
1401 static constexpr
auto
1404 if constexpr (bidirectional_range<_Vp>)
1405 return bidirectional_iterator_tag{};
1406 else if constexpr (forward_range<_Vp>)
1407 return forward_iterator_tag{};
1409 return input_iterator_tag{};
1414 using _Vp_iter = iterator_t<_Vp>;
1416 _Vp_iter _M_current = _Vp_iter();
1417 filter_view* _M_parent =
nullptr;
1420 using iterator_concept = decltype(_S_iter_concept());
1422 using value_type = range_value_t<_Vp>;
1423 using difference_type = range_difference_t<_Vp>;
1428 _Iterator(filter_view* __parent, _Vp_iter __current)
1429 : _M_current(
std::
move(__current)),
1433 constexpr
const _Vp_iter&
1434 base() const & noexcept
1435 {
return _M_current; }
1441 constexpr range_reference_t<_Vp>
1443 {
return *_M_current; }
1447 requires __detail::__has_arrow<_Vp_iter>
1448 && copyable<_Vp_iter>
1449 {
return _M_current; }
1451 constexpr _Iterator&
1454 _M_current = ranges::find_if(
std::move(++_M_current),
1455 ranges::end(_M_parent->_M_base),
1456 std::ref(*_M_parent->_M_pred));
1465 operator++(
int) requires forward_range<_Vp>
1472 constexpr _Iterator&
1473 operator--() requires bidirectional_range<_Vp>
1482 operator--(
int) requires bidirectional_range<_Vp>
1489 friend constexpr
bool
1490 operator==(
const _Iterator& __x,
const _Iterator& __y)
1491 requires equality_comparable<_Vp_iter>
1492 {
return __x._M_current == __y._M_current; }
1494 friend constexpr range_rvalue_reference_t<_Vp>
1495 iter_move(
const _Iterator& __i)
1496 noexcept(noexcept(ranges::iter_move(__i._M_current)))
1497 {
return ranges::iter_move(__i._M_current); }
1499 friend constexpr
void
1500 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
1501 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1503 { ranges::iter_swap(__x._M_current, __y._M_current); }
1509 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
1512 __equal(
const _Iterator& __i)
const
1513 {
return __i._M_current == _M_end; }
1516 _Sentinel() =
default;
1519 _Sentinel(filter_view* __parent)
1520 : _M_end(ranges::
end(__parent->_M_base))
1523 constexpr sentinel_t<_Vp>
1527 friend constexpr
bool
1528 operator==(
const _Iterator& __x,
const _Sentinel& __y)
1529 {
return __y.__equal(__x); }
1532 _Vp _M_base = _Vp();
1533 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
1534 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
1542 filter_view(_Vp
__base, _Pred __pred)
1554 constexpr
const _Pred&
1556 {
return *_M_pred; }
1561 if (_M_cached_begin._M_has_value())
1562 return {
this, _M_cached_begin._M_get(_M_base)};
1564 __glibcxx_assert(_M_pred.has_value());
1565 auto __it = ranges::find_if(ranges::begin(_M_base),
1566 ranges::end(_M_base),
1567 std::ref(*_M_pred));
1568 _M_cached_begin._M_set(_M_base, __it);
1575 if constexpr (common_range<_Vp>)
1576 return _Iterator{
this, ranges::end(_M_base)};
1578 return _Sentinel{
this};
1582 template<
typename _Range,
typename _Pred>
1583 filter_view(_Range&&, _Pred) -> filter_view<views::all_t<_Range>, _Pred>;
1589 template<
typename _Range,
typename _Pred>
1590 concept __can_filter_view
1591 = requires { filter_view(std::declval<_Range>(), std::declval<_Pred>()); };
1594 struct _Filter : __adaptor::_RangeAdaptor<_Filter>
1596 template<viewable_range _Range,
typename _Pred>
1597 requires __detail::__can_filter_view<_Range, _Pred>
1599 operator() [[nodiscard]] (_Range&& __r, _Pred&& __p)
const
1601 return filter_view(std::forward<_Range>(__r), std::forward<_Pred>(__p));
1604 using _RangeAdaptor<_Filter>::operator();
1605 static constexpr
int _S_arity = 2;
1606 static constexpr
bool _S_has_simple_extra_args =
true;
1609 inline constexpr _Filter filter;
1612 template<input_range _Vp, copy_constructible _Fp>
1613 requires view<_Vp> && is_object_v<_Fp>
1614 && regular_invocable<_Fp&, range_reference_t<_Vp>>
1616 range_reference_t<_Vp>>>
1617 class transform_view :
public view_interface<transform_view<_Vp, _Fp>>
1620 template<
bool _Const>
1621 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
1623 template<
bool _Const>
1627 template<
bool _Const>
1628 requires forward_range<_Base<_Const>>
1629 struct __iter_cat<_Const>
1635 using _Base = transform_view::_Base<_Const>;
1636 using _Res = invoke_result_t<_Fp&, range_reference_t<_Base>>;
1637 if constexpr (is_lvalue_reference_v<_Res>)
1640 =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
1641 if constexpr (derived_from<_Cat, contiguous_iterator_tag>)
1642 return random_access_iterator_tag{};
1647 return input_iterator_tag{};
1650 using iterator_category = decltype(_S_iter_cat());
1653 template<
bool _Const>
1656 template<
bool _Const>
1657 struct _Iterator : __iter_cat<_Const>
1660 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
1661 using _Base = transform_view::_Base<_Const>;
1666 if constexpr (random_access_range<_Base>)
1667 return random_access_iterator_tag{};
1668 else if constexpr (bidirectional_range<_Base>)
1669 return bidirectional_iterator_tag{};
1670 else if constexpr (forward_range<_Base>)
1671 return forward_iterator_tag{};
1673 return input_iterator_tag{};
1676 using _Base_iter = iterator_t<_Base>;
1678 _Base_iter _M_current = _Base_iter();
1679 _Parent* _M_parent =
nullptr;
1682 using iterator_concept = decltype(_S_iter_concept());
1685 = remove_cvref_t<invoke_result_t<_Fp&, range_reference_t<_Base>>>;
1686 using difference_type = range_difference_t<_Base>;
1691 _Iterator(_Parent* __parent, _Base_iter __current)
1692 : _M_current(
std::
move(__current)),
1697 _Iterator(_Iterator<!_Const> __i)
1699 && convertible_to<iterator_t<_Vp>, _Base_iter>
1700 : _M_current(
std::move(__i._M_current)), _M_parent(__i._M_parent)
1703 constexpr
const _Base_iter&
1704 base() const & noexcept
1705 {
return _M_current; }
1707 constexpr _Base_iter
1711 constexpr decltype(
auto)
1713 noexcept(noexcept(
std::
__invoke(*_M_parent->_M_fun, *_M_current)))
1716 constexpr _Iterator&
1728 operator++(
int) requires forward_range<_Base>
1735 constexpr _Iterator&
1736 operator--() requires bidirectional_range<_Base>
1743 operator--(
int) requires bidirectional_range<_Base>
1750 constexpr _Iterator&
1751 operator+=(difference_type __n) requires random_access_range<_Base>
1757 constexpr _Iterator&
1758 operator-=(difference_type __n) requires random_access_range<_Base>
1764 constexpr decltype(
auto)
1765 operator[](difference_type __n) const
1766 requires random_access_range<_Base>
1767 {
return std::__invoke(*_M_parent->_M_fun, _M_current[__n]); }
1769 friend constexpr
bool
1770 operator==(
const _Iterator& __x,
const _Iterator& __y)
1771 requires equality_comparable<_Base_iter>
1772 {
return __x._M_current == __y._M_current; }
1774 friend constexpr
bool
1775 operator<(
const _Iterator& __x,
const _Iterator& __y)
1776 requires random_access_range<_Base>
1777 {
return __x._M_current < __y._M_current; }
1779 friend constexpr
bool
1780 operator>(
const _Iterator& __x,
const _Iterator& __y)
1781 requires random_access_range<_Base>
1782 {
return __y < __x; }
1784 friend constexpr
bool
1785 operator<=(
const _Iterator& __x,
const _Iterator& __y)
1786 requires random_access_range<_Base>
1787 {
return !(__y < __x); }
1789 friend constexpr
bool
1790 operator>=(
const _Iterator& __x,
const _Iterator& __y)
1791 requires random_access_range<_Base>
1792 {
return !(__x < __y); }
1794 #ifdef __cpp_lib_three_way_comparison
1795 friend constexpr
auto
1796 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
1797 requires random_access_range<_Base>
1798 && three_way_comparable<_Base_iter>
1799 {
return __x._M_current <=> __y._M_current; }
1802 friend constexpr _Iterator
1803 operator+(_Iterator __i, difference_type __n)
1804 requires random_access_range<_Base>
1805 {
return {__i._M_parent, __i._M_current + __n}; }
1807 friend constexpr _Iterator
1808 operator+(difference_type __n, _Iterator __i)
1809 requires random_access_range<_Base>
1810 {
return {__i._M_parent, __i._M_current + __n}; }
1812 friend constexpr _Iterator
1813 operator-(_Iterator __i, difference_type __n)
1814 requires random_access_range<_Base>
1815 {
return {__i._M_parent, __i._M_current - __n}; }
1819 friend constexpr difference_type
1820 operator-(
const _Iterator& __x,
const _Iterator& __y)
1821 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
1822 {
return __x._M_current - __y._M_current; }
1824 friend constexpr decltype(
auto)
1825 iter_move(const _Iterator& __i) noexcept(noexcept(*__i))
1827 if constexpr (is_lvalue_reference_v<decltype(*__i)>)
1833 friend _Iterator<!_Const>;
1834 template<
bool> friend struct _Sentinel;
1837 template<
bool _Const>
1841 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
1842 using _Base = transform_view::_Base<_Const>;
1844 template<
bool _Const2>
1846 __distance_from(
const _Iterator<_Const2>& __i)
const
1847 {
return _M_end - __i._M_current; }
1849 template<
bool _Const2>
1851 __equal(
const _Iterator<_Const2>& __i)
const
1852 {
return __i._M_current == _M_end; }
1854 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
1857 _Sentinel() =
default;
1860 _Sentinel(sentinel_t<_Base> __end)
1865 _Sentinel(_Sentinel<!_Const> __i)
1867 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
1871 constexpr sentinel_t<_Base>
1875 template<
bool _Const2>
1876 requires sentinel_for<sentinel_t<_Base>,
1877 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
1878 friend constexpr
bool
1879 operator==(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
1880 {
return __y.__equal(__x); }
1882 template<
bool _Const2,
1883 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
1884 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
1885 friend constexpr range_difference_t<_Base2>
1886 operator-(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
1887 {
return -__y.__distance_from(__x); }
1889 template<
bool _Const2,
1890 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
1891 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
1892 friend constexpr range_difference_t<_Base2>
1893 operator-(
const _Sentinel& __y,
const _Iterator<_Const2>& __x)
1894 {
return __y.__distance_from(__x); }
1896 friend _Sentinel<!_Const>;
1899 _Vp _M_base = _Vp();
1900 [[no_unique_address]] __detail::__box<_Fp> _M_fun;
1908 transform_view(_Vp
__base, _Fp __fun)
1914 {
return _M_base ; }
1920 constexpr _Iterator<false>
1922 {
return _Iterator<false>{
this, ranges::begin(_M_base)}; }
1924 constexpr _Iterator<true>
1926 requires range<const _Vp>
1928 {
return _Iterator<true>{
this, ranges::begin(_M_base)}; }
1930 constexpr _Sentinel<false>
1932 {
return _Sentinel<false>{ranges::end(_M_base)}; }
1934 constexpr _Iterator<false>
1935 end() requires common_range<_Vp>
1936 {
return _Iterator<false>{
this, ranges::end(_M_base)}; }
1938 constexpr _Sentinel<true>
1940 requires range<const _Vp>
1942 {
return _Sentinel<true>{ranges::end(_M_base)}; }
1944 constexpr _Iterator<true>
1946 requires common_range<const _Vp>
1948 {
return _Iterator<true>{
this, ranges::end(_M_base)}; }
1951 size() requires sized_range<_Vp>
1952 {
return ranges::size(_M_base); }
1955 size() const requires sized_range<const _Vp>
1956 {
return ranges::size(_M_base); }
1959 template<
typename _Range,
typename _Fp>
1960 transform_view(_Range&&, _Fp) -> transform_view<views::all_t<_Range>, _Fp>;
1966 template<
typename _Range,
typename _Fp>
1967 concept __can_transform_view
1968 = requires { transform_view(std::declval<_Range>(), std::declval<_Fp>()); };
1971 struct _Transform : __adaptor::_RangeAdaptor<_Transform>
1973 template<viewable_range _Range,
typename _Fp>
1974 requires __detail::__can_transform_view<_Range, _Fp>
1976 operator() [[nodiscard]] (_Range&& __r, _Fp&& __f)
const
1978 return transform_view(std::forward<_Range>(__r), std::forward<_Fp>(__f));
1981 using _RangeAdaptor<_Transform>::operator();
1982 static constexpr
int _S_arity = 2;
1983 static constexpr
bool _S_has_simple_extra_args =
true;
1986 inline constexpr _Transform transform;
1990 class take_view :
public view_interface<take_view<_Vp>>
1993 template<
bool _Const>
1994 using _CI = counted_iterator<
1995 iterator_t<__detail::__maybe_const_t<_Const, _Vp>>>;
1997 template<
bool _Const>
2001 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2002 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2005 _Sentinel() =
default;
2008 _Sentinel(sentinel_t<_Base> __end)
2013 _Sentinel(_Sentinel<!_Const> __s)
2014 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2018 constexpr sentinel_t<_Base>
2022 friend constexpr
bool
2023 operator==(
const _CI<_Const>& __y,
const _Sentinel& __x)
2024 {
return __y.count() == 0 || __y.base() == __x._M_end; }
2026 template<
bool _OtherConst = !_Const,
2027 typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
2028 requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2029 friend constexpr
bool
2030 operator==(
const _CI<_OtherConst>& __y,
const _Sentinel& __x)
2031 {
return __y.count() == 0 || __y.base() == __x._M_end; }
2033 friend _Sentinel<!_Const>;
2036 _Vp _M_base = _Vp();
2037 range_difference_t<_Vp> _M_count = 0;
2043 take_view(_Vp base, range_difference_t<_Vp> __count)
2056 begin() requires (!__detail::__simple_view<_Vp>)
2058 if constexpr (sized_range<_Vp>)
2060 if constexpr (random_access_range<_Vp>)
2061 return ranges::begin(_M_base);
2065 return counted_iterator(ranges::begin(_M_base), __sz);
2069 return counted_iterator(ranges::begin(_M_base), _M_count);
2073 begin() const requires range<const _Vp>
2075 if constexpr (sized_range<const _Vp>)
2077 if constexpr (random_access_range<const _Vp>)
2078 return ranges::begin(_M_base);
2082 return counted_iterator(ranges::begin(_M_base), __sz);
2086 return counted_iterator(ranges::begin(_M_base), _M_count);
2090 end() requires (!__detail::__simple_view<_Vp>)
2092 if constexpr (sized_range<_Vp>)
2094 if constexpr (random_access_range<_Vp>)
2095 return ranges::begin(_M_base) +
size();
2097 return default_sentinel;
2100 return _Sentinel<false>{ranges::end(_M_base)};
2104 end() const requires range<const _Vp>
2106 if constexpr (sized_range<const _Vp>)
2108 if constexpr (random_access_range<const _Vp>)
2109 return ranges::begin(_M_base) +
size();
2111 return default_sentinel;
2114 return _Sentinel<true>{ranges::end(_M_base)};
2118 size() requires sized_range<_Vp>
2120 auto __n = ranges::size(_M_base);
2121 return std::min(__n,
static_cast<decltype(__n)
>(_M_count));
2125 size() const requires sized_range<const _Vp>
2127 auto __n = ranges::size(_M_base);
2128 return std::min(__n,
static_cast<decltype(__n)
>(_M_count));
2135 template<
typename _Range>
2136 take_view(_Range&&, range_difference_t<_Range>)
2137 -> take_view<views::all_t<_Range>>;
2139 template<
typename _Tp>
2140 inline constexpr
bool enable_borrowed_range<take_view<_Tp>>
2141 = enable_borrowed_range<_Tp>;
2147 template<
typename _Range>
2148 inline constexpr
bool __is_empty_view =
false;
2150 template<
typename _Tp>
2151 inline constexpr
bool __is_empty_view<empty_view<_Tp>> =
true;
2153 template<
typename _Range>
2154 inline constexpr
bool __is_basic_string_view =
false;
2156 template<
typename _CharT,
typename _Traits>
2157 inline constexpr
bool __is_basic_string_view<basic_string_view<_CharT, _Traits>>
2160 template<
typename _Range>
2161 inline constexpr
bool __is_subrange =
false;
2163 template<
typename _Iter,
typename _Sent, subrange_kind _Kind>
2164 inline constexpr
bool __is_subrange<subrange<_Iter, _Sent, _Kind>> =
true;
2166 template<
typename _Range>
2167 inline constexpr
bool __is_iota_view =
false;
2169 template<
typename _Winc,
typename _Bound>
2170 inline constexpr
bool __is_iota_view<iota_view<_Winc, _Bound>> =
true;
2172 template<
typename _Range,
typename _Dp>
2173 concept __can_take_view
2174 = requires { take_view(std::declval<_Range>(), std::declval<_Dp>()); };
2177 struct _Take : __adaptor::_RangeAdaptor<_Take>
2179 template<viewable_range _Range,
typename _Dp = range_difference_t<_Range>>
2180 requires __detail::__can_take_view<_Range, _Dp>
2182 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n)
const
2184 using _Tp = remove_cvref_t<_Range>;
2185 if constexpr (__detail::__is_empty_view<_Tp>)
2187 else if constexpr (random_access_range<_Tp>
2189 && (std::__detail::__is_span<_Tp>
2190 || __detail::__is_basic_string_view<_Tp>
2191 || __detail::__is_subrange<_Tp>
2192 || __detail::__is_iota_view<_Tp>))
2194 __n = std::min<_Dp>(ranges::distance(__r), __n);
2195 auto __begin = ranges::begin(__r);
2196 auto __end = __begin + __n;
2197 if constexpr (std::__detail::__is_span<_Tp>)
2198 return span<typename _Tp::element_type>(__begin, __end);
2199 else if constexpr (__detail::__is_basic_string_view<_Tp>)
2200 return _Tp(__begin, __end);
2201 else if constexpr (__detail::__is_subrange<_Tp>)
2202 return subrange<iterator_t<_Tp>>(__begin, __end);
2204 return iota_view(*__begin, *__end);
2207 return take_view(std::forward<_Range>(__r), __n);
2210 using _RangeAdaptor<_Take>::operator();
2211 static constexpr
int _S_arity = 2;
2215 template<
typename _Tp>
2216 static constexpr
bool _S_has_simple_extra_args
2217 = ranges::__detail::__is_integer_like<_Tp>;
2220 inline constexpr _Take take;
2223 template<view _Vp,
typename _Pred>
2224 requires input_range<_Vp> && is_object_v<_Pred>
2225 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2226 class take_while_view :
public view_interface<take_while_view<_Vp, _Pred>>
2228 template<
bool _Const>
2232 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2234 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2235 const _Pred* _M_pred =
nullptr;
2238 _Sentinel() =
default;
2241 _Sentinel(sentinel_t<_Base> __end,
const _Pred* __pred)
2242 : _M_end(__end), _M_pred(__pred)
2246 _Sentinel(_Sentinel<!_Const> __s)
2247 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2248 : _M_end(__s._M_end), _M_pred(__s._M_pred)
2251 constexpr sentinel_t<_Base>
2252 base()
const {
return _M_end; }
2254 friend constexpr
bool
2255 operator==(
const iterator_t<_Base>& __x,
const _Sentinel& __y)
2256 {
return __y._M_end == __x || !
std::__invoke(*__y._M_pred, *__x); }
2258 template<
bool _OtherConst = !_Const,
2259 typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
2260 requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2261 friend constexpr
bool
2262 operator==(
const iterator_t<_Base2>& __x,
const _Sentinel& __y)
2263 {
return __y._M_end == __x || !
std::__invoke(*__y._M_pred, *__x); }
2265 friend _Sentinel<!_Const>;
2268 _Vp _M_base = _Vp();
2269 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
2277 take_while_view(_Vp base, _Pred __pred)
2289 constexpr
const _Pred&
2291 {
return *_M_pred; }
2294 begin() requires (!__detail::__simple_view<_Vp>)
2295 {
return ranges::begin(_M_base); }
2298 begin() const requires range<const _Vp>
2299 && indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
2300 {
return ranges::begin(_M_base); }
2303 end() requires (!__detail::__simple_view<_Vp>)
2304 {
return _Sentinel<false>(ranges::end(_M_base),
2308 end() const requires range<const _Vp>
2309 && indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
2310 {
return _Sentinel<true>(ranges::end(_M_base),
2314 template<
typename _Range,
typename _Pred>
2315 take_while_view(_Range&&, _Pred)
2316 -> take_while_view<views::all_t<_Range>, _Pred>;
2322 template<
typename _Range,
typename _Pred>
2323 concept __can_take_while_view
2324 = requires { take_while_view(std::declval<_Range>(), std::declval<_Pred>()); };
2327 struct _TakeWhile : __adaptor::_RangeAdaptor<_TakeWhile>
2329 template<viewable_range _Range,
typename _Pred>
2330 requires __detail::__can_take_while_view<_Range, _Pred>
2332 operator() [[nodiscard]] (_Range&& __r, _Pred&& __p)
const
2334 return take_while_view(std::forward<_Range>(__r), std::forward<_Pred>(__p));
2337 using _RangeAdaptor<_TakeWhile>::operator();
2338 static constexpr
int _S_arity = 2;
2339 static constexpr
bool _S_has_simple_extra_args =
true;
2342 inline constexpr _TakeWhile take_while;
2346 class drop_view :
public view_interface<drop_view<_Vp>>
2349 _Vp _M_base = _Vp();
2350 range_difference_t<_Vp> _M_count = 0;
2354 static constexpr
bool _S_needs_cached_begin
2355 = !(random_access_range<const _Vp> && sized_range<const _Vp>);
2356 [[no_unique_address]]
2357 __detail::__maybe_present_t<_S_needs_cached_begin,
2358 __detail::_CachedPosition<_Vp>>
2365 drop_view(_Vp
__base, range_difference_t<_Vp> __count)
2367 { __glibcxx_assert(__count >= 0); }
2380 requires (!(__detail::__simple_view<_Vp>
2381 && random_access_range<const _Vp>
2382 && sized_range<const _Vp>))
2384 if constexpr (_S_needs_cached_begin)
2385 if (_M_cached_begin._M_has_value())
2386 return _M_cached_begin._M_get(_M_base);
2388 auto __it = ranges::next(ranges::begin(_M_base),
2389 _M_count, ranges::end(_M_base));
2390 if constexpr (_S_needs_cached_begin)
2391 _M_cached_begin._M_set(_M_base, __it);
2399 requires random_access_range<const _Vp> && sized_range<const _Vp>
2401 return ranges::next(ranges::begin(_M_base), _M_count,
2402 ranges::end(_M_base));
2406 end() requires (!__detail::__simple_view<_Vp>)
2407 {
return ranges::end(_M_base); }
2410 end() const requires range<const _Vp>
2411 {
return ranges::end(_M_base); }
2414 size() requires sized_range<_Vp>
2416 const auto __s = ranges::size(_M_base);
2417 const auto __c =
static_cast<decltype(__s)
>(_M_count);
2418 return __s < __c ? 0 : __s - __c;
2422 size() const requires sized_range<const _Vp>
2424 const auto __s = ranges::size(_M_base);
2425 const auto __c =
static_cast<decltype(__s)
>(_M_count);
2426 return __s < __c ? 0 : __s - __c;
2430 template<
typename _Range>
2431 drop_view(_Range&&, range_difference_t<_Range>)
2432 -> drop_view<views::all_t<_Range>>;
2434 template<
typename _Tp>
2435 inline constexpr
bool enable_borrowed_range<drop_view<_Tp>>
2436 = enable_borrowed_range<_Tp>;
2442 template<
typename _Range,
typename _Dp>
2443 concept __can_drop_view
2444 = requires { drop_view(std::declval<_Range>(), std::declval<_Dp>()); };
2447 struct _Drop : __adaptor::_RangeAdaptor<_Drop>
2449 template<viewable_range _Range,
typename _Dp = range_difference_t<_Range>>
2450 requires __detail::__can_drop_view<_Range, _Dp>
2452 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n)
const
2454 using _Tp = remove_cvref_t<_Range>;
2455 if constexpr (__detail::__is_empty_view<_Tp>)
2457 else if constexpr (random_access_range<_Tp>
2459 && (std::__detail::__is_span<_Tp>
2460 || __detail::__is_basic_string_view<_Tp>
2461 || __detail::__is_iota_view<_Tp>
2462 || __detail::__is_subrange<_Tp>))
2464 __n = std::min<_Dp>(ranges::distance(__r), __n);
2465 auto __begin = ranges::begin(__r) + __n;
2466 auto __end = ranges::end(__r);
2467 if constexpr (std::__detail::__is_span<_Tp>)
2468 return span<typename _Tp::element_type>(__begin, __end);
2469 else if constexpr (__detail::__is_subrange<_Tp>)
2471 if constexpr (_Tp::_S_store_size)
2473 using ranges::__detail::__to_unsigned_like;
2474 auto __m = ranges::distance(__r) - __n;
2475 return _Tp(__begin, __end, __to_unsigned_like(__m));
2478 return _Tp(__begin, __end);
2481 return _Tp(__begin, __end);
2484 return drop_view(std::forward<_Range>(__r), __n);
2487 using _RangeAdaptor<_Drop>::operator();
2488 static constexpr
int _S_arity = 2;
2489 template<
typename _Tp>
2490 static constexpr
bool _S_has_simple_extra_args
2491 = _Take::_S_has_simple_extra_args<_Tp>;
2494 inline constexpr _Drop drop;
2497 template<view _Vp,
typename _Pred>
2498 requires input_range<_Vp> && is_object_v<_Pred>
2499 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2500 class drop_while_view :
public view_interface<drop_while_view<_Vp, _Pred>>
2503 _Vp _M_base = _Vp();
2504 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
2505 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
2513 drop_while_view(_Vp
__base, _Pred __pred)
2525 constexpr
const _Pred&
2527 {
return *_M_pred; }
2532 if (_M_cached_begin._M_has_value())
2533 return _M_cached_begin._M_get(_M_base);
2535 __glibcxx_assert(_M_pred.has_value());
2536 auto __it = ranges::find_if_not(ranges::begin(_M_base),
2537 ranges::end(_M_base),
2538 std::cref(*_M_pred));
2539 _M_cached_begin._M_set(_M_base, __it);
2545 {
return ranges::end(_M_base); }
2548 template<
typename _Range,
typename _Pred>
2549 drop_while_view(_Range&&, _Pred)
2550 -> drop_while_view<views::all_t<_Range>, _Pred>;
2552 template<
typename _Tp,
typename _Pred>
2553 inline constexpr
bool enable_borrowed_range<drop_while_view<_Tp, _Pred>>
2554 = enable_borrowed_range<_Tp>;
2560 template<
typename _Range,
typename _Pred>
2561 concept __can_drop_while_view
2562 = requires { drop_while_view(std::declval<_Range>(), std::declval<_Pred>()); };
2565 struct _DropWhile : __adaptor::_RangeAdaptor<_DropWhile>
2567 template<viewable_range _Range,
typename _Pred>
2568 requires __detail::__can_drop_while_view<_Range, _Pred>
2570 operator() [[nodiscard]] (_Range&& __r, _Pred&& __p)
const
2572 return drop_while_view(std::forward<_Range>(__r),
2573 std::forward<_Pred>(__p));
2576 using _RangeAdaptor<_DropWhile>::operator();
2577 static constexpr
int _S_arity = 2;
2578 static constexpr
bool _S_has_simple_extra_args =
true;
2581 inline constexpr _DropWhile drop_while;
2584 template<input_range _Vp>
2585 requires view<_Vp> && input_range<range_reference_t<_Vp>>
2586 class join_view :
public view_interface<join_view<_Vp>>
2589 using _InnerRange = range_reference_t<_Vp>;
2591 template<
bool _Const>
2592 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2594 template<
bool _Const>
2595 using _Outer_iter = iterator_t<_Base<_Const>>;
2597 template<
bool _Const>
2598 using _Inner_iter = iterator_t<range_reference_t<_Base<_Const>>>;
2600 template<
bool _Const>
2601 static constexpr
bool _S_ref_is_glvalue
2602 = is_reference_v<range_reference_t<_Base<_Const>>>;
2604 template<
bool _Const>
2608 template<
bool _Const>
2609 requires _S_ref_is_glvalue<_Const>
2610 && forward_range<_Base<_Const>>
2611 && forward_range<range_reference_t<_Base<_Const>>>
2612 struct __iter_cat<_Const>
2615 static constexpr
auto
2618 using _Outer_iter = join_view::_Outer_iter<_Const>;
2619 using _Inner_iter = join_view::_Inner_iter<_Const>;
2620 using _OuterCat =
typename iterator_traits<_Outer_iter>::iterator_category;
2621 using _InnerCat =
typename iterator_traits<_Inner_iter>::iterator_category;
2622 if constexpr (derived_from<_OuterCat, bidirectional_iterator_tag>
2623 && derived_from<_InnerCat, bidirectional_iterator_tag>
2624 && common_range<range_reference_t<_Base<_Const>>>)
2625 return bidirectional_iterator_tag{};
2626 else if constexpr (derived_from<_OuterCat, forward_iterator_tag>
2627 && derived_from<_InnerCat, forward_iterator_tag>)
2628 return forward_iterator_tag{};
2630 return input_iterator_tag{};
2633 using iterator_category = decltype(_S_iter_cat());
2636 template<
bool _Const>
2639 template<
bool _Const>
2640 struct _Iterator : __iter_cat<_Const>
2643 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
2644 using _Base = join_view::_Base<_Const>;
2646 static constexpr
bool _S_ref_is_glvalue
2647 = join_view::_S_ref_is_glvalue<_Const>;
2652 auto __update_inner = [
this] (
const iterator_t<_Base>& __x) ->
auto&& {
2653 if constexpr (_S_ref_is_glvalue)
2656 return _M_parent->_M_inner._M_emplace_deref(__x);
2659 for (; _M_outer != ranges::end(_M_parent->_M_base); ++_M_outer)
2661 auto&& __inner = __update_inner(_M_outer);
2662 _M_inner = ranges::begin(__inner);
2663 if (_M_inner != ranges::end(__inner))
2667 if constexpr (_S_ref_is_glvalue)
2668 _M_inner = _Inner_iter();
2671 static constexpr
auto
2674 if constexpr (_S_ref_is_glvalue
2675 && bidirectional_range<_Base>
2676 && bidirectional_range<range_reference_t<_Base>>
2677 && common_range<range_reference_t<_Base>>)
2678 return bidirectional_iterator_tag{};
2679 else if constexpr (_S_ref_is_glvalue
2680 && forward_range<_Base>
2681 && forward_range<range_reference_t<_Base>>)
2682 return forward_iterator_tag{};
2684 return input_iterator_tag{};
2687 using _Outer_iter = join_view::_Outer_iter<_Const>;
2688 using _Inner_iter = join_view::_Inner_iter<_Const>;
2690 _Outer_iter _M_outer = _Outer_iter();
2691 _Inner_iter _M_inner = _Inner_iter();
2692 _Parent* _M_parent =
nullptr;
2695 using iterator_concept = decltype(_S_iter_concept());
2697 using value_type = range_value_t<range_reference_t<_Base>>;
2698 using difference_type
2699 = common_type_t<range_difference_t<_Base>,
2700 range_difference_t<range_reference_t<_Base>>>;
2707 _Iterator(_Parent* __parent, _Outer_iter __outer)
2708 : _M_outer(
std::
move(__outer)),
2713 _Iterator(_Iterator<!_Const> __i)
2715 && convertible_to<iterator_t<_Vp>, _Outer_iter>
2716 && convertible_to<iterator_t<_InnerRange>, _Inner_iter>
2718 _M_parent(__i._M_parent)
2721 constexpr decltype(
auto)
2723 {
return *_M_inner; }
2727 constexpr _Inner_iter
2729 requires __detail::__has_arrow<_Inner_iter>
2730 && copyable<_Inner_iter>
2731 {
return _M_inner; }
2733 constexpr _Iterator&
2736 auto&& __inner_range = [
this] () ->
auto&& {
2737 if constexpr (_S_ref_is_glvalue)
2740 return *_M_parent->_M_inner;
2742 if (++_M_inner == ranges::end(__inner_range))
2756 requires _S_ref_is_glvalue && forward_range<_Base>
2757 && forward_range<range_reference_t<_Base>>
2764 constexpr _Iterator&
2766 requires _S_ref_is_glvalue && bidirectional_range<_Base>
2767 && bidirectional_range<range_reference_t<_Base>>
2768 && common_range<range_reference_t<_Base>>
2770 if (_M_outer == ranges::end(_M_parent->_M_base))
2771 _M_inner = ranges::end(*--_M_outer);
2772 while (_M_inner == ranges::begin(*_M_outer))
2773 _M_inner = ranges::end(*--_M_outer);
2780 requires _S_ref_is_glvalue && bidirectional_range<_Base>
2781 && bidirectional_range<range_reference_t<_Base>>
2782 && common_range<range_reference_t<_Base>>
2789 friend constexpr
bool
2790 operator==(
const _Iterator& __x,
const _Iterator& __y)
2791 requires _S_ref_is_glvalue
2792 && equality_comparable<_Outer_iter>
2793 && equality_comparable<_Inner_iter>
2795 return (__x._M_outer == __y._M_outer
2796 && __x._M_inner == __y._M_inner);
2799 friend constexpr decltype(
auto)
2800 iter_move(const _Iterator& __i)
2801 noexcept(noexcept(ranges::iter_move(__i._M_inner)))
2802 {
return ranges::iter_move(__i._M_inner); }
2804 friend constexpr
void
2805 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
2806 noexcept(noexcept(ranges::iter_swap(__x._M_inner, __y._M_inner)))
2808 {
return ranges::iter_swap(__x._M_inner, __y._M_inner); }
2810 friend _Iterator<!_Const>;
2811 template<
bool>
friend struct _Sentinel;
2814 template<
bool _Const>
2818 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
2819 using _Base = join_view::_Base<_Const>;
2821 template<
bool _Const2>
2823 __equal(
const _Iterator<_Const2>& __i)
const
2824 {
return __i._M_outer == _M_end; }
2826 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2829 _Sentinel() =
default;
2832 _Sentinel(_Parent* __parent)
2833 : _M_end(ranges::
end(__parent->_M_base))
2837 _Sentinel(_Sentinel<!_Const> __s)
2838 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2842 template<
bool _Const2>
2843 requires sentinel_for<sentinel_t<_Base>,
2844 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
2845 friend constexpr
bool
2846 operator==(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
2847 {
return __y.__equal(__x); }
2849 friend _Sentinel<!_Const>;
2852 _Vp _M_base = _Vp();
2853 [[no_unique_address]]
2854 __detail::__non_propagating_cache<remove_cv_t<_InnerRange>> _M_inner;
2875 constexpr
bool __use_const
2876 = (__detail::__simple_view<_Vp>
2877 && is_reference_v<range_reference_t<_Vp>>);
2878 return _Iterator<__use_const>{
this, ranges::begin(_M_base)};
2883 requires input_range<const _Vp>
2884 && is_reference_v<range_reference_t<const _Vp>>
2886 return _Iterator<true>{
this, ranges::begin(_M_base)};
2892 if constexpr (forward_range<_Vp> && is_reference_v<_InnerRange>
2893 && forward_range<_InnerRange>
2894 && common_range<_Vp> && common_range<_InnerRange>)
2895 return _Iterator<__detail::__simple_view<_Vp>>{
this,
2896 ranges::end(_M_base)};
2898 return _Sentinel<__detail::__simple_view<_Vp>>{
this};
2903 requires input_range<const _Vp>
2904 && is_reference_v<range_reference_t<const _Vp>>
2906 if constexpr (forward_range<const _Vp>
2907 && is_reference_v<range_reference_t<const _Vp>>
2908 && forward_range<range_reference_t<const _Vp>>
2909 && common_range<const _Vp>
2910 && common_range<range_reference_t<const _Vp>>)
2911 return _Iterator<true>{
this, ranges::end(_M_base)};
2913 return _Sentinel<true>{
this};
2917 template<
typename _Range>
2918 explicit join_view(_Range&&) -> join_view<views::all_t<_Range>>;
2924 template<
typename _Range>
2925 concept __can_join_view
2926 = requires { join_view<all_t<_Range>>{std::declval<_Range>()}; };
2929 struct _Join : __adaptor::_RangeAdaptorClosure
2931 template<viewable_range _Range>
2932 requires __detail::__can_join_view<_Range>
2934 operator() [[nodiscard]] (_Range&& __r)
const
2938 return join_view<all_t<_Range>>{std::forward<_Range>(__r)};
2941 static constexpr
bool _S_has_simple_call_op =
true;
2944 inline constexpr _Join join;
2950 struct __require_constant;
2952 template<
typename _Range>
2953 concept __tiny_range = sized_range<_Range>
2955 {
typename __require_constant<remove_reference_t<_Range>::size()>; }
2956 && (remove_reference_t<_Range>::size() <= 1);
2958 template<
typename _Base>
2959 struct __lazy_split_view_outer_iter_cat
2962 template<forward_range _Base>
2963 struct __lazy_split_view_outer_iter_cat<_Base>
2964 {
using iterator_category = input_iterator_tag; };
2966 template<
typename _Base>
2967 struct __lazy_split_view_inner_iter_cat
2970 template<forward_range _Base>
2971 struct __lazy_split_view_inner_iter_cat<_Base>
2974 static constexpr
auto
2977 using _Cat =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
2978 if constexpr (derived_from<_Cat, forward_iterator_tag>)
2979 return forward_iterator_tag{};
2984 using iterator_category = decltype(_S_iter_cat());
2988 template<input_range _Vp, forward_range _Pattern>
2989 requires view<_Vp> && view<_Pattern>
2990 && indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
2992 && (forward_range<_Vp> || __detail::__tiny_range<_Pattern>)
2993 class lazy_split_view :
public view_interface<lazy_split_view<_Vp, _Pattern>>
2996 template<
bool _Const>
2997 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2999 template<
bool _Const>
3002 template<
bool _Const>
3004 : __detail::__lazy_split_view_outer_iter_cat<_Base<_Const>>
3007 using _Parent = __detail::__maybe_const_t<_Const, lazy_split_view>;
3008 using _Base = lazy_split_view::_Base<_Const>;
3012 {
return __current() == ranges::end(_M_parent->_M_base) && !_M_trailing_empty; }
3019 __current() noexcept
3021 if constexpr (forward_range<_Vp>)
3024 return *_M_parent->_M_current;
3028 __current() const noexcept
3030 if constexpr (forward_range<_Vp>)
3033 return *_M_parent->_M_current;
3036 _Parent* _M_parent =
nullptr;
3039 [[no_unique_address]]
3040 __detail::__maybe_present_t<forward_range<_Vp>,
3041 iterator_t<_Base>> _M_current;
3042 bool _M_trailing_empty =
false;
3045 using iterator_concept = __conditional_t<forward_range<_Base>,
3046 forward_iterator_tag,
3047 input_iterator_tag>;
3049 using difference_type = range_difference_t<_Base>;
3051 struct value_type : view_interface<value_type>
3054 _OuterIter _M_i = _OuterIter();
3057 value_type() =
default;
3060 value_type(_OuterIter __i)
3064 constexpr _InnerIter<_Const>
3066 {
return _InnerIter<_Const>{_M_i}; }
3068 constexpr default_sentinel_t
3069 end() const noexcept
3070 {
return default_sentinel; }
3073 _OuterIter() =
default;
3076 _OuterIter(_Parent* __parent) requires (!forward_range<_Base>)
3077 : _M_parent(__parent)
3081 _OuterIter(_Parent* __parent, iterator_t<_Base> __current)
3082 requires forward_range<_Base>
3083 : _M_parent(__parent),
3088 _OuterIter(_OuterIter<!_Const> __i)
3090 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
3091 : _M_parent(__i._M_parent), _M_current(
std::move(__i._M_current))
3094 constexpr value_type
3096 {
return value_type{*
this}; }
3098 constexpr _OuterIter&
3103 const auto __end = ranges::end(_M_parent->_M_base);
3104 if (__current() == __end)
3106 _M_trailing_empty =
false;
3109 const auto [__pbegin, __pend] =
subrange{_M_parent->_M_pattern};
3110 if (__pbegin == __pend)
3112 else if constexpr (__detail::__tiny_range<_Pattern>)
3114 __current() = ranges::find(
std::move(__current()), __end,
3116 if (__current() != __end)
3119 if (__current() == __end)
3120 _M_trailing_empty =
true;
3127 = ranges::mismatch(__current(), __end, __pbegin, __pend);
3131 if (__current() == __end)
3132 _M_trailing_empty =
true;
3135 }
while (++__current() != __end);
3139 constexpr decltype(
auto)
3142 if constexpr (forward_range<_Base>)
3152 friend constexpr
bool
3153 operator==(
const _OuterIter& __x,
const _OuterIter& __y)
3154 requires forward_range<_Base>
3156 return __x._M_current == __y._M_current
3157 && __x._M_trailing_empty == __y._M_trailing_empty;
3160 friend constexpr
bool
3161 operator==(
const _OuterIter& __x, default_sentinel_t)
3162 {
return __x.__at_end(); };
3164 friend _OuterIter<!_Const>;
3165 friend _InnerIter<_Const>;
3168 template<
bool _Const>
3170 : __detail::__lazy_split_view_inner_iter_cat<_Base<_Const>>
3173 using _Base = lazy_split_view::_Base<_Const>;
3178 auto [__pcur, __pend] =
subrange{_M_i._M_parent->_M_pattern};
3179 auto __end = ranges::end(_M_i._M_parent->_M_base);
3180 if constexpr (__detail::__tiny_range<_Pattern>)
3182 const auto& __cur = _M_i_current();
3185 if (__pcur == __pend)
3186 return _M_incremented;
3187 return *__cur == *__pcur;
3191 auto __cur = _M_i_current();
3194 if (__pcur == __pend)
3195 return _M_incremented;
3198 if (*__cur != *__pcur)
3200 if (++__pcur == __pend)
3202 }
while (++__cur != __end);
3208 _M_i_current() noexcept
3209 {
return _M_i.__current(); }
3212 _M_i_current() const noexcept
3213 {
return _M_i.__current(); }
3215 _OuterIter<_Const> _M_i = _OuterIter<_Const>();
3216 bool _M_incremented =
false;
3219 using iterator_concept
3220 =
typename _OuterIter<_Const>::iterator_concept;
3222 using value_type = range_value_t<_Base>;
3223 using difference_type = range_difference_t<_Base>;
3225 _InnerIter() =
default;
3228 _InnerIter(_OuterIter<_Const> __i)
3232 constexpr
const iterator_t<_Base>&
3233 base() const& noexcept
3234 {
return _M_i_current(); }
3236 constexpr iterator_t<_Base>
3237 base() && requires forward_range<_Vp>
3240 constexpr decltype(
auto)
3242 {
return *_M_i_current(); }
3244 constexpr _InnerIter&
3247 _M_incremented =
true;
3248 if constexpr (!forward_range<_Base>)
3249 if constexpr (_Pattern::size() == 0)
3255 constexpr decltype(auto)
3258 if constexpr (forward_range<_Base>)
3268 friend constexpr
bool
3269 operator==(
const _InnerIter& __x,
const _InnerIter& __y)
3270 requires forward_range<_Base>
3271 {
return __x._M_i == __y._M_i; }
3273 friend constexpr
bool
3274 operator==(
const _InnerIter& __x, default_sentinel_t)
3275 {
return __x.__at_end(); }
3277 friend constexpr decltype(
auto)
3278 iter_move(const _InnerIter& __i)
3279 noexcept(noexcept(ranges::iter_move(__i._M_i_current())))
3280 {
return ranges::iter_move(__i._M_i_current()); }
3282 friend constexpr
void
3283 iter_swap(
const _InnerIter& __x,
const _InnerIter& __y)
3284 noexcept(noexcept(ranges::iter_swap(__x._M_i_current(),
3285 __y._M_i_current())))
3287 { ranges::iter_swap(__x._M_i_current(), __y._M_i_current()); }
3290 _Vp _M_base = _Vp();
3291 _Pattern _M_pattern = _Pattern();
3293 [[no_unique_address]]
3294 __detail::__maybe_present_t<!forward_range<_Vp>,
3295 __detail::__non_propagating_cache<iterator_t<_Vp>>> _M_current;
3304 lazy_split_view(_Vp
__base, _Pattern __pattern)
3308 template<input_range _Range>
3309 requires constructible_from<_Vp, views::all_t<_Range>>
3310 && constructible_from<_Pattern, single_view<range_value_t<_Range>>>
3312 lazy_split_view(_Range&& __r, range_value_t<_Range> __e)
3313 : _M_base(views::all(
std::
forward<_Range>(__r))),
3314 _M_pattern(views::single(
std::
move(__e)))
3328 if constexpr (forward_range<_Vp>)
3330 constexpr
bool __simple
3331 = __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
3332 return _OuterIter<__simple>{
this, ranges::begin(_M_base)};
3336 _M_current = ranges::begin(_M_base);
3337 return _OuterIter<false>{
this};
3342 begin() const requires forward_range<_Vp> && forward_range<const _Vp>
3344 return _OuterIter<true>{
this, ranges::begin(_M_base)};
3348 end() requires forward_range<_Vp> && common_range<_Vp>
3350 constexpr
bool __simple
3351 = __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
3352 return _OuterIter<__simple>{
this, ranges::end(_M_base)};
3358 if constexpr (forward_range<_Vp>
3359 && forward_range<const _Vp>
3360 && common_range<const _Vp>)
3361 return _OuterIter<true>{
this, ranges::end(_M_base)};
3363 return default_sentinel;
3367 template<
typename _Range,
typename _Pattern>
3368 lazy_split_view(_Range&&, _Pattern&&)
3369 -> lazy_split_view<views::all_t<_Range>, views::all_t<_Pattern>>;
3371 template<input_range _Range>
3372 lazy_split_view(_Range&&, range_value_t<_Range>)
3373 -> lazy_split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
3379 template<
typename _Range,
typename _Pattern>
3380 concept __can_lazy_split_view
3381 = requires { lazy_split_view(std::declval<_Range>(), std::declval<_Pattern>()); };
3384 struct _LazySplit : __adaptor::_RangeAdaptor<_LazySplit>
3386 template<viewable_range _Range,
typename _Pattern>
3387 requires __detail::__can_lazy_split_view<_Range, _Pattern>
3389 operator() [[nodiscard]] (_Range&& __r, _Pattern&& __f)
const
3391 return lazy_split_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
3394 using _RangeAdaptor<_LazySplit>::operator();
3395 static constexpr
int _S_arity = 2;
3400 template<
typename _Pattern>
3401 static constexpr
bool _S_has_simple_extra_args
3402 = is_scalar_v<_Pattern> || (view<_Pattern>
3403 && copy_constructible<_Pattern>);
3406 inline constexpr _LazySplit lazy_split;
3409 template<forward_range _Vp, forward_range _Pattern>
3410 requires view<_Vp> && view<_Pattern>
3411 && indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
3413 class split_view :
public view_interface<split_view<_Vp, _Pattern>>
3416 _Vp _M_base = _Vp();
3417 _Pattern _M_pattern = _Pattern();
3418 __detail::__non_propagating_cache<subrange<iterator_t<_Vp>>> _M_cached_begin;
3429 split_view(_Vp
__base, _Pattern __pattern)
3433 template<forward_range _Range>
3434 requires constructible_from<_Vp, views::all_t<_Range>>
3435 && constructible_from<_Pattern, single_view<range_value_t<_Range>>>
3437 split_view(_Range&& __r, range_value_t<_Range> __e)
3438 : _M_base(views::all(
std::
forward<_Range>(__r))),
3439 _M_pattern(views::single(
std::
move(__e)))
3453 if (!_M_cached_begin)
3454 _M_cached_begin = _M_find_next(ranges::begin(_M_base));
3455 return {
this, ranges::begin(_M_base), *_M_cached_begin};
3461 if constexpr (common_range<_Vp>)
3462 return _Iterator{
this, ranges::end(_M_base), {}};
3464 return _Sentinel{
this};
3467 constexpr subrange<iterator_t<_Vp>>
3468 _M_find_next(iterator_t<_Vp> __it)
3470 auto [__b, __e] = ranges::search(
subrange(__it, ranges::end(_M_base)), _M_pattern);
3471 if (__b != ranges::end(_M_base) && ranges::empty(_M_pattern))
3483 split_view* _M_parent =
nullptr;
3484 iterator_t<_Vp> _M_cur = iterator_t<_Vp>();
3485 subrange<iterator_t<_Vp>> _M_next = subrange<iterator_t<_Vp>>();
3486 bool _M_trailing_empty =
false;
3488 friend struct _Sentinel;
3491 using iterator_concept = forward_iterator_tag;
3492 using iterator_category = input_iterator_tag;
3493 using value_type = subrange<iterator_t<_Vp>>;
3494 using difference_type = range_difference_t<_Vp>;
3496 _Iterator() =
default;
3499 _Iterator(split_view* __parent,
3500 iterator_t<_Vp> __current,
3501 subrange<iterator_t<_Vp>> __next)
3502 : _M_parent(__parent),
3507 constexpr iterator_t<_Vp>
3511 constexpr value_type
3513 {
return {_M_cur, _M_next.begin()}; }
3515 constexpr _Iterator&
3518 _M_cur = _M_next.begin();
3519 if (_M_cur != ranges::end(_M_parent->_M_base))
3521 _M_cur = _M_next.end();
3522 if (_M_cur == ranges::end(_M_parent->_M_base))
3524 _M_trailing_empty =
true;
3525 _M_next = {_M_cur, _M_cur};
3528 _M_next = _M_parent->_M_find_next(_M_cur);
3531 _M_trailing_empty =
false;
3543 friend constexpr
bool
3544 operator==(
const _Iterator& __x,
const _Iterator& __y)
3546 return __x._M_cur == __y._M_cur
3547 && __x._M_trailing_empty == __y._M_trailing_empty;
3554 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
3557 _M_equal(
const _Iterator& __x)
const
3558 {
return __x._M_cur == _M_end && !__x._M_trailing_empty; }
3561 _Sentinel() =
default;
3564 _Sentinel(split_view* __parent)
3565 : _M_end(ranges::
end(__parent->_M_base))
3568 friend constexpr
bool
3569 operator==(
const _Iterator& __x,
const _Sentinel& __y)
3570 {
return __y._M_equal(__x); }
3574 template<
typename _Range,
typename _Pattern>
3575 split_view(_Range&&, _Pattern&&)
3576 -> split_view<views::all_t<_Range>, views::all_t<_Pattern>>;
3578 template<forward_range _Range>
3579 split_view(_Range&&, range_value_t<_Range>)
3580 -> split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
3586 template<
typename _Range,
typename _Pattern>
3587 concept __can_split_view
3588 = requires { split_view(std::declval<_Range>(), std::declval<_Pattern>()); };
3591 struct _Split : __adaptor::_RangeAdaptor<_Split>
3593 template<viewable_range _Range,
typename _Pattern>
3594 requires __detail::__can_split_view<_Range, _Pattern>
3596 operator() [[nodiscard]] (_Range&& __r, _Pattern&& __f)
const
3598 return split_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
3601 using _RangeAdaptor<_Split>::operator();
3602 static constexpr
int _S_arity = 2;
3603 template<
typename _Pattern>
3604 static constexpr
bool _S_has_simple_extra_args
3605 = _LazySplit::_S_has_simple_extra_args<_Pattern>;
3608 inline constexpr _Split split;
3615 template<input_or_output_iterator _Iter>
3617 operator() [[nodiscard]] (_Iter __i, iter_difference_t<_Iter> __n)
const
3619 if constexpr (contiguous_iterator<_Iter>)
3620 return span(std::__to_address(__i), __n);
3621 else if constexpr (random_access_iterator<_Iter>)
3629 inline constexpr _Counted counted{};
3633 requires (!common_range<_Vp>) && copyable<iterator_t<_Vp>>
3634 class common_view :
public view_interface<common_view<_Vp>>
3637 _Vp _M_base = _Vp();
3643 common_view(_Vp __r)
3668 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3669 return ranges::begin(_M_base);
3671 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
3672 (ranges::begin(_M_base));
3676 begin() const requires range<const _Vp>
3678 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
3679 return ranges::begin(_M_base);
3681 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
3682 (ranges::begin(_M_base));
3688 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3689 return ranges::begin(_M_base) + ranges::size(_M_base);
3691 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
3692 (ranges::end(_M_base));
3696 end() const requires range<const _Vp>
3698 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
3699 return ranges::begin(_M_base) + ranges::size(_M_base);
3701 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
3702 (ranges::end(_M_base));
3706 size() requires sized_range<_Vp>
3707 {
return ranges::size(_M_base); }
3710 size() const requires sized_range<const _Vp>
3711 {
return ranges::size(_M_base); }
3714 template<
typename _Range>
3715 common_view(_Range&&) -> common_view<views::all_t<_Range>>;
3717 template<
typename _Tp>
3718 inline constexpr
bool enable_borrowed_range<common_view<_Tp>>
3719 = enable_borrowed_range<_Tp>;
3725 template<
typename _Range>
3726 concept __already_common = common_range<_Range>
3727 && requires { views::all(std::declval<_Range>()); };
3729 template<
typename _Range>
3730 concept __can_common_view
3731 = requires { common_view{std::declval<_Range>()}; };
3734 struct _Common : __adaptor::_RangeAdaptorClosure
3736 template<viewable_range _Range>
3737 requires __detail::__already_common<_Range>
3738 || __detail::__can_common_view<_Range>
3740 operator() [[nodiscard]] (_Range&& __r)
const
3742 if constexpr (__detail::__already_common<_Range>)
3743 return views::all(std::forward<_Range>(__r));
3745 return common_view{std::forward<_Range>(__r)};
3748 static constexpr
bool _S_has_simple_call_op =
true;
3751 inline constexpr _Common common;
3755 requires bidirectional_range<_Vp>
3756 class reverse_view :
public view_interface<reverse_view<_Vp>>
3759 static constexpr
bool _S_needs_cached_begin
3760 = !common_range<_Vp> && !(random_access_range<_Vp>
3761 && sized_sentinel_for<sentinel_t<_Vp>,
3764 _Vp _M_base = _Vp();
3765 [[no_unique_address]]
3766 __detail::__maybe_present_t<_S_needs_cached_begin,
3767 __detail::_CachedPosition<_Vp>>
3774 reverse_view(_Vp __r)
3786 constexpr reverse_iterator<iterator_t<_Vp>>
3789 if constexpr (_S_needs_cached_begin)
3790 if (_M_cached_begin._M_has_value())
3793 auto __it = ranges::next(ranges::begin(_M_base), ranges::end(_M_base));
3794 if constexpr (_S_needs_cached_begin)
3795 _M_cached_begin._M_set(_M_base, __it);
3800 begin() requires common_range<_Vp>
3804 begin() const requires common_range<const _Vp>
3807 constexpr reverse_iterator<iterator_t<_Vp>>
3812 end() const requires common_range<const _Vp>
3816 size() requires sized_range<_Vp>
3817 {
return ranges::size(_M_base); }
3820 size() const requires sized_range<const _Vp>
3821 {
return ranges::size(_M_base); }
3824 template<
typename _Range>
3825 reverse_view(_Range&&) -> reverse_view<views::all_t<_Range>>;
3827 template<
typename _Tp>
3828 inline constexpr
bool enable_borrowed_range<reverse_view<_Tp>>
3829 = enable_borrowed_range<_Tp>;
3836 inline constexpr
bool __is_reversible_subrange =
false;
3838 template<
typename _Iter, subrange_kind _Kind>
3839 inline constexpr
bool
3840 __is_reversible_subrange<subrange<reverse_iterator<_Iter>,
3841 reverse_iterator<_Iter>,
3845 inline constexpr
bool __is_reverse_view =
false;
3847 template<
typename _Vp>
3848 inline constexpr
bool __is_reverse_view<reverse_view<_Vp>> =
true;
3850 template<
typename _Range>
3851 concept __can_reverse_view
3852 = requires { reverse_view{std::declval<_Range>()}; };
3855 struct _Reverse : __adaptor::_RangeAdaptorClosure
3857 template<viewable_range _Range>
3858 requires __detail::__is_reverse_view<remove_cvref_t<_Range>>
3859 || __detail::__is_reversible_subrange<remove_cvref_t<_Range>>
3860 || __detail::__can_reverse_view<_Range>
3862 operator() [[nodiscard]] (_Range&& __r)
const
3864 using _Tp = remove_cvref_t<_Range>;
3865 if constexpr (__detail::__is_reverse_view<_Tp>)
3866 return std::forward<_Range>(__r).base();
3867 else if constexpr (__detail::__is_reversible_subrange<_Tp>)
3869 using _Iter = decltype(ranges::begin(__r).base());
3870 if constexpr (sized_range<_Tp>)
3871 return subrange<_Iter, _Iter, subrange_kind::sized>
3872 {__r.end().base(), __r.begin().base(), __r.size()};
3874 return subrange<_Iter, _Iter, subrange_kind::unsized>
3875 {__r.end().base(), __r.begin().base()};
3878 return reverse_view{std::forward<_Range>(__r)};
3881 static constexpr
bool _S_has_simple_call_op =
true;
3884 inline constexpr _Reverse reverse;
3889 template<
typename _Tp,
size_t _Nm>
3890 concept __has_tuple_element = requires(_Tp __t)
3892 typename tuple_size<_Tp>::type;
3893 requires _Nm < tuple_size_v<_Tp>;
3894 typename tuple_element_t<_Nm, _Tp>;
3895 { std::get<_Nm>(__t) }
3896 -> convertible_to<const tuple_element_t<_Nm, _Tp>&>;
3899 template<
typename _Tp,
size_t _Nm>
3900 concept __returnable_element
3901 = is_reference_v<_Tp> || move_constructible<tuple_element_t<_Nm, _Tp>>;
3904 template<input_range _Vp,
size_t _Nm>
3906 && __detail::__has_tuple_element<range_value_t<_Vp>, _Nm>
3907 && __detail::__has_tuple_element<remove_reference_t<range_reference_t<_Vp>>,
3909 && __detail::__returnable_element<range_reference_t<_Vp>, _Nm>
3910 class elements_view :
public view_interface<elements_view<_Vp, _Nm>>
3916 elements_view(_Vp base)
3929 begin() requires (!__detail::__simple_view<_Vp>)
3930 {
return _Iterator<false>(ranges::begin(_M_base)); }
3933 begin() const requires range<const _Vp>
3934 {
return _Iterator<true>(ranges::begin(_M_base)); }
3937 end() requires (!__detail::__simple_view<_Vp> && !common_range<_Vp>)
3938 {
return _Sentinel<false>{ranges::end(_M_base)}; }
3941 end() requires (!__detail::__simple_view<_Vp> && common_range<_Vp>)
3942 {
return _Iterator<false>{ranges::end(_M_base)}; }
3945 end() const requires range<const _Vp>
3946 {
return _Sentinel<true>{ranges::end(_M_base)}; }
3949 end() const requires common_range<const _Vp>
3950 {
return _Iterator<true>{ranges::end(_M_base)}; }
3953 size() requires sized_range<_Vp>
3954 {
return ranges::size(_M_base); }
3957 size() const requires sized_range<const _Vp>
3958 {
return ranges::size(_M_base); }
3961 template<
bool _Const>
3962 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
3964 template<
bool _Const>
3968 template<
bool _Const>
3969 requires forward_range<_Base<_Const>>
3970 struct __iter_cat<_Const>
3973 static auto _S_iter_cat()
3975 using _Base = elements_view::_Base<_Const>;
3976 using _Cat =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
3977 using _Res = decltype((std::get<_Nm>(*
std::declval<iterator_t<_Base>>())));
3978 if constexpr (!is_lvalue_reference_v<_Res>)
3979 return input_iterator_tag{};
3980 else if constexpr (derived_from<_Cat, random_access_iterator_tag>)
3981 return random_access_iterator_tag{};
3986 using iterator_category = decltype(_S_iter_cat());
3989 template<
bool _Const>
3992 template<
bool _Const>
3993 struct _Iterator : __iter_cat<_Const>
3996 using _Base = elements_view::_Base<_Const>;
3998 iterator_t<_Base> _M_current = iterator_t<_Base>();
4000 static constexpr decltype(
auto)
4001 _S_get_element(const iterator_t<_Base>& __i)
4003 if constexpr (is_reference_v<range_reference_t<_Base>>)
4004 return
std::get<_Nm>(*__i);
4007 using _Et = remove_cv_t<tuple_element_t<_Nm, range_reference_t<_Base>>>;
4008 return static_cast<_Et
>(std::get<_Nm>(*__i));
4015 if constexpr (random_access_range<_Base>)
4016 return random_access_iterator_tag{};
4017 else if constexpr (bidirectional_range<_Base>)
4018 return bidirectional_iterator_tag{};
4019 else if constexpr (forward_range<_Base>)
4020 return forward_iterator_tag{};
4022 return input_iterator_tag{};
4025 friend _Iterator<!_Const>;
4028 using iterator_concept = decltype(_S_iter_concept());
4031 = remove_cvref_t<tuple_element_t<_Nm, range_value_t<_Base>>>;
4032 using difference_type = range_difference_t<_Base>;
4037 _Iterator(iterator_t<_Base> current)
4038 : _M_current(
std::
move(current))
4042 _Iterator(_Iterator<!_Const> i)
4043 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
4047 constexpr
const iterator_t<_Base>&
4048 base() const& noexcept
4049 {
return _M_current; }
4051 constexpr iterator_t<_Base>
4055 constexpr decltype(
auto)
4057 {
return _S_get_element(_M_current); }
4059 constexpr _Iterator&
4071 operator++(
int) requires forward_range<_Base>
4078 constexpr _Iterator&
4079 operator--() requires bidirectional_range<_Base>
4086 operator--(
int) requires bidirectional_range<_Base>
4093 constexpr _Iterator&
4094 operator+=(difference_type __n)
4095 requires random_access_range<_Base>
4101 constexpr _Iterator&
4102 operator-=(difference_type __n)
4103 requires random_access_range<_Base>
4109 constexpr decltype(
auto)
4110 operator[](difference_type __n) const
4111 requires random_access_range<_Base>
4112 {
return _S_get_element(_M_current + __n); }
4114 friend constexpr
bool
4115 operator==(
const _Iterator& __x,
const _Iterator& __y)
4116 requires equality_comparable<iterator_t<_Base>>
4117 {
return __x._M_current == __y._M_current; }
4119 friend constexpr
bool
4120 operator<(
const _Iterator& __x,
const _Iterator& __y)
4121 requires random_access_range<_Base>
4122 {
return __x._M_current < __y._M_current; }
4124 friend constexpr
bool
4125 operator>(
const _Iterator& __x,
const _Iterator& __y)
4126 requires random_access_range<_Base>
4127 {
return __y._M_current < __x._M_current; }
4129 friend constexpr
bool
4130 operator<=(
const _Iterator& __x,
const _Iterator& __y)
4131 requires random_access_range<_Base>
4132 {
return !(__y._M_current > __x._M_current); }
4134 friend constexpr
bool
4135 operator>=(
const _Iterator& __x,
const _Iterator& __y)
4136 requires random_access_range<_Base>
4137 {
return !(__x._M_current > __y._M_current); }
4139 #ifdef __cpp_lib_three_way_comparison
4140 friend constexpr
auto
4141 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
4142 requires random_access_range<_Base>
4143 && three_way_comparable<iterator_t<_Base>>
4144 {
return __x._M_current <=> __y._M_current; }
4147 friend constexpr _Iterator
4148 operator+(
const _Iterator& __x, difference_type __y)
4149 requires random_access_range<_Base>
4150 {
return _Iterator{__x} += __y; }
4152 friend constexpr _Iterator
4153 operator+(difference_type __x,
const _Iterator& __y)
4154 requires random_access_range<_Base>
4155 {
return __y + __x; }
4157 friend constexpr _Iterator
4158 operator-(
const _Iterator& __x, difference_type __y)
4159 requires random_access_range<_Base>
4160 {
return _Iterator{__x} -= __y; }
4164 friend constexpr difference_type
4165 operator-(
const _Iterator& __x,
const _Iterator& __y)
4166 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
4167 {
return __x._M_current - __y._M_current; }
4169 template <
bool>
friend struct _Sentinel;
4172 template<
bool _Const>
4176 template<
bool _Const2>
4178 _M_equal(
const _Iterator<_Const2>& __x)
const
4179 {
return __x._M_current == _M_end; }
4181 template<
bool _Const2>
4183 _M_distance_from(
const _Iterator<_Const2>& __i)
const
4184 {
return _M_end - __i._M_current; }
4186 using _Base = elements_view::_Base<_Const>;
4187 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
4190 _Sentinel() =
default;
4193 _Sentinel(sentinel_t<_Base> __end)
4198 _Sentinel(_Sentinel<!_Const> __other)
4200 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
4204 constexpr sentinel_t<_Base>
4208 template<
bool _Const2>
4209 requires sentinel_for<sentinel_t<_Base>,
4210 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
4211 friend constexpr
bool
4212 operator==(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
4213 {
return __y._M_equal(__x); }
4215 template<
bool _Const2,
4216 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
4217 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
4218 friend constexpr range_difference_t<_Base2>
4219 operator-(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
4220 {
return -__y._M_distance_from(__x); }
4222 template<
bool _Const2,
4223 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
4224 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
4225 friend constexpr range_difference_t<_Base2>
4226 operator-(
const _Sentinel& __x,
const _Iterator<_Const2>& __y)
4227 {
return __x._M_distance_from(__y); }
4229 friend _Sentinel<!_Const>;
4232 _Vp _M_base = _Vp();
4235 template<
typename _Tp,
size_t _Nm>
4236 inline constexpr
bool enable_borrowed_range<elements_view<_Tp, _Nm>>
4237 = enable_borrowed_range<_Tp>;
4239 template<
typename _Range>
4240 using keys_view = elements_view<views::all_t<_Range>, 0>;
4242 template<
typename _Range>
4243 using values_view = elements_view<views::all_t<_Range>, 1>;
4249 template<
size_t _Nm,
typename _Range>
4250 concept __can_elements_view
4251 = requires { elements_view<all_t<_Range>, _Nm>{std::declval<_Range>()}; };
4254 template<
size_t _Nm>
4255 struct _Elements : __adaptor::_RangeAdaptorClosure
4257 template<viewable_range _Range>
4258 requires __detail::__can_elements_view<_Nm, _Range>
4260 operator() [[nodiscard]] (_Range&& __r)
const
4262 return elements_view<all_t<_Range>, _Nm>{std::forward<_Range>(__r)};
4265 static constexpr
bool _S_has_simple_call_op =
true;
4268 template<
size_t _Nm>
4269 inline constexpr _Elements<_Nm> elements;
4270 inline constexpr
auto keys = elements<0>;
4271 inline constexpr
auto values = elements<1>;
4276 namespace views = ranges::views;
4278 _GLIBCXX_END_NAMESPACE_VERSION
concept input_range
A range for which ranges::begin returns an input iterator.
requires(_Kind==subrange_kind::sized||!sized_sentinel_for< _Sent, _It >) class subrange subrange(_It, _Sent) -> subrange< _It, _Sent >
The ranges::subrange class template.
constexpr complex< _Tp > operator*(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x times y.
constexpr complex< _Tp > operator-(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x minus y.
constexpr complex< _Tp > operator+(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x plus y.
basic_istream< char > istream
Base class for char input streams.
typename make_unsigned< _Tp >::type make_unsigned_t
Alias template for make_unsigned.
typename decay< _Tp >::type decay_t
Alias template for decay.
typename invoke_result< _Fn, _Args... >::type invoke_result_t
std::invoke_result_t
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
auto declval() noexcept -> decltype(__declval< _Tp >(0))
constexpr __invoke_result< _Callable, _Args... >::type __invoke(_Callable &&__fn, _Args &&... __args) noexcept(__is_nothrow_invocable< _Callable, _Args... >::value)
Invoke a callable object.
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
constexpr _Tp && forward(typename std::remove_reference< _Tp >::type &__t) noexcept
Forward an lvalue.
_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 const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
constexpr reverse_iterator< _Iterator > make_reverse_iterator(_Iterator __i)
Generator function for reverse_iterator.
constexpr void iota(_ForwardIterator __first, _ForwardIterator __last, _Tp __value)
Create a range of sequentially increasing values.
ISO C++ entities toplevel namespace is std.
concept weakly_incrementable
Requirements on types that can be incremented with ++.
concept same_as
[concept.same], concept same_as
bitset< _Nb > operator|(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
concept copy_constructible
[concept.copyconstructible], concept copy_constructible
constexpr auto empty(const _Container &__cont) noexcept(noexcept(__cont.empty())) -> decltype(__cont.empty())
Return whether a container is empty.
constexpr auto size(const _Container &__cont) noexcept(noexcept(__cont.size())) -> decltype(__cont.size())
Return the size of a container.
concept indirectly_swappable
[alg.req.ind.swap], concept indirectly_swappable
constexpr auto data(_Container &__cont) noexcept(noexcept(__cont.data())) -> decltype(__cont.data())
Return the data pointer of a container.
concept default_initializable
[concept.defaultinitializable], concept default_initializable
concept regular_invocable
[concept.regularinvocable], concept regular_invocable
concept constructible_from
[concept.constructible], concept constructible_from
constexpr _Iterator __base(_Iterator __it)
Class template for optional values.
A view that contains no elements.
A view that contains exactly one element.
The ranges::view_interface class template.