30#ifndef _GLIBCXX_RANGES
31#define _GLIBCXX_RANGES 1
33#if __cplusplus > 201703L
35#pragma GCC system_header
48#if __cplusplus > 202002L
54#define __glibcxx_want_ranges
55#define __glibcxx_want_ranges_as_const
56#define __glibcxx_want_ranges_as_rvalue
57#define __glibcxx_want_ranges_cartesian_product
58#define __glibcxx_want_ranges_chunk
59#define __glibcxx_want_ranges_chunk_by
60#define __glibcxx_want_ranges_enumerate
61#define __glibcxx_want_ranges_iota
62#define __glibcxx_want_ranges_join_with
63#define __glibcxx_want_ranges_repeat
64#define __glibcxx_want_ranges_slide
65#define __glibcxx_want_ranges_stride
66#define __glibcxx_want_ranges_to_container
67#define __glibcxx_want_ranges_zip
70#ifdef __glibcxx_generator
71# include <bits/elements_of.h>
80namespace std _GLIBCXX_VISIBILITY(default)
82_GLIBCXX_BEGIN_NAMESPACE_VERSION
97 template<
typename _Tp>
requires is_object_v<_Tp>
99 :
public view_interface<empty_view<_Tp>>
102 static constexpr _Tp*
begin() noexcept {
return nullptr; }
103 static constexpr _Tp*
end() noexcept {
return nullptr; }
104 static constexpr _Tp*
data() noexcept {
return nullptr; }
105 static constexpr size_t size() noexcept {
return 0; }
106 static constexpr bool empty() noexcept {
return true; }
109 template<
typename _Tp>
110 inline constexpr bool enable_borrowed_range<empty_view<_Tp>> =
true;
114#if __cpp_lib_ranges >= 202207L
116 template<
typename _Tp>
117 concept __boxable = move_constructible<_Tp> && is_object_v<_Tp>;
119 template<
typename _Tp>
120 concept __boxable = copy_constructible<_Tp> && is_object_v<_Tp>;
123 template<__boxable _Tp>
124 struct __box : std::optional<_Tp>
126 using std::optional<_Tp>::optional;
130 noexcept(is_nothrow_default_constructible_v<_Tp>)
131 requires default_initializable<_Tp>
132 :
std::optional<_Tp>{std::in_place}
135 __box(
const __box&) =
default;
136 __box(__box&&) =
default;
138 using std::optional<_Tp>::operator=;
144 operator=(
const __box& __that)
145 noexcept(is_nothrow_copy_constructible_v<_Tp>)
146 requires (!copyable<_Tp>) && copy_constructible<_Tp>
151 this->emplace(*__that);
159 operator=(__box&& __that)
160 noexcept(is_nothrow_move_constructible_v<_Tp>)
161 requires (!movable<_Tp>)
174 template<
typename _Tp>
175 concept __boxable_copyable
176 = copy_constructible<_Tp>
177 && (copyable<_Tp> || (is_nothrow_move_constructible_v<_Tp>
178 && is_nothrow_copy_constructible_v<_Tp>));
179 template<
typename _Tp>
180 concept __boxable_movable
181 = (!copy_constructible<_Tp>)
182 && (movable<_Tp> || is_nothrow_move_constructible_v<_Tp>);
188 template<__boxable _Tp>
189 requires __boxable_copyable<_Tp> || __boxable_movable<_Tp>
193 [[no_unique_address]] _Tp _M_value = _Tp();
196 __box()
requires default_initializable<_Tp> = default;
199 __box(const _Tp& __t)
200 noexcept(is_nothrow_copy_constructible_v<_Tp>)
201 requires copy_constructible<_Tp>
207 noexcept(is_nothrow_move_constructible_v<_Tp>)
211 template<
typename... _Args>
212 requires constructible_from<_Tp, _Args...>
214 __box(in_place_t, _Args&&... __args)
215 noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
219 __box(
const __box&) =
default;
220 __box(__box&&) =
default;
221 __box& operator=(
const __box&)
requires copyable<_Tp> =
default;
222 __box& operator=(__box&&)
requires movable<_Tp> = default;
227 operator=(const __box& __that) noexcept
228 requires (!copyable<_Tp>) && copy_constructible<_Tp>
230 static_assert(is_nothrow_copy_constructible_v<_Tp>);
241 operator=(__box&& __that)
noexcept
242 requires (!movable<_Tp>)
244 static_assert(is_nothrow_move_constructible_v<_Tp>);
254 has_value() const noexcept
269 constexpr const _Tp&&
274 operator->() noexcept
278 operator->() const noexcept
284#if __cpp_lib_ranges >= 202207L
285 template<move_constructible _Tp>
287 template<copy_constructible _Tp>
289 requires is_object_v<_Tp>
290 class single_view :
public view_interface<single_view<_Tp>>
293 single_view()
requires default_initializable<_Tp> = default;
296 single_view(const _Tp& __t)
297 noexcept(is_nothrow_copy_constructible_v<_Tp>)
298 requires copy_constructible<_Tp>
303 single_view(_Tp&& __t)
304 noexcept(is_nothrow_move_constructible_v<_Tp>)
310 template<
typename... _Args>
311 requires constructible_from<_Tp, _Args...>
313 single_view(in_place_t, _Args&&... __args)
314 noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
315 : _M_value{in_place,
std::
forward<_Args>(__args)...}
323 begin() const noexcept
328 {
return data() + 1; }
332 {
return data() + 1; }
334 static constexpr size_t
340 {
return _M_value.operator->(); }
343 data() const noexcept
344 {
return _M_value.operator->(); }
347 [[no_unique_address]] __detail::__box<_Tp> _M_value;
350 template<
typename _Tp>
351 single_view(_Tp) -> single_view<_Tp>;
355 template<
typename _Wp>
356 constexpr auto __to_signed_like(_Wp __w)
noexcept
358 if constexpr (!integral<_Wp>)
359 return iter_difference_t<_Wp>();
360 else if constexpr (
sizeof(iter_difference_t<_Wp>) >
sizeof(_Wp))
361 return iter_difference_t<_Wp>(__w);
362 else if constexpr (
sizeof(ptrdiff_t) >
sizeof(_Wp))
363 return ptrdiff_t(__w);
364 else if constexpr (
sizeof(
long long) >
sizeof(_Wp))
365 return (
long long)(__w);
366#ifdef __SIZEOF_INT128__
367 else if constexpr (__SIZEOF_INT128__ >
sizeof(_Wp))
368 return __int128(__w);
371 return __max_diff_type(__w);
374 template<
typename _Wp>
375 using __iota_diff_t =
decltype(__to_signed_like(std::declval<_Wp>()));
377 template<
typename _It>
378 concept __decrementable = incrementable<_It>
381 { --__i } -> same_as<_It&>;
382 { __i-- } -> same_as<_It>;
385 template<
typename _It>
386 concept __advanceable = __decrementable<_It> && totally_ordered<_It>
387 &&
requires( _It __i,
const _It __j,
const __iota_diff_t<_It> __n)
389 { __i += __n } -> same_as<_It&>;
390 { __i -= __n } -> same_as<_It&>;
394 { __j - __j } -> convertible_to<__iota_diff_t<_It>>;
397 template<
typename _Winc>
398 struct __iota_view_iter_cat
401 template<incrementable _Winc>
402 struct __iota_view_iter_cat<_Winc>
403 {
using iterator_category = input_iterator_tag; };
406 template<weakly_incrementable _Winc,
407 semiregular _Bound = unreachable_sentinel_t>
408 requires std::__detail::__weakly_eq_cmp_with<_Winc, _Bound>
410 class iota_view :
public view_interface<iota_view<_Winc, _Bound>>
415 struct _Iterator : __detail::__iota_view_iter_cat<_Winc>
421 using namespace __detail;
422 if constexpr (__advanceable<_Winc>)
423 return random_access_iterator_tag{};
424 else if constexpr (__decrementable<_Winc>)
425 return bidirectional_iterator_tag{};
426 else if constexpr (incrementable<_Winc>)
427 return forward_iterator_tag{};
429 return input_iterator_tag{};
433 using iterator_concept =
decltype(_S_iter_concept());
435 using value_type = _Winc;
436 using difference_type = __detail::__iota_diff_t<_Winc>;
438 _Iterator()
requires default_initializable<_Winc> = default;
441 _Iterator(_Winc __value)
442 : _M_value(__value) { }
445 operator*() const noexcept(is_nothrow_copy_constructible_v<_Winc>)
460 operator++(
int)
requires incrementable<_Winc>
468 operator--()
requires __detail::__decrementable<_Winc>
475 operator--(
int)
requires __detail::__decrementable<_Winc>
483 operator+=(difference_type __n)
requires __detail::__advanceable<_Winc>
485 using __detail::__is_integer_like;
486 using __detail::__is_signed_integer_like;
487 if constexpr (__is_integer_like<_Winc>
488 && !__is_signed_integer_like<_Winc>)
490 if (__n >= difference_type(0))
491 _M_value +=
static_cast<_Winc
>(__n);
493 _M_value -=
static_cast<_Winc
>(-__n);
501 operator-=(difference_type __n)
requires __detail::__advanceable<_Winc>
503 using __detail::__is_integer_like;
504 using __detail::__is_signed_integer_like;
505 if constexpr (__is_integer_like<_Winc>
506 && !__is_signed_integer_like<_Winc>)
508 if (__n >= difference_type(0))
509 _M_value -=
static_cast<_Winc
>(__n);
511 _M_value +=
static_cast<_Winc
>(-__n);
519 operator[](difference_type __n)
const
520 requires __detail::__advanceable<_Winc>
521 {
return _Winc(_M_value + __n); }
523 friend constexpr bool
524 operator==(
const _Iterator& __x,
const _Iterator& __y)
525 requires equality_comparable<_Winc>
526 {
return __x._M_value == __y._M_value; }
528 friend constexpr bool
529 operator<(
const _Iterator& __x,
const _Iterator& __y)
530 requires totally_ordered<_Winc>
531 {
return __x._M_value < __y._M_value; }
533 friend constexpr bool
534 operator>(
const _Iterator& __x,
const _Iterator& __y)
535 requires totally_ordered<_Winc>
536 {
return __y < __x; }
538 friend constexpr bool
539 operator<=(
const _Iterator& __x,
const _Iterator& __y)
540 requires totally_ordered<_Winc>
541 {
return !(__y < __x); }
543 friend constexpr bool
544 operator>=(
const _Iterator& __x,
const _Iterator& __y)
545 requires totally_ordered<_Winc>
546 {
return !(__x < __y); }
548#ifdef __cpp_lib_three_way_comparison
549 friend constexpr auto
550 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
551 requires totally_ordered<_Winc> && three_way_comparable<_Winc>
552 {
return __x._M_value <=> __y._M_value; }
555 friend constexpr _Iterator
556 operator+(_Iterator __i, difference_type __n)
557 requires __detail::__advanceable<_Winc>
563 friend constexpr _Iterator
564 operator+(difference_type __n, _Iterator __i)
565 requires __detail::__advanceable<_Winc>
566 {
return __i += __n; }
568 friend constexpr _Iterator
569 operator-(_Iterator __i, difference_type __n)
570 requires __detail::__advanceable<_Winc>
576 friend constexpr difference_type
577 operator-(
const _Iterator& __x,
const _Iterator& __y)
578 requires __detail::__advanceable<_Winc>
580 using __detail::__is_integer_like;
581 using __detail::__is_signed_integer_like;
582 using _Dt = difference_type;
583 if constexpr (__is_integer_like<_Winc>)
585 if constexpr (__is_signed_integer_like<_Winc>)
586 return _Dt(_Dt(__x._M_value) - _Dt(__y._M_value));
588 return (__y._M_value > __x._M_value)
589 ? _Dt(-_Dt(__y._M_value - __x._M_value))
590 : _Dt(__x._M_value - __y._M_value);
593 return __x._M_value - __y._M_value;
597 _Winc _M_value = _Winc();
607 _M_equal(
const _Iterator& __x)
const
608 {
return __x._M_value == _M_bound; }
611 _M_distance_from(
const _Iterator& __x)
const
612 {
return _M_bound - __x._M_value; }
614 _Bound _M_bound = _Bound();
617 _Sentinel() =
default;
620 _Sentinel(_Bound __bound)
621 : _M_bound(__bound) { }
623 friend constexpr bool
624 operator==(
const _Iterator& __x,
const _Sentinel& __y)
625 {
return __y._M_equal(__x); }
627 friend constexpr iter_difference_t<_Winc>
628 operator-(
const _Iterator& __x,
const _Sentinel& __y)
629 requires sized_sentinel_for<_Bound, _Winc>
630 {
return -__y._M_distance_from(__x); }
632 friend constexpr iter_difference_t<_Winc>
633 operator-(
const _Sentinel& __x,
const _Iterator& __y)
634 requires sized_sentinel_for<_Bound, _Winc>
635 {
return __x._M_distance_from(__y); }
640 _Winc _M_value = _Winc();
641 [[no_unique_address]] _Bound _M_bound = _Bound();
644 iota_view()
requires default_initializable<_Winc> = default;
647 iota_view(_Winc __value)
652 iota_view(type_identity_t<_Winc> __value,
653 type_identity_t<_Bound> __bound)
654 : _M_value(__value), _M_bound(__bound)
656 if constexpr (totally_ordered_with<_Winc, _Bound>)
657 __glibcxx_assert(
bool(__value <= __bound) );
661 iota_view(_Iterator __first, _Iterator __last)
662 requires same_as<_Winc, _Bound>
663 : iota_view(__first._M_value, __last._M_value)
667 iota_view(_Iterator __first, unreachable_sentinel_t __last)
668 requires same_as<_Bound, unreachable_sentinel_t>
669 : iota_view(__first._M_value, __last)
673 iota_view(_Iterator __first, _Sentinel __last)
674 requires (!same_as<_Winc, _Bound>) && (!same_as<_Bound, unreachable_sentinel_t>)
675 : iota_view(__first._M_value, __last._M_bound)
679 begin()
const {
return _Iterator{_M_value}; }
684 if constexpr (same_as<_Bound, unreachable_sentinel_t>)
685 return unreachable_sentinel;
687 return _Sentinel{_M_bound};
691 end() const requires same_as<_Winc, _Bound>
692 {
return _Iterator{_M_bound}; }
696 requires (same_as<_Winc, _Bound> && __detail::__advanceable<_Winc>)
697 || (integral<_Winc> && integral<_Bound>)
698 || sized_sentinel_for<_Bound, _Winc>
700 using __detail::__is_integer_like;
701 using __detail::__to_unsigned_like;
702 if constexpr (integral<_Winc> && integral<_Bound>)
705 return _Up(_M_bound) - _Up(_M_value);
707 else if constexpr (__is_integer_like<_Winc>)
708 return __to_unsigned_like(_M_bound) - __to_unsigned_like(_M_value);
710 return __to_unsigned_like(_M_bound - _M_value);
714 template<
typename _Winc,
typename _Bound>
715 requires (!__detail::__is_integer_like<_Winc>
716 || !__detail::__is_integer_like<_Bound>
717 || (__detail::__is_signed_integer_like<_Winc>
718 == __detail::__is_signed_integer_like<_Bound>))
719 iota_view(_Winc, _Bound) -> iota_view<_Winc, _Bound>;
721 template<
typename _Winc,
typename _Bound>
722 inline constexpr bool
723 enable_borrowed_range<iota_view<_Winc, _Bound>> =
true;
727 template<
typename _Tp>
728 inline constexpr empty_view<_Tp>
empty{};
732 template<
typename _Tp>
733 concept __can_single_view
734 =
requires { single_view<decay_t<_Tp>>(std::declval<_Tp>()); };
739 template<__detail::__can_single_view _Tp>
741 operator() [[nodiscard]] (_Tp&& __e)
const
742 noexcept(
noexcept(single_view<decay_t<_Tp>>(std::forward<_Tp>(__e))))
743 {
return single_view<decay_t<_Tp>>(std::forward<_Tp>(__e)); }
746 inline constexpr _Single single{};
750 template<
typename... _Args>
751 concept __can_iota_view =
requires { iota_view(std::declval<_Args>()...); };
756 template<__detail::__can_iota_view _Tp>
758 operator() [[nodiscard]] (_Tp&& __e)
const
759 {
return iota_view(std::forward<_Tp>(__e)); }
761 template<
typename _Tp,
typename _Up>
762 requires __detail::__can_iota_view<_Tp, _Up>
764 operator() [[nodiscard]] (_Tp&& __e, _Up&& __f)
const
765 {
return iota_view(std::forward<_Tp>(__e), std::forward<_Up>(__f)); }
768 inline constexpr _Iota
iota{};
774 template<
typename _Val,
typename _CharT,
typename _Traits>
775 concept __stream_extractable
776 =
requires(basic_istream<_CharT, _Traits>& is, _Val& t) { is >> t; };
779 template<movable _Val,
typename _CharT,
780 typename _Traits = char_traits<_CharT>>
781 requires default_initializable<_Val>
782 && __detail::__stream_extractable<_Val, _CharT, _Traits>
783 class basic_istream_view
784 :
public view_interface<basic_istream_view<_Val, _CharT, _Traits>>
788 basic_istream_view(basic_istream<_CharT, _Traits>& __stream)
795 *_M_stream >> _M_object;
796 return _Iterator{
this};
799 constexpr default_sentinel_t
804 basic_istream<_CharT, _Traits>* _M_stream;
805 _Val _M_object = _Val();
810 using iterator_concept = input_iterator_tag;
811 using difference_type = ptrdiff_t;
812 using value_type = _Val;
815 _Iterator(basic_istream_view* __parent) noexcept
816 : _M_parent(__parent)
819 _Iterator(
const _Iterator&) =
delete;
820 _Iterator(_Iterator&&) =
default;
821 _Iterator& operator=(
const _Iterator&) =
delete;
822 _Iterator& operator=(_Iterator&&) =
default;
827 *_M_parent->_M_stream >> _M_parent->_M_object;
837 {
return _M_parent->_M_object; }
840 operator==(
const _Iterator& __x, default_sentinel_t)
841 {
return __x._M_at_end(); }
844 basic_istream_view* _M_parent;
848 {
return !*_M_parent->_M_stream; }
854 template<
typename _Val>
855 using istream_view = basic_istream_view<_Val, char>;
857 template<
typename _Val>
858 using wistream_view = basic_istream_view<_Val, wchar_t>;
864 template<
typename _Tp,
typename _Up>
865 concept __can_istream_view =
requires (_Up __e) {
866 basic_istream_view<_Tp, typename _Up::char_type, typename _Up::traits_type>(__e);
870 template<
typename _Tp>
873 template<
typename _CharT,
typename _Traits>
875 operator() [[nodiscard]] (basic_istream<_CharT, _Traits>& __e)
const
876 requires __detail::__can_istream_view<_Tp, remove_reference_t<
decltype(__e)>>
877 {
return basic_istream_view<_Tp, _CharT, _Traits>(__e); }
880 template<
typename _Tp>
881 inline constexpr _Istream<_Tp>
istream;
895 template<
bool _Present,
typename _Tp>
896 using __maybe_present_t = __conditional_t<_Present, _Tp, _Empty>;
899 template<
bool _Const,
typename _Tp>
900 using __maybe_const_t = __conditional_t<_Const, const _Tp, _Tp>;
905using __detail::__maybe_const_t;
907namespace views::__adaptor
910 template<
typename _Adaptor,
typename... _Args>
911 concept __adaptor_invocable
912 =
requires { std::declval<_Adaptor>()(declval<_Args>()...); };
916 template<
typename _Adaptor,
typename... _Args>
917 concept __adaptor_partial_app_viable = (_Adaptor::_S_arity > 1)
918 && (
sizeof...(_Args) == _Adaptor::_S_arity - 1)
919 && (constructible_from<decay_t<_Args>, _Args> && ...);
921 template<
typename _Adaptor,
typename... _Args>
924 template<
typename _Lhs,
typename _Rhs>
932 template<
typename _Derived>
933 struct _RangeAdaptorClosure
936 template<
typename _Tp,
typename _Up>
937 requires (!same_as<_Tp, _RangeAdaptorClosure<_Up>>)
938 void __is_range_adaptor_closure_fn
939 (
const _Tp&,
const _RangeAdaptorClosure<_Up>&);
941 template<
typename _Tp>
942 concept __is_range_adaptor_closure
943 =
requires (_Tp __t) { __adaptor::__is_range_adaptor_closure_fn(__t, __t); };
946 template<
typename _Self,
typename _Range>
947 requires __is_range_adaptor_closure<_Self>
948 && __adaptor_invocable<_Self, _Range>
951 {
return std::forward<_Self>(__self)(std::forward<_Range>(__r)); }
955 template<
typename _Lhs,
typename _Rhs>
956 requires __is_range_adaptor_closure<_Lhs>
957 && __is_range_adaptor_closure<_Rhs>
961 return _Pipe<decay_t<_Lhs>, decay_t<_Rhs>>{std::forward<_Lhs>(__lhs),
962 std::forward<_Rhs>(__rhs)};
976 template<
typename _Derived>
981 template<
typename... _Args>
982 requires __adaptor_partial_app_viable<_Derived, _Args...>
984 operator()(_Args&&... __args)
const
986 return _Partial<_Derived, decay_t<_Args>...>{0, std::forward<_Args>(__args)...};
993 template<
typename _Adaptor>
994 concept __closure_has_simple_call_op = _Adaptor::_S_has_simple_call_op;
998 template<
typename _Adaptor,
typename... _Args>
999 concept __adaptor_has_simple_extra_args = _Adaptor::_S_has_simple_extra_args
1000 || _Adaptor::template _S_has_simple_extra_args<_Args...>;
1004 template<
typename _Adaptor,
typename... _Args>
1005 struct _Partial : _RangeAdaptorClosure<_Partial<_Adaptor, _Args...>>
1007 tuple<_Args...> _M_args;
1011 template<
typename... _Ts>
1013 _Partial(
int, _Ts&&... __args)
1019#if __cpp_explicit_this_parameter
1020 template<
typename _Self,
typename _Range>
1021 requires __adaptor_invocable<_Adaptor, _Range, __like_t<_Self, _Args>...>
1023 operator()(
this _Self&& __self, _Range&& __r)
1025 auto __forwarder = [&__r] (
auto&&... __args) {
1026 return _Adaptor{}(std::forward<_Range>(__r),
1027 std::forward<decltype(__args)>(__args)...);
1029 return std::apply(__forwarder, std::forward<_Self>(__self)._M_args);
1032 template<
typename _Range>
1033 requires __adaptor_invocable<_Adaptor, _Range,
const _Args&...>
1035 operator()(_Range&& __r)
const &
1037 auto __forwarder = [&__r] (
const auto&... __args) {
1038 return _Adaptor{}(std::forward<_Range>(__r), __args...);
1040 return std::apply(__forwarder, _M_args);
1043 template<
typename _Range>
1044 requires __adaptor_invocable<_Adaptor, _Range, _Args...>
1046 operator()(_Range&& __r) &&
1048 auto __forwarder = [&__r] (
auto&... __args) {
1049 return _Adaptor{}(std::forward<_Range>(__r),
std::move(__args)...);
1051 return std::apply(__forwarder, _M_args);
1054 template<
typename _Range>
1056 operator()(_Range&& __r)
const && =
delete;
1062 template<
typename _Adaptor,
typename _Arg>
1063 struct _Partial<_Adaptor, _Arg> : _RangeAdaptorClosure<_Partial<_Adaptor, _Arg>>
1067 template<
typename _Tp>
1069 _Partial(
int, _Tp&& __arg)
1073#if __cpp_explicit_this_parameter
1074 template<
typename _Self,
typename _Range>
1075 requires __adaptor_invocable<_Adaptor, _Range, __like_t<_Self, _Arg>>
1077 operator()(
this _Self&& __self, _Range&& __r)
1078 {
return _Adaptor{}(std::forward<_Range>(__r), std::forward<_Self>(__self)._M_arg); }
1080 template<
typename _Range>
1081 requires __adaptor_invocable<_Adaptor, _Range, const _Arg&>
1083 operator()(_Range&& __r)
const &
1084 {
return _Adaptor{}(std::forward<_Range>(__r), _M_arg); }
1086 template<
typename _Range>
1087 requires __adaptor_invocable<_Adaptor, _Range, _Arg>
1089 operator()(_Range&& __r) &&
1090 {
return _Adaptor{}(std::forward<_Range>(__r),
std::move(_M_arg)); }
1092 template<
typename _Range>
1094 operator()(_Range&& __r)
const && =
delete;
1102 template<
typename _Adaptor,
typename... _Args>
1103 requires __adaptor_has_simple_extra_args<_Adaptor, _Args...>
1104 && (is_trivially_copyable_v<_Args> && ...)
1105 struct _Partial<_Adaptor, _Args...> : _RangeAdaptorClosure<_Partial<_Adaptor, _Args...>>
1107 tuple<_Args...> _M_args;
1109 template<
typename... _Ts>
1111 _Partial(
int, _Ts&&... __args)
1117 template<
typename _Range>
1118 requires __adaptor_invocable<_Adaptor, _Range,
const _Args&...>
1120 operator()(_Range&& __r)
const
1122 auto __forwarder = [&__r] (
const auto&... __args) {
1123 return _Adaptor{}(std::forward<_Range>(__r), __args...);
1125 return std::apply(__forwarder, _M_args);
1128 static constexpr bool _S_has_simple_call_op =
true;
1133 template<
typename _Adaptor,
typename _Arg>
1134 requires __adaptor_has_simple_extra_args<_Adaptor, _Arg>
1135 && is_trivially_copyable_v<_Arg>
1136 struct _Partial<_Adaptor, _Arg> : _RangeAdaptorClosure<_Partial<_Adaptor, _Arg>>
1140 template<
typename _Tp>
1142 _Partial(
int, _Tp&& __arg)
1146 template<
typename _Range>
1147 requires __adaptor_invocable<_Adaptor, _Range, const _Arg&>
1149 operator()(_Range&& __r)
const
1150 {
return _Adaptor{}(std::forward<_Range>(__r), _M_arg); }
1152 static constexpr bool _S_has_simple_call_op =
true;
1155 template<
typename _Lhs,
typename _Rhs,
typename _Range>
1156 concept __pipe_invocable
1157 =
requires { std::declval<_Rhs>()(std::declval<_Lhs>()(std::declval<_Range>())); };
1161 template<
typename _Lhs,
typename _Rhs>
1162 struct _Pipe : _RangeAdaptorClosure<_Pipe<_Lhs, _Rhs>>
1164 [[no_unique_address]] _Lhs _M_lhs;
1165 [[no_unique_address]] _Rhs _M_rhs;
1167 template<
typename _Tp,
typename _Up>
1169 _Pipe(_Tp&& __lhs, _Up&& __rhs)
1175#if __cpp_explicit_this_parameter
1176 template<
typename _Self,
typename _Range>
1177 requires __pipe_invocable<__like_t<_Self, _Lhs>, __like_t<_Self, _Rhs>, _Range>
1179 operator()(
this _Self&& __self, _Range&& __r)
1181 return (std::forward<_Self>(__self)._M_rhs
1182 (std::forward<_Self>(__self)._M_lhs
1183 (std::forward<_Range>(__r))));
1186 template<
typename _Range>
1187 requires __pipe_invocable<const _Lhs&, const _Rhs&, _Range>
1189 operator()(_Range&& __r)
const &
1190 {
return _M_rhs(_M_lhs(std::forward<_Range>(__r))); }
1192 template<
typename _Range>
1193 requires __pipe_invocable<_Lhs, _Rhs, _Range>
1195 operator()(_Range&& __r) &&
1198 template<
typename _Range>
1200 operator()(_Range&& __r)
const && =
delete;
1208 template<
typename _Lhs,
typename _Rhs>
1209 requires __closure_has_simple_call_op<_Lhs>
1210 && __closure_has_simple_call_op<_Rhs>
1211 struct _Pipe<_Lhs, _Rhs> : _RangeAdaptorClosure<_Pipe<_Lhs, _Rhs>>
1213 [[no_unique_address]] _Lhs _M_lhs;
1214 [[no_unique_address]] _Rhs _M_rhs;
1216 template<
typename _Tp,
typename _Up>
1218 _Pipe(_Tp&& __lhs, _Up&& __rhs)
1222 template<
typename _Range>
1223 requires __pipe_invocable<const _Lhs&, const _Rhs&, _Range>
1225 operator()(_Range&& __r)
const
1226 {
return _M_rhs(_M_lhs(std::forward<_Range>(__r))); }
1228 static constexpr bool _S_has_simple_call_op =
true;
1232#if __cpp_lib_ranges >= 202202L
1234 template<
typename _Derived>
1235 requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
1236 class range_adaptor_closure
1237 :
public views::__adaptor::_RangeAdaptorClosure<_Derived>
1241 template<range _Range>
requires is_object_v<_Range>
1242 class ref_view :
public view_interface<ref_view<_Range>>
1247 static void _S_fun(_Range&);
1248 static void _S_fun(_Range&&) =
delete;
1251 template<__detail::__different_from<ref_view> _Tp>
1252 requires convertible_to<_Tp, _Range&>
1253 &&
requires { _S_fun(declval<_Tp>()); }
1256 noexcept(
noexcept(
static_cast<_Range&
>(std::declval<_Tp>())))
1264 constexpr iterator_t<_Range>
1266 {
return ranges::begin(*_M_r); }
1268 constexpr sentinel_t<_Range>
1270 {
return ranges::end(*_M_r); }
1273 empty() const requires requires { ranges::empty(*_M_r); }
1274 {
return ranges::empty(*_M_r); }
1277 size() const requires sized_range<_Range>
1278 {
return ranges::size(*_M_r); }
1281 data() const requires contiguous_range<_Range>
1282 {
return ranges::data(*_M_r); }
1285 template<
typename _Range>
1286 ref_view(_Range&) -> ref_view<_Range>;
1288 template<
typename _Tp>
1289 inline constexpr bool enable_borrowed_range<ref_view<_Tp>> =
true;
1291 template<range _Range>
1292 requires movable<_Range>
1293 && (!__detail::__is_initializer_list<remove_cv_t<_Range>>)
1294 class owning_view : public view_interface<owning_view<_Range>>
1297 _Range _M_r = _Range();
1300 owning_view()
requires default_initializable<_Range> = default;
1303 owning_view(_Range&& __t)
1304 noexcept(is_nothrow_move_constructible_v<_Range>)
1308 owning_view(owning_view&&) =
default;
1309 owning_view& operator=(owning_view&&) =
default;
1315 constexpr const _Range&
1316 base() const& noexcept
1323 constexpr const _Range&&
1324 base() const&& noexcept
1327 constexpr iterator_t<_Range>
1329 {
return ranges::begin(_M_r); }
1331 constexpr sentinel_t<_Range>
1333 {
return ranges::end(_M_r); }
1336 begin() const requires range<const _Range>
1337 {
return ranges::begin(_M_r); }
1340 end() const requires range<const _Range>
1341 {
return ranges::end(_M_r); }
1344 empty()
requires requires { ranges::empty(_M_r); }
1345 {
return ranges::empty(_M_r); }
1348 empty() const requires requires { ranges::empty(_M_r); }
1349 {
return ranges::empty(_M_r); }
1352 size()
requires sized_range<_Range>
1353 {
return ranges::size(_M_r); }
1356 size() const requires sized_range<const _Range>
1357 {
return ranges::size(_M_r); }
1360 data()
requires contiguous_range<_Range>
1361 {
return ranges::data(_M_r); }
1364 data() const requires contiguous_range<const _Range>
1365 {
return ranges::data(_M_r); }
1368 template<
typename _Tp>
1369 inline constexpr bool enable_borrowed_range<owning_view<_Tp>>
1370 = enable_borrowed_range<_Tp>;
1376 template<
typename _Range>
1377 concept __can_ref_view =
requires { ref_view{std::declval<_Range>()}; };
1379 template<
typename _Range>
1380 concept __can_owning_view =
requires { owning_view{std::declval<_Range>()}; };
1383 struct _All : __adaptor::_RangeAdaptorClosure<_All>
1385 template<
typename _Range>
1386 static constexpr bool
1389 if constexpr (view<decay_t<_Range>>)
1390 return is_nothrow_constructible_v<decay_t<_Range>, _Range>;
1391 else if constexpr (__detail::__can_ref_view<_Range>)
1394 return noexcept(owning_view{std::declval<_Range>()});
1397 template<viewable_range _Range>
1398 requires view<decay_t<_Range>>
1399 || __detail::__can_ref_view<_Range>
1400 || __detail::__can_owning_view<_Range>
1402 operator() [[nodiscard]] (_Range&& __r)
const
1403 noexcept(_S_noexcept<_Range>())
1405 if constexpr (view<decay_t<_Range>>)
1406 return std::forward<_Range>(__r);
1407 else if constexpr (__detail::__can_ref_view<_Range>)
1408 return ref_view{std::forward<_Range>(__r)};
1410 return owning_view{std::forward<_Range>(__r)};
1413 static constexpr bool _S_has_simple_call_op =
true;
1416 inline constexpr _All all;
1418 template<viewable_range _Range>
1419 using all_t =
decltype(all(std::declval<_Range>()));
1424 template<
typename _Tp>
1425 struct __non_propagating_cache
1433 template<
typename _Tp>
1434 requires is_object_v<_Tp>
1435 struct __non_propagating_cache<_Tp>
1436 :
protected _Optional_base<_Tp>
1438 __non_propagating_cache() =
default;
1441 __non_propagating_cache(
const __non_propagating_cache&)
noexcept
1445 __non_propagating_cache(__non_propagating_cache&& __other)
noexcept
1446 { __other._M_reset(); }
1448 constexpr __non_propagating_cache&
1449 operator=(
const __non_propagating_cache& __other)
noexcept
1456 constexpr __non_propagating_cache&
1457 operator=(__non_propagating_cache&& __other)
noexcept
1464 constexpr __non_propagating_cache&
1465 operator=(_Tp __val)
1468 this->_M_payload._M_construct(
std::move(__val));
1473 operator bool() const noexcept
1474 {
return this->_M_is_engaged(); }
1478 {
return this->_M_get(); }
1480 constexpr const _Tp&
1482 {
return this->_M_get(); }
1484 template<
typename _Iter>
1486 _M_emplace_deref(
const _Iter& __i)
1489 auto __f = [] (
auto& __x) {
return *__x; };
1490 this->_M_payload._M_apply(_Optional_func{__f}, __i);
1491 return this->_M_get();
1495 template<range _Range>
1496 struct _CachedPosition
1499 _M_has_value()
const
1502 constexpr iterator_t<_Range>
1503 _M_get(
const _Range&)
const
1505 __glibcxx_assert(
false);
1506 __builtin_unreachable();
1510 _M_set(
const _Range&,
const iterator_t<_Range>&)
const
1514 template<forward_range _Range>
1515 struct _CachedPosition<_Range>
1516 :
protected __non_propagating_cache<iterator_t<_Range>>
1519 _M_has_value()
const
1520 {
return this->_M_is_engaged(); }
1522 constexpr iterator_t<_Range>
1523 _M_get(
const _Range&)
const
1525 __glibcxx_assert(_M_has_value());
1530 _M_set(
const _Range&,
const iterator_t<_Range>& __it)
1532 __glibcxx_assert(!_M_has_value());
1535 this->_M_payload._M_engaged =
true;
1539 template<random_access_range _Range>
1540 requires (
sizeof(range_difference_t<_Range>)
1541 <=
sizeof(iterator_t<_Range>))
1542 struct _CachedPosition<_Range>
1545 range_difference_t<_Range> _M_offset = -1;
1548 _CachedPosition() =
default;
1551 _CachedPosition(
const _CachedPosition&) =
default;
1554 _CachedPosition(_CachedPosition&& __other)
noexcept
1557 constexpr _CachedPosition&
1558 operator=(
const _CachedPosition&) =
default;
1560 constexpr _CachedPosition&
1561 operator=(_CachedPosition&& __other)
noexcept
1564 _M_offset = __other._M_offset;
1565 __other._M_offset = -1;
1570 _M_has_value()
const
1571 {
return _M_offset >= 0; }
1573 constexpr iterator_t<_Range>
1574 _M_get(_Range& __r)
const
1576 __glibcxx_assert(_M_has_value());
1577 return ranges::begin(__r) + _M_offset;
1581 _M_set(_Range& __r,
const iterator_t<_Range>& __it)
1583 __glibcxx_assert(!_M_has_value());
1584 _M_offset = __it - ranges::begin(__r);
1591 template<
typename _Base>
1592 struct __filter_view_iter_cat
1595 template<forward_range _Base>
1596 struct __filter_view_iter_cat<_Base>
1602 using _Cat =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
1603 if constexpr (derived_from<_Cat, bidirectional_iterator_tag>)
1604 return bidirectional_iterator_tag{};
1605 else if constexpr (derived_from<_Cat, forward_iterator_tag>)
1606 return forward_iterator_tag{};
1611 using iterator_category =
decltype(_S_iter_cat());
1615 template<input_range _Vp,
1616 indirect_unary_predicate<iterator_t<_Vp>> _Pred>
1617 requires view<_Vp> && is_object_v<_Pred>
1618 class filter_view :
public view_interface<filter_view<_Vp, _Pred>>
1623 struct _Iterator : __detail::__filter_view_iter_cat<_Vp>
1626 static constexpr auto
1629 if constexpr (bidirectional_range<_Vp>)
1630 return bidirectional_iterator_tag{};
1631 else if constexpr (forward_range<_Vp>)
1632 return forward_iterator_tag{};
1634 return input_iterator_tag{};
1639 using _Vp_iter = iterator_t<_Vp>;
1641 _Vp_iter _M_current = _Vp_iter();
1642 filter_view* _M_parent =
nullptr;
1645 using iterator_concept =
decltype(_S_iter_concept());
1647 using value_type = range_value_t<_Vp>;
1648 using difference_type = range_difference_t<_Vp>;
1650 _Iterator()
requires default_initializable<_Vp_iter> = default;
1653 _Iterator(filter_view* __parent, _Vp_iter __current)
1654 : _M_current(
std::move(__current)),
1658 constexpr const _Vp_iter&
1659 base() const & noexcept
1660 {
return _M_current; }
1666 constexpr range_reference_t<_Vp>
1668 {
return *_M_current; }
1672 requires __detail::__has_arrow<_Vp_iter>
1673 && copyable<_Vp_iter>
1674 {
return _M_current; }
1676 constexpr _Iterator&
1679 _M_current = ranges::find_if(
std::move(++_M_current),
1680 ranges::end(_M_parent->_M_base),
1681 std::ref(*_M_parent->_M_pred));
1690 operator++(
int)
requires forward_range<_Vp>
1697 constexpr _Iterator&
1698 operator--()
requires bidirectional_range<_Vp>
1707 operator--(
int)
requires bidirectional_range<_Vp>
1714 friend constexpr bool
1715 operator==(
const _Iterator& __x,
const _Iterator& __y)
1716 requires equality_comparable<_Vp_iter>
1717 {
return __x._M_current == __y._M_current; }
1719 friend constexpr range_rvalue_reference_t<_Vp>
1720 iter_move(
const _Iterator& __i)
1721 noexcept(
noexcept(ranges::iter_move(__i._M_current)))
1722 {
return ranges::iter_move(__i._M_current); }
1724 friend constexpr void
1725 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
1726 noexcept(
noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1727 requires indirectly_swappable<_Vp_iter>
1728 { ranges::iter_swap(__x._M_current, __y._M_current); }
1734 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
1737 __equal(
const _Iterator& __i)
const
1738 {
return __i._M_current == _M_end; }
1741 _Sentinel() =
default;
1744 _Sentinel(filter_view* __parent)
1745 : _M_end(ranges::
end(__parent->_M_base))
1748 constexpr sentinel_t<_Vp>
1752 friend constexpr bool
1753 operator==(
const _Iterator& __x,
const _Sentinel& __y)
1754 {
return __y.__equal(__x); }
1757 _Vp _M_base = _Vp();
1758 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
1759 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
1762 filter_view()
requires (default_initializable<_Vp>
1763 && default_initializable<_Pred>)
1767 filter_view(_Vp __base, _Pred __pred)
1772 base() const& requires copy_constructible<_Vp>
1779 constexpr const _Pred&
1781 {
return *_M_pred; }
1786 if (_M_cached_begin._M_has_value())
1787 return {
this, _M_cached_begin._M_get(_M_base)};
1789 __glibcxx_assert(_M_pred.has_value());
1790 auto __it = ranges::find_if(ranges::begin(_M_base),
1791 ranges::end(_M_base),
1792 std::ref(*_M_pred));
1793 _M_cached_begin._M_set(_M_base, __it);
1800 if constexpr (common_range<_Vp>)
1801 return _Iterator{
this, ranges::end(_M_base)};
1803 return _Sentinel{
this};
1807 template<
typename _Range,
typename _Pred>
1808 filter_view(_Range&&, _Pred) -> filter_view<views::all_t<_Range>, _Pred>;
1814 template<
typename _Range,
typename _Pred>
1815 concept __can_filter_view
1816 =
requires { filter_view(std::declval<_Range>(), std::declval<_Pred>()); };
1819 struct _Filter : __adaptor::_RangeAdaptor<_Filter>
1821 template<viewable_range _Range,
typename _Pred>
1822 requires __detail::__can_filter_view<_Range, _Pred>
1824 operator() [[nodiscard]] (_Range&& __r, _Pred&& __p)
const
1826 return filter_view(std::forward<_Range>(__r), std::forward<_Pred>(__p));
1829 using _RangeAdaptor<_Filter>::operator();
1830 static constexpr int _S_arity = 2;
1831 static constexpr bool _S_has_simple_extra_args =
true;
1834 inline constexpr _Filter filter;
1837#if __cpp_lib_ranges >= 202207L
1838 template<input_range _Vp, move_constructible _Fp>
1840 template<input_range _Vp, copy_constructible _Fp>
1842 requires view<_Vp> && is_object_v<_Fp>
1843 && regular_invocable<_Fp&, range_reference_t<_Vp>>
1844 && std::__detail::__can_reference<invoke_result_t<_Fp&,
1845 range_reference_t<_Vp>>>
1846 class transform_view :
public view_interface<transform_view<_Vp, _Fp>>
1849 template<
bool _Const>
1850 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
1852 template<
bool _Const>
1856 template<
bool _Const>
1857 requires forward_range<_Base<_Const>>
1858 struct __iter_cat<_Const>
1864 using _Base = transform_view::_Base<_Const>;
1865 using _Res = invoke_result_t<_Fp&, range_reference_t<_Base>>;
1866 if constexpr (is_lvalue_reference_v<_Res>)
1869 =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
1870 if constexpr (derived_from<_Cat, contiguous_iterator_tag>)
1871 return random_access_iterator_tag{};
1876 return input_iterator_tag{};
1879 using iterator_category =
decltype(_S_iter_cat());
1882 template<
bool _Const>
1885 template<
bool _Const>
1886 struct _Iterator : __iter_cat<_Const>
1889 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
1890 using _Base = transform_view::_Base<_Const>;
1895 if constexpr (random_access_range<_Base>)
1896 return random_access_iterator_tag{};
1897 else if constexpr (bidirectional_range<_Base>)
1898 return bidirectional_iterator_tag{};
1899 else if constexpr (forward_range<_Base>)
1900 return forward_iterator_tag{};
1902 return input_iterator_tag{};
1905 using _Base_iter = iterator_t<_Base>;
1907 _Base_iter _M_current = _Base_iter();
1908 _Parent* _M_parent =
nullptr;
1911 using iterator_concept =
decltype(_S_iter_concept());
1914 = remove_cvref_t<invoke_result_t<_Fp&, range_reference_t<_Base>>>;
1915 using difference_type = range_difference_t<_Base>;
1917 _Iterator()
requires default_initializable<_Base_iter> = default;
1920 _Iterator(_Parent* __parent, _Base_iter __current)
1921 : _M_current(
std::move(__current)),
1926 _Iterator(_Iterator<!_Const> __i)
1928 && convertible_to<iterator_t<_Vp>, _Base_iter>
1929 : _M_current(
std::move(__i._M_current)), _M_parent(__i._M_parent)
1932 constexpr const _Base_iter&
1933 base() const & noexcept
1934 {
return _M_current; }
1936 constexpr _Base_iter
1940 constexpr decltype(
auto)
1942 noexcept(
noexcept(
std::__invoke(*_M_parent->_M_fun, *_M_current)))
1945 constexpr _Iterator&
1957 operator++(
int)
requires forward_range<_Base>
1964 constexpr _Iterator&
1965 operator--()
requires bidirectional_range<_Base>
1972 operator--(
int)
requires bidirectional_range<_Base>
1979 constexpr _Iterator&
1980 operator+=(difference_type __n)
requires random_access_range<_Base>
1986 constexpr _Iterator&
1987 operator-=(difference_type __n)
requires random_access_range<_Base>
1993 constexpr decltype(
auto)
1994 operator[](difference_type __n)
const
1995 requires random_access_range<_Base>
1996 {
return std::__invoke(*_M_parent->_M_fun, _M_current[__n]); }
1998 friend constexpr bool
1999 operator==(
const _Iterator& __x,
const _Iterator& __y)
2000 requires equality_comparable<_Base_iter>
2001 {
return __x._M_current == __y._M_current; }
2003 friend constexpr bool
2004 operator<(
const _Iterator& __x,
const _Iterator& __y)
2005 requires random_access_range<_Base>
2006 {
return __x._M_current < __y._M_current; }
2008 friend constexpr bool
2009 operator>(
const _Iterator& __x,
const _Iterator& __y)
2010 requires random_access_range<_Base>
2011 {
return __y < __x; }
2013 friend constexpr bool
2014 operator<=(
const _Iterator& __x,
const _Iterator& __y)
2015 requires random_access_range<_Base>
2016 {
return !(__y < __x); }
2018 friend constexpr bool
2019 operator>=(
const _Iterator& __x,
const _Iterator& __y)
2020 requires random_access_range<_Base>
2021 {
return !(__x < __y); }
2023#ifdef __cpp_lib_three_way_comparison
2024 friend constexpr auto
2025 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
2026 requires random_access_range<_Base>
2027 && three_way_comparable<_Base_iter>
2028 {
return __x._M_current <=> __y._M_current; }
2031 friend constexpr _Iterator
2032 operator+(_Iterator __i, difference_type __n)
2033 requires random_access_range<_Base>
2034 {
return {__i._M_parent, __i._M_current + __n}; }
2036 friend constexpr _Iterator
2037 operator+(difference_type __n, _Iterator __i)
2038 requires random_access_range<_Base>
2039 {
return {__i._M_parent, __i._M_current + __n}; }
2041 friend constexpr _Iterator
2042 operator-(_Iterator __i, difference_type __n)
2043 requires random_access_range<_Base>
2044 {
return {__i._M_parent, __i._M_current - __n}; }
2048 friend constexpr difference_type
2049 operator-(
const _Iterator& __x,
const _Iterator& __y)
2050 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
2051 {
return __x._M_current - __y._M_current; }
2053 friend constexpr decltype(
auto)
2054 iter_move(
const _Iterator& __i)
noexcept(
noexcept(*__i))
2056 if constexpr (is_lvalue_reference_v<
decltype(*__i)>)
2062 friend _Iterator<!_Const>;
2063 template<
bool>
friend struct _Sentinel;
2066 template<
bool _Const>
2070 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
2071 using _Base = transform_view::_Base<_Const>;
2073 template<
bool _Const2>
2075 __distance_from(
const _Iterator<_Const2>& __i)
const
2076 {
return _M_end - __i._M_current; }
2078 template<
bool _Const2>
2080 __equal(
const _Iterator<_Const2>& __i)
const
2081 {
return __i._M_current == _M_end; }
2083 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2086 _Sentinel() =
default;
2089 _Sentinel(sentinel_t<_Base> __end)
2094 _Sentinel(_Sentinel<!_Const> __i)
2096 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2100 constexpr sentinel_t<_Base>
2104 template<
bool _Const2>
2105 requires sentinel_for<sentinel_t<_Base>,
2106 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
2107 friend constexpr bool
2108 operator==(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
2109 {
return __y.__equal(__x); }
2111 template<
bool _Const2,
2112 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
2113 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2114 friend constexpr range_difference_t<_Base2>
2115 operator-(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
2116 {
return -__y.__distance_from(__x); }
2118 template<
bool _Const2,
2119 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
2120 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2121 friend constexpr range_difference_t<_Base2>
2122 operator-(
const _Sentinel& __y,
const _Iterator<_Const2>& __x)
2123 {
return __y.__distance_from(__x); }
2125 friend _Sentinel<!_Const>;
2128 _Vp _M_base = _Vp();
2129 [[no_unique_address]] __detail::__box<_Fp> _M_fun;
2132 transform_view()
requires (default_initializable<_Vp>
2133 && default_initializable<_Fp>)
2137 transform_view(_Vp __base, _Fp __fun)
2142 base() const& requires copy_constructible<_Vp>
2143 {
return _M_base ; }
2149 constexpr _Iterator<false>
2151 {
return _Iterator<false>{
this, ranges::begin(_M_base)}; }
2153 constexpr _Iterator<true>
2155 requires range<const _Vp>
2156 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
2157 {
return _Iterator<true>{
this, ranges::begin(_M_base)}; }
2159 constexpr _Sentinel<false>
2161 {
return _Sentinel<false>{ranges::end(_M_base)}; }
2163 constexpr _Iterator<false>
2164 end()
requires common_range<_Vp>
2165 {
return _Iterator<false>{
this, ranges::end(_M_base)}; }
2167 constexpr _Sentinel<true>
2169 requires range<const _Vp>
2170 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
2171 {
return _Sentinel<true>{ranges::end(_M_base)}; }
2173 constexpr _Iterator<true>
2175 requires common_range<const _Vp>
2176 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
2177 {
return _Iterator<true>{
this, ranges::end(_M_base)}; }
2180 size()
requires sized_range<_Vp>
2181 {
return ranges::size(_M_base); }
2184 size() const requires sized_range<const _Vp>
2185 {
return ranges::size(_M_base); }
2188 template<
typename _Range,
typename _Fp>
2189 transform_view(_Range&&, _Fp) -> transform_view<views::all_t<_Range>, _Fp>;
2195 template<
typename _Range,
typename _Fp>
2196 concept __can_transform_view
2197 =
requires { transform_view(std::declval<_Range>(), std::declval<_Fp>()); };
2200 struct _Transform : __adaptor::_RangeAdaptor<_Transform>
2202 template<viewable_range _Range,
typename _Fp>
2203 requires __detail::__can_transform_view<_Range, _Fp>
2205 operator() [[nodiscard]] (_Range&& __r, _Fp&& __f)
const
2207 return transform_view(std::forward<_Range>(__r), std::forward<_Fp>(__f));
2210 using _RangeAdaptor<_Transform>::operator();
2211 static constexpr int _S_arity = 2;
2212 static constexpr bool _S_has_simple_extra_args =
true;
2215 inline constexpr _Transform transform;
2219 class take_view :
public view_interface<take_view<_Vp>>
2222 template<
bool _Const>
2223 using _CI = counted_iterator<
2224 iterator_t<__detail::__maybe_const_t<_Const, _Vp>>>;
2226 template<
bool _Const>
2230 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2231 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2234 _Sentinel() =
default;
2237 _Sentinel(sentinel_t<_Base> __end)
2242 _Sentinel(_Sentinel<!_Const> __s)
2243 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2247 constexpr sentinel_t<_Base>
2251 friend constexpr bool
2252 operator==(
const _CI<_Const>& __y,
const _Sentinel& __x)
2253 {
return __y.count() == 0 || __y.base() == __x._M_end; }
2255 template<
bool _OtherConst = !_Const,
2256 typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
2257 requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2258 friend constexpr bool
2259 operator==(
const _CI<_OtherConst>& __y,
const _Sentinel& __x)
2260 {
return __y.count() == 0 || __y.base() == __x._M_end; }
2262 friend _Sentinel<!_Const>;
2265 _Vp _M_base = _Vp();
2266 range_difference_t<_Vp> _M_count = 0;
2269 take_view()
requires default_initializable<_Vp> = default;
2272 take_view(_Vp __base, range_difference_t<_Vp> __count)
2273 : _M_base(
std::move(__base)), _M_count(
std::move(__count))
2277 base() const& requires copy_constructible<_Vp>
2285 begin()
requires (!__detail::__simple_view<_Vp>)
2287 if constexpr (sized_range<_Vp>)
2289 if constexpr (random_access_range<_Vp>)
2290 return ranges::begin(_M_base);
2294 return counted_iterator(ranges::begin(_M_base), __sz);
2298 return counted_iterator(ranges::begin(_M_base), _M_count);
2302 begin() const requires range<const _Vp>
2304 if constexpr (sized_range<const _Vp>)
2306 if constexpr (random_access_range<const _Vp>)
2307 return ranges::begin(_M_base);
2311 return counted_iterator(ranges::begin(_M_base), __sz);
2315 return counted_iterator(ranges::begin(_M_base), _M_count);
2319 end()
requires (!__detail::__simple_view<_Vp>)
2321 if constexpr (sized_range<_Vp>)
2323 if constexpr (random_access_range<_Vp>)
2324 return ranges::begin(_M_base) +
size();
2329 return _Sentinel<false>{ranges::end(_M_base)};
2333 end() const requires range<const _Vp>
2335 if constexpr (sized_range<const _Vp>)
2337 if constexpr (random_access_range<const _Vp>)
2338 return ranges::begin(_M_base) +
size();
2343 return _Sentinel<true>{ranges::end(_M_base)};
2347 size()
requires sized_range<_Vp>
2349 auto __n = ranges::size(_M_base);
2350 return std::min(__n,
static_cast<decltype(__n)
>(_M_count));
2354 size() const requires sized_range<const _Vp>
2356 auto __n = ranges::size(_M_base);
2357 return std::min(__n,
static_cast<decltype(__n)
>(_M_count));
2364 template<
typename _Range>
2365 take_view(_Range&&, range_difference_t<_Range>)
2366 -> take_view<views::all_t<_Range>>;
2368 template<
typename _Tp>
2369 inline constexpr bool enable_borrowed_range<take_view<_Tp>>
2370 = enable_borrowed_range<_Tp>;
2376 template<
typename _Range>
2377 inline constexpr bool __is_empty_view =
false;
2379 template<
typename _Tp>
2380 inline constexpr bool __is_empty_view<empty_view<_Tp>> =
true;
2382 template<
typename _Range>
2383 inline constexpr bool __is_basic_string_view =
false;
2385 template<
typename _CharT,
typename _Traits>
2386 inline constexpr bool __is_basic_string_view<basic_string_view<_CharT, _Traits>>
2389 template<
typename _Range>
2390 inline constexpr bool __is_subrange =
false;
2392 template<
typename _Iter,
typename _Sent, subrange_kind _Kind>
2393 inline constexpr bool __is_subrange<subrange<_Iter, _Sent, _Kind>> =
true;
2395 template<
typename _Range>
2396 inline constexpr bool __is_iota_view =
false;
2398 template<
typename _Winc,
typename _Bound>
2399 inline constexpr bool __is_iota_view<iota_view<_Winc, _Bound>> =
true;
2401 template<
typename _Range>
2402 inline constexpr bool __is_repeat_view =
false;
2404 template<
typename _Range>
2406 __take_of_repeat_view(_Range&&, range_difference_t<_Range>);
2408 template<
typename _Range,
typename _Dp>
2409 concept __can_take_view
2410 =
requires { take_view(std::declval<_Range>(), std::declval<_Dp>()); };
2413 struct _Take : __adaptor::_RangeAdaptor<_Take>
2415 template<viewable_range _Range,
typename _Dp = range_difference_t<_Range>>
2416 requires __detail::__can_take_view<_Range, _Dp>
2418 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n)
const
2420 using _Tp = remove_cvref_t<_Range>;
2421 if constexpr (__detail::__is_empty_view<_Tp>)
2423 else if constexpr (random_access_range<_Tp>
2425 && (std::__detail::__is_span<_Tp>
2426 || __detail::__is_basic_string_view<_Tp>
2427 || __detail::__is_subrange<_Tp>
2428 || __detail::__is_iota_view<_Tp>))
2430 __n = std::min<_Dp>(ranges::distance(__r), __n);
2431 auto __begin = ranges::begin(__r);
2432 auto __end = __begin + __n;
2433 if constexpr (std::__detail::__is_span<_Tp>)
2434 return span<typename _Tp::element_type>(__begin, __end);
2435 else if constexpr (__detail::__is_basic_string_view<_Tp>)
2436 return _Tp(__begin, __end);
2437 else if constexpr (__detail::__is_subrange<_Tp>)
2438 return subrange<iterator_t<_Tp>>(__begin, __end);
2440 return iota_view(*__begin, *__end);
2442 else if constexpr (__detail::__is_repeat_view<_Tp>)
2443 return __detail::__take_of_repeat_view(std::forward<_Range>(__r), __n);
2445 return take_view(std::forward<_Range>(__r), __n);
2448 using _RangeAdaptor<_Take>::operator();
2449 static constexpr int _S_arity = 2;
2453 template<
typename _Tp>
2454 static constexpr bool _S_has_simple_extra_args
2455 = ranges::__detail::__is_integer_like<_Tp>;
2458 inline constexpr _Take take;
2461 template<view _Vp,
typename _Pred>
2462 requires input_range<_Vp> && is_object_v<_Pred>
2463 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2464 class take_while_view :
public view_interface<take_while_view<_Vp, _Pred>>
2466 template<
bool _Const>
2470 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2472 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2473 const _Pred* _M_pred =
nullptr;
2476 _Sentinel() =
default;
2479 _Sentinel(sentinel_t<_Base> __end,
const _Pred* __pred)
2480 : _M_end(__end), _M_pred(__pred)
2484 _Sentinel(_Sentinel<!_Const> __s)
2485 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2486 : _M_end(__s._M_end), _M_pred(__s._M_pred)
2489 constexpr sentinel_t<_Base>
2490 base()
const {
return _M_end; }
2492 friend constexpr bool
2493 operator==(
const iterator_t<_Base>& __x,
const _Sentinel& __y)
2494 {
return __y._M_end == __x || !
std::__invoke(*__y._M_pred, *__x); }
2496 template<
bool _OtherConst = !_Const,
2497 typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
2498 requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2499 friend constexpr bool
2500 operator==(
const iterator_t<_Base2>& __x,
const _Sentinel& __y)
2501 {
return __y._M_end == __x || !
std::__invoke(*__y._M_pred, *__x); }
2503 friend _Sentinel<!_Const>;
2506 _Vp _M_base = _Vp();
2507 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
2510 take_while_view()
requires (default_initializable<_Vp>
2511 && default_initializable<_Pred>)
2515 take_while_view(_Vp __base, _Pred __pred)
2520 base() const& requires copy_constructible<_Vp>
2527 constexpr const _Pred&
2529 {
return *_M_pred; }
2532 begin()
requires (!__detail::__simple_view<_Vp>)
2533 {
return ranges::begin(_M_base); }
2536 begin() const requires range<const _Vp>
2537 && indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
2538 {
return ranges::begin(_M_base); }
2541 end()
requires (!__detail::__simple_view<_Vp>)
2542 {
return _Sentinel<false>(ranges::end(_M_base),
2546 end() const requires range<const _Vp>
2547 && indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
2548 {
return _Sentinel<true>(ranges::end(_M_base),
2552 template<
typename _Range,
typename _Pred>
2553 take_while_view(_Range&&, _Pred)
2554 -> take_while_view<views::all_t<_Range>, _Pred>;
2560 template<
typename _Range,
typename _Pred>
2561 concept __can_take_while_view
2562 =
requires { take_while_view(std::declval<_Range>(), std::declval<_Pred>()); };
2565 struct _TakeWhile : __adaptor::_RangeAdaptor<_TakeWhile>
2567 template<viewable_range _Range,
typename _Pred>
2568 requires __detail::__can_take_while_view<_Range, _Pred>
2570 operator() [[nodiscard]] (_Range&& __r, _Pred&& __p)
const
2572 return take_while_view(std::forward<_Range>(__r), std::forward<_Pred>(__p));
2575 using _RangeAdaptor<_TakeWhile>::operator();
2576 static constexpr int _S_arity = 2;
2577 static constexpr bool _S_has_simple_extra_args =
true;
2580 inline constexpr _TakeWhile take_while;
2584 class drop_view :
public view_interface<drop_view<_Vp>>
2587 _Vp _M_base = _Vp();
2588 range_difference_t<_Vp> _M_count = 0;
2592 static constexpr bool _S_needs_cached_begin
2593 = !(random_access_range<const _Vp> && sized_range<const _Vp>);
2594 [[no_unique_address]]
2595 __detail::__maybe_present_t<_S_needs_cached_begin,
2596 __detail::_CachedPosition<_Vp>>
2600 drop_view()
requires default_initializable<_Vp> = default;
2603 drop_view(_Vp __base, range_difference_t<_Vp> __count)
2604 : _M_base(
std::move(__base)), _M_count(__count)
2605 { __glibcxx_assert(__count >= 0); }
2608 base() const& requires copy_constructible<_Vp>
2618 requires (!(__detail::__simple_view<_Vp>
2619 && random_access_range<const _Vp>
2620 && sized_range<const _Vp>))
2622 if constexpr (_S_needs_cached_begin)
2623 if (_M_cached_begin._M_has_value())
2624 return _M_cached_begin._M_get(_M_base);
2626 auto __it = ranges::next(ranges::begin(_M_base),
2627 _M_count, ranges::end(_M_base));
2628 if constexpr (_S_needs_cached_begin)
2629 _M_cached_begin._M_set(_M_base, __it);
2637 requires random_access_range<const _Vp> && sized_range<const _Vp>
2639 return ranges::next(ranges::begin(_M_base), _M_count,
2640 ranges::end(_M_base));
2644 end()
requires (!__detail::__simple_view<_Vp>)
2645 {
return ranges::end(_M_base); }
2648 end() const requires range<const _Vp>
2649 {
return ranges::end(_M_base); }
2652 size()
requires sized_range<_Vp>
2654 const auto __s = ranges::size(_M_base);
2655 const auto __c =
static_cast<decltype(__s)
>(_M_count);
2656 return __s < __c ? 0 : __s - __c;
2660 size() const requires sized_range<const _Vp>
2662 const auto __s = ranges::size(_M_base);
2663 const auto __c =
static_cast<decltype(__s)
>(_M_count);
2664 return __s < __c ? 0 : __s - __c;
2668 template<
typename _Range>
2669 drop_view(_Range&&, range_difference_t<_Range>)
2670 -> drop_view<views::all_t<_Range>>;
2672 template<
typename _Tp>
2673 inline constexpr bool enable_borrowed_range<drop_view<_Tp>>
2674 = enable_borrowed_range<_Tp>;
2680 template<
typename _Range>
2682 __drop_of_repeat_view(_Range&&, range_difference_t<_Range>);
2684 template<
typename _Range,
typename _Dp>
2685 concept __can_drop_view
2686 =
requires { drop_view(std::declval<_Range>(), std::declval<_Dp>()); };
2689 struct _Drop : __adaptor::_RangeAdaptor<_Drop>
2691 template<viewable_range _Range,
typename _Dp = range_difference_t<_Range>>
2692 requires __detail::__can_drop_view<_Range, _Dp>
2694 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n)
const
2696 using _Tp = remove_cvref_t<_Range>;
2697 if constexpr (__detail::__is_empty_view<_Tp>)
2699 else if constexpr (random_access_range<_Tp>
2701 && (std::__detail::__is_span<_Tp>
2702 || __detail::__is_basic_string_view<_Tp>
2703 || __detail::__is_iota_view<_Tp>
2704 || __detail::__is_subrange<_Tp>))
2706 __n = std::min<_Dp>(ranges::distance(__r), __n);
2707 auto __begin = ranges::begin(__r) + __n;
2708 auto __end = ranges::end(__r);
2709 if constexpr (std::__detail::__is_span<_Tp>)
2710 return span<typename _Tp::element_type>(__begin, __end);
2711 else if constexpr (__detail::__is_subrange<_Tp>)
2713 if constexpr (_Tp::_S_store_size)
2715 using ranges::__detail::__to_unsigned_like;
2716 auto __m = ranges::distance(__r) - __n;
2717 return _Tp(__begin, __end, __to_unsigned_like(__m));
2720 return _Tp(__begin, __end);
2723 return _Tp(__begin, __end);
2725 else if constexpr (__detail::__is_repeat_view<_Tp>)
2726 return __detail::__drop_of_repeat_view(std::forward<_Range>(__r), __n);
2728 return drop_view(std::forward<_Range>(__r), __n);
2731 using _RangeAdaptor<_Drop>::operator();
2732 static constexpr int _S_arity = 2;
2733 template<
typename _Tp>
2734 static constexpr bool _S_has_simple_extra_args
2735 = _Take::_S_has_simple_extra_args<_Tp>;
2738 inline constexpr _Drop drop;
2741 template<view _Vp,
typename _Pred>
2742 requires input_range<_Vp> && is_object_v<_Pred>
2743 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2744 class drop_while_view :
public view_interface<drop_while_view<_Vp, _Pred>>
2747 _Vp _M_base = _Vp();
2748 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
2749 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
2752 drop_while_view()
requires (default_initializable<_Vp>
2753 && default_initializable<_Pred>)
2757 drop_while_view(_Vp __base, _Pred __pred)
2762 base() const& requires copy_constructible<_Vp>
2769 constexpr const _Pred&
2771 {
return *_M_pred; }
2776 if (_M_cached_begin._M_has_value())
2777 return _M_cached_begin._M_get(_M_base);
2779 __glibcxx_assert(_M_pred.has_value());
2780 auto __it = ranges::find_if_not(ranges::begin(_M_base),
2781 ranges::end(_M_base),
2782 std::cref(*_M_pred));
2783 _M_cached_begin._M_set(_M_base, __it);
2789 {
return ranges::end(_M_base); }
2792 template<
typename _Range,
typename _Pred>
2793 drop_while_view(_Range&&, _Pred)
2794 -> drop_while_view<views::all_t<_Range>, _Pred>;
2796 template<
typename _Tp,
typename _Pred>
2797 inline constexpr bool enable_borrowed_range<drop_while_view<_Tp, _Pred>>
2798 = enable_borrowed_range<_Tp>;
2804 template<
typename _Range,
typename _Pred>
2805 concept __can_drop_while_view
2806 =
requires { drop_while_view(std::declval<_Range>(), std::declval<_Pred>()); };
2809 struct _DropWhile : __adaptor::_RangeAdaptor<_DropWhile>
2811 template<viewable_range _Range,
typename _Pred>
2812 requires __detail::__can_drop_while_view<_Range, _Pred>
2814 operator() [[nodiscard]] (_Range&& __r, _Pred&& __p)
const
2816 return drop_while_view(std::forward<_Range>(__r),
2817 std::forward<_Pred>(__p));
2820 using _RangeAdaptor<_DropWhile>::operator();
2821 static constexpr int _S_arity = 2;
2822 static constexpr bool _S_has_simple_extra_args =
true;
2825 inline constexpr _DropWhile drop_while;
2830 template<
typename _Tp>
2832 __as_lvalue(_Tp&& __t)
2833 {
return static_cast<_Tp&
>(__t); }
2836 template<input_range _Vp>
2837 requires view<_Vp> && input_range<range_reference_t<_Vp>>
2838 class join_view :
public view_interface<join_view<_Vp>>
2841 using _InnerRange = range_reference_t<_Vp>;
2843 template<
bool _Const>
2844 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2846 template<
bool _Const>
2847 using _Outer_iter = iterator_t<_Base<_Const>>;
2849 template<
bool _Const>
2850 using _Inner_iter = iterator_t<range_reference_t<_Base<_Const>>>;
2852 template<
bool _Const>
2853 static constexpr bool _S_ref_is_glvalue
2854 = is_reference_v<range_reference_t<_Base<_Const>>>;
2856 template<
bool _Const>
2860 template<
bool _Const>
2861 requires _S_ref_is_glvalue<_Const>
2862 && forward_range<_Base<_Const>>
2863 && forward_range<range_reference_t<_Base<_Const>>>
2864 struct __iter_cat<_Const>
2867 static constexpr auto
2870 using _Outer_iter = join_view::_Outer_iter<_Const>;
2871 using _Inner_iter = join_view::_Inner_iter<_Const>;
2872 using _OuterCat =
typename iterator_traits<_Outer_iter>::iterator_category;
2873 using _InnerCat =
typename iterator_traits<_Inner_iter>::iterator_category;
2874 if constexpr (derived_from<_OuterCat, bidirectional_iterator_tag>
2875 && derived_from<_InnerCat, bidirectional_iterator_tag>
2876 && common_range<range_reference_t<_Base<_Const>>>)
2877 return bidirectional_iterator_tag{};
2878 else if constexpr (derived_from<_OuterCat, forward_iterator_tag>
2879 && derived_from<_InnerCat, forward_iterator_tag>)
2880 return forward_iterator_tag{};
2882 return input_iterator_tag{};
2885 using iterator_category =
decltype(_S_iter_cat());
2888 template<
bool _Const>
2891 template<
bool _Const>
2892 struct _Iterator : __iter_cat<_Const>
2895 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
2896 using _Base = join_view::_Base<_Const>;
2900 static constexpr bool _S_ref_is_glvalue
2901 = join_view::_S_ref_is_glvalue<_Const>;
2906 auto __update_inner = [
this] (
const iterator_t<_Base>& __x) ->
auto&& {
2907 if constexpr (_S_ref_is_glvalue)
2910 return _M_parent->_M_inner._M_emplace_deref(__x);
2913 _Outer_iter& __outer = _M_get_outer();
2914 for (; __outer != ranges::end(_M_parent->_M_base); ++__outer)
2916 auto&& __inner = __update_inner(__outer);
2917 _M_inner = ranges::begin(__inner);
2918 if (_M_inner != ranges::end(__inner))
2922 if constexpr (_S_ref_is_glvalue)
2926 static constexpr auto
2929 if constexpr (_S_ref_is_glvalue
2930 && bidirectional_range<_Base>
2931 && bidirectional_range<range_reference_t<_Base>>
2932 && common_range<range_reference_t<_Base>>)
2933 return bidirectional_iterator_tag{};
2934 else if constexpr (_S_ref_is_glvalue
2935 && forward_range<_Base>
2936 && forward_range<range_reference_t<_Base>>)
2937 return forward_iterator_tag{};
2939 return input_iterator_tag{};
2942 using _Outer_iter = join_view::_Outer_iter<_Const>;
2943 using _Inner_iter = join_view::_Inner_iter<_Const>;
2945 constexpr _Outer_iter&
2948 if constexpr (forward_range<_Base>)
2951 return *_M_parent->_M_outer;
2954 constexpr const _Outer_iter&
2955 _M_get_outer()
const
2957 if constexpr (forward_range<_Base>)
2960 return *_M_parent->_M_outer;
2964 _Iterator(_Parent* __parent, _Outer_iter __outer)
requires forward_range<_Base>
2965 : _M_outer(
std::move(__outer)), _M_parent(__parent)
2969 _Iterator(_Parent* __parent)
requires (!forward_range<_Base>)
2970 : _M_parent(__parent)
2973 [[no_unique_address]]
2974 __detail::__maybe_present_t<forward_range<_Base>, _Outer_iter> _M_outer;
2975 optional<_Inner_iter> _M_inner;
2976 _Parent* _M_parent =
nullptr;
2979 using iterator_concept =
decltype(_S_iter_concept());
2981 using value_type = range_value_t<range_reference_t<_Base>>;
2982 using difference_type
2983 = common_type_t<range_difference_t<_Base>,
2984 range_difference_t<range_reference_t<_Base>>>;
2986 _Iterator() =
default;
2989 _Iterator(_Iterator<!_Const> __i)
2991 && convertible_to<iterator_t<_Vp>, _Outer_iter>
2992 && convertible_to<iterator_t<_InnerRange>, _Inner_iter>
2994 _M_parent(__i._M_parent)
2997 constexpr decltype(
auto)
2999 {
return **_M_inner; }
3003 constexpr _Inner_iter
3005 requires __detail::__has_arrow<_Inner_iter>
3006 && copyable<_Inner_iter>
3007 {
return *_M_inner; }
3009 constexpr _Iterator&
3012 auto&& __inner_range = [
this] () ->
auto&& {
3013 if constexpr (_S_ref_is_glvalue)
3014 return *_M_get_outer();
3016 return *_M_parent->_M_inner;
3018 if (++*_M_inner == ranges::end(__inner_range))
3032 requires _S_ref_is_glvalue && forward_range<_Base>
3033 && forward_range<range_reference_t<_Base>>
3040 constexpr _Iterator&
3042 requires _S_ref_is_glvalue && bidirectional_range<_Base>
3043 && bidirectional_range<range_reference_t<_Base>>
3044 && common_range<range_reference_t<_Base>>
3046 if (_M_outer == ranges::end(_M_parent->_M_base))
3047 _M_inner = ranges::end(__detail::__as_lvalue(*--_M_outer));
3048 while (*_M_inner == ranges::begin(__detail::__as_lvalue(*_M_outer)))
3049 *_M_inner = ranges::end(__detail::__as_lvalue(*--_M_outer));
3056 requires _S_ref_is_glvalue && bidirectional_range<_Base>
3057 && bidirectional_range<range_reference_t<_Base>>
3058 && common_range<range_reference_t<_Base>>
3065 friend constexpr bool
3066 operator==(
const _Iterator& __x,
const _Iterator& __y)
3067 requires _S_ref_is_glvalue
3068 && forward_range<_Base>
3069 && equality_comparable<_Inner_iter>
3071 return (__x._M_outer == __y._M_outer
3072 && __x._M_inner == __y._M_inner);
3075 friend constexpr decltype(
auto)
3076 iter_move(
const _Iterator& __i)
3077 noexcept(
noexcept(ranges::iter_move(*__i._M_inner)))
3078 {
return ranges::iter_move(*__i._M_inner); }
3080 friend constexpr void
3081 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
3082 noexcept(
noexcept(ranges::iter_swap(*__x._M_inner, *__y._M_inner)))
3083 requires indirectly_swappable<_Inner_iter>
3084 {
return ranges::iter_swap(*__x._M_inner, *__y._M_inner); }
3086 friend _Iterator<!_Const>;
3087 template<
bool>
friend struct _Sentinel;
3090 template<
bool _Const>
3094 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
3095 using _Base = join_view::_Base<_Const>;
3097 template<
bool _Const2>
3099 __equal(
const _Iterator<_Const2>& __i)
const
3100 {
return __i._M_get_outer() == _M_end; }
3102 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
3105 _Sentinel() =
default;
3108 _Sentinel(_Parent* __parent)
3109 : _M_end(ranges::
end(__parent->_M_base))
3113 _Sentinel(_Sentinel<!_Const> __s)
3114 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
3118 template<
bool _Const2>
3119 requires sentinel_for<sentinel_t<_Base>,
3120 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
3121 friend constexpr bool
3122 operator==(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
3123 {
return __y.__equal(__x); }
3125 friend _Sentinel<!_Const>;
3128 _Vp _M_base = _Vp();
3129 [[no_unique_address]]
3130 __detail::__maybe_present_t<!forward_range<_Vp>,
3131 __detail::__non_propagating_cache<iterator_t<_Vp>>> _M_outer;
3132 [[no_unique_address]]
3133 __detail::__non_propagating_cache<remove_cv_t<_InnerRange>> _M_inner;
3136 join_view()
requires default_initializable<_Vp> = default;
3139 join_view(_Vp __base)
3140 : _M_base(
std::move(__base))
3144 base() const& requires copy_constructible<_Vp>
3154 if constexpr (forward_range<_Vp>)
3156 constexpr bool __use_const
3157 = (__detail::__simple_view<_Vp>
3158 && is_reference_v<range_reference_t<_Vp>>);
3159 return _Iterator<__use_const>{
this, ranges::begin(_M_base)};
3163 _M_outer = ranges::begin(_M_base);
3164 return _Iterator<false>{
this};
3170 requires forward_range<const _Vp>
3171 && is_reference_v<range_reference_t<const _Vp>>
3172 && input_range<range_reference_t<const _Vp>>
3174 return _Iterator<true>{
this, ranges::begin(_M_base)};
3180 if constexpr (forward_range<_Vp> && is_reference_v<_InnerRange>
3181 && forward_range<_InnerRange>
3182 && common_range<_Vp> && common_range<_InnerRange>)
3183 return _Iterator<__detail::__simple_view<_Vp>>{
this,
3184 ranges::end(_M_base)};
3186 return _Sentinel<__detail::__simple_view<_Vp>>{
this};
3191 requires forward_range<const _Vp>
3192 && is_reference_v<range_reference_t<const _Vp>>
3193 && input_range<range_reference_t<const _Vp>>
3195 if constexpr (is_reference_v<range_reference_t<const _Vp>>
3196 && forward_range<range_reference_t<const _Vp>>
3197 && common_range<const _Vp>
3198 && common_range<range_reference_t<const _Vp>>)
3199 return _Iterator<true>{
this, ranges::end(_M_base)};
3201 return _Sentinel<true>{
this};
3205 template<
typename _Range>
3206 explicit join_view(_Range&&) -> join_view<views::all_t<_Range>>;
3212 template<
typename _Range>
3213 concept __can_join_view
3214 =
requires { join_view<all_t<_Range>>{std::declval<_Range>()}; };
3217 struct _Join : __adaptor::_RangeAdaptorClosure<_Join>
3219 template<viewable_range _Range>
3220 requires __detail::__can_join_view<_Range>
3222 operator() [[nodiscard]] (_Range&& __r)
const
3226 return join_view<all_t<_Range>>{std::forward<_Range>(__r)};
3229 static constexpr bool _S_has_simple_call_op =
true;
3232 inline constexpr _Join join;
3238 struct __require_constant;
3240 template<
typename _Range>
3241 concept __tiny_range = sized_range<_Range>
3243 {
typename __require_constant<remove_reference_t<_Range>::size()>; }
3244 && (remove_reference_t<_Range>::size() <= 1);
3246 template<
typename _Base>
3247 struct __lazy_split_view_outer_iter_cat
3250 template<forward_range _Base>
3251 struct __lazy_split_view_outer_iter_cat<_Base>
3252 {
using iterator_category = input_iterator_tag; };
3254 template<
typename _Base>
3255 struct __lazy_split_view_inner_iter_cat
3258 template<forward_range _Base>
3259 struct __lazy_split_view_inner_iter_cat<_Base>
3262 static constexpr auto
3265 using _Cat =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
3266 if constexpr (derived_from<_Cat, forward_iterator_tag>)
3267 return forward_iterator_tag{};
3272 using iterator_category =
decltype(_S_iter_cat());
3276 template<input_range _Vp, forward_range _Pattern>
3277 requires view<_Vp> && view<_Pattern>
3278 && indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
3280 && (forward_range<_Vp> || __detail::__tiny_range<_Pattern>)
3281 class lazy_split_view : public view_interface<lazy_split_view<_Vp, _Pattern>>
3284 template<
bool _Const>
3285 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
3287 template<
bool _Const>
3290 template<
bool _Const>
3292 : __detail::__lazy_split_view_outer_iter_cat<_Base<_Const>>
3295 using _Parent = __detail::__maybe_const_t<_Const, lazy_split_view>;
3296 using _Base = lazy_split_view::_Base<_Const>;
3300 {
return __current() == ranges::end(_M_parent->_M_base) && !_M_trailing_empty; }
3307 __current() noexcept
3309 if constexpr (forward_range<_Vp>)
3312 return *_M_parent->_M_current;
3316 __current() const noexcept
3318 if constexpr (forward_range<_Vp>)
3321 return *_M_parent->_M_current;
3324 _Parent* _M_parent =
nullptr;
3326 [[no_unique_address]]
3327 __detail::__maybe_present_t<forward_range<_Vp>,
3328 iterator_t<_Base>> _M_current;
3329 bool _M_trailing_empty =
false;
3332 using iterator_concept = __conditional_t<forward_range<_Base>,
3333 forward_iterator_tag,
3334 input_iterator_tag>;
3336 using difference_type = range_difference_t<_Base>;
3338 struct value_type : view_interface<value_type>
3341 _OuterIter _M_i = _OuterIter();
3344 value_type() =
default;
3347 value_type(_OuterIter __i)
3351 constexpr _InnerIter<_Const>
3353 {
return _InnerIter<_Const>{_M_i}; }
3355 constexpr default_sentinel_t
3356 end() const noexcept
3360 _OuterIter() =
default;
3363 _OuterIter(_Parent* __parent)
requires (!forward_range<_Base>)
3364 : _M_parent(__parent)
3368 _OuterIter(_Parent* __parent, iterator_t<_Base> __current)
3369 requires forward_range<_Base>
3370 : _M_parent(__parent),
3375 _OuterIter(_OuterIter<!_Const> __i)
3377 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
3378 : _M_parent(__i._M_parent), _M_current(
std::move(__i._M_current)),
3379 _M_trailing_empty(__i._M_trailing_empty)
3382 constexpr value_type
3384 {
return value_type{*
this}; }
3386 constexpr _OuterIter&
3391 const auto __end = ranges::end(_M_parent->_M_base);
3392 if (__current() == __end)
3394 _M_trailing_empty =
false;
3397 const auto [__pbegin, __pend] = subrange{_M_parent->_M_pattern};
3398 if (__pbegin == __pend)
3400 else if constexpr (__detail::__tiny_range<_Pattern>)
3402 __current() = ranges::find(
std::move(__current()), __end,
3404 if (__current() != __end)
3407 if (__current() == __end)
3408 _M_trailing_empty =
true;
3415 = ranges::mismatch(__current(), __end, __pbegin, __pend);
3419 if (__current() == __end)
3420 _M_trailing_empty =
true;
3423 }
while (++__current() != __end);
3427 constexpr decltype(
auto)
3430 if constexpr (forward_range<_Base>)
3440 friend constexpr bool
3441 operator==(
const _OuterIter& __x,
const _OuterIter& __y)
3442 requires forward_range<_Base>
3444 return __x._M_current == __y._M_current
3445 && __x._M_trailing_empty == __y._M_trailing_empty;
3448 friend constexpr bool
3449 operator==(
const _OuterIter& __x, default_sentinel_t)
3450 {
return __x.__at_end(); };
3452 friend _OuterIter<!_Const>;
3453 friend _InnerIter<_Const>;
3456 template<
bool _Const>
3458 : __detail::__lazy_split_view_inner_iter_cat<_Base<_Const>>
3461 using _Base = lazy_split_view::_Base<_Const>;
3466 auto [__pcur, __pend] = subrange{_M_i._M_parent->_M_pattern};
3467 auto __end = ranges::end(_M_i._M_parent->_M_base);
3468 if constexpr (__detail::__tiny_range<_Pattern>)
3470 const auto& __cur = _M_i_current();
3473 if (__pcur == __pend)
3474 return _M_incremented;
3475 return *__cur == *__pcur;
3479 auto __cur = _M_i_current();
3482 if (__pcur == __pend)
3483 return _M_incremented;
3486 if (*__cur != *__pcur)
3488 if (++__pcur == __pend)
3490 }
while (++__cur != __end);
3496 _M_i_current() noexcept
3497 {
return _M_i.__current(); }
3500 _M_i_current() const noexcept
3501 {
return _M_i.__current(); }
3503 _OuterIter<_Const> _M_i = _OuterIter<_Const>();
3504 bool _M_incremented =
false;
3507 using iterator_concept
3508 =
typename _OuterIter<_Const>::iterator_concept;
3510 using value_type = range_value_t<_Base>;
3511 using difference_type = range_difference_t<_Base>;
3513 _InnerIter() =
default;
3516 _InnerIter(_OuterIter<_Const> __i)
3520 constexpr const iterator_t<_Base>&
3521 base() const& noexcept
3522 {
return _M_i_current(); }
3524 constexpr iterator_t<_Base>
3525 base() &&
requires forward_range<_Vp>
3528 constexpr decltype(
auto)
3530 {
return *_M_i_current(); }
3532 constexpr _InnerIter&
3535 _M_incremented =
true;
3536 if constexpr (!forward_range<_Base>)
3537 if constexpr (_Pattern::size() == 0)
3543 constexpr decltype(
auto)
3546 if constexpr (forward_range<_Base>)
3556 friend constexpr bool
3557 operator==(
const _InnerIter& __x,
const _InnerIter& __y)
3558 requires forward_range<_Base>
3559 {
return __x._M_i == __y._M_i; }
3561 friend constexpr bool
3562 operator==(
const _InnerIter& __x, default_sentinel_t)
3563 {
return __x.__at_end(); }
3565 friend constexpr decltype(
auto)
3566 iter_move(
const _InnerIter& __i)
3567 noexcept(
noexcept(ranges::iter_move(__i._M_i_current())))
3568 {
return ranges::iter_move(__i._M_i_current()); }
3570 friend constexpr void
3571 iter_swap(
const _InnerIter& __x,
const _InnerIter& __y)
3572 noexcept(
noexcept(ranges::iter_swap(__x._M_i_current(),
3573 __y._M_i_current())))
3574 requires indirectly_swappable<iterator_t<_Base>>
3575 { ranges::iter_swap(__x._M_i_current(), __y._M_i_current()); }
3578 _Vp _M_base = _Vp();
3579 _Pattern _M_pattern = _Pattern();
3580 [[no_unique_address]]
3581 __detail::__maybe_present_t<!forward_range<_Vp>,
3582 __detail::__non_propagating_cache<iterator_t<_Vp>>> _M_current;
3586 lazy_split_view()
requires (default_initializable<_Vp>
3587 && default_initializable<_Pattern>)
3591 lazy_split_view(_Vp __base, _Pattern __pattern)
3595 template<input_range _Range>
3596 requires constructible_from<_Vp, views::all_t<_Range>>
3597 && constructible_from<_Pattern, single_view<range_value_t<_Range>>>
3599 lazy_split_view(_Range&& __r, range_value_t<_Range> __e)
3600 : _M_base(views::all(
std::
forward<_Range>(__r))),
3601 _M_pattern(views::single(
std::
move(__e)))
3605 base() const& requires copy_constructible<_Vp>
3615 if constexpr (forward_range<_Vp>)
3617 constexpr bool __simple
3618 = __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
3619 return _OuterIter<__simple>{
this, ranges::begin(_M_base)};
3623 _M_current = ranges::begin(_M_base);
3624 return _OuterIter<false>{
this};
3629 begin() const requires forward_range<_Vp> && forward_range<const _Vp>
3631 return _OuterIter<true>{
this, ranges::begin(_M_base)};
3635 end()
requires forward_range<_Vp> && common_range<_Vp>
3637 constexpr bool __simple
3638 = __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
3639 return _OuterIter<__simple>{
this, ranges::end(_M_base)};
3645 if constexpr (forward_range<_Vp>
3646 && forward_range<const _Vp>
3647 && common_range<const _Vp>)
3648 return _OuterIter<true>{
this, ranges::end(_M_base)};
3654 template<
typename _Range,
typename _Pattern>
3655 lazy_split_view(_Range&&, _Pattern&&)
3656 -> lazy_split_view<views::all_t<_Range>, views::all_t<_Pattern>>;
3658 template<input_range _Range>
3659 lazy_split_view(_Range&&, range_value_t<_Range>)
3660 -> lazy_split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
3666 template<
typename _Range,
typename _Pattern>
3667 concept __can_lazy_split_view
3668 =
requires { lazy_split_view(std::declval<_Range>(), std::declval<_Pattern>()); };
3671 struct _LazySplit : __adaptor::_RangeAdaptor<_LazySplit>
3673 template<viewable_range _Range,
typename _Pattern>
3674 requires __detail::__can_lazy_split_view<_Range, _Pattern>
3676 operator() [[nodiscard]] (_Range&& __r, _Pattern&& __f)
const
3678 return lazy_split_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
3681 using _RangeAdaptor<_LazySplit>::operator();
3682 static constexpr int _S_arity = 2;
3687 template<
typename _Pattern>
3688 static constexpr bool _S_has_simple_extra_args
3689 = is_scalar_v<_Pattern> || (view<_Pattern>
3690 && copy_constructible<_Pattern>);
3693 inline constexpr _LazySplit lazy_split;
3696 template<forward_range _Vp, forward_range _Pattern>
3697 requires view<_Vp> && view<_Pattern>
3698 && indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
3700 class split_view :
public view_interface<split_view<_Vp, _Pattern>>
3703 _Vp _M_base = _Vp();
3704 _Pattern _M_pattern = _Pattern();
3705 __detail::__non_propagating_cache<subrange<iterator_t<_Vp>>> _M_cached_begin;
3711 split_view()
requires (default_initializable<_Vp>
3712 && default_initializable<_Pattern>)
3716 split_view(_Vp __base, _Pattern __pattern)
3720 template<forward_range _Range>
3721 requires constructible_from<_Vp, views::all_t<_Range>>
3722 && constructible_from<_Pattern, single_view<range_value_t<_Range>>>
3724 split_view(_Range&& __r, range_value_t<_Range> __e)
3725 : _M_base(views::all(
std::
forward<_Range>(__r))),
3726 _M_pattern(views::single(
std::
move(__e)))
3730 base() const& requires copy_constructible<_Vp>
3740 if (!_M_cached_begin)
3741 _M_cached_begin = _M_find_next(ranges::begin(_M_base));
3742 return {
this, ranges::begin(_M_base), *_M_cached_begin};
3748 if constexpr (common_range<_Vp>)
3749 return _Iterator{
this, ranges::end(_M_base), {}};
3751 return _Sentinel{
this};
3754 constexpr subrange<iterator_t<_Vp>>
3755 _M_find_next(iterator_t<_Vp> __it)
3757 auto [__b, __e] = ranges::search(subrange(__it, ranges::end(_M_base)), _M_pattern);
3758 if (__b != ranges::end(_M_base) && ranges::empty(_M_pattern))
3770 split_view* _M_parent =
nullptr;
3771 iterator_t<_Vp> _M_cur = iterator_t<_Vp>();
3772 subrange<iterator_t<_Vp>> _M_next = subrange<iterator_t<_Vp>>();
3773 bool _M_trailing_empty =
false;
3775 friend struct _Sentinel;
3778 using iterator_concept = forward_iterator_tag;
3779 using iterator_category = input_iterator_tag;
3780 using value_type = subrange<iterator_t<_Vp>>;
3781 using difference_type = range_difference_t<_Vp>;
3783 _Iterator() =
default;
3786 _Iterator(split_view* __parent,
3787 iterator_t<_Vp> __current,
3788 subrange<iterator_t<_Vp>> __next)
3789 : _M_parent(__parent),
3794 constexpr iterator_t<_Vp>
3798 constexpr value_type
3800 {
return {_M_cur, _M_next.begin()}; }
3802 constexpr _Iterator&
3805 _M_cur = _M_next.begin();
3806 if (_M_cur != ranges::end(_M_parent->_M_base))
3808 _M_cur = _M_next.end();
3809 if (_M_cur == ranges::end(_M_parent->_M_base))
3811 _M_trailing_empty =
true;
3812 _M_next = {_M_cur, _M_cur};
3815 _M_next = _M_parent->_M_find_next(_M_cur);
3818 _M_trailing_empty =
false;
3830 friend constexpr bool
3831 operator==(
const _Iterator& __x,
const _Iterator& __y)
3833 return __x._M_cur == __y._M_cur
3834 && __x._M_trailing_empty == __y._M_trailing_empty;
3841 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
3844 _M_equal(
const _Iterator& __x)
const
3845 {
return __x._M_cur == _M_end && !__x._M_trailing_empty; }
3848 _Sentinel() =
default;
3851 _Sentinel(split_view* __parent)
3852 : _M_end(ranges::
end(__parent->_M_base))
3855 friend constexpr bool
3856 operator==(
const _Iterator& __x,
const _Sentinel& __y)
3857 {
return __y._M_equal(__x); }
3861 template<
typename _Range,
typename _Pattern>
3862 split_view(_Range&&, _Pattern&&)
3863 -> split_view<views::all_t<_Range>, views::all_t<_Pattern>>;
3865 template<forward_range _Range>
3866 split_view(_Range&&, range_value_t<_Range>)
3867 -> split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
3873 template<
typename _Range,
typename _Pattern>
3874 concept __can_split_view
3875 =
requires { split_view(std::declval<_Range>(), std::declval<_Pattern>()); };
3878 struct _Split : __adaptor::_RangeAdaptor<_Split>
3880 template<viewable_range _Range,
typename _Pattern>
3881 requires __detail::__can_split_view<_Range, _Pattern>
3883 operator() [[nodiscard]] (_Range&& __r, _Pattern&& __f)
const
3885 return split_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
3888 using _RangeAdaptor<_Split>::operator();
3889 static constexpr int _S_arity = 2;
3890 template<
typename _Pattern>
3891 static constexpr bool _S_has_simple_extra_args
3892 = _LazySplit::_S_has_simple_extra_args<_Pattern>;
3895 inline constexpr _Split split;
3902 template<input_or_output_iterator _Iter>
3904 operator() [[nodiscard]] (_Iter __i, iter_difference_t<_Iter> __n)
const
3906 if constexpr (contiguous_iterator<_Iter>)
3907 return span(std::__to_address(__i), __n);
3908 else if constexpr (random_access_iterator<_Iter>)
3909 return subrange(__i, __i + __n);
3911 return subrange(counted_iterator(
std::move(__i), __n),
3916 inline constexpr _Counted counted{};
3920 requires (!common_range<_Vp>) && copyable<iterator_t<_Vp>>
3921 class common_view : public view_interface<common_view<_Vp>>
3924 _Vp _M_base = _Vp();
3927 common_view()
requires default_initializable<_Vp> = default;
3930 common_view(_Vp __r)
3931 : _M_base(
std::move(__r))
3935 base() const& requires copy_constructible<_Vp>
3945 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3946 return ranges::begin(_M_base);
3948 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
3949 (ranges::begin(_M_base));
3953 begin() const requires range<const _Vp>
3955 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
3956 return ranges::begin(_M_base);
3958 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
3959 (ranges::begin(_M_base));
3965 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3966 return ranges::begin(_M_base) + ranges::size(_M_base);
3968 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
3969 (ranges::end(_M_base));
3973 end() const requires range<const _Vp>
3975 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
3976 return ranges::begin(_M_base) + ranges::size(_M_base);
3978 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
3979 (ranges::end(_M_base));
3983 size()
requires sized_range<_Vp>
3984 {
return ranges::size(_M_base); }
3987 size() const requires sized_range<const _Vp>
3988 {
return ranges::size(_M_base); }
3991 template<
typename _Range>
3992 common_view(_Range&&) -> common_view<views::all_t<_Range>>;
3994 template<
typename _Tp>
3995 inline constexpr bool enable_borrowed_range<common_view<_Tp>>
3996 = enable_borrowed_range<_Tp>;
4002 template<
typename _Range>
4003 concept __already_common = common_range<_Range>
4004 &&
requires { views::all(std::declval<_Range>()); };
4006 template<
typename _Range>
4007 concept __can_common_view
4008 =
requires { common_view{std::declval<_Range>()}; };
4011 struct _Common : __adaptor::_RangeAdaptorClosure<_Common>
4013 template<viewable_range _Range>
4014 requires __detail::__already_common<_Range>
4015 || __detail::__can_common_view<_Range>
4017 operator() [[nodiscard]] (_Range&& __r)
const
4019 if constexpr (__detail::__already_common<_Range>)
4020 return views::all(std::forward<_Range>(__r));
4022 return common_view{std::forward<_Range>(__r)};
4025 static constexpr bool _S_has_simple_call_op =
true;
4028 inline constexpr _Common common;
4032 requires bidirectional_range<_Vp>
4033 class reverse_view :
public view_interface<reverse_view<_Vp>>
4036 static constexpr bool _S_needs_cached_begin
4037 = !common_range<_Vp> && !(random_access_range<_Vp>
4038 && sized_sentinel_for<sentinel_t<_Vp>,
4041 _Vp _M_base = _Vp();
4042 [[no_unique_address]]
4043 __detail::__maybe_present_t<_S_needs_cached_begin,
4044 __detail::_CachedPosition<_Vp>>
4048 reverse_view()
requires default_initializable<_Vp> = default;
4051 reverse_view(_Vp __r)
4052 : _M_base(
std::move(__r))
4056 base() const& requires copy_constructible<_Vp>
4063 constexpr reverse_iterator<iterator_t<_Vp>>
4066 if constexpr (_S_needs_cached_begin)
4067 if (_M_cached_begin._M_has_value())
4070 auto __it = ranges::next(ranges::begin(_M_base), ranges::end(_M_base));
4071 if constexpr (_S_needs_cached_begin)
4072 _M_cached_begin._M_set(_M_base, __it);
4077 begin()
requires common_range<_Vp>
4081 begin() const requires common_range<const _Vp>
4084 constexpr reverse_iterator<iterator_t<_Vp>>
4089 end() const requires common_range<const _Vp>
4093 size()
requires sized_range<_Vp>
4094 {
return ranges::size(_M_base); }
4097 size() const requires sized_range<const _Vp>
4098 {
return ranges::size(_M_base); }
4101 template<
typename _Range>
4102 reverse_view(_Range&&) -> reverse_view<views::all_t<_Range>>;
4104 template<
typename _Tp>
4105 inline constexpr bool enable_borrowed_range<reverse_view<_Tp>>
4106 = enable_borrowed_range<_Tp>;
4113 inline constexpr bool __is_reversible_subrange =
false;
4115 template<
typename _Iter, subrange_kind _Kind>
4116 inline constexpr bool
4117 __is_reversible_subrange<subrange<reverse_iterator<_Iter>,
4118 reverse_iterator<_Iter>,
4122 inline constexpr bool __is_reverse_view =
false;
4124 template<
typename _Vp>
4125 inline constexpr bool __is_reverse_view<reverse_view<_Vp>> =
true;
4127 template<
typename _Range>
4128 concept __can_reverse_view
4129 =
requires { reverse_view{std::declval<_Range>()}; };
4132 struct _Reverse : __adaptor::_RangeAdaptorClosure<_Reverse>
4134 template<viewable_range _Range>
4135 requires __detail::__is_reverse_view<remove_cvref_t<_Range>>
4136 || __detail::__is_reversible_subrange<remove_cvref_t<_Range>>
4137 || __detail::__can_reverse_view<_Range>
4139 operator() [[nodiscard]] (_Range&& __r)
const
4141 using _Tp = remove_cvref_t<_Range>;
4142 if constexpr (__detail::__is_reverse_view<_Tp>)
4143 return std::forward<_Range>(__r).base();
4144 else if constexpr (__detail::__is_reversible_subrange<_Tp>)
4146 using _Iter =
decltype(ranges::begin(__r).base());
4147 if constexpr (sized_range<_Tp>)
4148 return subrange<_Iter, _Iter, subrange_kind::sized>
4149 {__r.end().base(), __r.begin().base(), __r.size()};
4151 return subrange<_Iter, _Iter, subrange_kind::unsized>
4152 {__r.end().base(), __r.begin().base()};
4155 return reverse_view{std::forward<_Range>(__r)};
4158 static constexpr bool _S_has_simple_call_op =
true;
4161 inline constexpr _Reverse reverse;
4166 template<
typename _Tp,
size_t _Nm>
4167 concept __has_tuple_element =
requires(_Tp __t)
4169 typename tuple_size<_Tp>::type;
4170 requires _Nm < tuple_size_v<_Tp>;
4171 typename tuple_element_t<_Nm, _Tp>;
4172 { std::get<_Nm>(__t) }
4173 -> convertible_to<const tuple_element_t<_Nm, _Tp>&>;
4176 template<
typename _Tp,
size_t _Nm>
4177 concept __returnable_element
4178 = is_reference_v<_Tp> || move_constructible<tuple_element_t<_Nm, _Tp>>;
4181 template<input_range _Vp,
size_t _Nm>
4183 && __detail::__has_tuple_element<range_value_t<_Vp>, _Nm>
4184 && __detail::__has_tuple_element<remove_reference_t<range_reference_t<_Vp>>,
4186 && __detail::__returnable_element<range_reference_t<_Vp>, _Nm>
4187 class elements_view :
public view_interface<elements_view<_Vp, _Nm>>
4190 elements_view()
requires default_initializable<_Vp> = default;
4193 elements_view(_Vp __base)
4194 : _M_base(
std::move(__base))
4198 base() const& requires copy_constructible<_Vp>
4206 begin()
requires (!__detail::__simple_view<_Vp>)
4207 {
return _Iterator<false>(ranges::begin(_M_base)); }
4210 begin() const requires range<const _Vp>
4211 {
return _Iterator<true>(ranges::begin(_M_base)); }
4214 end()
requires (!__detail::__simple_view<_Vp> && !common_range<_Vp>)
4215 {
return _Sentinel<false>{ranges::end(_M_base)}; }
4218 end()
requires (!__detail::__simple_view<_Vp> && common_range<_Vp>)
4219 {
return _Iterator<false>{ranges::end(_M_base)}; }
4222 end() const requires range<const _Vp>
4223 {
return _Sentinel<true>{ranges::end(_M_base)}; }
4226 end() const requires common_range<const _Vp>
4227 {
return _Iterator<true>{ranges::end(_M_base)}; }
4230 size()
requires sized_range<_Vp>
4231 {
return ranges::size(_M_base); }
4234 size() const requires sized_range<const _Vp>
4235 {
return ranges::size(_M_base); }
4238 template<
bool _Const>
4239 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
4241 template<
bool _Const>
4245 template<
bool _Const>
4246 requires forward_range<_Base<_Const>>
4247 struct __iter_cat<_Const>
4250 static auto _S_iter_cat()
4252 using _Base = elements_view::_Base<_Const>;
4253 using _Cat =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
4254 using _Res =
decltype((std::get<_Nm>(*
std::declval<iterator_t<_Base>>())));
4255 if constexpr (!is_lvalue_reference_v<_Res>)
4256 return input_iterator_tag{};
4257 else if constexpr (derived_from<_Cat, random_access_iterator_tag>)
4258 return random_access_iterator_tag{};
4263 using iterator_category =
decltype(_S_iter_cat());
4266 template<
bool _Const>
4269 template<
bool _Const>
4270 struct _Iterator : __iter_cat<_Const>
4273 using _Base = elements_view::_Base<_Const>;
4275 iterator_t<_Base> _M_current = iterator_t<_Base>();
4277 static constexpr decltype(
auto)
4278 _S_get_element(
const iterator_t<_Base>& __i)
4280 if constexpr (is_reference_v<range_reference_t<_Base>>)
4281 return std::get<_Nm>(*__i);
4284 using _Et = remove_cv_t<tuple_element_t<_Nm, range_reference_t<_Base>>>;
4285 return static_cast<_Et
>(std::get<_Nm>(*__i));
4292 if constexpr (random_access_range<_Base>)
4293 return random_access_iterator_tag{};
4294 else if constexpr (bidirectional_range<_Base>)
4295 return bidirectional_iterator_tag{};
4296 else if constexpr (forward_range<_Base>)
4297 return forward_iterator_tag{};
4299 return input_iterator_tag{};
4302 friend _Iterator<!_Const>;
4305 using iterator_concept =
decltype(_S_iter_concept());
4308 = remove_cvref_t<tuple_element_t<_Nm, range_value_t<_Base>>>;
4309 using difference_type = range_difference_t<_Base>;
4311 _Iterator()
requires default_initializable<iterator_t<_Base>> = default;
4314 _Iterator(iterator_t<_Base> __current)
4315 : _M_current(
std::move(__current))
4319 _Iterator(_Iterator<!_Const> __i)
4320 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
4324 constexpr const iterator_t<_Base>&
4325 base() const& noexcept
4326 {
return _M_current; }
4328 constexpr iterator_t<_Base>
4332 constexpr decltype(
auto)
4334 {
return _S_get_element(_M_current); }
4336 constexpr _Iterator&
4348 operator++(
int)
requires forward_range<_Base>
4355 constexpr _Iterator&
4356 operator--()
requires bidirectional_range<_Base>
4363 operator--(
int)
requires bidirectional_range<_Base>
4370 constexpr _Iterator&
4371 operator+=(difference_type __n)
4372 requires random_access_range<_Base>
4378 constexpr _Iterator&
4379 operator-=(difference_type __n)
4380 requires random_access_range<_Base>
4386 constexpr decltype(
auto)
4387 operator[](difference_type __n)
const
4388 requires random_access_range<_Base>
4389 {
return _S_get_element(_M_current + __n); }
4391 friend constexpr bool
4392 operator==(
const _Iterator& __x,
const _Iterator& __y)
4393 requires equality_comparable<iterator_t<_Base>>
4394 {
return __x._M_current == __y._M_current; }
4396 friend constexpr bool
4397 operator<(
const _Iterator& __x,
const _Iterator& __y)
4398 requires random_access_range<_Base>
4399 {
return __x._M_current < __y._M_current; }
4401 friend constexpr bool
4402 operator>(
const _Iterator& __x,
const _Iterator& __y)
4403 requires random_access_range<_Base>
4404 {
return __y._M_current < __x._M_current; }
4406 friend constexpr bool
4407 operator<=(
const _Iterator& __x,
const _Iterator& __y)
4408 requires random_access_range<_Base>
4409 {
return !(__y._M_current > __x._M_current); }
4411 friend constexpr bool
4412 operator>=(
const _Iterator& __x,
const _Iterator& __y)
4413 requires random_access_range<_Base>
4414 {
return !(__x._M_current > __y._M_current); }
4416#ifdef __cpp_lib_three_way_comparison
4417 friend constexpr auto
4418 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
4419 requires random_access_range<_Base>
4420 && three_way_comparable<iterator_t<_Base>>
4421 {
return __x._M_current <=> __y._M_current; }
4424 friend constexpr _Iterator
4425 operator+(
const _Iterator& __x, difference_type __y)
4426 requires random_access_range<_Base>
4427 {
return _Iterator{__x} += __y; }
4429 friend constexpr _Iterator
4430 operator+(difference_type __x,
const _Iterator& __y)
4431 requires random_access_range<_Base>
4432 {
return __y + __x; }
4434 friend constexpr _Iterator
4435 operator-(
const _Iterator& __x, difference_type __y)
4436 requires random_access_range<_Base>
4437 {
return _Iterator{__x} -= __y; }
4441 friend constexpr difference_type
4442 operator-(
const _Iterator& __x,
const _Iterator& __y)
4443 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
4444 {
return __x._M_current - __y._M_current; }
4446 template <
bool>
friend struct _Sentinel;
4449 template<
bool _Const>
4453 template<
bool _Const2>
4455 _M_equal(
const _Iterator<_Const2>& __x)
const
4456 {
return __x._M_current == _M_end; }
4458 template<
bool _Const2>
4460 _M_distance_from(
const _Iterator<_Const2>& __i)
const
4461 {
return _M_end - __i._M_current; }
4463 using _Base = elements_view::_Base<_Const>;
4464 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
4467 _Sentinel() =
default;
4470 _Sentinel(sentinel_t<_Base> __end)
4475 _Sentinel(_Sentinel<!_Const> __other)
4477 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
4481 constexpr sentinel_t<_Base>
4485 template<
bool _Const2>
4486 requires sentinel_for<sentinel_t<_Base>,
4487 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
4488 friend constexpr bool
4489 operator==(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
4490 {
return __y._M_equal(__x); }
4492 template<
bool _Const2,
4493 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
4494 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
4495 friend constexpr range_difference_t<_Base2>
4496 operator-(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
4497 {
return -__y._M_distance_from(__x); }
4499 template<
bool _Const2,
4500 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
4501 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
4502 friend constexpr range_difference_t<_Base2>
4503 operator-(
const _Sentinel& __x,
const _Iterator<_Const2>& __y)
4504 {
return __x._M_distance_from(__y); }
4506 friend _Sentinel<!_Const>;
4509 _Vp _M_base = _Vp();
4512 template<
typename _Tp,
size_t _Nm>
4513 inline constexpr bool enable_borrowed_range<elements_view<_Tp, _Nm>>
4514 = enable_borrowed_range<_Tp>;
4516 template<
typename _Range>
4517 using keys_view = elements_view<views::all_t<_Range>, 0>;
4519 template<
typename _Range>
4520 using values_view = elements_view<views::all_t<_Range>, 1>;
4526 template<
size_t _Nm,
typename _Range>
4527 concept __can_elements_view
4528 =
requires { elements_view<all_t<_Range>, _Nm>{std::declval<_Range>()}; };
4531 template<
size_t _Nm>
4532 struct _Elements : __adaptor::_RangeAdaptorClosure<_Elements<_Nm>>
4534 template<viewable_range _Range>
4535 requires __detail::__can_elements_view<_Nm, _Range>
4537 operator() [[nodiscard]] (_Range&& __r)
const
4539 return elements_view<all_t<_Range>, _Nm>{std::forward<_Range>(__r)};
4542 static constexpr bool _S_has_simple_call_op =
true;
4545 template<
size_t _Nm>
4546 inline constexpr _Elements<_Nm> elements;
4547 inline constexpr auto keys = elements<0>;
4548 inline constexpr auto values = elements<1>;
4551#ifdef __cpp_lib_ranges_zip
4554 template<
typename... _Rs>
4555 concept __zip_is_common = (
sizeof...(_Rs) == 1 && (common_range<_Rs> && ...))
4556 || (!(bidirectional_range<_Rs> && ...) && (common_range<_Rs> && ...))
4557 || ((random_access_range<_Rs> && ...) && (sized_range<_Rs> && ...));
4559 template<
typename... _Ts>
4560 struct __tuple_or_pair
4563 template<
typename _Tp,
typename _Up>
4564 struct __tuple_or_pair<_Tp, _Up>
4565 {
using type = pair<_Tp, _Up>; };
4567 template<
typename... _Ts>
4568 using __tuple_or_pair_t =
typename __tuple_or_pair<_Ts...>::type;
4570 template<
typename _Fp,
typename _Tuple>
4572 __tuple_transform(_Fp&& __f, _Tuple&& __tuple)
4574 return std::apply([&]<
typename... _Ts>(_Ts&&... __elts) {
4575 return __tuple_or_pair_t<invoke_result_t<_Fp&, _Ts>...>
4577 }, std::forward<_Tuple>(__tuple));
4580 template<
typename _Fp,
typename _Tuple>
4582 __tuple_for_each(_Fp&& __f, _Tuple&& __tuple)
4584 std::apply([&]<
typename... _Ts>(_Ts&&... __elts) {
4586 }, std::forward<_Tuple>(__tuple));
4590 template<input_range... _Vs>
4591 requires (view<_Vs> && ...) && (
sizeof...(_Vs) > 0)
4592 class zip_view :
public view_interface<zip_view<_Vs...>>
4594 tuple<_Vs...> _M_views;
4596 template<
bool>
class _Iterator;
4597 template<
bool>
class _Sentinel;
4600 zip_view() =
default;
4603 zip_view(_Vs... __views)
4604 : _M_views(
std::
move(__views)...)
4608 begin()
requires (!(__detail::__simple_view<_Vs> && ...))
4609 {
return _Iterator<false>(__detail::__tuple_transform(ranges::begin, _M_views)); }
4612 begin() const requires (range<const _Vs> && ...)
4613 {
return _Iterator<true>(__detail::__tuple_transform(ranges::begin, _M_views)); }
4616 end()
requires (!(__detail::__simple_view<_Vs> && ...))
4618 if constexpr (!__detail::__zip_is_common<_Vs...>)
4619 return _Sentinel<false>(__detail::__tuple_transform(ranges::end, _M_views));
4620 else if constexpr ((random_access_range<_Vs> && ...))
4621 return begin() + iter_difference_t<_Iterator<false>>(
size());
4623 return _Iterator<false>(__detail::__tuple_transform(ranges::end, _M_views));
4627 end() const requires (range<const _Vs> && ...)
4629 if constexpr (!__detail::__zip_is_common<
const _Vs...>)
4630 return _Sentinel<true>(__detail::__tuple_transform(ranges::end, _M_views));
4631 else if constexpr ((random_access_range<const _Vs> && ...))
4632 return begin() + iter_difference_t<_Iterator<true>>(
size());
4634 return _Iterator<true>(__detail::__tuple_transform(ranges::end, _M_views));
4638 size()
requires (sized_range<_Vs> && ...)
4640 return std::apply([](
auto... sizes) {
4641 using _CT = __detail::__make_unsigned_like_t<
common_type_t<
decltype(sizes)...>>;
4642 return ranges::min({_CT(sizes)...});
4643 }, __detail::__tuple_transform(ranges::size, _M_views));
4647 size() const requires (sized_range<const _Vs> && ...)
4649 return std::apply([](
auto... sizes) {
4650 using _CT = __detail::__make_unsigned_like_t<
common_type_t<
decltype(sizes)...>>;
4651 return ranges::min({_CT(sizes)...});
4652 }, __detail::__tuple_transform(ranges::size, _M_views));
4656 template<
typename... _Rs>
4657 zip_view(_Rs&&...) -> zip_view<views::all_t<_Rs>...>;
4659 template<
typename... _Views>
4660 inline constexpr bool enable_borrowed_range<zip_view<_Views...>>
4661 = (enable_borrowed_range<_Views> && ...);
4665 template<
bool _Const,
typename... _Vs>
4666 concept __all_random_access
4667 = (random_access_range<__maybe_const_t<_Const, _Vs>> && ...);
4669 template<
bool _Const,
typename... _Vs>
4670 concept __all_bidirectional
4671 = (bidirectional_range<__maybe_const_t<_Const, _Vs>> && ...);
4673 template<
bool _Const,
typename... _Vs>
4674 concept __all_forward
4675 = (forward_range<__maybe_const_t<_Const, _Vs>> && ...);
4677 template<
bool _Const,
typename... _Views>
4678 struct __zip_view_iter_cat
4681 template<
bool _Const,
typename... _Views>
4682 requires __all_forward<_Const, _Views...>
4683 struct __zip_view_iter_cat<_Const, _Views...>
4684 {
using iterator_category = input_iterator_tag; };
4687 template<input_range... _Vs>
4688 requires (view<_Vs> && ...) && (
sizeof...(_Vs) > 0)
4689 template<
bool _Const>
4690 class zip_view<_Vs...>::_Iterator
4691 :
public __detail::__zip_view_iter_cat<_Const, _Vs...>
4696 __detail::__tuple_or_pair_t<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>...> _M_current;
4699 _Iterator(
decltype(_M_current) __current)
4700 : _M_current(
std::
move(__current))
4706 if constexpr (__detail::__all_random_access<_Const, _Vs...>)
4707 return random_access_iterator_tag{};
4708 else if constexpr (__detail::__all_bidirectional<_Const, _Vs...>)
4709 return bidirectional_iterator_tag{};
4710 else if constexpr (__detail::__all_forward<_Const, _Vs...>)
4711 return forward_iterator_tag{};
4713 return input_iterator_tag{};
4717 template<move_constructible _Fp, input_range... _Ws>
4718 requires (view<_Ws> && ...) && (
sizeof...(_Ws) > 0) && is_object_v<_Fp>
4719 && regular_invocable<_Fp&, range_reference_t<_Ws>...>
4720 && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Ws>...>>
4721 friend class zip_transform_view;
4726 using iterator_concept =
decltype(_S_iter_concept());
4728 = __detail::__tuple_or_pair_t<range_value_t<__detail::__maybe_const_t<_Const, _Vs>>...>;
4729 using difference_type
4730 = common_type_t<range_difference_t<__detail::__maybe_const_t<_Const, _Vs>>...>;
4732 _Iterator() =
default;
4735 _Iterator(_Iterator<!_Const> __i)
4737 && (convertible_to<iterator_t<_Vs>,
4738 iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4739 : _M_current(
std::
move(__i._M_current))
4745 auto __f = [](
auto& __i) ->
decltype(
auto) {
4748 return __detail::__tuple_transform(__f, _M_current);
4751 constexpr _Iterator&
4754 __detail::__tuple_for_each([](
auto& __i) { ++__i; }, _M_current);
4764 requires __detail::__all_forward<_Const, _Vs...>
4771 constexpr _Iterator&
4773 requires __detail::__all_bidirectional<_Const, _Vs...>
4775 __detail::__tuple_for_each([](
auto& __i) { --__i; }, _M_current);
4781 requires __detail::__all_bidirectional<_Const, _Vs...>
4788 constexpr _Iterator&
4789 operator+=(difference_type __x)
4790 requires __detail::__all_random_access<_Const, _Vs...>
4792 auto __f = [&]<
typename _It>(_It& __i) {
4793 __i += iter_difference_t<_It>(__x);
4795 __detail::__tuple_for_each(__f, _M_current);
4799 constexpr _Iterator&
4800 operator-=(difference_type __x)
4801 requires __detail::__all_random_access<_Const, _Vs...>
4803 auto __f = [&]<
typename _It>(_It& __i) {
4804 __i -= iter_difference_t<_It>(__x);
4806 __detail::__tuple_for_each(__f, _M_current);
4811 operator[](difference_type __n)
const
4812 requires __detail::__all_random_access<_Const, _Vs...>
4814 auto __f = [&]<
typename _It>(_It& __i) ->
decltype(
auto) {
4815 return __i[iter_difference_t<_It>(__n)];
4817 return __detail::__tuple_transform(__f, _M_current);
4820 friend constexpr bool
4821 operator==(
const _Iterator& __x,
const _Iterator& __y)
4822 requires (equality_comparable<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4824 if constexpr (__detail::__all_bidirectional<_Const, _Vs...>)
4825 return __x._M_current == __y._M_current;
4828 return ((std::get<_Is>(__x._M_current) == std::get<_Is>(__y._M_current)) || ...);
4832 friend constexpr auto
4833 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
4834 requires __detail::__all_random_access<_Const, _Vs...>
4835 {
return __x._M_current <=> __y._M_current; }
4837 friend constexpr _Iterator
4838 operator+(
const _Iterator& __i, difference_type __n)
4839 requires __detail::__all_random_access<_Const, _Vs...>
4846 friend constexpr _Iterator
4847 operator+(difference_type __n,
const _Iterator& __i)
4848 requires __detail::__all_random_access<_Const, _Vs...>
4855 friend constexpr _Iterator
4856 operator-(
const _Iterator& __i, difference_type __n)
4857 requires __detail::__all_random_access<_Const, _Vs...>
4864 friend constexpr difference_type
4865 operator-(
const _Iterator& __x,
const _Iterator& __y)
4866 requires (sized_sentinel_for<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>,
4867 iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4870 return ranges::min({difference_type(std::get<_Is>(__x._M_current)
4871 - std::get<_Is>(__y._M_current))...},
4873 [](difference_type __i) {
4874 return __detail::__to_unsigned_like(__i < 0 ? -__i : __i);
4879 friend constexpr auto
4880 iter_move(
const _Iterator& __i)
4881 {
return __detail::__tuple_transform(ranges::iter_move, __i._M_current); }
4883 friend constexpr void
4884 iter_swap(
const _Iterator& __l,
const _Iterator& __r)
4885 requires (indirectly_swappable<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4888 (ranges::iter_swap(std::get<_Is>(__l._M_current), std::get<_Is>(__r._M_current)), ...);
4892 friend class zip_view;
4895 template<input_range... _Vs>
4896 requires (view<_Vs> && ...) && (
sizeof...(_Vs) > 0)
4897 template<
bool _Const>
4898 class zip_view<_Vs...>::_Sentinel
4900 __detail::__tuple_or_pair_t<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>...> _M_end;
4903 _Sentinel(
decltype(_M_end) __end)
4907 friend class zip_view;
4910 _Sentinel() =
default;
4913 _Sentinel(_Sentinel<!_Const> __i)
4915 && (convertible_to<sentinel_t<_Vs>,
4916 sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4917 : _M_end(
std::
move(__i._M_end))
4920 template<
bool _OtherConst>
4921 requires (sentinel_for<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>,
4922 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vs>>> && ...)
4923 friend constexpr bool
4924 operator==(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
4927 return ((std::get<_Is>(__x._M_current) == std::get<_Is>(__y._M_end)) || ...);
4931 template<
bool _OtherConst>
4932 requires (sized_sentinel_for<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>,
4933 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vs>>> && ...)
4934 friend constexpr auto
4935 operator-(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
4938 = common_type_t<range_difference_t<__detail::__maybe_const_t<_OtherConst, _Vs>>...>;
4940 return ranges::min({_Ret(std::get<_Is>(__x._M_current) - std::get<_Is>(__y._M_end))...},
4943 return __detail::__to_unsigned_like(__i < 0 ? -__i : __i);
4948 template<
bool _OtherConst>
4949 requires (sized_sentinel_for<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>,
4950 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vs>>> && ...)
4951 friend constexpr auto
4952 operator-(
const _Sentinel& __y,
const _Iterator<_OtherConst>& __x)
4953 {
return -(__x - __y); }
4960 template<
typename... _Ts>
4961 concept __can_zip_view
4962 =
requires { zip_view<all_t<_Ts>...>(std::declval<_Ts>()...); };
4967 template<
typename... _Ts>
4968 requires (
sizeof...(_Ts) == 0 || __detail::__can_zip_view<_Ts...>)
4970 operator() [[nodiscard]] (_Ts&&... __ts)
const
4972 if constexpr (
sizeof...(_Ts) == 0)
4973 return views::empty<tuple<>>;
4975 return zip_view<all_t<_Ts>...>(std::forward<_Ts>(__ts)...);
4979 inline constexpr _Zip zip;
4984 template<
typename _Range,
bool _Const>
4985 using __range_iter_cat
4986 =
typename iterator_traits<iterator_t<__maybe_const_t<_Const, _Range>>>::iterator_category;
4989 template<move_constructible _Fp, input_range... _Vs>
4990 requires (view<_Vs> && ...) && (
sizeof...(_Vs) > 0) && is_object_v<_Fp>
4991 && regular_invocable<_Fp&, range_reference_t<_Vs>...>
4992 && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Vs>...>>
4993 class zip_transform_view :
public view_interface<zip_transform_view<_Fp, _Vs...>>
4995 [[no_unique_address]] __detail::__box<_Fp> _M_fun;
4996 zip_view<_Vs...> _M_zip;
4998 using _InnerView = zip_view<_Vs...>;
5000 template<
bool _Const>
5001 using __ziperator = iterator_t<__detail::__maybe_const_t<_Const, _InnerView>>;
5003 template<
bool _Const>
5004 using __zentinel = sentinel_t<__detail::__maybe_const_t<_Const, _InnerView>>;
5006 template<
bool _Const>
5007 using _Base = __detail::__maybe_const_t<_Const, _InnerView>;
5009 template<
bool _Const>
5013 template<
bool _Const>
5014 requires forward_range<_Base<_Const>>
5015 struct __iter_cat<_Const>
5021 using __detail::__maybe_const_t;
5022 using __detail::__range_iter_cat;
5023 using _Res = invoke_result_t<__maybe_const_t<_Const, _Fp>&,
5024 range_reference_t<__maybe_const_t<_Const, _Vs>>...>;
5025 if constexpr (!is_lvalue_reference_v<_Res>)
5026 return input_iterator_tag{};
5027 else if constexpr ((derived_from<__range_iter_cat<_Vs, _Const>,
5028 random_access_iterator_tag> && ...))
5029 return random_access_iterator_tag{};
5030 else if constexpr ((derived_from<__range_iter_cat<_Vs, _Const>,
5031 bidirectional_iterator_tag> && ...))
5032 return bidirectional_iterator_tag{};
5033 else if constexpr ((derived_from<__range_iter_cat<_Vs, _Const>,
5034 forward_iterator_tag> && ...))
5035 return forward_iterator_tag{};
5037 return input_iterator_tag{};
5040 using iterator_category =
decltype(_S_iter_cat());
5043 template<
bool>
class _Iterator;
5044 template<
bool>
class _Sentinel;
5047 zip_transform_view() =
default;
5050 zip_transform_view(_Fp __fun, _Vs... __views)
5056 {
return _Iterator<false>(*
this, _M_zip.begin()); }
5060 requires range<const _InnerView>
5061 && regular_invocable<const _Fp&, range_reference_t<const _Vs>...>
5062 {
return _Iterator<true>(*
this, _M_zip.begin()); }
5067 if constexpr (common_range<_InnerView>)
5068 return _Iterator<false>(*
this, _M_zip.end());
5070 return _Sentinel<false>(_M_zip.end());
5075 requires range<const _InnerView>
5076 && regular_invocable<const _Fp&, range_reference_t<const _Vs>...>
5078 if constexpr (common_range<const _InnerView>)
5079 return _Iterator<true>(*
this, _M_zip.end());
5081 return _Sentinel<true>(_M_zip.end());
5085 size()
requires sized_range<_InnerView>
5086 {
return _M_zip.size(); }
5089 size() const requires sized_range<const _InnerView>
5090 {
return _M_zip.size(); }
5093 template<
class _Fp,
class... Rs>
5094 zip_transform_view(_Fp, Rs&&...) -> zip_transform_view<_Fp, views::all_t<Rs>...>;
5096 template<move_constructible _Fp, input_range... _Vs>
5097 requires (view<_Vs> && ...) && (
sizeof...(_Vs) > 0) && is_object_v<_Fp>
5098 && regular_invocable<_Fp&, range_reference_t<_Vs>...>
5099 && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Vs>...>>
5100 template<
bool _Const>
5101 class zip_transform_view<_Fp, _Vs...>::_Iterator :
public __iter_cat<_Const>
5103 using _Parent = __detail::__maybe_const_t<_Const, zip_transform_view>;
5105 _Parent* _M_parent =
nullptr;
5106 __ziperator<_Const> _M_inner;
5109 _Iterator(_Parent& __parent, __ziperator<_Const> __inner)
5113 friend class zip_transform_view;
5117 using iterator_concept =
typename __ziperator<_Const>::iterator_concept;
5119 = remove_cvref_t<invoke_result_t<__detail::__maybe_const_t<_Const, _Fp>&,
5120 range_reference_t<__detail::__maybe_const_t<_Const, _Vs>>...>>;
5121 using difference_type = range_difference_t<_Base<_Const>>;
5123 _Iterator() =
default;
5126 _Iterator(_Iterator<!_Const> __i)
5127 requires _Const && convertible_to<__ziperator<false>, __ziperator<_Const>>
5128 : _M_parent(__i._M_parent), _M_inner(
std::move(__i._M_inner))
5131 constexpr decltype(
auto)
5134 return std::apply([&](
const auto&... __iters) ->
decltype(
auto) {
5136 }, _M_inner._M_current);
5139 constexpr _Iterator&
5151 operator++(
int)
requires forward_range<_Base<_Const>>
5158 constexpr _Iterator&
5159 operator--()
requires bidirectional_range<_Base<_Const>>
5166 operator--(
int)
requires bidirectional_range<_Base<_Const>>
5173 constexpr _Iterator&
5174 operator+=(difference_type __x)
requires random_access_range<_Base<_Const>>
5180 constexpr _Iterator&
5181 operator-=(difference_type __x)
requires random_access_range<_Base<_Const>>
5187 constexpr decltype(
auto)
5188 operator[](difference_type __n)
const requires random_access_range<_Base<_Const>>
5190 return std::apply([&]<
typename... _Is>(
const _Is&... __iters) ->
decltype(
auto) {
5191 return std::__invoke(*_M_parent->_M_fun, __iters[iter_difference_t<_Is>(__n)]...);
5192 }, _M_inner._M_current);
5195 friend constexpr bool
5196 operator==(
const _Iterator& __x,
const _Iterator& __y)
5197 requires equality_comparable<__ziperator<_Const>>
5198 {
return __x._M_inner == __y._M_inner; }
5200 friend constexpr auto
5201 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
5202 requires random_access_range<_Base<_Const>>
5203 {
return __x._M_inner <=> __y._M_inner; }
5205 friend constexpr _Iterator
5206 operator+(
const _Iterator& __i, difference_type __n)
5207 requires random_access_range<_Base<_Const>>
5208 {
return _Iterator(*__i._M_parent, __i._M_inner + __n); }
5210 friend constexpr _Iterator
5211 operator+(difference_type __n,
const _Iterator& __i)
5212 requires random_access_range<_Base<_Const>>
5213 {
return _Iterator(*__i._M_parent, __i._M_inner + __n); }
5215 friend constexpr _Iterator
5216 operator-(
const _Iterator& __i, difference_type __n)
5217 requires random_access_range<_Base<_Const>>
5218 {
return _Iterator(*__i._M_parent, __i._M_inner - __n); }
5220 friend constexpr difference_type
5221 operator-(
const _Iterator& __x,
const _Iterator& __y)
5222 requires sized_sentinel_for<__ziperator<_Const>, __ziperator<_Const>>
5223 {
return __x._M_inner - __y._M_inner; }
5226 template<move_constructible _Fp, input_range... _Vs>
5227 requires (view<_Vs> && ...) && (
sizeof...(_Vs) > 0) && is_object_v<_Fp>
5228 && regular_invocable<_Fp&, range_reference_t<_Vs>...>
5229 && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Vs>...>>
5230 template<
bool _Const>
5231 class zip_transform_view<_Fp, _Vs...>::_Sentinel
5233 __zentinel<_Const> _M_inner;
5236 _Sentinel(__zentinel<_Const> __inner)
5240 friend class zip_transform_view;
5243 _Sentinel() =
default;
5246 _Sentinel(_Sentinel<!_Const> __i)
5247 requires _Const && convertible_to<__zentinel<false>, __zentinel<_Const>>
5251 template<
bool _OtherConst>
5252 requires sentinel_for<__zentinel<_Const>, __ziperator<_OtherConst>>
5253 friend constexpr bool
5254 operator==(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
5255 {
return __x._M_inner == __y._M_inner; }
5257 template<
bool _OtherConst>
5258 requires sized_sentinel_for<__zentinel<_Const>, __ziperator<_OtherConst>>
5259 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
5260 operator-(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
5261 {
return __x._M_inner - __y._M_inner; }
5263 template<
bool _OtherConst>
5264 requires sized_sentinel_for<__zentinel<_Const>, __ziperator<_OtherConst>>
5265 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
5266 operator-(
const _Sentinel& __x,
const _Iterator<_OtherConst>& __y)
5267 {
return __x._M_inner - __y._M_inner; }
5274 template<
typename _Fp,
typename... _Ts>
5275 concept __can_zip_transform_view
5276 =
requires { zip_transform_view(std::declval<_Fp>(), std::declval<_Ts>()...); };
5279 struct _ZipTransform
5281 template<
typename _Fp,
typename... _Ts>
5282 requires (
sizeof...(_Ts) == 0) || __detail::__can_zip_transform_view<_Fp, _Ts...>
5284 operator() [[nodiscard]] (_Fp&& __f, _Ts&&... __ts)
const
5286 if constexpr (
sizeof...(_Ts) == 0)
5287 return views::empty<decay_t<invoke_result_t<decay_t<_Fp>&>>>;
5289 return zip_transform_view(std::forward<_Fp>(__f), std::forward<_Ts>(__ts)...);
5293 inline constexpr _ZipTransform zip_transform;
5296 template<forward_range _Vp,
size_t _Nm>
5297 requires view<_Vp> && (_Nm > 0)
5298 class adjacent_view : public view_interface<adjacent_view<_Vp, _Nm>>
5300 _Vp _M_base = _Vp();
5302 template<
bool>
class _Iterator;
5303 template<
bool>
class _Sentinel;
5305 struct __as_sentinel
5309 adjacent_view()
requires default_initializable<_Vp> = default;
5312 adjacent_view(_Vp __base)
5313 : _M_base(
std::move(__base))
5317 begin()
requires (!__detail::__simple_view<_Vp>)
5318 {
return _Iterator<false>(ranges::begin(_M_base), ranges::end(_M_base)); }
5321 begin() const requires range<const _Vp>
5322 {
return _Iterator<true>(ranges::begin(_M_base), ranges::end(_M_base)); }
5325 end()
requires (!__detail::__simple_view<_Vp>)
5327 if constexpr (common_range<_Vp>)
5328 return _Iterator<false>(__as_sentinel{}, ranges::begin(_M_base), ranges::end(_M_base));
5330 return _Sentinel<false>(ranges::end(_M_base));
5334 end() const requires range<const _Vp>
5336 if constexpr (common_range<const _Vp>)
5337 return _Iterator<true>(__as_sentinel{}, ranges::begin(_M_base), ranges::end(_M_base));
5339 return _Sentinel<true>(ranges::end(_M_base));
5343 size()
requires sized_range<_Vp>
5345 using _ST =
decltype(ranges::size(_M_base));
5346 using _CT = common_type_t<_ST, size_t>;
5347 auto __sz =
static_cast<_CT
>(ranges::size(_M_base));
5348 __sz -= std::min<_CT>(__sz, _Nm - 1);
5349 return static_cast<_ST
>(__sz);
5353 size() const requires sized_range<const _Vp>
5355 using _ST =
decltype(ranges::size(_M_base));
5356 using _CT = common_type_t<_ST, size_t>;
5357 auto __sz =
static_cast<_CT
>(ranges::size(_M_base));
5358 __sz -= std::min<_CT>(__sz, _Nm - 1);
5359 return static_cast<_ST
>(__sz);
5363 template<
typename _Vp,
size_t _Nm>
5364 inline constexpr bool enable_borrowed_range<adjacent_view<_Vp, _Nm>>
5365 = enable_borrowed_range<_Vp>;
5370 template<
typename _Tp,
size_t _Nm>
5375 template<
typename _Fp,
size_t _Nm>
5378 template<
typename... _Ts>
5379 static invoke_result_t<_Fp, _Ts...>
5380 __tuple_apply(
const tuple<_Ts...>&);
5382 template<
typename _Tp>
5383 decltype(__tuple_apply(
std::declval<__repeated_tuple<_Tp, _Nm>>()))
5388 template<forward_range _Vp,
size_t _Nm>
5389 requires view<_Vp> && (_Nm > 0)
5390 template<bool _Const>
5391 class adjacent_view<_Vp, _Nm>::_Iterator
5396 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
5397 array<iterator_t<_Base>, _Nm> _M_current = array<iterator_t<_Base>, _Nm>();
5400 _Iterator(iterator_t<_Base> __first, sentinel_t<_Base> __last)
5402 for (
auto& __i : _M_current)
5405 ranges::advance(__first, 1, __last);
5410 _Iterator(__as_sentinel, iterator_t<_Base> __first, iterator_t<_Base> __last)
5412 if constexpr (!bidirectional_range<_Base>)
5413 for (
auto& __it : _M_current)
5416 for (
size_t __i = 0; __i < _Nm; ++__i)
5418 _M_current[_Nm - 1 - __i] = __last;
5419 ranges::advance(__last, -1, __first);
5426 if constexpr (random_access_range<_Base>)
5427 return random_access_iterator_tag{};
5428 else if constexpr (bidirectional_range<_Base>)
5429 return bidirectional_iterator_tag{};
5431 return forward_iterator_tag{};
5434 friend class adjacent_view;
5437 template<forward_range _Wp, move_constructible _Fp,
size_t _Mm>
5438 requires view<_Wp> && (_Mm > 0) && is_object_v<_Fp>
5439 && regular_invocable<__detail::__unarize<_Fp&, _Mm>, range_reference_t<_Wp>>
5440 && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Mm>,
5441 range_reference_t<_Wp>>>
5442 friend class adjacent_transform_view;
5446 using iterator_category = input_iterator_tag;
5447 using iterator_concept =
decltype(_S_iter_concept());
5449 pair<range_value_t<_Base>, range_value_t<_Base>>,
5450 __detail::__repeated_tuple<range_value_t<_Base>, _Nm>>;
5451 using difference_type = range_difference_t<_Base>;
5453 _Iterator() =
default;
5456 _Iterator(_Iterator<!_Const> __i)
5457 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
5459 for (
size_t __j = 0; __j < _Nm; ++__j)
5460 _M_current[__j] =
std::move(__i._M_current[__j]);
5466 auto __f = [](
auto& __i) ->
decltype(
auto) {
return *__i; };
5467 return __detail::__tuple_transform(__f, _M_current);
5470 constexpr _Iterator&
5473 for (
auto& __i : _M_current)
5486 constexpr _Iterator&
5487 operator--()
requires bidirectional_range<_Base>
5489 for (
auto& __i : _M_current)
5495 operator--(
int)
requires bidirectional_range<_Base>
5502 constexpr _Iterator&
5503 operator+=(difference_type __x)
5504 requires random_access_range<_Base>
5506 for (
auto& __i : _M_current)
5511 constexpr _Iterator&
5512 operator-=(difference_type __x)
5513 requires random_access_range<_Base>
5515 for (
auto& __i : _M_current)
5521 operator[](difference_type __n)
const
5522 requires random_access_range<_Base>
5524 auto __f = [&](
auto& __i) ->
decltype(
auto) {
return __i[__n]; };
5525 return __detail::__tuple_transform(__f, _M_current);
5528 friend constexpr bool
5529 operator==(
const _Iterator& __x,
const _Iterator& __y)
5530 {
return __x._M_current.back() == __y._M_current.back(); }
5532 friend constexpr bool
5533 operator<(
const _Iterator& __x,
const _Iterator& __y)
5534 requires random_access_range<_Base>
5535 {
return __x._M_current.back() < __y._M_current.back(); }
5537 friend constexpr bool
5538 operator>(
const _Iterator& __x,
const _Iterator& __y)
5539 requires random_access_range<_Base>
5540 {
return __y < __x; }
5542 friend constexpr bool
5543 operator<=(
const _Iterator& __x,
const _Iterator& __y)
5544 requires random_access_range<_Base>
5545 {
return !(__y < __x); }
5547 friend constexpr bool
5548 operator>=(
const _Iterator& __x,
const _Iterator& __y)
5549 requires random_access_range<_Base>
5550 {
return !(__x < __y); }
5552 friend constexpr auto
5553 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
5554 requires random_access_range<_Base>
5555 && three_way_comparable<iterator_t<_Base>>
5556 {
return __x._M_current.back() <=> __y._M_current.back(); }
5558 friend constexpr _Iterator
5559 operator+(
const _Iterator& __i, difference_type __n)
5560 requires random_access_range<_Base>
5567 friend constexpr _Iterator
5568 operator+(difference_type __n,
const _Iterator& __i)
5569 requires random_access_range<_Base>
5576 friend constexpr _Iterator
5577 operator-(
const _Iterator& __i, difference_type __n)
5578 requires random_access_range<_Base>
5585 friend constexpr difference_type
5586 operator-(
const _Iterator& __x,
const _Iterator& __y)
5587 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
5588 {
return __x._M_current.back() - __y._M_current.back(); }
5590 friend constexpr auto
5591 iter_move(
const _Iterator& __i)
5592 {
return __detail::__tuple_transform(ranges::iter_move, __i._M_current); }
5594 friend constexpr void
5595 iter_swap(
const _Iterator& __l,
const _Iterator& __r)
5596 requires indirectly_swappable<iterator_t<_Base>>
5598 for (
size_t __i = 0; __i < _Nm; __i++)
5599 ranges::iter_swap(__l._M_current[__i], __r._M_current[__i]);
5603 template<forward_range _Vp,
size_t _Nm>
5604 requires view<_Vp> && (_Nm > 0)
5605 template<bool _Const>
5606 class adjacent_view<_Vp, _Nm>::_Sentinel
5608 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
5610 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
5613 _Sentinel(sentinel_t<_Base> __end)
5617 friend class adjacent_view;
5620 _Sentinel() =
default;
5623 _Sentinel(_Sentinel<!_Const> __i)
5624 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
5628 template<
bool _OtherConst>
5629 requires sentinel_for<sentinel_t<_Base>,
5630 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
5631 friend constexpr bool
5632 operator==(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
5633 {
return __x._M_current.back() == __y._M_end; }
5635 template<
bool _OtherConst>
5636 requires sized_sentinel_for<sentinel_t<_Base>,
5637 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
5638 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _Vp>>
5639 operator-(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
5640 {
return __x._M_current.back() - __y._M_end; }
5642 template<
bool _OtherConst>
5643 requires sized_sentinel_for<sentinel_t<_Base>,
5644 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
5645 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _Vp>>
5646 operator-(
const _Sentinel& __y,
const _Iterator<_OtherConst>& __x)
5647 {
return __y._M_end - __x._M_current.back(); }
5654 template<
size_t _Nm,
typename _Range>
5655 concept __can_adjacent_view
5656 =
requires { adjacent_view<all_t<_Range>, _Nm>(std::declval<_Range>()); };
5659 template<
size_t _Nm>
5660 struct _Adjacent : __adaptor::_RangeAdaptorClosure<_Adjacent<_Nm>>
5662 template<viewable_range _Range>
5663 requires (_Nm == 0) || __detail::__can_adjacent_view<_Nm, _Range>
5665 operator() [[nodiscard]] (_Range&& __r)
const
5667 if constexpr (_Nm == 0)
5668 return views::empty<tuple<>>;
5670 return adjacent_view<all_t<_Range>, _Nm>(std::forward<_Range>(__r));
5674 template<
size_t _Nm>
5675 inline constexpr _Adjacent<_Nm> adjacent;
5677 inline constexpr auto pairwise = adjacent<2>;
5680 template<forward_range _Vp, move_constructible _Fp,
size_t _Nm>
5681 requires view<_Vp> && (_Nm > 0) && is_object_v<_Fp>
5682 && regular_invocable<__detail::__unarize<_Fp&, _Nm>, range_reference_t<_Vp>>
5683 && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Nm>,
5684 range_reference_t<_Vp>>>
5685 class adjacent_transform_view : public view_interface<adjacent_transform_view<_Vp, _Fp, _Nm>>
5687 [[no_unique_address]] __detail::__box<_Fp> _M_fun;
5688 adjacent_view<_Vp, _Nm> _M_inner;
5690 using _InnerView = adjacent_view<_Vp, _Nm>;
5692 template<
bool _Const>
5693 using _InnerIter = iterator_t<__detail::__maybe_const_t<_Const, _InnerView>>;
5695 template<
bool _Const>
5696 using _InnerSent = sentinel_t<__detail::__maybe_const_t<_Const, _InnerView>>;
5698 template<
bool>
class _Iterator;
5699 template<
bool>
class _Sentinel;
5702 adjacent_transform_view() =
default;
5705 adjacent_transform_view(_Vp __base, _Fp __fun)
5711 {
return _Iterator<false>(*
this, _M_inner.begin()); }
5715 requires range<const _InnerView>
5716 && regular_invocable<__detail::__unarize<const _Fp&, _Nm>,
5717 range_reference_t<const _Vp>>
5718 {
return _Iterator<true>(*
this, _M_inner.begin()); }
5723 if constexpr (common_range<_InnerView>)
5724 return _Iterator<false>(*
this, _M_inner.end());
5726 return _Sentinel<false>(_M_inner.end());
5731 requires range<const _InnerView>
5732 && regular_invocable<__detail::__unarize<const _Fp&, _Nm>,
5733 range_reference_t<const _Vp>>
5735 if constexpr (common_range<const _InnerView>)
5736 return _Iterator<true>(*
this, _M_inner.end());
5738 return _Sentinel<true>(_M_inner.end());
5742 size()
requires sized_range<_InnerView>
5743 {
return _M_inner.size(); }
5746 size() const requires sized_range<const _InnerView>
5747 {
return _M_inner.size(); }
5750 template<forward_range _Vp, move_constructible _Fp,
size_t _Nm>
5751 requires view<_Vp> && (_Nm > 0) && is_object_v<_Fp>
5752 && regular_invocable<__detail::__unarize<_Fp&, _Nm>, range_reference_t<_Vp>>
5753 && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Nm>,
5754 range_reference_t<_Vp>>>
5755 template<bool _Const>
5756 class adjacent_transform_view<_Vp, _Fp, _Nm>::_Iterator
5758 using _Parent = __detail::__maybe_const_t<_Const, adjacent_transform_view>;
5759 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
5761 _Parent* _M_parent =
nullptr;
5762 _InnerIter<_Const> _M_inner;
5765 _Iterator(_Parent& __parent, _InnerIter<_Const> __inner)
5772 using __detail::__maybe_const_t;
5773 using __detail::__unarize;
5774 using _Res = invoke_result_t<__unarize<__maybe_const_t<_Const, _Fp>&, _Nm>,
5775 range_reference_t<_Base>>;
5776 using _Cat =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
5777 if constexpr (!is_lvalue_reference_v<_Res>)
5778 return input_iterator_tag{};
5779 else if constexpr (derived_from<_Cat, random_access_iterator_tag>)
5780 return random_access_iterator_tag{};
5781 else if constexpr (derived_from<_Cat, bidirectional_iterator_tag>)
5782 return bidirectional_iterator_tag{};
5783 else if constexpr (derived_from<_Cat, forward_iterator_tag>)
5784 return forward_iterator_tag{};
5786 return input_iterator_tag{};
5789 friend class adjacent_transform_view;
5792 using iterator_category =
decltype(_S_iter_cat());
5793 using iterator_concept =
typename _InnerIter<_Const>::iterator_concept;
5795 = remove_cvref_t<invoke_result_t
5796 <__detail::__unarize<__detail::__maybe_const_t<_Const, _Fp>&, _Nm>,
5797 range_reference_t<_Base>>>;
5798 using difference_type = range_difference_t<_Base>;
5800 _Iterator() =
default;
5803 _Iterator(_Iterator<!_Const> __i)
5804 requires _Const && convertible_to<_InnerIter<false>, _InnerIter<_Const>>
5805 : _M_parent(__i._M_parent), _M_inner(
std::move(__i._M_inner))
5808 constexpr decltype(
auto)
5811 return std::apply([&](
const auto&... __iters) ->
decltype(
auto) {
5813 }, _M_inner._M_current);
5816 constexpr _Iterator&
5831 constexpr _Iterator&
5832 operator--()
requires bidirectional_range<_Base>
5839 operator--(
int)
requires bidirectional_range<_Base>
5846 constexpr _Iterator&
5847 operator+=(difference_type __x)
requires random_access_range<_Base>
5853 constexpr _Iterator&
5854 operator-=(difference_type __x)
requires random_access_range<_Base>
5860 constexpr decltype(
auto)
5861 operator[](difference_type __n)
const requires random_access_range<_Base>
5863 return std::apply([&](
const auto&... __iters) ->
decltype(
auto) {
5865 }, _M_inner._M_current);
5868 friend constexpr bool
5869 operator==(
const _Iterator& __x,
const _Iterator& __y)
5870 {
return __x._M_inner == __y._M_inner; }
5872 friend constexpr bool
5873 operator<(
const _Iterator& __x,
const _Iterator& __y)
5874 requires random_access_range<_Base>
5875 {
return __x._M_inner < __y._M_inner; }
5877 friend constexpr bool
5878 operator>(
const _Iterator& __x,
const _Iterator& __y)
5879 requires random_access_range<_Base>
5880 {
return __x._M_inner > __y._M_inner; }
5882 friend constexpr bool
5883 operator<=(
const _Iterator& __x,
const _Iterator& __y)
5884 requires random_access_range<_Base>
5885 {
return __x._M_inner <= __y._M_inner; }
5887 friend constexpr bool
5888 operator>=(
const _Iterator& __x,
const _Iterator& __y)
5889 requires random_access_range<_Base>
5890 {
return __x._M_inner >= __y._M_inner; }
5892 friend constexpr auto
5893 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
5894 requires random_access_range<_Base> &&
5895 three_way_comparable<_InnerIter<_Const>>
5896 {
return __x._M_inner <=> __y._M_inner; }
5898 friend constexpr _Iterator
5899 operator+(
const _Iterator& __i, difference_type __n)
5900 requires random_access_range<_Base>
5901 {
return _Iterator(*__i._M_parent, __i._M_inner + __n); }
5903 friend constexpr _Iterator
5904 operator+(difference_type __n,
const _Iterator& __i)
5905 requires random_access_range<_Base>
5906 {
return _Iterator(*__i._M_parent, __i._M_inner + __n); }
5908 friend constexpr _Iterator
5909 operator-(
const _Iterator& __i, difference_type __n)
5910 requires random_access_range<_Base>
5911 {
return _Iterator(*__i._M_parent, __i._M_inner - __n); }
5913 friend constexpr difference_type
5914 operator-(
const _Iterator& __x,
const _Iterator& __y)
5915 requires sized_sentinel_for<_InnerIter<_Const>, _InnerIter<_Const>>
5916 {
return __x._M_inner - __y._M_inner; }
5919 template<forward_range _Vp, move_constructible _Fp,
size_t _Nm>
5920 requires view<_Vp> && (_Nm > 0) && is_object_v<_Fp>
5921 && regular_invocable<__detail::__unarize<_Fp&, _Nm>, range_reference_t<_Vp>>
5922 && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Nm>,
5923 range_reference_t<_Vp>>>
5924 template<bool _Const>
5925 class adjacent_transform_view<_Vp, _Fp, _Nm>::_Sentinel
5927 _InnerSent<_Const> _M_inner;
5930 _Sentinel(_InnerSent<_Const> __inner)
5934 friend class adjacent_transform_view;
5937 _Sentinel() =
default;
5940 _Sentinel(_Sentinel<!_Const> __i)
5941 requires _Const && convertible_to<_InnerSent<false>, _InnerSent<_Const>>
5945 template<
bool _OtherConst>
5946 requires sentinel_for<_InnerSent<_Const>, _InnerIter<_OtherConst>>
5947 friend constexpr bool
5948 operator==(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
5949 {
return __x._M_inner == __y._M_inner; }
5951 template<
bool _OtherConst>
5952 requires sized_sentinel_for<_InnerSent<_Const>, _InnerIter<_OtherConst>>
5953 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
5954 operator-(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
5955 {
return __x._M_inner - __y._M_inner; }
5957 template<
bool _OtherConst>
5958 requires sized_sentinel_for<_InnerSent<_Const>, _InnerIter<_OtherConst>>
5959 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
5960 operator-(
const _Sentinel& __x,
const _Iterator<_OtherConst>& __y)
5961 {
return __x._M_inner - __y._M_inner; }
5968 template<
size_t _Nm,
typename _Range,
typename _Fp>
5969 concept __can_adjacent_transform_view
5970 =
requires { adjacent_transform_view<all_t<_Range>, decay_t<_Fp>, _Nm>
5971 (std::declval<_Range>(), std::declval<_Fp>()); };
5974 template<
size_t _Nm>
5975 struct _AdjacentTransform : __adaptor::_RangeAdaptor<_AdjacentTransform<_Nm>>
5977 template<viewable_range _Range,
typename _Fp>
5978 requires (_Nm == 0) || __detail::__can_adjacent_transform_view<_Nm, _Range, _Fp>
5980 operator() [[nodiscard]] (_Range&& __r, _Fp&& __f)
const
5982 if constexpr (_Nm == 0)
5983 return zip_transform(std::forward<_Fp>(__f));
5985 return adjacent_transform_view<all_t<_Range>, decay_t<_Fp>, _Nm>
5986 (std::forward<_Range>(__r), std::forward<_Fp>(__f));
5989 using __adaptor::_RangeAdaptor<_AdjacentTransform>::operator();
5990 static constexpr int _S_arity = 2;
5991 static constexpr bool _S_has_simple_extra_args =
true;
5994 template<
size_t _Nm>
5995 inline constexpr _AdjacentTransform<_Nm> adjacent_transform;
5997 inline constexpr auto pairwise_transform = adjacent_transform<2>;
6001#ifdef __cpp_lib_ranges_chunk
6004 template<
typename _Tp>
6005 constexpr _Tp __div_ceil(_Tp __num, _Tp __denom)
6007 _Tp __r = __num / __denom;
6008 if (__num % __denom)
6015 requires input_range<_Vp>
6016 class chunk_view :
public view_interface<chunk_view<_Vp>>
6019 range_difference_t<_Vp> _M_n;
6020 range_difference_t<_Vp> _M_remainder = 0;
6021 __detail::__non_propagating_cache<iterator_t<_Vp>> _M_current;
6028 chunk_view(_Vp __base, range_difference_t<_Vp> __n)
6030 { __glibcxx_assert(__n >= 0); }
6033 base() const & requires copy_constructible<_Vp>
6040 constexpr _OuterIter
6043 _M_current = ranges::begin(_M_base);
6044 _M_remainder = _M_n;
6045 return _OuterIter(*
this);
6048 constexpr default_sentinel_t
6049 end() const noexcept
6053 size()
requires sized_range<_Vp>
6055 return __detail::__to_unsigned_like(__detail::__div_ceil
6056 (ranges::distance(_M_base), _M_n));
6060 size() const requires sized_range<const _Vp>
6062 return __detail::__to_unsigned_like(__detail::__div_ceil
6063 (ranges::distance(_M_base), _M_n));
6067 template<
typename _Range>
6068 chunk_view(_Range&&, range_difference_t<_Range>) -> chunk_view<views::all_t<_Range>>;
6071 requires input_range<_Vp>
6072 class chunk_view<_Vp>::_OuterIter
6074 chunk_view* _M_parent;
6077 _OuterIter(chunk_view& __parent) noexcept
6084 using iterator_concept = input_iterator_tag;
6085 using difference_type = range_difference_t<_Vp>;
6089 _OuterIter(_OuterIter&&) =
default;
6090 _OuterIter& operator=(_OuterIter&&) =
default;
6092 constexpr value_type
6095 __glibcxx_assert(*
this != default_sentinel);
6096 return value_type(*_M_parent);
6099 constexpr _OuterIter&
6102 __glibcxx_assert(*
this != default_sentinel);
6103 ranges::advance(*_M_parent->_M_current, _M_parent->_M_remainder,
6104 ranges::end(_M_parent->_M_base));
6105 _M_parent->_M_remainder = _M_parent->_M_n;
6113 friend constexpr bool
6114 operator==(
const _OuterIter& __x, default_sentinel_t)
6116 return *__x._M_parent->_M_current == ranges::end(__x._M_parent->_M_base)
6117 && __x._M_parent->_M_remainder != 0;
6120 friend constexpr difference_type
6121 operator-(default_sentinel_t,
const _OuterIter& __x)
6122 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6124 const auto __dist = ranges::end(__x._M_parent->_M_base) - *__x._M_parent->_M_current;
6126 if (__dist < __x._M_parent->_M_remainder)
6127 return __dist == 0 ? 0 : 1;
6129 return 1 + __detail::__div_ceil(__dist - __x._M_parent->_M_remainder,
6130 __x._M_parent->_M_n);
6133 friend constexpr difference_type
6134 operator-(
const _OuterIter& __x, default_sentinel_t __y)
6135 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6136 {
return -(__y - __x); }
6140 requires input_range<_Vp>
6141 struct chunk_view<_Vp>::_OuterIter::value_type : view_interface<value_type>
6144 chunk_view* _M_parent;
6147 value_type(chunk_view& __parent) noexcept
6154 constexpr _InnerIter
6155 begin() const noexcept
6156 {
return _InnerIter(*_M_parent); }
6158 constexpr default_sentinel_t
6159 end() const noexcept
6164 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6166 return __detail::__to_unsigned_like
6167 (ranges::min(_M_parent->_M_remainder,
6168 ranges::end(_M_parent->_M_base) - *_M_parent->_M_current));
6173 requires input_range<_Vp>
6174 class chunk_view<_Vp>::_InnerIter
6176 chunk_view* _M_parent;
6179 _InnerIter(chunk_view& __parent) noexcept
6183 friend _OuterIter::value_type;
6186 using iterator_concept = input_iterator_tag;
6187 using difference_type = range_difference_t<_Vp>;
6188 using value_type = range_value_t<_Vp>;
6190 _InnerIter(_InnerIter&&) =
default;
6191 _InnerIter& operator=(_InnerIter&&) =
default;
6193 constexpr const iterator_t<_Vp>&
6195 {
return *_M_parent->_M_current; }
6197 constexpr range_reference_t<_Vp>
6200 __glibcxx_assert(*
this != default_sentinel);
6201 return **_M_parent->_M_current;
6204 constexpr _InnerIter&
6207 __glibcxx_assert(*
this != default_sentinel);
6208 ++*_M_parent->_M_current;
6209 if (*_M_parent->_M_current == ranges::end(_M_parent->_M_base))
6210 _M_parent->_M_remainder = 0;
6212 --_M_parent->_M_remainder;
6220 friend constexpr bool
6221 operator==(
const _InnerIter& __x, default_sentinel_t)
noexcept
6222 {
return __x._M_parent->_M_remainder == 0; }
6224 friend constexpr difference_type
6225 operator-(default_sentinel_t,
const _InnerIter& __x)
6226 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6228 return ranges::min(__x._M_parent->_M_remainder,
6229 ranges::end(__x._M_parent->_M_base) - *__x._M_parent->_M_current);
6232 friend constexpr difference_type
6233 operator-(
const _InnerIter& __x, default_sentinel_t __y)
6234 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6235 {
return -(__y - __x); }
6239 requires forward_range<_Vp>
6240 class chunk_view<_Vp> :
public view_interface<chunk_view<_Vp>>
6243 range_difference_t<_Vp> _M_n;
6244 template<
bool>
class _Iterator;
6248 chunk_view(_Vp __base, range_difference_t<_Vp> __n)
6250 { __glibcxx_assert(__n > 0); }
6253 base() const & requires copy_constructible<_Vp>
6261 begin()
requires (!__detail::__simple_view<_Vp>)
6262 {
return _Iterator<false>(
this, ranges::begin(_M_base)); }
6265 begin() const requires forward_range<const _Vp>
6266 {
return _Iterator<true>(
this, ranges::begin(_M_base)); }
6269 end()
requires (!__detail::__simple_view<_Vp>)
6271 if constexpr (common_range<_Vp> && sized_range<_Vp>)
6273 auto __missing = (_M_n - ranges::distance(_M_base) % _M_n) % _M_n;
6274 return _Iterator<false>(
this, ranges::end(_M_base), __missing);
6276 else if constexpr (common_range<_Vp> && !bidirectional_range<_Vp>)
6277 return _Iterator<false>(
this, ranges::end(_M_base));
6283 end() const requires forward_range<const _Vp>
6285 if constexpr (common_range<const _Vp> && sized_range<const _Vp>)
6287 auto __missing = (_M_n - ranges::distance(_M_base) % _M_n) % _M_n;
6288 return _Iterator<true>(
this, ranges::end(_M_base), __missing);
6290 else if constexpr (common_range<const _Vp> && !bidirectional_range<const _Vp>)
6291 return _Iterator<true>(
this, ranges::end(_M_base));
6297 size()
requires sized_range<_Vp>
6299 return __detail::__to_unsigned_like(__detail::__div_ceil
6300 (ranges::distance(_M_base), _M_n));
6304 size() const requires sized_range<const _Vp>
6306 return __detail::__to_unsigned_like(__detail::__div_ceil
6307 (ranges::distance(_M_base), _M_n));
6311 template<
typename _Vp>
6312 inline constexpr bool enable_borrowed_range<chunk_view<_Vp>>
6313 = forward_range<_Vp> && enable_borrowed_range<_Vp>;
6316 requires forward_range<_Vp>
6317 template<
bool _Const>
6318 class chunk_view<_Vp>::_Iterator
6320 using _Parent = __detail::__maybe_const_t<_Const, chunk_view>;
6321 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
6323 iterator_t<_Base> _M_current = iterator_t<_Base>();
6324 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
6325 range_difference_t<_Base> _M_n = 0;
6326 range_difference_t<_Base> _M_missing = 0;
6329 _Iterator(_Parent* __parent, iterator_t<_Base> __current,
6330 range_difference_t<_Base> __missing = 0)
6331 : _M_current(__current), _M_end(ranges::
end(__parent->_M_base)),
6332 _M_n(__parent->_M_n), _M_missing(__missing)
6338 if constexpr (random_access_range<_Base>)
6339 return random_access_iterator_tag{};
6340 else if constexpr (bidirectional_range<_Base>)
6341 return bidirectional_iterator_tag{};
6343 return forward_iterator_tag{};
6349 using iterator_category = input_iterator_tag;
6350 using iterator_concept =
decltype(_S_iter_cat());
6351 using value_type =
decltype(views::take(subrange(_M_current, _M_end), _M_n));
6352 using difference_type = range_difference_t<_Base>;
6354 _Iterator() =
default;
6356 constexpr _Iterator(_Iterator<!_Const> __i)
6358 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
6359 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
6361 _M_n(__i._M_n), _M_missing(__i._M_missing)
6364 constexpr iterator_t<_Base>
6366 {
return _M_current; }
6368 constexpr value_type
6371 __glibcxx_assert(_M_current != _M_end);
6372 return views::take(subrange(_M_current, _M_end), _M_n);
6375 constexpr _Iterator&
6378 __glibcxx_assert(_M_current != _M_end);
6379 _M_missing = ranges::advance(_M_current, _M_n, _M_end);
6391 constexpr _Iterator&
6392 operator--()
requires bidirectional_range<_Base>
6394 ranges::advance(_M_current, _M_missing - _M_n);
6400 operator--(
int)
requires bidirectional_range<_Base>
6407 constexpr _Iterator&
6408 operator+=(difference_type __x)
6409 requires random_access_range<_Base>
6413 __glibcxx_assert(ranges::distance(_M_current, _M_end) > _M_n * (__x - 1));
6414 _M_missing = ranges::advance(_M_current, _M_n * __x, _M_end);
6418 ranges::advance(_M_current, _M_n * __x + _M_missing);
6424 constexpr _Iterator&
6425 operator-=(difference_type __x)
6426 requires random_access_range<_Base>
6427 {
return *
this += -__x; }
6429 constexpr value_type
6430 operator[](difference_type __n)
const
6431 requires random_access_range<_Base>
6432 {
return *(*
this + __n); }
6434 friend constexpr bool
6435 operator==(
const _Iterator& __x,
const _Iterator& __y)
6436 {
return __x._M_current == __y._M_current; }
6438 friend constexpr bool
6439 operator==(
const _Iterator& __x, default_sentinel_t)
6440 {
return __x._M_current == __x._M_end; }
6442 friend constexpr bool
6443 operator<(
const _Iterator& __x,
const _Iterator& __y)
6444 requires random_access_range<_Base>
6445 {
return __x._M_current > __y._M_current; }
6447 friend constexpr bool
6448 operator>(
const _Iterator& __x,
const _Iterator& __y)
6449 requires random_access_range<_Base>
6450 {
return __y < __x; }
6452 friend constexpr bool
6453 operator<=(
const _Iterator& __x,
const _Iterator& __y)
6454 requires random_access_range<_Base>
6455 {
return !(__y < __x); }
6457 friend constexpr bool
6458 operator>=(
const _Iterator& __x,
const _Iterator& __y)
6459 requires random_access_range<_Base>
6460 {
return !(__x < __y); }
6462 friend constexpr auto
6463 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
6464 requires random_access_range<_Base>
6465 && three_way_comparable<iterator_t<_Base>>
6466 {
return __x._M_current <=> __y._M_current; }
6468 friend constexpr _Iterator
6469 operator+(
const _Iterator& __i, difference_type __n)
6470 requires random_access_range<_Base>
6477 friend constexpr _Iterator
6478 operator+(difference_type __n,
const _Iterator& __i)
6479 requires random_access_range<_Base>
6486 friend constexpr _Iterator
6487 operator-(
const _Iterator& __i, difference_type __n)
6488 requires random_access_range<_Base>
6495 friend constexpr difference_type
6496 operator-(
const _Iterator& __x,
const _Iterator& __y)
6497 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
6499 return (__x._M_current - __y._M_current
6500 + __x._M_missing - __y._M_missing) / __x._M_n;
6503 friend constexpr difference_type
6504 operator-(default_sentinel_t __y,
const _Iterator& __x)
6505 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
6506 {
return __detail::__div_ceil(__x._M_end - __x._M_current, __x._M_n); }
6508 friend constexpr difference_type
6509 operator-(
const _Iterator& __x, default_sentinel_t __y)
6510 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
6511 {
return -(__y - __x); }
6518 template<
typename _Range,
typename _Dp>
6519 concept __can_chunk_view
6520 =
requires { chunk_view(std::declval<_Range>(), std::declval<_Dp>()); };
6523 struct _Chunk : __adaptor::_RangeAdaptor<_Chunk>
6525 template<viewable_range _Range,
typename _Dp = range_difference_t<_Range>>
6526 requires __detail::__can_chunk_view<_Range, _Dp>
6528 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n)
const
6529 {
return chunk_view(std::forward<_Range>(__r), __n); }
6531 using __adaptor::_RangeAdaptor<_Chunk>::operator();
6532 static constexpr int _S_arity = 2;
6533 static constexpr bool _S_has_simple_extra_args =
true;
6536 inline constexpr _Chunk chunk;
6540#ifdef __cpp_lib_ranges_slide
6543 template<
typename _Vp>
6544 concept __slide_caches_nothing = random_access_range<_Vp> && sized_range<_Vp>;
6546 template<
typename _Vp>
6547 concept __slide_caches_last
6548 = !__slide_caches_nothing<_Vp> && bidirectional_range<_Vp> && common_range<_Vp>;
6550 template<
typename _Vp>
6551 concept __slide_caches_first
6552 = !__slide_caches_nothing<_Vp> && !__slide_caches_last<_Vp>;
6555 template<forward_range _Vp>
6557 class slide_view :
public view_interface<slide_view<_Vp>>
6560 range_difference_t<_Vp> _M_n;
6561 [[no_unique_address]]
6562 __detail::__maybe_present_t<__detail::__slide_caches_first<_Vp>,
6563 __detail::_CachedPosition<_Vp>> _M_cached_begin;
6564 [[no_unique_address]]
6565 __detail::__maybe_present_t<__detail::__slide_caches_last<_Vp>,
6566 __detail::_CachedPosition<_Vp>> _M_cached_end;
6568 template<
bool>
class _Iterator;
6573 slide_view(_Vp __base, range_difference_t<_Vp> __n)
6575 { __glibcxx_assert(__n > 0); }
6578 begin()
requires (!(__detail::__simple_view<_Vp>
6579 && __detail::__slide_caches_nothing<const _Vp>))
6581 if constexpr (__detail::__slide_caches_first<_Vp>)
6583 iterator_t<_Vp> __it;
6584 if (_M_cached_begin._M_has_value())
6585 __it = _M_cached_begin._M_get(_M_base);
6588 __it = ranges::next(ranges::begin(_M_base), _M_n - 1, ranges::end(_M_base));
6589 _M_cached_begin._M_set(_M_base, __it);
6591 return _Iterator<false>(ranges::begin(_M_base),
std::move(__it), _M_n);
6594 return _Iterator<false>(ranges::begin(_M_base), _M_n);
6598 begin() const requires __detail::__slide_caches_nothing<const _Vp>
6599 {
return _Iterator<true>(ranges::begin(_M_base), _M_n); }
6602 end()
requires (!(__detail::__simple_view<_Vp>
6603 && __detail::__slide_caches_nothing<const _Vp>))
6605 if constexpr (__detail::__slide_caches_nothing<_Vp>)
6606 return _Iterator<false>(ranges::begin(_M_base) + range_difference_t<_Vp>(
size()),
6608 else if constexpr (__detail::__slide_caches_last<_Vp>)
6610 iterator_t<_Vp> __it;
6611 if (_M_cached_end._M_has_value())
6612 __it = _M_cached_end._M_get(_M_base);
6615 __it = ranges::prev(ranges::end(_M_base), _M_n - 1, ranges::begin(_M_base));
6616 _M_cached_end._M_set(_M_base, __it);
6618 return _Iterator<false>(
std::move(__it), _M_n);
6620 else if constexpr (common_range<_Vp>)
6621 return _Iterator<false>(ranges::end(_M_base), ranges::end(_M_base), _M_n);
6623 return _Sentinel(ranges::end(_M_base));
6627 end() const requires __detail::__slide_caches_nothing<const _Vp>
6628 {
return begin() + range_difference_t<const _Vp>(
size()); }
6631 size()
requires sized_range<_Vp>
6633 auto __sz = ranges::distance(_M_base) - _M_n + 1;
6636 return __detail::__to_unsigned_like(__sz);
6640 size() const requires sized_range<const _Vp>
6642 auto __sz = ranges::distance(_M_base) - _M_n + 1;
6645 return __detail::__to_unsigned_like(__sz);
6649 template<
typename _Range>
6650 slide_view(_Range&&, range_difference_t<_Range>) -> slide_view<views::all_t<_Range>>;
6652 template<
typename _Vp>
6653 inline constexpr bool enable_borrowed_range<slide_view<_Vp>>
6654 = enable_borrowed_range<_Vp>;
6656 template<forward_range _Vp>
6658 template<
bool _Const>
6659 class slide_view<_Vp>::_Iterator
6661 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
6662 static constexpr bool _S_last_elt_present
6663 = __detail::__slide_caches_first<_Base>;
6665 iterator_t<_Base> _M_current = iterator_t<_Base>();
6666 [[no_unique_address]]
6667 __detail::__maybe_present_t<_S_last_elt_present, iterator_t<_Base>>
6668 _M_last_elt =
decltype(_M_last_elt)();
6669 range_difference_t<_Base> _M_n = 0;
6672 _Iterator(iterator_t<_Base> __current, range_difference_t<_Base> __n)
6673 requires (!_S_last_elt_present)
6674 : _M_current(__current), _M_n(__n)
6678 _Iterator(iterator_t<_Base> __current, iterator_t<_Base> __last_elt,
6679 range_difference_t<_Base> __n)
6680 requires _S_last_elt_present
6681 : _M_current(__current), _M_last_elt(__last_elt), _M_n(__n)
6687 if constexpr (random_access_range<_Base>)
6688 return random_access_iterator_tag{};
6689 else if constexpr (bidirectional_range<_Base>)
6690 return bidirectional_iterator_tag{};
6692 return forward_iterator_tag{};
6696 friend slide_view::_Sentinel;
6699 using iterator_category = input_iterator_tag;
6700 using iterator_concept =
decltype(_S_iter_concept());
6701 using value_type =
decltype(views::counted(_M_current, _M_n));
6702 using difference_type = range_difference_t<_Base>;
6704 _Iterator() =
default;
6707 _Iterator(_Iterator<!_Const> __i)
6708 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
6709 : _M_current(
std::move(__i._M_current)), _M_n(__i._M_n)
6714 {
return views::counted(_M_current, _M_n); }
6716 constexpr _Iterator&
6720 if constexpr (_S_last_elt_present)
6733 constexpr _Iterator&
6734 operator--()
requires bidirectional_range<_Base>
6737 if constexpr (_S_last_elt_present)
6743 operator--(
int)
requires bidirectional_range<_Base>
6750 constexpr _Iterator&
6751 operator+=(difference_type __x)
6752 requires random_access_range<_Base>
6755 if constexpr (_S_last_elt_present)
6760 constexpr _Iterator&
6761 operator-=(difference_type __x)
6762 requires random_access_range<_Base>
6765 if constexpr (_S_last_elt_present)
6771 operator[](difference_type __n)
const
6772 requires random_access_range<_Base>
6773 {
return views::counted(_M_current + __n, _M_n); }
6775 friend constexpr bool
6776 operator==(
const _Iterator& __x,
const _Iterator& __y)
6778 if constexpr (_S_last_elt_present)
6779 return __x._M_last_elt == __y._M_last_elt;
6781 return __x._M_current == __y._M_current;
6784 friend constexpr bool
6785 operator<(
const _Iterator& __x,
const _Iterator& __y)
6786 requires random_access_range<_Base>
6787 {
return __x._M_current < __y._M_current; }
6789 friend constexpr bool
6790 operator>(
const _Iterator& __x,
const _Iterator& __y)
6791 requires random_access_range<_Base>
6792 {
return __y < __x; }
6794 friend constexpr bool
6795 operator<=(
const _Iterator& __x,
const _Iterator& __y)
6796 requires random_access_range<_Base>
6797 {
return !(__y < __x); }
6799 friend constexpr bool
6800 operator>=(
const _Iterator& __x,
const _Iterator& __y)
6801 requires random_access_range<_Base>
6802 {
return !(__x < __y); }
6804 friend constexpr auto
6805 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
6806 requires random_access_range<_Base>
6807 && three_way_comparable<iterator_t<_Base>>
6808 {
return __x._M_current <=> __y._M_current; }
6810 friend constexpr _Iterator
6811 operator+(
const _Iterator& __i, difference_type __n)
6812 requires random_access_range<_Base>
6819 friend constexpr _Iterator
6820 operator+(difference_type __n,
const _Iterator& __i)
6821 requires random_access_range<_Base>
6828 friend constexpr _Iterator
6829 operator-(
const _Iterator& __i, difference_type __n)
6830 requires random_access_range<_Base>
6837 friend constexpr difference_type
6838 operator-(
const _Iterator& __x,
const _Iterator& __y)
6839 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
6841 if constexpr (_S_last_elt_present)
6842 return __x._M_last_elt - __y._M_last_elt;
6844 return __x._M_current - __y._M_current;
6848 template<forward_range _Vp>
6850 class slide_view<_Vp>::_Sentinel
6852 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
6855 _Sentinel(sentinel_t<_Vp> __end)
6862 _Sentinel() =
default;
6864 friend constexpr bool
6865 operator==(
const _Iterator<false>& __x,
const _Sentinel& __y)
6866 {
return __x._M_last_elt == __y._M_end; }
6868 friend constexpr range_difference_t<_Vp>
6869 operator-(
const _Iterator<false>& __x,
const _Sentinel& __y)
6870 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6871 {
return __x._M_last_elt - __y._M_end; }
6873 friend constexpr range_difference_t<_Vp>
6874 operator-(
const _Sentinel& __y,
const _Iterator<false>& __x)
6875 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6876 {
return __y._M_end -__x._M_last_elt; }
6883 template<
typename _Range,
typename _Dp>
6884 concept __can_slide_view
6885 =
requires { slide_view(std::declval<_Range>(), std::declval<_Dp>()); };
6888 struct _Slide : __adaptor::_RangeAdaptor<_Slide>
6890 template<viewable_range _Range,
typename _Dp = range_difference_t<_Range>>
6891 requires __detail::__can_slide_view<_Range, _Dp>
6893 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n)
const
6894 {
return slide_view(std::forward<_Range>(__r), __n); }
6896 using __adaptor::_RangeAdaptor<_Slide>::operator();
6897 static constexpr int _S_arity = 2;
6898 static constexpr bool _S_has_simple_extra_args =
true;
6901 inline constexpr _Slide slide;
6905#ifdef __cpp_lib_ranges_chunk_by
6906 template<forward_range _Vp,
6907 indirect_binary_predicate<iterator_t<_Vp>, iterator_t<_Vp>> _Pred>
6908 requires view<_Vp> && is_object_v<_Pred>
6909 class chunk_by_view :
public view_interface<chunk_by_view<_Vp, _Pred>>
6911 _Vp _M_base = _Vp();
6912 __detail::__box<_Pred> _M_pred;
6913 __detail::_CachedPosition<_Vp> _M_cached_begin;
6915 constexpr iterator_t<_Vp>
6916 _M_find_next(iterator_t<_Vp> __current)
6918 __glibcxx_assert(_M_pred.has_value());
6919 auto __pred = [
this]<
typename _Tp,
typename _Up>(_Tp&& __x, _Up&& __y) {
6920 return !bool((*_M_pred)(std::forward<_Tp>(__x), std::forward<_Up>(__y)));
6922 auto __it = ranges::adjacent_find(__current, ranges::end(_M_base), __pred);
6923 return ranges::next(__it, 1, ranges::end(_M_base));
6926 constexpr iterator_t<_Vp>
6927 _M_find_prev(iterator_t<_Vp> __current)
requires bidirectional_range<_Vp>
6929 __glibcxx_assert(_M_pred.has_value());
6930 auto __pred = [
this]<
typename _Tp,
typename _Up>(_Tp&& __x, _Up&& __y) {
6931 return !bool((*_M_pred)(std::forward<_Up>(__y), std::forward<_Tp>(__x)));
6935 __glibcxx_assert(__rbegin != __rend);
6936 auto __it = ranges::adjacent_find(__rbegin, __rend, __pred).base();
6937 return ranges::prev(__it, 1, ranges::begin(_M_base));
6943 chunk_by_view()
requires (default_initializable<_Vp>
6944 && default_initializable<_Pred>)
6948 chunk_by_view(_Vp __base, _Pred __pred)
6953 base() const & requires copy_constructible<_Vp>
6960 constexpr const _Pred&
6962 {
return *_M_pred; }
6967 __glibcxx_assert(_M_pred.has_value());
6968 iterator_t<_Vp> __it;
6969 if (_M_cached_begin._M_has_value())
6970 __it = _M_cached_begin._M_get(_M_base);
6973 __it = _M_find_next(ranges::begin(_M_base));
6974 _M_cached_begin._M_set(_M_base, __it);
6976 return _Iterator(*
this, ranges::begin(_M_base), __it);
6982 if constexpr (common_range<_Vp>)
6983 return _Iterator(*
this, ranges::end(_M_base), ranges::end(_M_base));
6989 template<
typename _Range,
typename _Pred>
6990 chunk_by_view(_Range&&, _Pred) -> chunk_by_view<views::all_t<_Range>, _Pred>;
6992 template<forward_range _Vp,
6993 indirect_binary_predicate<iterator_t<_Vp>, iterator_t<_Vp>> _Pred>
6994 requires view<_Vp> && is_object_v<_Pred>
6995 class chunk_by_view<_Vp, _Pred>::_Iterator
6997 chunk_by_view* _M_parent =
nullptr;
6998 iterator_t<_Vp> _M_current = iterator_t<_Vp>();
6999 iterator_t<_Vp> _M_next = iterator_t<_Vp>();
7002 _Iterator(chunk_by_view& __parent, iterator_t<_Vp> __current, iterator_t<_Vp> __next)
7003 : _M_parent(
std::
__addressof(__parent)), _M_current(__current), _M_next(__next)
7009 if constexpr (bidirectional_range<_Vp>)
7010 return bidirectional_iterator_tag{};
7012 return forward_iterator_tag{};
7015 friend chunk_by_view;
7018 using value_type = subrange<iterator_t<_Vp>>;
7019 using difference_type = range_difference_t<_Vp>;
7020 using iterator_category = input_iterator_tag;
7021 using iterator_concept =
decltype(_S_iter_concept());
7023 _Iterator() =
default;
7025 constexpr value_type
7028 __glibcxx_assert(_M_current != _M_next);
7029 return ranges::subrange(_M_current, _M_next);
7032 constexpr _Iterator&
7035 __glibcxx_assert(_M_current != _M_next);
7036 _M_current = _M_next;
7037 _M_next = _M_parent->_M_find_next(_M_current);
7049 constexpr _Iterator&
7050 operator--()
requires bidirectional_range<_Vp>
7052 _M_next = _M_current;
7053 _M_current = _M_parent->_M_find_prev(_M_next);
7058 operator--(
int)
requires bidirectional_range<_Vp>
7065 friend constexpr bool
7066 operator==(
const _Iterator& __x,
const _Iterator& __y)
7067 {
return __x._M_current == __y._M_current; }
7069 friend constexpr bool
7070 operator==(
const _Iterator& __x, default_sentinel_t)
7071 {
return __x._M_current == __x._M_next; }
7078 template<
typename _Range,
typename _Pred>
7079 concept __can_chunk_by_view
7080 =
requires { chunk_by_view(std::declval<_Range>(), std::declval<_Pred>()); };
7083 struct _ChunkBy : __adaptor::_RangeAdaptor<_ChunkBy>
7085 template<viewable_range _Range,
typename _Pred>
7086 requires __detail::__can_chunk_by_view<_Range, _Pred>
7088 operator() [[nodiscard]] (_Range&& __r, _Pred&& __pred)
const
7089 {
return chunk_by_view(std::forward<_Range>(__r), std::forward<_Pred>(__pred)); }
7091 using __adaptor::_RangeAdaptor<_ChunkBy>::operator();
7092 static constexpr int _S_arity = 2;
7093 static constexpr bool _S_has_simple_extra_args =
true;
7096 inline constexpr _ChunkBy chunk_by;
7100#ifdef __cpp_lib_ranges_join_with
7103 template<
typename _Range,
typename _Pattern>
7104 concept __compatible_joinable_ranges
7105 = common_with<range_value_t<_Range>, range_value_t<_Pattern>>
7106 && common_reference_with<range_reference_t<_Range>,
7107 range_reference_t<_Pattern>>
7108 && common_reference_with<range_rvalue_reference_t<_Range>,
7109 range_rvalue_reference_t<_Pattern>>;
7111 template<
typename _Range>
7112 concept __bidirectional_common = bidirectional_range<_Range> && common_range<_Range>;
7115 template<input_range _Vp, forward_range _Pattern>
7116 requires view<_Vp> && view<_Pattern>
7117 && input_range<range_reference_t<_Vp>>
7118 && __detail::__compatible_joinable_ranges<range_reference_t<_Vp>, _Pattern>
7119 class join_with_view :
public view_interface<join_with_view<_Vp, _Pattern>>
7121 using _InnerRange = range_reference_t<_Vp>;
7123 _Vp _M_base = _Vp();
7124 [[no_unique_address]]
7125 __detail::__maybe_present_t<!forward_range<_Vp>,
7126 __detail::__non_propagating_cache<iterator_t<_Vp>>> _M_outer_it;
7127 __detail::__non_propagating_cache<remove_cv_t<_InnerRange>> _M_inner;
7128 _Pattern _M_pattern = _Pattern();
7130 template<
bool _Const>
using _Base = __detail::__maybe_const_t<_Const, _Vp>;
7131 template<
bool _Const>
using _InnerBase = range_reference_t<_Base<_Const>>;
7132 template<
bool _Const>
using _PatternBase = __detail::__maybe_const_t<_Const, _Pattern>;
7134 template<
bool _Const>
using _OuterIter = iterator_t<_Base<_Const>>;
7135 template<
bool _Const>
using _InnerIter = iterator_t<_InnerBase<_Const>>;
7136 template<
bool _Const>
using _PatternIter = iterator_t<_PatternBase<_Const>>;
7138 template<
bool _Const>
7139 static constexpr bool _S_ref_is_glvalue = is_reference_v<_InnerBase<_Const>>;
7141 template<
bool _Const>
7145 template<
bool _Const>
7146 requires _S_ref_is_glvalue<_Const>
7147 && forward_range<_Base<_Const>>
7148 && forward_range<_InnerBase<_Const>>
7149 struct __iter_cat<_Const>
7155 using _OuterIter = join_with_view::_OuterIter<_Const>;
7156 using _InnerIter = join_with_view::_InnerIter<_Const>;
7157 using _PatternIter = join_with_view::_PatternIter<_Const>;
7158 using _OuterCat =
typename iterator_traits<_OuterIter>::iterator_category;
7159 using _InnerCat =
typename iterator_traits<_InnerIter>::iterator_category;
7160 using _PatternCat =
typename iterator_traits<_PatternIter>::iterator_category;
7161 if constexpr (!is_lvalue_reference_v<common_reference_t<iter_reference_t<_InnerIter>,
7162 iter_reference_t<_PatternIter>>>)
7163 return input_iterator_tag{};
7164 else if constexpr (derived_from<_OuterCat, bidirectional_iterator_tag>
7165 && derived_from<_InnerCat, bidirectional_iterator_tag>
7166 && derived_from<_PatternCat, bidirectional_iterator_tag>
7167 && common_range<_InnerBase<_Const>>
7168 && common_range<_PatternBase<_Const>>)
7169 return bidirectional_iterator_tag{};
7170 else if constexpr (derived_from<_OuterCat, forward_iterator_tag>
7171 && derived_from<_InnerCat, forward_iterator_tag>
7172 && derived_from<_PatternCat, forward_iterator_tag>)
7173 return forward_iterator_tag{};
7175 return input_iterator_tag{};
7178 using iterator_category =
decltype(_S_iter_cat());
7181 template<
bool>
struct _Iterator;
7182 template<
bool>
struct _Sentinel;
7185 join_with_view()
requires (default_initializable<_Vp>
7186 && default_initializable<_Pattern>)
7190 join_with_view(_Vp __base, _Pattern __pattern)
7194 template<input_range _Range>
7195 requires constructible_from<_Vp, views::all_t<_Range>>
7196 && constructible_from<_Pattern, single_view<range_value_t<_InnerRange>>>
7198 join_with_view(_Range&& __r, range_value_t<_InnerRange> __e)
7199 : _M_base(views::all(
std::
forward<_Range>(__r))),
7200 _M_pattern(views::single(
std::
move(__e)))
7204 base() const& requires copy_constructible<_Vp>
7214 if constexpr (forward_range<_Vp>)
7216 constexpr bool __use_const = is_reference_v<_InnerRange>
7217 && __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
7218 return _Iterator<__use_const>{*
this, ranges::begin(_M_base)};
7222 _M_outer_it = ranges::begin(_M_base);
7223 return _Iterator<false>{*
this};
7229 requires forward_range<const _Vp>
7230 && forward_range<const _Pattern>
7231 && is_reference_v<range_reference_t<const _Vp>>
7232 && input_range<range_reference_t<const _Vp>>
7233 {
return _Iterator<true>{*
this, ranges::begin(_M_base)}; }
7238 constexpr bool __use_const
7239 = __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
7240 if constexpr (is_reference_v<_InnerRange>
7241 && forward_range<_Vp> && common_range<_Vp>
7242 && forward_range<_InnerRange> && common_range<_InnerRange>)
7243 return _Iterator<__use_const>{*
this, ranges::end(_M_base)};
7245 return _Sentinel<__use_const>{*
this};
7250 requires forward_range<const _Vp>
7251 && forward_range<const _Pattern>
7252 && is_reference_v<range_reference_t<const _Vp>>
7253 && input_range<range_reference_t<const _Vp>>
7255 using _InnerConstRange = range_reference_t<const _Vp>;
7256 if constexpr (forward_range<_InnerConstRange>
7257 && common_range<const _Vp>
7258 && common_range<_InnerConstRange>)
7259 return _Iterator<true>{*
this, ranges::end(_M_base)};
7261 return _Sentinel<true>{*
this};
7265 template<
typename _Range,
typename _Pattern>
7266 join_with_view(_Range&&, _Pattern&&)
7267 -> join_with_view<views::all_t<_Range>, views::all_t<_Pattern>>;
7269 template<input_range _Range>
7270 join_with_view(_Range&&, range_value_t<range_reference_t<_Range>>)
7271 -> join_with_view<views::all_t<_Range>,
7272 single_view<range_value_t<range_reference_t<_Range>>>>;
7274 template<input_range _Vp, forward_range _Pattern>
7275 requires view<_Vp> && view<_Pattern>
7276 && input_range<range_reference_t<_Vp>>
7277 && __detail::__compatible_joinable_ranges<range_reference_t<_Vp>, _Pattern>
7278 template<
bool _Const>
7279 class join_with_view<_Vp, _Pattern>::_Iterator :
public __iter_cat<_Const>
7281 using _Parent = __detail::__maybe_const_t<_Const, join_with_view>;
7282 using _Base = join_with_view::_Base<_Const>;
7283 using _InnerBase = join_with_view::_InnerBase<_Const>;
7284 using _PatternBase = join_with_view::_PatternBase<_Const>;
7286 using _OuterIter = join_with_view::_OuterIter<_Const>;
7287 using _InnerIter = join_with_view::_InnerIter<_Const>;
7288 using _PatternIter = join_with_view::_PatternIter<_Const>;
7290 static constexpr bool _S_ref_is_glvalue = join_with_view::_S_ref_is_glvalue<_Const>;
7292 _Parent* _M_parent =
nullptr;
7293 [[no_unique_address]]
7294 __detail::__maybe_present_t<forward_range<_Base>, _OuterIter> _M_outer_it;
7295 variant<_PatternIter, _InnerIter> _M_inner_it;
7297 constexpr _OuterIter&
7300 if constexpr (forward_range<_Base>)
7303 return *_M_parent->_M_outer_it;
7306 constexpr const _OuterIter&
7307 _M_get_outer()
const
7309 if constexpr (forward_range<_Base>)
7312 return *_M_parent->_M_outer_it;
7316 _Iterator(_Parent& __parent, _OuterIter __outer)
7317 requires forward_range<_Base>
7320 if (_M_get_outer() != ranges::end(_M_parent->_M_base))
7322 auto&& __inner = _M_update_inner();
7323 _M_inner_it.template emplace<1>(ranges::begin(__inner));
7329 _Iterator(_Parent& __parent)
7330 requires (!forward_range<_Base>)
7333 if (_M_get_outer() != ranges::end(_M_parent->_M_base))
7335 auto&& __inner = _M_update_inner();
7336 _M_inner_it.template emplace<1>(ranges::begin(__inner));
7344 _OuterIter& __outer = _M_get_outer();
7345 if constexpr (_S_ref_is_glvalue)
7346 return __detail::__as_lvalue(*__outer);
7348 return _M_parent->_M_inner._M_emplace_deref(__outer);
7354 if constexpr (_S_ref_is_glvalue)
7355 return __detail::__as_lvalue(*_M_get_outer());
7357 return *_M_parent->_M_inner;
7365 if (_M_inner_it.index() == 0)
7367 if (std::get<0>(_M_inner_it) != ranges::end(_M_parent->_M_pattern))
7370 auto&& __inner = _M_update_inner();
7371 _M_inner_it.template emplace<1>(ranges::begin(__inner));
7375 auto&& __inner = _M_get_inner();
7376 if (std::get<1>(_M_inner_it) != ranges::end(__inner))
7379 if (++_M_get_outer() == ranges::end(_M_parent->_M_base))
7381 if constexpr (_S_ref_is_glvalue)
7382 _M_inner_it.template emplace<0>();
7386 _M_inner_it.template emplace<0>(ranges::begin(_M_parent->_M_pattern));
7394 if constexpr (_S_ref_is_glvalue
7395 && bidirectional_range<_Base>
7396 && __detail::__bidirectional_common<_InnerBase>
7397 && __detail::__bidirectional_common<_PatternBase>)
7398 return bidirectional_iterator_tag{};
7399 else if constexpr (_S_ref_is_glvalue
7400 && forward_range<_Base>
7401 && forward_range<_InnerBase>)
7402 return forward_iterator_tag{};
7404 return input_iterator_tag{};
7407 friend join_with_view;
7410 using iterator_concept =
decltype(_S_iter_concept());
7412 using value_type = common_type_t<iter_value_t<_InnerIter>,
7413 iter_value_t<_PatternIter>>;
7414 using difference_type = common_type_t<iter_difference_t<_OuterIter>,
7415 iter_difference_t<_InnerIter>,
7416 iter_difference_t<_PatternIter>>;
7418 _Iterator() =
default;
7421 _Iterator(_Iterator<!_Const> __i)
7423 && convertible_to<iterator_t<_Vp>, _OuterIter>
7424 && convertible_to<iterator_t<_InnerRange>, _InnerIter>
7425 && convertible_to<iterator_t<_Pattern>, _PatternIter>
7426 : _M_parent(__i._M_parent),
7429 if (__i._M_inner_it.index() == 0)
7430 _M_inner_it.template emplace<0>(std::get<0>(
std::move(__i._M_inner_it)));
7432 _M_inner_it.template emplace<1>(std::get<1>(
std::move(__i._M_inner_it)));
7435 constexpr common_reference_t<iter_reference_t<_InnerIter>,
7436 iter_reference_t<_PatternIter>>
7439 if (_M_inner_it.index() == 0)
7440 return *std::get<0>(_M_inner_it);
7442 return *std::get<1>(_M_inner_it);
7445 constexpr _Iterator&
7448 if (_M_inner_it.index() == 0)
7449 ++std::get<0>(_M_inner_it);
7451 ++std::get<1>(_M_inner_it);
7462 requires _S_ref_is_glvalue
7463 && forward_iterator<_OuterIter> && forward_iterator<_InnerIter>
7465 _Iterator __tmp = *
this;
7470 constexpr _Iterator&
7472 requires _S_ref_is_glvalue
7473 && bidirectional_range<_Base>
7474 && __detail::__bidirectional_common<_InnerBase>
7475 && __detail::__bidirectional_common<_PatternBase>
7477 if (_M_outer_it == ranges::end(_M_parent->_M_base))
7479 auto&& __inner = *--_M_outer_it;
7480 _M_inner_it.template emplace<1>(ranges::end(__inner));
7485 if (_M_inner_it.index() == 0)
7487 auto& __it = std::get<0>(_M_inner_it);
7488 if (__it == ranges::begin(_M_parent->_M_pattern))
7490 auto&& __inner = *--_M_outer_it;
7491 _M_inner_it.template emplace<1>(ranges::end(__inner));
7498 auto& __it = std::get<1>(_M_inner_it);
7499 auto&& __inner = *_M_outer_it;
7500 if (__it == ranges::begin(__inner))
7501 _M_inner_it.template emplace<0>(ranges::end(_M_parent->_M_pattern));
7507 if (_M_inner_it.index() == 0)
7508 --std::get<0>(_M_inner_it);
7510 --std::get<1>(_M_inner_it);
7516 requires _S_ref_is_glvalue && bidirectional_range<_Base>
7517 && __detail::__bidirectional_common<_InnerBase>
7518 && __detail::__bidirectional_common<_PatternBase>
7520 _Iterator __tmp = *
this;
7525 friend constexpr bool
7526 operator==(
const _Iterator& __x,
const _Iterator& __y)
7527 requires _S_ref_is_glvalue
7528 && forward_range<_Base> && equality_comparable<_InnerIter>
7529 {
return __x._M_outer_it == __y._M_outer_it && __x._M_inner_it ==__y._M_inner_it; }
7531 friend constexpr common_reference_t<iter_rvalue_reference_t<_InnerIter>,
7532 iter_rvalue_reference_t<_PatternIter>>
7533 iter_move(
const _Iterator& __x)
7535 if (__x._M_inner_it.index() == 0)
7536 return ranges::iter_move(std::get<0>(__x._M_inner_it));
7538 return ranges::iter_move(std::get<1>(__x._M_inner_it));
7541 friend constexpr void
7542 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
7543 requires indirectly_swappable<_InnerIter, _PatternIter>
7545 if (__x._M_inner_it.index() == 0)
7547 if (__y._M_inner_it.index() == 0)
7548 ranges::iter_swap(std::get<0>(__x._M_inner_it), std::get<0>(__y._M_inner_it));
7550 ranges::iter_swap(std::get<0>(__x._M_inner_it), std::get<1>(__y._M_inner_it));
7554 if (__y._M_inner_it.index() == 0)
7555 ranges::iter_swap(std::get<1>(__x._M_inner_it), std::get<0>(__y._M_inner_it));
7557 ranges::iter_swap(std::get<1>(__x._M_inner_it), std::get<1>(__y._M_inner_it));
7562 template<input_range _Vp, forward_range _Pattern>
7563 requires view<_Vp> && view<_Pattern>
7564 && input_range<range_reference_t<_Vp>>
7565 && __detail::__compatible_joinable_ranges<range_reference_t<_Vp>, _Pattern>
7566 template<
bool _Const>
7567 class join_with_view<_Vp, _Pattern>::_Sentinel
7569 using _Parent = __detail::__maybe_const_t<_Const, join_with_view>;
7570 using _Base = join_with_view::_Base<_Const>;
7572 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
7575 _Sentinel(_Parent& __parent)
7576 : _M_end(ranges::
end(__parent._M_base))
7579 friend join_with_view;
7582 _Sentinel() =
default;
7585 _Sentinel(_Sentinel<!_Const> __s)
7586 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
7590 template<
bool _OtherConst>
7591 requires sentinel_for<sentinel_t<_Base>,
7592 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
7593 friend constexpr bool
7594 operator==(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
7595 {
return __x._M_get_outer() == __y._M_end; }
7602 template<
typename _Range,
typename _Pattern>
7603 concept __can_join_with_view
7604 =
requires { join_with_view(std::declval<_Range>(), std::declval<_Pattern>()); };
7607 struct _JoinWith : __adaptor::_RangeAdaptor<_JoinWith>
7609 template<viewable_range _Range,
typename _Pattern>
7610 requires __detail::__can_join_with_view<_Range, _Pattern>
7612 operator() [[nodiscard]] (_Range&& __r, _Pattern&& __f)
const
7614 return join_with_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
7617 using _RangeAdaptor<_JoinWith>::operator();
7618 static constexpr int _S_arity = 2;
7619 template<
typename _Pattern>
7620 static constexpr bool _S_has_simple_extra_args
7621 = _LazySplit::_S_has_simple_extra_args<_Pattern>;
7624 inline constexpr _JoinWith join_with;
7628#ifdef __cpp_lib_ranges_repeat
7629 template<move_constructible _Tp, semiregular _Bound = unreachable_sentinel_t>
7630 requires is_object_v<_Tp> && same_as<_Tp, remove_cv_t<_Tp>>
7631 && (__detail::__is_integer_like<_Bound> || same_as<_Bound, unreachable_sentinel_t>)
7632 class repeat_view : public view_interface<repeat_view<_Tp, _Bound>>
7634 __detail::__box<_Tp> _M_value;
7635 [[no_unique_address]] _Bound _M_bound = _Bound();
7639 template<
typename _Range>
7640 friend constexpr auto
7641 views::__detail::__take_of_repeat_view(_Range&&, range_difference_t<_Range>);
7643 template<
typename _Range>
7644 friend constexpr auto
7645 views::__detail::__drop_of_repeat_view(_Range&&, range_difference_t<_Range>);
7648 repeat_view()
requires default_initializable<_Tp> = default;
7651 repeat_view(const _Tp& __value, _Bound __bound = _Bound())
7652 requires copy_constructible<_Tp>
7653 : _M_value(__value), _M_bound(__bound)
7655 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7656 __glibcxx_assert(__bound >= 0);
7660 repeat_view(_Tp&& __value, _Bound __bound = _Bound())
7661 : _M_value(
std::
move(__value)), _M_bound(__bound)
7664 template<
typename... _Args,
typename... _BoundArgs>
7665 requires constructible_from<_Tp, _Args...>
7666 && constructible_from<_Bound, _BoundArgs...>
7668 repeat_view(piecewise_construct_t,
7669 tuple<_Args...> __args,
7670 tuple<_BoundArgs...> __bound_args = tuple<>{})
7671 : _M_value(
std::make_from_tuple<_Tp>(
std::
move(__args))),
7672 _M_bound(
std::make_from_tuple<_Bound>(
std::
move(__bound_args)))
7680 end() const requires (!same_as<_Bound, unreachable_sentinel_t>)
7683 constexpr unreachable_sentinel_t
7684 end() const noexcept
7685 {
return unreachable_sentinel; }
7688 size() const requires (!same_as<_Bound, unreachable_sentinel_t>)
7689 {
return __detail::__to_unsigned_like(_M_bound); }
7692 template<
typename _Tp,
typename _Bound>
7693 repeat_view(_Tp, _Bound) -> repeat_view<_Tp, _Bound>;
7695 template<move_constructible _Tp, semiregular _Bound>
7696 requires is_object_v<_Tp> && same_as<_Tp, remove_cv_t<_Tp>>
7697 && (__detail::__is_integer_like<_Bound> || same_as<_Bound, unreachable_sentinel_t>)
7698 class repeat_view<_Tp, _Bound>::_Iterator
7701 = __conditional_t<same_as<_Bound, unreachable_sentinel_t>, ptrdiff_t, _Bound>;
7703 const _Tp* _M_value =
nullptr;
7704 __index_type _M_current = __index_type();
7707 _Iterator(
const _Tp* __value, __index_type __bound = __index_type())
7708 : _M_value(__value), _M_current(__bound)
7710 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7711 __glibcxx_assert(__bound >= 0);
7717 using iterator_concept = random_access_iterator_tag;
7718 using iterator_category = random_access_iterator_tag;
7719 using value_type = _Tp;
7720 using difference_type = __conditional_t<__detail::__is_signed_integer_like<__index_type>,
7722 __detail::__iota_diff_t<__index_type>>;
7724 _Iterator() =
default;
7726 constexpr const _Tp&
7728 {
return *_M_value; }
7730 constexpr _Iterator&
7745 constexpr _Iterator&
7748 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7749 __glibcxx_assert(_M_current > 0);
7762 constexpr _Iterator&
7763 operator+=(difference_type __n)
7765 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7766 __glibcxx_assert(_M_current + __n >= 0);
7771 constexpr _Iterator&
7772 operator-=(difference_type __n)
7774 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7775 __glibcxx_assert(_M_current - __n >= 0);
7780 constexpr const _Tp&
7781 operator[](difference_type __n)
const noexcept
7782 {
return *(*
this + __n); }
7784 friend constexpr bool
7785 operator==(
const _Iterator& __x,
const _Iterator& __y)
7786 {
return __x._M_current == __y._M_current; }
7788 friend constexpr auto
7789 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
7790 {
return __x._M_current <=> __y._M_current; }
7792 friend constexpr _Iterator
7793 operator+(_Iterator __i, difference_type __n)
7799 friend constexpr _Iterator
7800 operator+(difference_type __n, _Iterator __i)
7801 {
return __i + __n; }
7803 friend constexpr _Iterator
7804 operator-(_Iterator __i, difference_type __n)
7810 friend constexpr difference_type
7811 operator-(
const _Iterator& __x,
const _Iterator& __y)
7813 return (
static_cast<difference_type
>(__x._M_current)
7814 -
static_cast<difference_type
>(__y._M_current));
7822 template<
typename _Tp,
typename _Bound>
7823 inline constexpr bool __is_repeat_view<repeat_view<_Tp, _Bound>> =
true;
7825 template<
typename _Tp>
7826 concept __can_repeat_view
7827 =
requires { repeat_view(std::declval<_Tp>()); };
7829 template<
typename _Tp,
typename _Bound>
7830 concept __can_bounded_repeat_view
7831 =
requires { repeat_view(std::declval<_Tp>(), std::declval<_Bound>()); };
7836 template<
typename _Tp>
7837 requires __detail::__can_repeat_view<_Tp>
7839 operator() [[nodiscard]] (_Tp&& __value)
const
7840 {
return repeat_view(std::forward<_Tp>(__value)); }
7842 template<
typename _Tp,
typename _Bound>
7843 requires __detail::__can_bounded_repeat_view<_Tp, _Bound>
7845 operator() [[nodiscard]] (_Tp&& __value, _Bound __bound)
const
7846 {
return repeat_view(std::forward<_Tp>(__value), __bound); }
7849 inline constexpr _Repeat repeat;
7853 template<
typename _Range>
7855 __take_of_repeat_view(_Range&& __r, range_difference_t<_Range> __n)
7857 using _Tp = remove_cvref_t<_Range>;
7858 static_assert(__is_repeat_view<_Tp>);
7859 if constexpr (sized_range<_Tp>)
7860 return views::repeat(*std::forward<_Range>(__r)._M_value,
7861 std::min(ranges::distance(__r), __n));
7863 return views::repeat(*std::forward<_Range>(__r)._M_value, __n);
7866 template<
typename _Range>
7868 __drop_of_repeat_view(_Range&& __r, range_difference_t<_Range> __n)
7870 using _Tp = remove_cvref_t<_Range>;
7871 static_assert(__is_repeat_view<_Tp>);
7872 if constexpr (sized_range<_Tp>)
7874 auto __sz = ranges::distance(__r);
7875 return views::repeat(*std::forward<_Range>(__r)._M_value,
7885#ifdef __cpp_lib_ranges_stride
7886 template<input_range _Vp>
7888 class stride_view :
public view_interface<stride_view<_Vp>>
7891 range_difference_t<_Vp> _M_stride;
7893 template<
bool _Const>
using _Base = __detail::__maybe_const_t<_Const, _Vp>;
7895 template<
bool _Const>
7899 template<
bool _Const>
7900 requires forward_range<_Base<_Const>>
7901 struct __iter_cat<_Const>
7907 using _Cat =
typename iterator_traits<iterator_t<_Base<_Const>>>::iterator_category;
7908 if constexpr (derived_from<_Cat, random_access_iterator_tag>)
7909 return random_access_iterator_tag{};
7914 using iterator_category =
decltype(_S_iter_cat());
7917 template<
bool>
class _Iterator;
7921 stride_view(_Vp __base, range_difference_t<_Vp> __stride)
7923 { __glibcxx_assert(__stride > 0); }
7926 base() const& requires copy_constructible<_Vp>
7933 constexpr range_difference_t<_Vp>
7934 stride() const noexcept
7935 {
return _M_stride; }
7938 begin()
requires (!__detail::__simple_view<_Vp>)
7939 {
return _Iterator<false>(
this, ranges::begin(_M_base)); }
7942 begin() const requires range<const _Vp>
7943 {
return _Iterator<true>(
this, ranges::begin(_M_base)); }
7946 end()
requires (!__detail::__simple_view<_Vp>)
7948 if constexpr (common_range<_Vp> && sized_range<_Vp> && forward_range<_Vp>)
7950 auto __missing = (_M_stride - ranges::distance(_M_base) % _M_stride) % _M_stride;
7951 return _Iterator<false>(
this, ranges::end(_M_base), __missing);
7953 else if constexpr (common_range<_Vp> && !bidirectional_range<_Vp>)
7954 return _Iterator<false>(
this, ranges::end(_M_base));
7960 end() const requires range<const _Vp>
7962 if constexpr (common_range<const _Vp> && sized_range<const _Vp>
7963 && forward_range<const _Vp>)
7965 auto __missing = (_M_stride - ranges::distance(_M_base) % _M_stride) % _M_stride;
7966 return _Iterator<true>(
this, ranges::end(_M_base), __missing);
7968 else if constexpr (common_range<const _Vp> && !bidirectional_range<const _Vp>)
7969 return _Iterator<true>(
this, ranges::end(_M_base));
7975 size()
requires sized_range<_Vp>
7977 return __detail::__to_unsigned_like
7978 (__detail::__div_ceil(ranges::distance(_M_base), _M_stride));
7982 size() const requires sized_range<const _Vp>
7984 return __detail::__to_unsigned_like
7985 (__detail::__div_ceil(ranges::distance(_M_base), _M_stride));
7989 template<
typename _Range>
7990 stride_view(_Range&&, range_difference_t<_Range>) -> stride_view<views::all_t<_Range>>;
7992 template<
typename _Vp>
7993 inline constexpr bool enable_borrowed_range<stride_view<_Vp>>
7994 = enable_borrowed_range<_Vp>;
7996 template<input_range _Vp>
7998 template<
bool _Const>
7999 class stride_view<_Vp>::_Iterator :
public __iter_cat<_Const>
8001 using _Parent = __detail::__maybe_const_t<_Const, stride_view>;
8002 using _Base = stride_view::_Base<_Const>;
8004 iterator_t<_Base> _M_current = iterator_t<_Base>();
8005 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
8006 range_difference_t<_Base> _M_stride = 0;
8007 range_difference_t<_Base> _M_missing = 0;
8010 _Iterator(_Parent* __parent, iterator_t<_Base> __current,
8011 range_difference_t<_Base> __missing = 0)
8012 : _M_current(
std::
move(__current)), _M_end(ranges::
end(__parent->_M_base)),
8013 _M_stride(__parent->_M_stride), _M_missing(__missing)
8019 if constexpr (random_access_range<_Base>)
8020 return random_access_iterator_tag{};
8021 else if constexpr (bidirectional_range<_Base>)
8022 return bidirectional_iterator_tag{};
8023 else if constexpr (forward_range<_Base>)
8024 return forward_iterator_tag{};
8026 return input_iterator_tag{};
8032 using difference_type = range_difference_t<_Base>;
8033 using value_type = range_value_t<_Base>;
8034 using iterator_concept =
decltype(_S_iter_concept());
8037 _Iterator()
requires default_initializable<iterator_t<_Base>> = default;
8040 _Iterator(_Iterator<!_Const> __other)
8042 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
8043 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
8044 : _M_current(
std::move(__other._M_current)), _M_end(
std::move(__other._M_end)),
8045 _M_stride(__other._M_stride), _M_missing(__other._M_missing)
8048 constexpr iterator_t<_Base>
8052 constexpr const iterator_t<_Base>&
8053 base() const & noexcept
8054 {
return _M_current; }
8056 constexpr decltype(
auto)
8058 {
return *_M_current; }
8060 constexpr _Iterator&
8063 __glibcxx_assert(_M_current != _M_end);
8064 _M_missing = ranges::advance(_M_current, _M_stride, _M_end);
8073 operator++(
int)
requires forward_range<_Base>
8080 constexpr _Iterator&
8081 operator--()
requires bidirectional_range<_Base>
8083 ranges::advance(_M_current, _M_missing - _M_stride);
8089 operator--(
int)
requires bidirectional_range<_Base>
8096 constexpr _Iterator&
8097 operator+=(difference_type __n)
requires random_access_range<_Base>
8101 __glibcxx_assert(ranges::distance(_M_current, _M_end) > _M_stride * (__n - 1));
8102 _M_missing = ranges::advance(_M_current, _M_stride * __n, _M_end);
8106 ranges::advance(_M_current, _M_stride * __n + _M_missing);
8112 constexpr _Iterator&
8113 operator-=(difference_type __n)
requires random_access_range<_Base>
8114 {
return *
this += -__n; }
8116 constexpr decltype(
auto)
operator[](difference_type __n)
const
8117 requires random_access_range<_Base>
8118 {
return *(*
this + __n); }
8120 friend constexpr bool
8121 operator==(
const _Iterator& __x, default_sentinel_t)
8122 {
return __x._M_current == __x._M_end; }
8124 friend constexpr bool
8125 operator==(
const _Iterator& __x,
const _Iterator& __y)
8126 requires equality_comparable<iterator_t<_Base>>
8127 {
return __x._M_current == __y._M_current; }
8129 friend constexpr bool
8130 operator<(
const _Iterator& __x,
const _Iterator& __y)
8131 requires random_access_range<_Base>
8132 {
return __x._M_current < __y._M_current; }
8134 friend constexpr bool
8135 operator>(
const _Iterator& __x,
const _Iterator& __y)
8136 requires random_access_range<_Base>
8137 {
return __y._M_current < __x._M_current; }
8139 friend constexpr bool
8140 operator<=(
const _Iterator& __x,
const _Iterator& __y)
8141 requires random_access_range<_Base>
8142 {
return !(__y._M_current < __x._M_current); }
8144 friend constexpr bool
8145 operator>=(
const _Iterator& __x,
const _Iterator& __y)
8146 requires random_access_range<_Base>
8147 {
return !(__x._M_current < __y._M_current); }
8149 friend constexpr auto
8150 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
8151 requires random_access_range<_Base> && three_way_comparable<iterator_t<_Base>>
8152 {
return __x._M_current <=> __y._M_current; }
8154 friend constexpr _Iterator
8155 operator+(
const _Iterator& __i, difference_type __n)
8156 requires random_access_range<_Base>
8163 friend constexpr _Iterator
8164 operator+(difference_type __n,
const _Iterator& __i)
8165 requires random_access_range<_Base>
8166 {
return __i + __n; }
8168 friend constexpr _Iterator
8169 operator-(
const _Iterator& __i, difference_type __n)
8170 requires random_access_range<_Base>
8177 friend constexpr difference_type
8178 operator-(
const _Iterator& __x,
const _Iterator& __y)
8179 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
8181 auto __n = __x._M_current - __y._M_current;
8182 if constexpr (forward_range<_Base>)
8183 return (__n + __x._M_missing - __y._M_missing) / __x._M_stride;
8185 return -__detail::__div_ceil(-__n, __x._M_stride);
8187 return __detail::__div_ceil(__n, __x._M_stride);
8190 friend constexpr difference_type
8191 operator-(default_sentinel_t __y,
const _Iterator& __x)
8192 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
8193 {
return __detail::__div_ceil(__x._M_end - __x._M_current, __x._M_stride); }
8195 friend constexpr difference_type
8196 operator-(
const _Iterator& __x, default_sentinel_t __y)
8197 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
8198 {
return -(__y - __x); }
8200 friend constexpr range_rvalue_reference_t<_Base>
8201 iter_move(
const _Iterator& __i)
8202 noexcept(
noexcept(ranges::iter_move(__i._M_current)))
8203 {
return ranges::iter_move(__i._M_current); }
8205 friend constexpr void
8206 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
8207 noexcept(
noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
8208 requires indirectly_swappable<iterator_t<_Base>>
8209 { ranges::iter_swap(__x._M_current, __y._M_current); }
8216 template<
typename _Range,
typename _Dp>
8217 concept __can_stride_view
8218 =
requires { stride_view(std::declval<_Range>(), std::declval<_Dp>()); };
8221 struct _Stride : __adaptor::_RangeAdaptor<_Stride>
8223 template<viewable_range _Range,
typename _Dp = range_difference_t<_Range>>
8224 requires __detail::__can_stride_view<_Range, _Dp>
8226 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n)
const
8227 {
return stride_view(std::forward<_Range>(__r), __n); }
8229 using __adaptor::_RangeAdaptor<_Stride>::operator();
8230 static constexpr int _S_arity = 2;
8231 static constexpr bool _S_has_simple_extra_args =
true;
8234 inline constexpr _Stride stride;
8238#ifdef __cpp_lib_ranges_cartesian_product
8241 template<
bool _Const,
typename _First,
typename... _Vs>
8242 concept __cartesian_product_is_random_access
8243 = (random_access_range<__maybe_const_t<_Const, _First>>
8245 && (random_access_range<__maybe_const_t<_Const, _Vs>>
8246 && sized_range<__maybe_const_t<_Const, _Vs>>));
8248 template<
typename _Range>
8249 concept __cartesian_product_common_arg
8250 = common_range<_Range> || (sized_range<_Range> && random_access_range<_Range>);
8252 template<
bool _Const,
typename _First,
typename... _Vs>
8253 concept __cartesian_product_is_bidirectional
8254 = (bidirectional_range<__maybe_const_t<_Const, _First>>
8256 && (bidirectional_range<__maybe_const_t<_Const, _Vs>>
8257 && __cartesian_product_common_arg<__maybe_const_t<_Const, _Vs>>));
8259 template<
typename _First,
typename... _Vs>
8260 concept __cartesian_product_is_common = __cartesian_product_common_arg<_First>;
8262 template<
typename... _Vs>
8263 concept __cartesian_product_is_sized = (sized_range<_Vs> && ...);
8265 template<
bool _Const,
template<
typename>
class FirstSent,
typename _First,
typename... _Vs>
8266 concept __cartesian_is_sized_sentinel
8267 = (sized_sentinel_for<FirstSent<__maybe_const_t<_Const, _First>>,
8268 iterator_t<__maybe_const_t<_Const, _First>>>
8270 && (sized_range<__maybe_const_t<_Const, _Vs>>
8271 && sized_sentinel_for<iterator_t<__maybe_const_t<_Const, _Vs>>,
8272 iterator_t<__maybe_const_t<_Const, _Vs>>>));
8274 template<__cartesian_product_common_arg _Range>
8276 __cartesian_common_arg_end(_Range& __r)
8278 if constexpr (common_range<_Range>)
8279 return ranges::end(__r);
8281 return ranges::begin(__r) + ranges::distance(__r);
8285 template<input_range _First, forward_range... _Vs>
8286 requires (view<_First> && ... && view<_Vs>)
8287 class cartesian_product_view : public view_interface<cartesian_product_view<_First, _Vs...>>
8289 tuple<_First, _Vs...> _M_bases;
8291 template<
bool>
class _Iterator;
8294 _S_difference_type()
8300 range_difference_t<_First>,
8301 range_difference_t<_Vs>...>{};
8305 cartesian_product_view() =
default;
8308 cartesian_product_view(_First __first, _Vs... __rest)
8312 constexpr _Iterator<false>
8313 begin()
requires (!__detail::__simple_view<_First> || ... || !__detail::__simple_view<_Vs>)
8314 {
return _Iterator<false>(*
this, __detail::__tuple_transform(ranges::begin, _M_bases)); }
8316 constexpr _Iterator<true>
8317 begin() const requires (range<const _First> && ... && range<const _Vs>)
8318 {
return _Iterator<true>(*
this, __detail::__tuple_transform(ranges::begin, _M_bases)); }
8320 constexpr _Iterator<false>
8321 end()
requires ((!__detail::__simple_view<_First> || ... || !__detail::__simple_view<_Vs>)
8322 && __detail::__cartesian_product_is_common<_First, _Vs...>)
8325 using _Ret = __detail::__tuple_or_pair_t<iterator_t<_First>,
8326 iterator_t<_Vs>...>;
8327 bool __empty_tail = (ranges::empty(std::get<1 + _Is>(_M_bases)) || ...);
8328 auto& __first = std::get<0>(_M_bases);
8329 return _Ret{(__empty_tail
8330 ? ranges::begin(__first)
8331 : __detail::__cartesian_common_arg_end(__first)),
8332 ranges::
begin(
std::get<1 + _Is>(_M_bases))...};
8335 return _Iterator<false>{*
this,
std::move(__its)};
8338 constexpr _Iterator<true>
8339 end() const requires __detail::__cartesian_product_is_common<const _First, const _Vs...>
8342 using _Ret = __detail::__tuple_or_pair_t<iterator_t<const _First>,
8343 iterator_t<const _Vs>...>;
8344 bool __empty_tail = (ranges::empty(std::get<1 + _Is>(_M_bases)) || ...);
8345 auto& __first = std::get<0>(_M_bases);
8346 return _Ret{(__empty_tail
8347 ? ranges::begin(__first)
8348 : __detail::__cartesian_common_arg_end(__first)),
8349 ranges::
begin(
std::get<1 + _Is>(_M_bases))...};
8352 return _Iterator<true>{*
this,
std::move(__its)};
8355 constexpr default_sentinel_t
8356 end() const noexcept
8360 size()
requires __detail::__cartesian_product_is_sized<_First, _Vs...>
8362 using _ST = __detail::__make_unsigned_like_t<
decltype(_S_difference_type())>;
8364 auto __size =
static_cast<_ST
>(1);
8365#ifdef _GLIBCXX_ASSERTIONS
8366 if constexpr (integral<_ST>)
8369 = (__builtin_mul_overflow(__size,
8370 static_cast<_ST
>(ranges::size(std::get<_Is>(_M_bases))),
8373 __glibcxx_assert(!__overflow);
8377 __size = (
static_cast<_ST
>(ranges::size(std::get<_Is>(_M_bases))) * ...);
8383 size() const requires __detail::__cartesian_product_is_sized<const _First, const _Vs...>
8385 using _ST = __detail::__make_unsigned_like_t<
decltype(_S_difference_type())>;
8387 auto __size =
static_cast<_ST
>(1);
8388#ifdef _GLIBCXX_ASSERTIONS
8389 if constexpr (integral<_ST>)
8392 = (__builtin_mul_overflow(__size,
8393 static_cast<_ST
>(ranges::size(std::get<_Is>(_M_bases))),
8396 __glibcxx_assert(!__overflow);
8400 __size = (
static_cast<_ST
>(ranges::size(std::get<_Is>(_M_bases))) * ...);
8406 template<
typename... _Vs>
8407 cartesian_product_view(_Vs&&...) -> cartesian_product_view<views::all_t<_Vs>...>;
8409 template<input_range _First, forward_range... _Vs>
8410 requires (view<_First> && ... && view<_Vs>)
8411 template<bool _Const>
8412 class cartesian_product_view<_First, _Vs...>::_Iterator
8414 using _Parent = __maybe_const_t<_Const, cartesian_product_view>;
8415 _Parent* _M_parent =
nullptr;
8416 __detail::__tuple_or_pair_t<iterator_t<__maybe_const_t<_Const, _First>>,
8417 iterator_t<__maybe_const_t<_Const, _Vs>>...> _M_current;
8420 _Iterator(_Parent& __parent,
decltype(_M_current) __current)
8422 _M_current(
std::
move(__current))
8428 if constexpr (__detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>)
8429 return random_access_iterator_tag{};
8430 else if constexpr (__detail::__cartesian_product_is_bidirectional<_Const, _First, _Vs...>)
8431 return bidirectional_iterator_tag{};
8432 else if constexpr (forward_range<__maybe_const_t<_Const, _First>>)
8433 return forward_iterator_tag{};
8435 return input_iterator_tag{};
8438 friend cartesian_product_view;
8441 using iterator_category = input_iterator_tag;
8442 using iterator_concept =
decltype(_S_iter_concept());
8444 = __detail::__tuple_or_pair_t<range_value_t<__maybe_const_t<_Const, _First>>,
8445 range_value_t<__maybe_const_t<_Const, _Vs>>...>;
8447 = __detail::__tuple_or_pair_t<range_reference_t<__maybe_const_t<_Const, _First>>,
8448 range_reference_t<__maybe_const_t<_Const, _Vs>>...>;
8449 using difference_type =
decltype(cartesian_product_view::_S_difference_type());
8451 _Iterator() =
default;
8454 _Iterator(_Iterator<!_Const> __i)
8456 && (convertible_to<iterator_t<_First>, iterator_t<const _First>>
8457 && ... && convertible_to<iterator_t<_Vs>, iterator_t<const _Vs>>)
8459 _M_current(
std::
move(__i._M_current))
8465 auto __f = [](
auto& __i) ->
decltype(
auto) {
8468 return __detail::__tuple_transform(__f, _M_current);
8471 constexpr _Iterator&
8483 operator++(
int)
requires forward_range<__maybe_const_t<_Const, _First>>
8490 constexpr _Iterator&
8492 requires __detail::__cartesian_product_is_bidirectional<_Const, _First, _Vs...>
8500 requires __detail::__cartesian_product_is_bidirectional<_Const, _First, _Vs...>
8507 constexpr _Iterator&
8508 operator+=(difference_type __x)
8509 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8515 constexpr _Iterator&
8516 operator-=(difference_type __x)
8517 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8518 {
return *
this += -__x; }
8521 operator[](difference_type __n)
const
8522 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8523 {
return *((*this) + __n); }
8525 friend constexpr bool
8526 operator==(
const _Iterator& __x,
const _Iterator& __y)
8527 requires equality_comparable<iterator_t<__maybe_const_t<_Const, _First>>>
8528 {
return __x._M_current == __y._M_current; }
8530 friend constexpr bool
8531 operator==(
const _Iterator& __x, default_sentinel_t)
8534 return ((std::get<_Is>(__x._M_current)
8535 == ranges::end(std::get<_Is>(__x._M_parent->_M_bases)))
8540 friend constexpr auto
8541 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
8542 requires __detail::__all_random_access<_Const, _First, _Vs...>
8543 {
return __x._M_current <=> __y._M_current; }
8545 friend constexpr _Iterator
8546 operator+(_Iterator __x, difference_type __y)
8547 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8548 {
return __x += __y; }
8550 friend constexpr _Iterator
8551 operator+(difference_type __x, _Iterator __y)
8552 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8553 {
return __y += __x; }
8555 friend constexpr _Iterator
8556 operator-(_Iterator __x, difference_type __y)
8557 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8558 {
return __x -= __y; }
8560 friend constexpr difference_type
8561 operator-(
const _Iterator& __x,
const _Iterator& __y)
8562 requires __detail::__cartesian_is_sized_sentinel<_Const, iterator_t, _First, _Vs...>
8563 {
return __x._M_distance_from(__y._M_current); }
8565 friend constexpr difference_type
8566 operator-(
const _Iterator& __i, default_sentinel_t)
8567 requires __detail::__cartesian_is_sized_sentinel<_Const, sentinel_t, _First, _Vs...>
8570 return tuple{ranges::end(std::get<0>(__i._M_parent->_M_bases)),
8571 ranges::begin(std::get<1 + _Is>(__i._M_parent->_M_bases))...};
8573 return __i._M_distance_from(__end_tuple);
8576 friend constexpr difference_type
8577 operator-(default_sentinel_t,
const _Iterator& __i)
8578 requires __detail::__cartesian_is_sized_sentinel<_Const, sentinel_t, _First, _Vs...>
8581 friend constexpr auto
8582 iter_move(
const _Iterator& __i)
8583 {
return __detail::__tuple_transform(ranges::iter_move, __i._M_current); }
8585 friend constexpr void
8586 iter_swap(
const _Iterator& __l,
const _Iterator& __r)
8587 requires (indirectly_swappable<iterator_t<__maybe_const_t<_Const, _First>>>
8589 && indirectly_swappable<iterator_t<__maybe_const_t<_Const, _Vs>>>)
8592 (ranges::iter_swap(std::get<_Is>(__l._M_current), std::get<_Is>(__r._M_current)), ...);
8597 template<
size_t _Nm =
sizeof...(_Vs)>
8601 auto& __it = std::get<_Nm>(_M_current);
8603 if constexpr (_Nm > 0)
8604 if (__it == ranges::end(std::get<_Nm>(_M_parent->_M_bases)))
8606 __it = ranges::begin(std::get<_Nm>(_M_parent->_M_bases));
8611 template<
size_t _Nm =
sizeof...(_Vs)>
8615 auto& __it = std::get<_Nm>(_M_current);
8616 if constexpr (_Nm > 0)
8617 if (__it == ranges::begin(std::get<_Nm>(_M_parent->_M_bases)))
8619 __it = __detail::__cartesian_common_arg_end(std::get<_Nm>(_M_parent->_M_bases));
8625 template<
size_t _Nm =
sizeof...(_Vs)>
8627 _M_advance(difference_type __x)
8628 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8637 auto& __r = std::get<_Nm>(_M_parent->_M_bases);
8638 auto& __it = std::get<_Nm>(_M_current);
8639 if constexpr (_Nm == 0)
8641#ifdef _GLIBCXX_ASSERTIONS
8642 if constexpr (sized_range<__maybe_const_t<_Const, _First>>)
8644 auto __size = ranges::ssize(__r);
8645 auto __begin = ranges::begin(__r);
8646 auto __offset = __it - __begin;
8647 __glibcxx_assert(__offset + __x >= 0 && __offset + __x <= __size);
8654 auto __size = ranges::ssize(__r);
8655 auto __begin = ranges::begin(__r);
8656 auto __offset = __it - __begin;
8658 __x = __offset / __size;
8662 __offset = __size + __offset;
8665 __it = __begin + __offset;
8666 _M_advance<_Nm - 1>(__x);
8671 template<
typename _Tuple>
8672 constexpr difference_type
8673 _M_distance_from(
const _Tuple& __t)
const
8676 auto __sum =
static_cast<difference_type
>(0);
8677#ifdef _GLIBCXX_ASSERTIONS
8678 if constexpr (integral<difference_type>)
8681 = (__builtin_add_overflow(__sum, _M_scaled_distance<_Is>(__t), &__sum)
8683 __glibcxx_assert(!__overflow);
8687 __sum = (_M_scaled_distance<_Is>(__t) + ...);
8692 template<
size_t _Nm,
typename _Tuple>
8693 constexpr difference_type
8694 _M_scaled_distance(
const _Tuple& __t)
const
8696 auto __dist =
static_cast<difference_type
>(std::get<_Nm>(_M_current)
8697 - std::get<_Nm>(__t));
8698#ifdef _GLIBCXX_ASSERTIONS
8699 if constexpr (integral<difference_type>)
8701 bool __overflow = __builtin_mul_overflow(__dist, _M_scaled_size<_Nm+1>(), &__dist);
8702 __glibcxx_assert(!__overflow);
8706 __dist *= _M_scaled_size<_Nm+1>();
8710 template<
size_t _Nm>
8711 constexpr difference_type
8712 _M_scaled_size()
const
8714 if constexpr (_Nm <=
sizeof...(_Vs))
8716 auto __size =
static_cast<difference_type
>(ranges::size
8717 (std::get<_Nm>(_M_parent->_M_bases)));
8718#ifdef _GLIBCXX_ASSERTIONS
8719 if constexpr (integral<difference_type>)
8721 bool __overflow = __builtin_mul_overflow(__size, _M_scaled_size<_Nm+1>(), &__size);
8722 __glibcxx_assert(!__overflow);
8726 __size *= _M_scaled_size<_Nm+1>();
8730 return static_cast<difference_type
>(1);
8738 template<
typename... _Ts>
8739 concept __can_cartesian_product_view
8740 =
requires { cartesian_product_view<all_t<_Ts>...>(std::declval<_Ts>()...); };
8743 struct _CartesianProduct
8745 template<
typename... _Ts>
8746 requires (
sizeof...(_Ts) == 0 || __detail::__can_cartesian_product_view<_Ts...>)
8748 operator() [[nodiscard]] (_Ts&&... __ts)
const
8750 if constexpr (
sizeof...(_Ts) == 0)
8751 return views::single(tuple{});
8753 return cartesian_product_view<all_t<_Ts>...>(std::forward<_Ts>(__ts)...);
8757 inline constexpr _CartesianProduct cartesian_product;
8761#ifdef __cpp_lib_ranges_as_rvalue
8762 template<input_range _Vp>
8764 class as_rvalue_view :
public view_interface<as_rvalue_view<_Vp>>
8766 _Vp _M_base = _Vp();
8769 as_rvalue_view()
requires default_initializable<_Vp> = default;
8772 as_rvalue_view(_Vp __base)
8773 : _M_base(
std::move(__base))
8777 base() const& requires copy_constructible<_Vp>
8785 begin()
requires (!__detail::__simple_view<_Vp>)
8786 {
return move_iterator(ranges::begin(_M_base)); }
8789 begin() const requires range<const _Vp>
8790 {
return move_iterator(ranges::begin(_M_base)); }
8793 end()
requires (!__detail::__simple_view<_Vp>)
8795 if constexpr (common_range<_Vp>)
8796 return move_iterator(ranges::end(_M_base));
8798 return move_sentinel(ranges::end(_M_base));
8802 end() const requires range<const _Vp>
8804 if constexpr (common_range<const _Vp>)
8805 return move_iterator(ranges::end(_M_base));
8807 return move_sentinel(ranges::end(_M_base));
8811 size()
requires sized_range<_Vp>
8812 {
return ranges::size(_M_base); }
8815 size() const requires sized_range<const _Vp>
8816 {
return ranges::size(_M_base); }
8819 template<
typename _Range>
8820 as_rvalue_view(_Range&&) -> as_rvalue_view<views::all_t<_Range>>;
8822 template<
typename _Tp>
8823 inline constexpr bool enable_borrowed_range<as_rvalue_view<_Tp>>
8824 = enable_borrowed_range<_Tp>;
8830 template<
typename _Tp>
8831 concept __can_as_rvalue_view =
requires { as_rvalue_view(std::declval<_Tp>()); };
8834 struct _AsRvalue : __adaptor::_RangeAdaptorClosure<_AsRvalue>
8836 template<viewable_range _Range>
8837 requires __detail::__can_as_rvalue_view<_Range>
8839 operator() [[nodiscard]] (_Range&& __r)
const
8841 if constexpr (same_as<range_rvalue_reference_t<_Range>,
8842 range_reference_t<_Range>>)
8843 return views::all(std::forward<_Range>(__r));
8845 return as_rvalue_view(std::forward<_Range>(__r));
8849 inline constexpr _AsRvalue as_rvalue;
8853#ifdef __cpp_lib_ranges_enumerate
8856 template<
typename _Range>
8857 concept __range_with_movable_reference = input_range<_Range>
8858 && move_constructible<range_reference_t<_Range>>
8859 && move_constructible<range_rvalue_reference_t<_Range>>;
8863 requires __detail::__range_with_movable_reference<_Vp>
8864 class enumerate_view :
public view_interface<enumerate_view<_Vp>>
8866 _Vp _M_base = _Vp();
8868 template<
bool _Const>
class _Iterator;
8869 template<
bool _Const>
class _Sentinel;
8872 enumerate_view()
requires default_initializable<_Vp> = default;
8875 enumerate_view(_Vp __base)
8876 : _M_base(
std::move(__base))
8880 begin()
requires (!__detail::__simple_view<_Vp>)
8881 {
return _Iterator<false>(ranges::begin(_M_base), 0); }
8884 begin() const requires __detail::__range_with_movable_reference<const _Vp>
8885 {
return _Iterator<true>(ranges::begin(_M_base), 0); }
8888 end()
requires (!__detail::__simple_view<_Vp>)
8890 if constexpr (common_range<_Vp> && sized_range<_Vp>)
8891 return _Iterator<false>(ranges::end(_M_base), ranges::distance(_M_base));
8893 return _Sentinel<false>(ranges::end(_M_base));
8897 end() const requires __detail::__range_with_movable_reference<const _Vp>
8899 if constexpr (common_range<const _Vp> && sized_range<const _Vp>)
8900 return _Iterator<true>(ranges::end(_M_base), ranges::distance(_M_base));
8902 return _Sentinel<true>(ranges::end(_M_base));
8906 size()
requires sized_range<_Vp>
8907 {
return ranges::size(_M_base); }
8910 size() const requires sized_range<const _Vp>
8911 {
return ranges::size(_M_base); }
8914 base() const & requires copy_constructible<_Vp>
8922 template<
typename _Range>
8923 enumerate_view(_Range&&) -> enumerate_view<views::all_t<_Range>>;
8925 template<
typename _Tp>
8926 inline constexpr bool enable_borrowed_range<enumerate_view<_Tp>>
8927 = enable_borrowed_range<_Tp>;
8930 requires __detail::__range_with_movable_reference<_Vp>
8931 template<
bool _Const>
8932 class enumerate_view<_Vp>::_Iterator
8934 using _Base = __maybe_const_t<_Const, _Vp>;
8939 if constexpr (random_access_range<_Base>)
8940 return random_access_iterator_tag{};
8941 else if constexpr (bidirectional_range<_Base>)
8942 return bidirectional_iterator_tag{};
8943 else if constexpr (forward_range<_Base>)
8944 return forward_iterator_tag{};
8946 return input_iterator_tag{};
8949 friend enumerate_view;
8952 using iterator_category = input_iterator_tag;
8953 using iterator_concept =
decltype(_S_iter_concept());
8954 using difference_type = range_difference_t<_Base>;
8955 using value_type = tuple<difference_type, range_value_t<_Base>>;
8958 using __reference_type = tuple<difference_type, range_reference_t<_Base>>;
8960 iterator_t<_Base> _M_current = iterator_t<_Base>();
8961 difference_type _M_pos = 0;
8964 _Iterator(iterator_t<_Base> __current, difference_type __pos)
8965 : _M_current(
std::
move(__current)), _M_pos(__pos)
8969 _Iterator()
requires default_initializable<iterator_t<_Base>> = default;
8972 _Iterator(_Iterator<!_Const> __i)
8973 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
8974 : _M_current(
std::move(__i._M_current)), _M_pos(__i._M_pos)
8977 constexpr const iterator_t<_Base> &
8978 base() const & noexcept
8979 {
return _M_current; }
8981 constexpr iterator_t<_Base>
8985 constexpr difference_type
8986 index() const noexcept
8991 {
return __reference_type(_M_pos, *_M_current); }
8993 constexpr _Iterator&
9006 operator++(
int)
requires forward_range<_Base>
9013 constexpr _Iterator&
9014 operator--()
requires bidirectional_range<_Base>
9022 operator--(
int)
requires bidirectional_range<_Base>
9029 constexpr _Iterator&
9030 operator+=(difference_type __n)
requires random_access_range<_Base>
9037 constexpr _Iterator&
9038 operator-=(difference_type __n)
requires random_access_range<_Base>
9046 operator[](difference_type __n)
const requires random_access_range<_Base>
9047 {
return __reference_type(_M_pos + __n, _M_current[__n]); }
9049 friend constexpr bool
9050 operator==(
const _Iterator& __x,
const _Iterator& __y)
noexcept
9051 {
return __x._M_pos == __y._M_pos; }
9053 friend constexpr strong_ordering
9054 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
noexcept
9055 {
return __x._M_pos <=> __y._M_pos; }
9057 friend constexpr _Iterator
9058 operator+(
const _Iterator& __x, difference_type __y)
9059 requires random_access_range<_Base>
9060 {
return (
auto(__x) += __y); }
9062 friend constexpr _Iterator
9063 operator+(difference_type __x,
const _Iterator& __y)
9064 requires random_access_range<_Base>
9065 {
return auto(__y) += __x; }
9067 friend constexpr _Iterator
9068 operator-(
const _Iterator& __x, difference_type __y)
9069 requires random_access_range<_Base>
9070 {
return auto(__x) -= __y; }
9072 friend constexpr difference_type
9073 operator-(
const _Iterator& __x,
const _Iterator& __y)
9074 {
return __x._M_pos - __y._M_pos; }
9076 friend constexpr auto
9077 iter_move(
const _Iterator& __i)
9078 noexcept(
noexcept(ranges::iter_move(__i._M_current))
9079 && is_nothrow_move_constructible_v<range_rvalue_reference_t<_Base>>)
9081 return tuple<difference_type, range_rvalue_reference_t<_Base>>
9082 (__i._M_pos, ranges::iter_move(__i._M_current));
9087 requires __detail::__range_with_movable_reference<_Vp>
9088 template<
bool _Const>
9089 class enumerate_view<_Vp>::_Sentinel
9091 using _Base = __maybe_const_t<_Const, _Vp>;
9093 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
9096 _Sentinel(sentinel_t<_Base> __end)
9100 friend enumerate_view;
9103 _Sentinel() =
default;
9106 _Sentinel(_Sentinel<!_Const> __other)
9107 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
9111 constexpr sentinel_t<_Base>
9115 template<
bool _OtherConst>
9116 requires sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const_t<_OtherConst, _Vp>>>
9117 friend constexpr bool
9118 operator==(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
9119 {
return __x._M_current == __y._M_end; }
9121 template<
bool _OtherConst>
9122 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const_t<_OtherConst, _Vp>>>
9123 friend constexpr range_difference_t<__maybe_const_t<_OtherConst, _Vp>>
9124 operator-(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
9125 {
return __x._M_current - __y._M_end; }
9127 template<
bool _OtherConst>
9128 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const_t<_OtherConst, _Vp>>>
9129 friend constexpr range_difference_t<__maybe_const_t<_OtherConst, _Vp>>
9130 operator-(
const _Sentinel& __x,
const _Iterator<_OtherConst>& __y)
9131 {
return __x._M_end - __y._M_current; }
9138 template<
typename _Tp>
9139 concept __can_enumerate_view
9140 =
requires { enumerate_view<all_t<_Tp>>(std::declval<_Tp>()); };
9143 struct _Enumerate : __adaptor::_RangeAdaptorClosure<_Enumerate>
9145 template<viewable_range _Range>
9146 requires __detail::__can_enumerate_view<_Range>
9148 operator() [[nodiscard]] (_Range&& __r)
const
9149 {
return enumerate_view<all_t<_Range>>(std::forward<_Range>(__r)); }
9152 inline constexpr _Enumerate enumerate;
9156#ifdef __cpp_lib_ranges_as_const
9158 requires input_range<_Vp>
9159 class as_const_view :
public view_interface<as_const_view<_Vp>>
9161 _Vp _M_base = _Vp();
9164 as_const_view()
requires default_initializable<_Vp> = default;
9167 as_const_view(_Vp __base)
9168 noexcept(is_nothrow_move_constructible_v<_Vp>)
9169 : _M_base(
std::move(__base))
9174 noexcept(is_nothrow_copy_constructible_v<_Vp>)
9175 requires copy_constructible<_Vp>
9180 noexcept(is_nothrow_move_constructible_v<_Vp>)
9184 begin()
requires (!__detail::__simple_view<_Vp>)
9185 {
return ranges::cbegin(_M_base); }
9188 begin() const requires range<const _Vp>
9189 {
return ranges::cbegin(_M_base); }
9192 end()
requires (!__detail::__simple_view<_Vp>)
9193 {
return ranges::cend(_M_base); }
9196 end() const requires range<const _Vp>
9197 {
return ranges::cend(_M_base); }
9200 size()
requires sized_range<_Vp>
9201 {
return ranges::size(_M_base); }
9204 size() const requires sized_range<const _Vp>
9205 {
return ranges::size(_M_base); }
9208 template<
typename _Range>
9209 as_const_view(_Range&&) -> as_const_view<views::all_t<_Range>>;
9211 template<
typename _Tp>
9212 inline constexpr bool enable_borrowed_range<as_const_view<_Tp>>
9213 = enable_borrowed_range<_Tp>;
9219 template<
typename _Tp>
9220 inline constexpr bool __is_ref_view =
false;
9222 template<
typename _Range>
9223 inline constexpr bool __is_ref_view<ref_view<_Range>> =
true;
9225 template<
typename _Range>
9226 concept __can_as_const_view =
requires { as_const_view(std::declval<_Range>()); };
9229 struct _AsConst : __adaptor::_RangeAdaptorClosure<_AsConst>
9231 template<viewable_range _Range>
9233 operator()(_Range&& __r)
const
9234 noexcept(
noexcept(as_const_view(std::declval<_Range>())))
9235 requires __detail::__can_as_const_view<_Range>
9237 using _Tp = remove_cvref_t<_Range>;
9238 using element_type = remove_reference_t<range_reference_t<_Range>>;
9239 if constexpr (constant_range<views::all_t<_Range>>)
9240 return views::all(std::forward<_Range>(__r));
9241 else if constexpr (__detail::__is_empty_view<_Tp>)
9242 return views::empty<const element_type>;
9243 else if constexpr (std::__detail::__is_span<_Tp>)
9244 return span<const element_type, _Tp::extent>(std::forward<_Range>(__r));
9245 else if constexpr (__detail::__is_ref_view<_Tp>
9246 && constant_range<const element_type>)
9247 return ref_view(
static_cast<const element_type&
>
9248 (std::forward<_Range>(__r).base()));
9249 else if constexpr (is_lvalue_reference_v<_Range>
9250 && constant_range<const _Tp>
9252 return ref_view(
static_cast<const _Tp&
>(__r));
9254 return as_const_view(std::forward<_Range>(__r));
9258 inline constexpr _AsConst as_const;
9263 namespace views = ranges::views;
9265#if __cpp_lib_ranges_to_container
9271 template<
typename _Container>
9272 constexpr bool __reservable_container
9273 = sized_range<_Container>
9274 &&
requires(_Container& __c, range_size_t<_Container> __n) {
9276 { __c.capacity() } -> same_as<
decltype(__n)>;
9277 { __c.max_size() } -> same_as<
decltype(__n)>;
9280 template<
typename _Cont,
typename _Range>
9281 constexpr bool __toable =
requires {
9282 requires (!input_range<_Cont>
9283 || convertible_to<range_reference_t<_Range>,
9284 range_value_t<_Cont>>);
9305 template<
typename _Cont, input_range _Rg,
typename... _Args>
9306 requires (!view<_Cont>)
9308 to [[nodiscard]] (_Rg&& __r, _Args&&... __args)
9310 static_assert(!is_const_v<_Cont> && !is_volatile_v<_Cont>);
9311 static_assert(is_class_v<_Cont>);
9313 if constexpr (__detail::__toable<_Cont, _Rg>)
9315 if constexpr (constructible_from<_Cont, _Rg, _Args...>)
9316 return _Cont(std::forward<_Rg>(__r),
9317 std::forward<_Args>(__args)...);
9318 else if constexpr (constructible_from<_Cont, from_range_t, _Rg, _Args...>)
9319 return _Cont(from_range, std::forward<_Rg>(__r),
9320 std::forward<_Args>(__args)...);
9321 else if constexpr (
requires {
requires common_range<_Rg>;
9322 typename __iter_category_t<iterator_t<_Rg>>;
9323 requires derived_from<__iter_category_t<iterator_t<_Rg>>,
9324 input_iterator_tag>;
9325 requires constructible_from<_Cont, iterator_t<_Rg>,
9326 sentinel_t<_Rg>, _Args...>;
9328 return _Cont(ranges::begin(__r), ranges::end(__r),
9329 std::forward<_Args>(__args)...);
9332 using _RefT = range_reference_t<_Rg>;
9333 static_assert(constructible_from<_Cont, _Args...>);
9334 _Cont __c(std::forward<_Args>(__args)...);
9335 if constexpr (sized_range<_Rg>
9336 && __detail::__reservable_container<_Cont>)
9337 __c.reserve(
static_cast<range_size_t<_Cont>
>(ranges::size(__r)));
9341 auto __it = ranges::begin(__r);
9342 const auto __sent = ranges::end(__r);
9343 while (__it != __sent)
9345 if constexpr (
requires { __c.emplace_back(*__it); })
9346 __c.emplace_back(*__it);
9347 else if constexpr (
requires { __c.push_back(*__it); })
9348 __c.push_back(*__it);
9349 else if constexpr (
requires { __c.emplace(__c.end(), *__it); })
9350 __c.emplace(__c.end(), *__it);
9352 __c.insert(__c.end(), *__it);
9360 static_assert(input_range<range_reference_t<_Rg>>);
9363 return ranges::to<_Cont>(ref_view(__r) | views::transform(
9364 []<
typename _Elt>(_Elt&& __elem) {
9365 using _ValT = range_value_t<_Cont>;
9366 return ranges::to<_ValT>(std::forward<_Elt>(__elem));
9367 }), std::forward<_Args>(__args)...);
9374 template<
typename _Rg>
9377 using iterator_category = input_iterator_tag;
9378 using value_type = range_value_t<_Rg>;
9379 using difference_type = ptrdiff_t;
9380 using pointer = add_pointer_t<range_reference_t<_Rg>>;
9381 using reference = range_reference_t<_Rg>;
9383 pointer operator->()
const;
9384 _InputIter& operator++();
9385 _InputIter operator++(
int);
9386 bool operator==(
const _InputIter&)
const;
9389 template<
template<
typename...>
typename _Cont, input_range _Rg,
9392 =
decltype(_Cont(std::declval<_Rg>(), std::declval<_Args>()...));
9394 template<
template<
typename...>
typename _Cont, input_range _Rg,
9397 =
decltype(_Cont(from_range, std::declval<_Rg>(),
9398 std::declval<_Args>()...));
9400 template<
template<
typename...>
typename _Cont, input_range _Rg,
9405 std::declval<_Args>()...));
9410 template<
template<
typename...>
typename _Cont, input_range _Rg,
9413 to [[nodiscard]] (_Rg&& __r, _Args&&... __args)
9415 using __detail::_DeduceExpr1;
9416 using __detail::_DeduceExpr2;
9417 using __detail::_DeduceExpr3;
9418 if constexpr (
requires {
typename _DeduceExpr1<_Cont, _Rg, _Args...>; })
9419 return ranges::to<_DeduceExpr1<_Cont, _Rg, _Args...>>(
9420 std::forward<_Rg>(__r), std::forward<_Args>(__args)...);
9421 else if constexpr (
requires {
typename _DeduceExpr2<_Cont, _Rg, _Args...>; })
9422 return ranges::to<_DeduceExpr2<_Cont, _Rg, _Args...>>(
9423 std::forward<_Rg>(__r), std::forward<_Args>(__args)...);
9424 else if constexpr (
requires {
typename _DeduceExpr3<_Cont, _Rg, _Args...>; })
9425 return ranges::to<_DeduceExpr3<_Cont, _Rg, _Args...>>(
9426 std::forward<_Rg>(__r), std::forward<_Args>(__args)...);
9428 static_assert(
false);
9434 template<
typename _Cont>
9437 template<
typename _Range,
typename... _Args>
9438 requires requires { ranges::to<_Cont>(std::declval<_Range>(),
9439 std::declval<_Args>()...); }
9441 operator()(_Range&& __r, _Args&&... __args)
const
9443 return ranges::to<_Cont>(std::forward<_Range>(__r),
9444 std::forward<_Args>(__args)...);
9465 template<
typename _Cont,
typename... _Args>
9466 requires (!view<_Cont>)
9468 to [[nodiscard]] (_Args&&... __args)
9470 using __detail::_To;
9471 using views::__adaptor::_Partial;
9472 return _Partial<_To<_Cont>, decay_t<_Args>...>{0, std::forward<_Args>(__args)...};
9478 template<
template<
typename...>
typename _Cont>
9481 template<
typename _Range,
typename... _Args>
9482 requires requires { ranges::to<_Cont>(std::declval<_Range>(),
9483 std::declval<_Args>()...); }
9485 operator()(_Range&& __r, _Args&&... __args)
const
9487 return ranges::to<_Cont>(std::forward<_Range>(__r),
9488 std::forward<_Args>(__args)...);
9511 template<
template<
typename...>
typename _Cont,
typename... _Args>
9513 to [[nodiscard]] (_Args&&... __args)
9515 using __detail::_To2;
9516 using views::__adaptor::_Partial;
9517 return _Partial<_To2<_Cont>, decay_t<_Args>...>{0, std::forward<_Args>(__args)...};
9523_GLIBCXX_END_NAMESPACE_VERSION
constexpr bool operator<=(const duration< _Rep1, _Period1 > &__lhs, const duration< _Rep2, _Period2 > &__rhs)
constexpr bool operator>=(const duration< _Rep1, _Period1 > &__lhs, const duration< _Rep2, _Period2 > &__rhs)
constexpr bool operator<(const duration< _Rep1, _Period1 > &__lhs, const duration< _Rep2, _Period2 > &__rhs)
constexpr bool operator>(const duration< _Rep1, _Period1 > &__lhs, const duration< _Rep2, _Period2 > &__rhs)
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 common_type< _Tp... >::type common_type_t
Alias template for common_type.
typename conditional< _Cond, _Iftrue, _Iffalse >::type conditional_t
Alias template for conditional.
constexpr auto tuple_cat(_Tpls &&... __tpls) -> typename __tuple_cat_result< _Tpls... >::__type
Create a tuple containing all elements from multiple tuple-like objects.
auto declval() noexcept -> decltype(__declval< _Tp >(0))
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
constexpr __invoke_result< _Callable, _Args... >::type __invoke(_Callable &&__fn, _Args &&... __args) noexcept(__is_nothrow_invocable< _Callable, _Args... >::value)
Invoke a callable object.
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
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.
make_integer_sequence< size_t, _Num > make_index_sequence
Alias template make_index_sequence.
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.
constexpr default_sentinel_t default_sentinel
A default sentinel value.
constexpr auto data(_Container &__cont) noexcept(noexcept(__cont.data())) -> decltype(__cont.data())
Return the data pointer of a container.
constexpr bitset< _Nb > operator|(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
integer_sequence< size_t, _Idx... > index_sequence
Alias template index_sequence.
constexpr _Iterator __base(_Iterator __it)
Primary class template, tuple.