30#ifndef _GLIBCXX_RANGES
31#define _GLIBCXX_RANGES 1
33#if __cplusplus > 201703L
36#pragma GCC system_header
50#if __cplusplus > 202002L
56#define __glibcxx_want_algorithm_default_value_type
57#define __glibcxx_want_ranges
58#define __glibcxx_want_ranges_as_const
59#define __glibcxx_want_ranges_as_rvalue
60#define __glibcxx_want_ranges_cartesian_product
61#define __glibcxx_want_ranges_concat
62#define __glibcxx_want_ranges_chunk
63#define __glibcxx_want_ranges_chunk_by
64#define __glibcxx_want_ranges_enumerate
65#define __glibcxx_want_ranges_iota
66#define __glibcxx_want_ranges_join_with
67#define __glibcxx_want_ranges_repeat
68#define __glibcxx_want_ranges_slide
69#define __glibcxx_want_ranges_stride
70#define __glibcxx_want_ranges_to_container
71#define __glibcxx_want_ranges_zip
74#ifdef __glibcxx_generator
75# include <bits/elements_of.h>
84namespace std _GLIBCXX_VISIBILITY(default)
86_GLIBCXX_BEGIN_NAMESPACE_VERSION
101 template<
typename _Tp>
requires is_object_v<_Tp>
103 :
public view_interface<empty_view<_Tp>>
106 static constexpr _Tp*
begin() noexcept {
return nullptr; }
107 static constexpr _Tp*
end() noexcept {
return nullptr; }
108 static constexpr _Tp*
data() noexcept {
return nullptr; }
109 static constexpr size_t size() noexcept {
return 0; }
110 static constexpr bool empty() noexcept {
return true; }
113 template<
typename _Tp>
114 inline constexpr bool enable_borrowed_range<empty_view<_Tp>> =
true;
118#if __cpp_lib_ranges >= 202207L
120 template<
typename _Tp>
121 concept __boxable = move_constructible<_Tp> && is_object_v<_Tp>;
123 template<
typename _Tp>
124 concept __boxable = copy_constructible<_Tp> && is_object_v<_Tp>;
127 template<__boxable _Tp>
128 struct __box : std::optional<_Tp>
130 using std::optional<_Tp>::optional;
134 noexcept(is_nothrow_default_constructible_v<_Tp>)
135 requires default_initializable<_Tp>
136 :
std::optional<_Tp>{std::in_place}
139 __box(
const __box&) =
default;
140 __box(__box&&) =
default;
142 using std::optional<_Tp>::operator=;
148 operator=(
const __box& __that)
149 noexcept(is_nothrow_copy_constructible_v<_Tp>)
150 requires (!copyable<_Tp>) && copy_constructible<_Tp>
155 this->emplace(*__that);
163 operator=(__box&& __that)
164 noexcept(is_nothrow_move_constructible_v<_Tp>)
165 requires (!movable<_Tp>)
178 template<
typename _Tp>
179 concept __boxable_copyable
180 = copy_constructible<_Tp>
181 && (copyable<_Tp> || (is_nothrow_move_constructible_v<_Tp>
182 && is_nothrow_copy_constructible_v<_Tp>));
183 template<
typename _Tp>
184 concept __boxable_movable
185 = (!copy_constructible<_Tp>)
186 && (movable<_Tp> || is_nothrow_move_constructible_v<_Tp>);
192 template<__boxable _Tp>
193 requires __boxable_copyable<_Tp> || __boxable_movable<_Tp>
197 [[no_unique_address]] _Tp _M_value = _Tp();
200 __box()
requires default_initializable<_Tp> = default;
203 __box(const _Tp& __t)
204 noexcept(is_nothrow_copy_constructible_v<_Tp>)
205 requires copy_constructible<_Tp>
211 noexcept(is_nothrow_move_constructible_v<_Tp>)
215 template<
typename... _Args>
216 requires constructible_from<_Tp, _Args...>
218 __box(in_place_t, _Args&&... __args)
219 noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
223 __box(
const __box&) =
default;
224 __box(__box&&) =
default;
225 __box& operator=(
const __box&)
requires copyable<_Tp> =
default;
226 __box& operator=(__box&&)
requires movable<_Tp> = default;
231 operator=(const __box& __that) noexcept
232 requires (!copyable<_Tp>) && copy_constructible<_Tp>
234 static_assert(is_nothrow_copy_constructible_v<_Tp>);
245 operator=(__box&& __that)
noexcept
246 requires (!movable<_Tp>)
248 static_assert(is_nothrow_move_constructible_v<_Tp>);
258 has_value() const noexcept
273 constexpr const _Tp&&
278 operator->() noexcept
282 operator->() const noexcept
288#if __cpp_lib_ranges >= 202207L
289 template<move_constructible _Tp>
291 template<copy_constructible _Tp>
293 requires is_object_v<_Tp>
294 class single_view :
public view_interface<single_view<_Tp>>
297 single_view()
requires default_initializable<_Tp> = default;
300 single_view(const _Tp& __t)
301 noexcept(is_nothrow_copy_constructible_v<_Tp>)
302 requires copy_constructible<_Tp>
307 single_view(_Tp&& __t)
308 noexcept(is_nothrow_move_constructible_v<_Tp>)
314 template<
typename... _Args>
315 requires constructible_from<_Tp, _Args...>
317 single_view(in_place_t, _Args&&... __args)
318 noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
319 : _M_value{in_place,
std::
forward<_Args>(__args)...}
327 begin() const noexcept
332 {
return data() + 1; }
336 {
return data() + 1; }
340 static constexpr bool
344 static constexpr size_t
350 {
return _M_value.operator->(); }
353 data() const noexcept
354 {
return _M_value.operator->(); }
357 [[no_unique_address]] __detail::__box<_Tp> _M_value;
360 template<
typename _Tp>
361 single_view(_Tp) -> single_view<_Tp>;
365 template<
typename _Wp>
366 constexpr auto __to_signed_like(_Wp __w)
noexcept
368 if constexpr (!integral<_Wp>)
369 return iter_difference_t<_Wp>();
370 else if constexpr (
sizeof(iter_difference_t<_Wp>) >
sizeof(_Wp))
371 return iter_difference_t<_Wp>(__w);
372 else if constexpr (
sizeof(ptrdiff_t) >
sizeof(_Wp))
373 return ptrdiff_t(__w);
374 else if constexpr (
sizeof(
long long) >
sizeof(_Wp))
375 return (
long long)(__w);
376#ifdef __SIZEOF_INT128__
377 else if constexpr (__SIZEOF_INT128__ >
sizeof(_Wp))
378 return __int128(__w);
381 return __max_diff_type(__w);
384 template<
typename _Wp>
385 using __iota_diff_t =
decltype(__to_signed_like(std::declval<_Wp>()));
387 template<
typename _It>
388 concept __decrementable = incrementable<_It>
391 { --__i } -> same_as<_It&>;
392 { __i-- } -> same_as<_It>;
395 template<
typename _It>
396 concept __advanceable = __decrementable<_It> && totally_ordered<_It>
397 &&
requires( _It __i,
const _It __j,
const __iota_diff_t<_It> __n)
399 { __i += __n } -> same_as<_It&>;
400 { __i -= __n } -> same_as<_It&>;
404 { __j - __j } -> convertible_to<__iota_diff_t<_It>>;
407 template<
typename _Winc>
408 struct __iota_view_iter_cat
411 template<incrementable _Winc>
412 struct __iota_view_iter_cat<_Winc>
413 {
using iterator_category = input_iterator_tag; };
416 template<weakly_incrementable _Winc,
417 semiregular _Bound = unreachable_sentinel_t>
418 requires std::__detail::__weakly_eq_cmp_with<_Winc, _Bound>
420 class iota_view :
public view_interface<iota_view<_Winc, _Bound>>
425 struct _Iterator : __detail::__iota_view_iter_cat<_Winc>
431 using namespace __detail;
432 if constexpr (__advanceable<_Winc>)
433 return random_access_iterator_tag{};
434 else if constexpr (__decrementable<_Winc>)
435 return bidirectional_iterator_tag{};
436 else if constexpr (incrementable<_Winc>)
437 return forward_iterator_tag{};
439 return input_iterator_tag{};
443 using iterator_concept =
decltype(_S_iter_concept());
445 using value_type = _Winc;
446 using difference_type = __detail::__iota_diff_t<_Winc>;
448 _Iterator()
requires default_initializable<_Winc> = default;
451 _Iterator(_Winc __value)
452 : _M_value(__value) { }
455 operator*() const noexcept(is_nothrow_copy_constructible_v<_Winc>)
470 operator++(
int)
requires incrementable<_Winc>
478 operator--()
requires __detail::__decrementable<_Winc>
485 operator--(
int)
requires __detail::__decrementable<_Winc>
493 operator+=(difference_type __n)
requires __detail::__advanceable<_Winc>
495 using __detail::__is_integer_like;
496 using __detail::__is_signed_integer_like;
497 if constexpr (__is_integer_like<_Winc>
498 && !__is_signed_integer_like<_Winc>)
500 if (__n >= difference_type(0))
501 _M_value +=
static_cast<_Winc
>(__n);
503 _M_value -=
static_cast<_Winc
>(-__n);
511 operator-=(difference_type __n)
requires __detail::__advanceable<_Winc>
513 using __detail::__is_integer_like;
514 using __detail::__is_signed_integer_like;
515 if constexpr (__is_integer_like<_Winc>
516 && !__is_signed_integer_like<_Winc>)
518 if (__n >= difference_type(0))
519 _M_value -=
static_cast<_Winc
>(__n);
521 _M_value +=
static_cast<_Winc
>(-__n);
529 operator[](difference_type __n)
const
530 requires __detail::__advanceable<_Winc>
531 {
return _Winc(_M_value + __n); }
533 friend constexpr bool
534 operator==(
const _Iterator& __x,
const _Iterator& __y)
535 requires equality_comparable<_Winc>
536 {
return __x._M_value == __y._M_value; }
538 friend constexpr bool
539 operator<(
const _Iterator& __x,
const _Iterator& __y)
540 requires totally_ordered<_Winc>
541 {
return __x._M_value < __y._M_value; }
543 friend constexpr bool
544 operator>(
const _Iterator& __x,
const _Iterator& __y)
545 requires totally_ordered<_Winc>
546 {
return __y < __x; }
548 friend constexpr bool
549 operator<=(
const _Iterator& __x,
const _Iterator& __y)
550 requires totally_ordered<_Winc>
551 {
return !(__y < __x); }
553 friend constexpr bool
554 operator>=(
const _Iterator& __x,
const _Iterator& __y)
555 requires totally_ordered<_Winc>
556 {
return !(__x < __y); }
558#ifdef __cpp_lib_three_way_comparison
559 friend constexpr auto
560 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
561 requires totally_ordered<_Winc> && three_way_comparable<_Winc>
562 {
return __x._M_value <=> __y._M_value; }
565 friend constexpr _Iterator
566 operator+(_Iterator __i, difference_type __n)
567 requires __detail::__advanceable<_Winc>
573 friend constexpr _Iterator
574 operator+(difference_type __n, _Iterator __i)
575 requires __detail::__advanceable<_Winc>
576 {
return __i += __n; }
578 friend constexpr _Iterator
579 operator-(_Iterator __i, difference_type __n)
580 requires __detail::__advanceable<_Winc>
586 friend constexpr difference_type
587 operator-(
const _Iterator& __x,
const _Iterator& __y)
588 requires __detail::__advanceable<_Winc>
590 using __detail::__is_integer_like;
591 using __detail::__is_signed_integer_like;
592 using _Dt = difference_type;
593 if constexpr (__is_integer_like<_Winc>)
595 if constexpr (__is_signed_integer_like<_Winc>)
596 return _Dt(_Dt(__x._M_value) - _Dt(__y._M_value));
598 return (__y._M_value > __x._M_value)
599 ? _Dt(-_Dt(__y._M_value - __x._M_value))
600 : _Dt(__x._M_value - __y._M_value);
603 return __x._M_value - __y._M_value;
607 _Winc _M_value = _Winc();
617 _M_equal(
const _Iterator& __x)
const
618 {
return __x._M_value == _M_bound; }
621 _M_distance_from(
const _Iterator& __x)
const
622 {
return _M_bound - __x._M_value; }
624 _Bound _M_bound = _Bound();
627 _Sentinel() =
default;
630 _Sentinel(_Bound __bound)
631 : _M_bound(__bound) { }
633 friend constexpr bool
634 operator==(
const _Iterator& __x,
const _Sentinel& __y)
635 {
return __y._M_equal(__x); }
637 friend constexpr iter_difference_t<_Winc>
638 operator-(
const _Iterator& __x,
const _Sentinel& __y)
639 requires sized_sentinel_for<_Bound, _Winc>
640 {
return -__y._M_distance_from(__x); }
642 friend constexpr iter_difference_t<_Winc>
643 operator-(
const _Sentinel& __x,
const _Iterator& __y)
644 requires sized_sentinel_for<_Bound, _Winc>
645 {
return __x._M_distance_from(__y); }
650 _Winc _M_value = _Winc();
651 [[no_unique_address]] _Bound _M_bound = _Bound();
654 iota_view()
requires default_initializable<_Winc> = default;
657 iota_view(_Winc __value)
662 iota_view(type_identity_t<_Winc> __value,
663 type_identity_t<_Bound> __bound)
664 : _M_value(__value), _M_bound(__bound)
666 if constexpr (totally_ordered_with<_Winc, _Bound>)
667 __glibcxx_assert(
bool(__value <= __bound) );
671 iota_view(_Iterator __first, _Iterator __last)
672 requires same_as<_Winc, _Bound>
673 : iota_view(__first._M_value, __last._M_value)
677 iota_view(_Iterator __first, unreachable_sentinel_t __last)
678 requires same_as<_Bound, unreachable_sentinel_t>
679 : iota_view(__first._M_value, __last)
683 iota_view(_Iterator __first, _Sentinel __last)
684 requires (!same_as<_Winc, _Bound>) && (!same_as<_Bound, unreachable_sentinel_t>)
685 : iota_view(__first._M_value, __last._M_bound)
689 begin()
const {
return _Iterator{_M_value}; }
694 if constexpr (same_as<_Bound, unreachable_sentinel_t>)
695 return unreachable_sentinel;
697 return _Sentinel{_M_bound};
701 end() const requires same_as<_Winc, _Bound>
702 {
return _Iterator{_M_bound}; }
708 {
return _M_value == _M_bound; }
712 requires (same_as<_Winc, _Bound> && __detail::__advanceable<_Winc>)
713 || (integral<_Winc> && integral<_Bound>)
714 || sized_sentinel_for<_Bound, _Winc>
716 using __detail::__is_integer_like;
717 using __detail::__to_unsigned_like;
718 if constexpr (integral<_Winc> && integral<_Bound>)
721 return _Up(_M_bound) - _Up(_M_value);
723 else if constexpr (__is_integer_like<_Winc>)
724 return __to_unsigned_like(_M_bound) - __to_unsigned_like(_M_value);
726 return __to_unsigned_like(_M_bound - _M_value);
730 template<
typename _Winc,
typename _Bound>
731 requires (!__detail::__is_integer_like<_Winc>
732 || !__detail::__is_integer_like<_Bound>
733 || (__detail::__is_signed_integer_like<_Winc>
734 == __detail::__is_signed_integer_like<_Bound>))
735 iota_view(_Winc, _Bound) -> iota_view<_Winc, _Bound>;
737 template<
typename _Winc,
typename _Bound>
738 inline constexpr bool
739 enable_borrowed_range<iota_view<_Winc, _Bound>> =
true;
743 template<
typename _Tp>
744 inline constexpr empty_view<_Tp>
empty{};
748 template<
typename _Tp>
749 concept __can_single_view
750 =
requires { single_view<decay_t<_Tp>>(std::declval<_Tp>()); };
755 template<__detail::__can_single_view _Tp>
757 operator() [[nodiscard]] (_Tp&& __e)
const
758 noexcept(
noexcept(single_view<decay_t<_Tp>>(std::forward<_Tp>(__e))))
759 {
return single_view<decay_t<_Tp>>(std::forward<_Tp>(__e)); }
762 inline constexpr _Single single{};
766 template<
typename... _Args>
767 concept __can_iota_view =
requires { iota_view(std::declval<_Args>()...); };
772 template<__detail::__can_iota_view _Tp>
774 operator() [[nodiscard]] (_Tp&& __e)
const
775 {
return iota_view(std::forward<_Tp>(__e)); }
777 template<
typename _Tp,
typename _Up>
778 requires __detail::__can_iota_view<_Tp, _Up>
780 operator() [[nodiscard]] (_Tp&& __e, _Up&& __f)
const
781 {
return iota_view(std::forward<_Tp>(__e), std::forward<_Up>(__f)); }
784 inline constexpr _Iota
iota{};
790 template<
typename _Val,
typename _CharT,
typename _Traits>
791 concept __stream_extractable
792 =
requires(basic_istream<_CharT, _Traits>& is, _Val& t) { is >> t; };
795 template<movable _Val,
typename _CharT,
796 typename _Traits = char_traits<_CharT>>
797 requires default_initializable<_Val>
798 && __detail::__stream_extractable<_Val, _CharT, _Traits>
799 class basic_istream_view
800 :
public view_interface<basic_istream_view<_Val, _CharT, _Traits>>
804 basic_istream_view(basic_istream<_CharT, _Traits>& __stream)
811 *_M_stream >> _M_object;
812 return _Iterator{
this};
815 constexpr default_sentinel_t
820 basic_istream<_CharT, _Traits>* _M_stream;
821 _Val _M_object = _Val();
826 using iterator_concept = input_iterator_tag;
827 using difference_type = ptrdiff_t;
828 using value_type = _Val;
831 _Iterator(basic_istream_view* __parent) noexcept
832 : _M_parent(__parent)
835 _Iterator(
const _Iterator&) =
delete;
836 _Iterator(_Iterator&&) =
default;
837 _Iterator& operator=(
const _Iterator&) =
delete;
838 _Iterator& operator=(_Iterator&&) =
default;
843 *_M_parent->_M_stream >> _M_parent->_M_object;
853 {
return _M_parent->_M_object; }
856 operator==(
const _Iterator& __x, default_sentinel_t)
857 {
return __x._M_at_end(); }
860 basic_istream_view* _M_parent;
864 {
return !*_M_parent->_M_stream; }
870 template<
typename _Val>
871 using istream_view = basic_istream_view<_Val, char>;
873 template<
typename _Val>
874 using wistream_view = basic_istream_view<_Val, wchar_t>;
880 template<
typename _Tp,
typename _Up>
881 concept __can_istream_view =
requires (_Up __e) {
882 basic_istream_view<_Tp, typename _Up::char_type, typename _Up::traits_type>(__e);
886 template<
typename _Tp>
889 template<
typename _CharT,
typename _Traits>
891 operator() [[nodiscard]] (basic_istream<_CharT, _Traits>& __e)
const
892 requires __detail::__can_istream_view<_Tp, remove_reference_t<
decltype(__e)>>
893 {
return basic_istream_view<_Tp, _CharT, _Traits>(__e); }
896 template<
typename _Tp>
897 inline constexpr _Istream<_Tp>
istream;
905 template<
typename _Tp,
int _Disc>
914 template<
bool _Present,
typename _Tp,
int _Disc = 0>
915 using __maybe_present_t = __conditional_t<_Present, _Tp, _Absent<_Tp, _Disc>>;
918 template<
bool _Const,
typename _Tp>
919 using __maybe_const_t = __conditional_t<_Const, const _Tp, _Tp>;
924using __detail::__maybe_const_t;
926namespace views::__adaptor
929 template<
typename _Adaptor,
typename... _Args>
930 concept __adaptor_invocable
931 =
requires { std::declval<_Adaptor>()(declval<_Args>()...); };
935 template<
typename _Adaptor,
typename... _Args>
936 concept __adaptor_partial_app_viable = (_Adaptor::_S_arity > 1)
937 && (
sizeof...(_Args) == _Adaptor::_S_arity - 1)
938 && (constructible_from<decay_t<_Args>, _Args> && ...);
940 template<
typename _Adaptor,
typename... _Args>
943 template<
typename _Lhs,
typename _Rhs>
951 template<
typename _Derived>
952 struct _RangeAdaptorClosure
955 template<
typename _Tp,
typename _Up>
956 requires (!same_as<_Tp, _RangeAdaptorClosure<_Up>>)
957 void __is_range_adaptor_closure_fn
958 (
const _Tp&,
const _RangeAdaptorClosure<_Up>&);
960 template<
typename _Tp>
961 concept __is_range_adaptor_closure
962 =
requires (_Tp __t) { __adaptor::__is_range_adaptor_closure_fn(__t, __t); };
964#pragma GCC diagnostic push
965#pragma GCC diagnostic ignored "-Wdangling-reference"
967 template<
typename _Self,
typename _Range>
968 requires __is_range_adaptor_closure<_Self>
969 && __adaptor_invocable<_Self, _Range>
972 {
return std::forward<_Self>(__self)(std::forward<_Range>(__r)); }
976 template<
typename _Lhs,
typename _Rhs>
977 requires __is_range_adaptor_closure<_Lhs>
978 && __is_range_adaptor_closure<_Rhs>
982 return _Pipe<decay_t<_Lhs>, decay_t<_Rhs>>{std::forward<_Lhs>(__lhs),
983 std::forward<_Rhs>(__rhs)};
985#pragma GCC diagnostic pop
998 template<
typename _Derived>
1003 template<
typename... _Args>
1004 requires __adaptor_partial_app_viable<_Derived, _Args...>
1006 operator()(_Args&&... __args)
const
1008 return _Partial<_Derived, decay_t<_Args>...>{0, std::forward<_Args>(__args)...};
1015 template<
typename _Adaptor>
1016 concept __closure_has_simple_call_op = _Adaptor::_S_has_simple_call_op;
1020 template<
typename _Adaptor,
typename... _Args>
1021 concept __adaptor_has_simple_extra_args = _Adaptor::_S_has_simple_extra_args
1022 || _Adaptor::template _S_has_simple_extra_args<_Args...>;
1026 template<
typename _Adaptor,
typename... _Args>
1027 struct _Partial : _RangeAdaptorClosure<_Partial<_Adaptor, _Args...>>
1029 tuple<_Args...> _M_args;
1033 template<
typename... _Ts>
1035 _Partial(
int, _Ts&&... __args)
1041#if __cpp_explicit_this_parameter
1042 template<
typename _Self,
typename _Range>
1043 requires __adaptor_invocable<_Adaptor, _Range, __like_t<_Self, _Args>...>
1045 operator()(
this _Self&& __self, _Range&& __r)
1047 auto __forwarder = [&__r] (
auto&&... __args) {
1048 return _Adaptor{}(std::forward<_Range>(__r),
1049 std::forward<decltype(__args)>(__args)...);
1051 return std::apply(__forwarder, __like_t<_Self, _Partial>(__self)._M_args);
1054 template<
typename _Range>
1055 requires __adaptor_invocable<_Adaptor, _Range,
const _Args&...>
1057 operator()(_Range&& __r)
const &
1059 auto __forwarder = [&__r] (
const auto&... __args) {
1060 return _Adaptor{}(std::forward<_Range>(__r), __args...);
1062 return std::apply(__forwarder, _M_args);
1065 template<
typename _Range>
1066 requires __adaptor_invocable<_Adaptor, _Range, _Args...>
1068 operator()(_Range&& __r) &&
1070 auto __forwarder = [&__r] (
auto&... __args) {
1071 return _Adaptor{}(std::forward<_Range>(__r),
std::move(__args)...);
1073 return std::apply(__forwarder, _M_args);
1076 template<
typename _Range>
1078 operator()(_Range&& __r)
const && =
delete;
1084 template<
typename _Adaptor,
typename _Arg>
1085 struct _Partial<_Adaptor, _Arg> : _RangeAdaptorClosure<_Partial<_Adaptor, _Arg>>
1089 template<
typename _Tp>
1091 _Partial(
int, _Tp&& __arg)
1095#if __cpp_explicit_this_parameter
1096 template<
typename _Self,
typename _Range>
1097 requires __adaptor_invocable<_Adaptor, _Range, __like_t<_Self, _Arg>>
1099 operator()(
this _Self&& __self, _Range&& __r)
1101 return _Adaptor{}(std::forward<_Range>(__r),
1102 __like_t<_Self, _Partial>(__self)._M_arg);
1105 template<
typename _Range>
1106 requires __adaptor_invocable<_Adaptor, _Range, const _Arg&>
1108 operator()(_Range&& __r)
const &
1109 {
return _Adaptor{}(std::forward<_Range>(__r), _M_arg); }
1111 template<
typename _Range>
1112 requires __adaptor_invocable<_Adaptor, _Range, _Arg>
1114 operator()(_Range&& __r) &&
1115 {
return _Adaptor{}(std::forward<_Range>(__r),
std::move(_M_arg)); }
1117 template<
typename _Range>
1119 operator()(_Range&& __r)
const && =
delete;
1127 template<
typename _Adaptor,
typename... _Args>
1128 requires __adaptor_has_simple_extra_args<_Adaptor, _Args...>
1129 && (is_trivially_copyable_v<_Args> && ...)
1130 struct _Partial<_Adaptor, _Args...> : _RangeAdaptorClosure<_Partial<_Adaptor, _Args...>>
1132 tuple<_Args...> _M_args;
1134 template<
typename... _Ts>
1136 _Partial(
int, _Ts&&... __args)
1142 template<
typename _Range>
1143 requires __adaptor_invocable<_Adaptor, _Range,
const _Args&...>
1145 operator()(_Range&& __r)
const
1147 auto __forwarder = [&__r] (
const auto&... __args) {
1148 return _Adaptor{}(std::forward<_Range>(__r), __args...);
1150 return std::apply(__forwarder, _M_args);
1153 static constexpr bool _S_has_simple_call_op =
true;
1158 template<
typename _Adaptor,
typename _Arg>
1159 requires __adaptor_has_simple_extra_args<_Adaptor, _Arg>
1160 && is_trivially_copyable_v<_Arg>
1161 struct _Partial<_Adaptor, _Arg> : _RangeAdaptorClosure<_Partial<_Adaptor, _Arg>>
1165 template<
typename _Tp>
1167 _Partial(
int, _Tp&& __arg)
1171 template<
typename _Range>
1172 requires __adaptor_invocable<_Adaptor, _Range, const _Arg&>
1174 operator()(_Range&& __r)
const
1175 {
return _Adaptor{}(std::forward<_Range>(__r), _M_arg); }
1177 static constexpr bool _S_has_simple_call_op =
true;
1180 template<
typename _Lhs,
typename _Rhs,
typename _Range>
1181 concept __pipe_invocable
1182 =
requires { std::declval<_Rhs>()(std::declval<_Lhs>()(std::declval<_Range>())); };
1186 template<
typename _Lhs,
typename _Rhs>
1187 struct _Pipe : _RangeAdaptorClosure<_Pipe<_Lhs, _Rhs>>
1189 [[no_unique_address]] _Lhs _M_lhs;
1190 [[no_unique_address]] _Rhs _M_rhs;
1192 template<
typename _Tp,
typename _Up>
1194 _Pipe(_Tp&& __lhs, _Up&& __rhs)
1200#if __cpp_explicit_this_parameter
1201 template<
typename _Self,
typename _Range>
1202 requires __pipe_invocable<__like_t<_Self, _Lhs>, __like_t<_Self, _Rhs>, _Range>
1204 operator()(
this _Self&& __self, _Range&& __r)
1206 return (__like_t<_Self, _Pipe>(__self)._M_rhs
1207 (__like_t<_Self, _Pipe>(__self)._M_lhs
1208 (std::forward<_Range>(__r))));
1211 template<
typename _Range>
1212 requires __pipe_invocable<const _Lhs&, const _Rhs&, _Range>
1214 operator()(_Range&& __r)
const &
1215 {
return _M_rhs(_M_lhs(std::forward<_Range>(__r))); }
1217 template<
typename _Range>
1218 requires __pipe_invocable<_Lhs, _Rhs, _Range>
1220 operator()(_Range&& __r) &&
1223 template<
typename _Range>
1225 operator()(_Range&& __r)
const && =
delete;
1233 template<
typename _Lhs,
typename _Rhs>
1234 requires __closure_has_simple_call_op<_Lhs>
1235 && __closure_has_simple_call_op<_Rhs>
1236 struct _Pipe<_Lhs, _Rhs> : _RangeAdaptorClosure<_Pipe<_Lhs, _Rhs>>
1238 [[no_unique_address]] _Lhs _M_lhs;
1239 [[no_unique_address]] _Rhs _M_rhs;
1241 template<
typename _Tp,
typename _Up>
1243 _Pipe(_Tp&& __lhs, _Up&& __rhs)
1247 template<
typename _Range>
1248 requires __pipe_invocable<const _Lhs&, const _Rhs&, _Range>
1250 operator()(_Range&& __r)
const
1251 {
return _M_rhs(_M_lhs(std::forward<_Range>(__r))); }
1253 static constexpr bool _S_has_simple_call_op =
true;
1257#if __cpp_lib_ranges >= 202202L
1259 template<
typename _Derived>
1260 requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
1261 class range_adaptor_closure
1262 :
public views::__adaptor::_RangeAdaptorClosure<_Derived>
1266 template<range _Range>
requires is_object_v<_Range>
1267 class ref_view :
public view_interface<ref_view<_Range>>
1272 static void _S_fun(_Range&);
1273 static void _S_fun(_Range&&) =
delete;
1276 template<__detail::__different_from<ref_view> _Tp>
1277 requires convertible_to<_Tp, _Range&>
1278 &&
requires { _S_fun(declval<_Tp>()); }
1281 noexcept(
noexcept(
static_cast<_Range&
>(std::declval<_Tp>())))
1289 constexpr iterator_t<_Range>
1291 {
return ranges::begin(*_M_r); }
1293 constexpr sentinel_t<_Range>
1295 {
return ranges::end(*_M_r); }
1298 empty() const requires requires { ranges::empty(*_M_r); }
1299 {
return ranges::empty(*_M_r); }
1302 size() const requires sized_range<_Range>
1303 {
return ranges::size(*_M_r); }
1306 data() const requires contiguous_range<_Range>
1307 {
return ranges::data(*_M_r); }
1310 template<
typename _Range>
1311 ref_view(_Range&) -> ref_view<_Range>;
1313 template<
typename _Tp>
1314 inline constexpr bool enable_borrowed_range<ref_view<_Tp>> =
true;
1316 template<range _Range>
1317 requires movable<_Range>
1318 && (!__detail::__is_initializer_list<remove_cv_t<_Range>>)
1319 class owning_view : public view_interface<owning_view<_Range>>
1322 _Range _M_r = _Range();
1325 owning_view()
requires default_initializable<_Range> = default;
1328 owning_view(_Range&& __t)
1329 noexcept(is_nothrow_move_constructible_v<_Range>)
1333 owning_view(owning_view&&) =
default;
1334 owning_view& operator=(owning_view&&) =
default;
1340 constexpr const _Range&
1341 base() const& noexcept
1348 constexpr const _Range&&
1349 base() const&& noexcept
1352 constexpr iterator_t<_Range>
1354 {
return ranges::begin(_M_r); }
1356 constexpr sentinel_t<_Range>
1358 {
return ranges::end(_M_r); }
1361 begin() const requires range<const _Range>
1362 {
return ranges::begin(_M_r); }
1365 end() const requires range<const _Range>
1366 {
return ranges::end(_M_r); }
1369 empty()
requires requires { ranges::empty(_M_r); }
1370 {
return ranges::empty(_M_r); }
1373 empty() const requires requires { ranges::empty(_M_r); }
1374 {
return ranges::empty(_M_r); }
1377 size()
requires sized_range<_Range>
1378 {
return ranges::size(_M_r); }
1381 size() const requires sized_range<const _Range>
1382 {
return ranges::size(_M_r); }
1385 data()
requires contiguous_range<_Range>
1386 {
return ranges::data(_M_r); }
1389 data() const requires contiguous_range<const _Range>
1390 {
return ranges::data(_M_r); }
1393 template<
typename _Tp>
1394 inline constexpr bool enable_borrowed_range<owning_view<_Tp>>
1395 = enable_borrowed_range<_Tp>;
1401 template<
typename _Range>
1402 concept __can_ref_view =
requires { ref_view{std::declval<_Range>()}; };
1404 template<
typename _Range>
1405 concept __can_owning_view =
requires { owning_view{std::declval<_Range>()}; };
1408 struct _All : __adaptor::_RangeAdaptorClosure<_All>
1410 template<
typename _Range>
1411 static constexpr bool
1414 if constexpr (view<decay_t<_Range>>)
1415 return is_nothrow_constructible_v<decay_t<_Range>, _Range>;
1416 else if constexpr (__detail::__can_ref_view<_Range>)
1419 return noexcept(owning_view{std::declval<_Range>()});
1422 template<viewable_range _Range>
1423 requires view<decay_t<_Range>>
1424 || __detail::__can_ref_view<_Range>
1425 || __detail::__can_owning_view<_Range>
1427 operator() [[nodiscard]] (_Range&& __r)
const
1428 noexcept(_S_noexcept<_Range>())
1430 if constexpr (view<decay_t<_Range>>)
1431 return std::forward<_Range>(__r);
1432 else if constexpr (__detail::__can_ref_view<_Range>)
1433 return ref_view{std::forward<_Range>(__r)};
1435 return owning_view{std::forward<_Range>(__r)};
1438 static constexpr bool _S_has_simple_call_op =
true;
1441 inline constexpr _All all;
1443 template<viewable_range _Range>
1444 using all_t =
decltype(all(std::declval<_Range>()));
1449 template<
typename _Tp>
1450 struct __non_propagating_cache
1458 template<
typename _Tp>
1459 requires is_object_v<_Tp>
1460 struct __non_propagating_cache<_Tp>
1461 :
protected _Optional_base<_Tp>
1463 __non_propagating_cache() =
default;
1466 __non_propagating_cache(
const __non_propagating_cache&)
noexcept
1470 __non_propagating_cache(__non_propagating_cache&& __other)
noexcept
1471 { __other._M_reset(); }
1473 constexpr __non_propagating_cache&
1474 operator=(
const __non_propagating_cache& __other)
noexcept
1481 constexpr __non_propagating_cache&
1482 operator=(__non_propagating_cache&& __other)
noexcept
1489 constexpr __non_propagating_cache&
1490 operator=(_Tp __val)
1493 this->_M_payload._M_construct(
std::move(__val));
1498 operator bool() const noexcept
1499 {
return this->_M_is_engaged(); }
1503 {
return this->_M_get(); }
1505 constexpr const _Tp&
1507 {
return this->_M_get(); }
1509 template<
typename _Iter>
1511 _M_emplace_deref(
const _Iter& __i)
1514 auto __f = [] (
auto& __x) {
return *__x; };
1515 this->_M_payload._M_apply(_Optional_func{__f}, __i);
1516 return this->_M_get();
1520 template<range _Range>
1521 struct _CachedPosition
1524 _M_has_value()
const
1527 constexpr iterator_t<_Range>
1528 _M_get(
const _Range&)
const
1530 __glibcxx_assert(
false);
1531 __builtin_unreachable();
1535 _M_set(
const _Range&,
const iterator_t<_Range>&)
const
1539 template<forward_range _Range>
1540 struct _CachedPosition<_Range>
1541 :
protected __non_propagating_cache<iterator_t<_Range>>
1544 _M_has_value()
const
1545 {
return this->_M_is_engaged(); }
1547 constexpr iterator_t<_Range>
1548 _M_get(
const _Range&)
const
1550 __glibcxx_assert(_M_has_value());
1555 _M_set(
const _Range&,
const iterator_t<_Range>& __it)
1557 __glibcxx_assert(!_M_has_value());
1560 this->_M_payload._M_engaged =
true;
1564 template<random_access_range _Range>
1565 requires (
sizeof(range_difference_t<_Range>)
1566 <=
sizeof(iterator_t<_Range>))
1567 struct _CachedPosition<_Range>
1570 range_difference_t<_Range> _M_offset = -1;
1573 _CachedPosition() =
default;
1576 _CachedPosition(
const _CachedPosition&) =
default;
1579 _CachedPosition(_CachedPosition&& __other)
noexcept
1582 constexpr _CachedPosition&
1583 operator=(
const _CachedPosition&) =
default;
1585 constexpr _CachedPosition&
1586 operator=(_CachedPosition&& __other)
noexcept
1589 _M_offset = __other._M_offset;
1590 __other._M_offset = -1;
1595 _M_has_value()
const
1596 {
return _M_offset >= 0; }
1598 constexpr iterator_t<_Range>
1599 _M_get(_Range& __r)
const
1601 __glibcxx_assert(_M_has_value());
1602 return ranges::begin(__r) + _M_offset;
1606 _M_set(_Range& __r,
const iterator_t<_Range>& __it)
1608 __glibcxx_assert(!_M_has_value());
1609 _M_offset = __it - ranges::begin(__r);
1616 template<
typename _Base>
1617 struct __filter_view_iter_cat
1620 template<forward_range _Base>
1621 struct __filter_view_iter_cat<_Base>
1627 using _Cat =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
1628 if constexpr (derived_from<_Cat, bidirectional_iterator_tag>)
1629 return bidirectional_iterator_tag{};
1630 else if constexpr (derived_from<_Cat, forward_iterator_tag>)
1631 return forward_iterator_tag{};
1636 using iterator_category =
decltype(_S_iter_cat());
1640 template<input_range _Vp,
1641 indirect_unary_predicate<iterator_t<_Vp>> _Pred>
1642 requires view<_Vp> && is_object_v<_Pred>
1643 class filter_view :
public view_interface<filter_view<_Vp, _Pred>>
1648 struct _Iterator : __detail::__filter_view_iter_cat<_Vp>
1651 static constexpr auto
1654 if constexpr (bidirectional_range<_Vp>)
1655 return bidirectional_iterator_tag{};
1656 else if constexpr (forward_range<_Vp>)
1657 return forward_iterator_tag{};
1659 return input_iterator_tag{};
1664 using _Vp_iter = iterator_t<_Vp>;
1666 _Vp_iter _M_current = _Vp_iter();
1667 filter_view* _M_parent =
nullptr;
1670 using iterator_concept =
decltype(_S_iter_concept());
1672 using value_type = range_value_t<_Vp>;
1673 using difference_type = range_difference_t<_Vp>;
1675 _Iterator()
requires default_initializable<_Vp_iter> = default;
1678 _Iterator(filter_view* __parent, _Vp_iter __current)
1679 : _M_current(
std::move(__current)),
1683 constexpr const _Vp_iter&
1684 base() const & noexcept
1685 {
return _M_current; }
1691 constexpr range_reference_t<_Vp>
1693 {
return *_M_current; }
1697 requires __detail::__has_arrow<_Vp_iter>
1698 && copyable<_Vp_iter>
1699 {
return _M_current; }
1701 constexpr _Iterator&
1704 _M_current = ranges::find_if(
std::move(++_M_current),
1705 ranges::end(_M_parent->_M_base),
1706 std::ref(*_M_parent->_M_pred));
1715 operator++(
int)
requires forward_range<_Vp>
1722 constexpr _Iterator&
1723 operator--()
requires bidirectional_range<_Vp>
1732 operator--(
int)
requires bidirectional_range<_Vp>
1739 friend constexpr bool
1740 operator==(
const _Iterator& __x,
const _Iterator& __y)
1741 requires equality_comparable<_Vp_iter>
1742 {
return __x._M_current == __y._M_current; }
1744 friend constexpr range_rvalue_reference_t<_Vp>
1745 iter_move(
const _Iterator& __i)
1746 noexcept(
noexcept(ranges::iter_move(__i._M_current)))
1747 {
return ranges::iter_move(__i._M_current); }
1749 friend constexpr void
1750 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
1751 noexcept(
noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1752 requires indirectly_swappable<_Vp_iter>
1753 { ranges::iter_swap(__x._M_current, __y._M_current); }
1759 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
1762 __equal(
const _Iterator& __i)
const
1763 {
return __i._M_current == _M_end; }
1766 _Sentinel() =
default;
1769 _Sentinel(filter_view* __parent)
1770 : _M_end(ranges::
end(__parent->_M_base))
1773 constexpr sentinel_t<_Vp>
1777 friend constexpr bool
1778 operator==(
const _Iterator& __x,
const _Sentinel& __y)
1779 {
return __y.__equal(__x); }
1782 _Vp _M_base = _Vp();
1783 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
1784 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
1787 filter_view()
requires (default_initializable<_Vp>
1788 && default_initializable<_Pred>)
1792 filter_view(_Vp __base, _Pred __pred)
1797 base() const& requires copy_constructible<_Vp>
1804 constexpr const _Pred&
1806 {
return *_M_pred; }
1811 if (_M_cached_begin._M_has_value())
1812 return {
this, _M_cached_begin._M_get(_M_base)};
1814 __glibcxx_assert(_M_pred.has_value());
1815 auto __it = ranges::find_if(ranges::begin(_M_base),
1816 ranges::end(_M_base),
1817 std::ref(*_M_pred));
1818 _M_cached_begin._M_set(_M_base, __it);
1825 if constexpr (common_range<_Vp>)
1826 return _Iterator{
this, ranges::end(_M_base)};
1828 return _Sentinel{
this};
1832 template<
typename _Range,
typename _Pred>
1833 filter_view(_Range&&, _Pred) -> filter_view<views::all_t<_Range>, _Pred>;
1839 template<
typename _Range,
typename _Pred>
1840 concept __can_filter_view
1841 =
requires { filter_view(std::declval<_Range>(), std::declval<_Pred>()); };
1844 struct _Filter : __adaptor::_RangeAdaptor<_Filter>
1846 template<viewable_range _Range,
typename _Pred>
1847 requires __detail::__can_filter_view<_Range, _Pred>
1849 operator() [[nodiscard]] (_Range&& __r, _Pred&& __p)
const
1851 return filter_view(std::forward<_Range>(__r), std::forward<_Pred>(__p));
1854 using _RangeAdaptor<_Filter>::operator();
1855 static constexpr int _S_arity = 2;
1856 static constexpr bool _S_has_simple_extra_args =
true;
1859 inline constexpr _Filter filter;
1862#if __cpp_lib_ranges >= 202207L
1863 template<input_range _Vp, move_constructible _Fp>
1865 template<input_range _Vp, copy_constructible _Fp>
1867 requires view<_Vp> && is_object_v<_Fp>
1868 && regular_invocable<_Fp&, range_reference_t<_Vp>>
1869 && std::__detail::__can_reference<invoke_result_t<_Fp&,
1870 range_reference_t<_Vp>>>
1871 class transform_view :
public view_interface<transform_view<_Vp, _Fp>>
1874 template<
bool _Const>
1875 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
1877 template<
bool _Const>
1881 template<
bool _Const>
1882 requires forward_range<_Base<_Const>>
1883 struct __iter_cat<_Const>
1892 using _Base = transform_view::_Base<_Const>;
1893 using _Res = invoke_result_t<__maybe_const_t<_Const, _Fp>&,
1894 range_reference_t<_Base>>;
1897 if constexpr (is_reference_v<_Res>)
1900 =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
1901 if constexpr (derived_from<_Cat, contiguous_iterator_tag>)
1902 return random_access_iterator_tag{};
1907 return input_iterator_tag{};
1910 using iterator_category =
decltype(_S_iter_cat());
1913 template<
bool _Const>
1916 template<
bool _Const>
1917 struct _Iterator : __iter_cat<_Const>
1920 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
1921 using _Base = transform_view::_Base<_Const>;
1926 if constexpr (random_access_range<_Base>)
1927 return random_access_iterator_tag{};
1928 else if constexpr (bidirectional_range<_Base>)
1929 return bidirectional_iterator_tag{};
1930 else if constexpr (forward_range<_Base>)
1931 return forward_iterator_tag{};
1933 return input_iterator_tag{};
1936 using _Base_iter = iterator_t<_Base>;
1938 _Base_iter _M_current = _Base_iter();
1939 _Parent* _M_parent =
nullptr;
1942 using iterator_concept =
decltype(_S_iter_concept());
1945 = remove_cvref_t<invoke_result_t<__maybe_const_t<_Const, _Fp>&,
1946 range_reference_t<_Base>>>;
1947 using difference_type = range_difference_t<_Base>;
1949 _Iterator()
requires default_initializable<_Base_iter> = default;
1952 _Iterator(_Parent* __parent, _Base_iter __current)
1953 : _M_current(
std::move(__current)),
1958 _Iterator(_Iterator<!_Const> __i)
1960 && convertible_to<iterator_t<_Vp>, _Base_iter>
1961 : _M_current(
std::move(__i._M_current)), _M_parent(__i._M_parent)
1964 constexpr const _Base_iter&
1965 base() const & noexcept
1966 {
return _M_current; }
1968 constexpr _Base_iter
1972 constexpr decltype(
auto)
1974 noexcept(
noexcept(
std::__invoke(*_M_parent->_M_fun, *_M_current)))
1977 constexpr _Iterator&
1989 operator++(
int)
requires forward_range<_Base>
1996 constexpr _Iterator&
1997 operator--()
requires bidirectional_range<_Base>
2004 operator--(
int)
requires bidirectional_range<_Base>
2011 constexpr _Iterator&
2012 operator+=(difference_type __n)
requires random_access_range<_Base>
2018 constexpr _Iterator&
2019 operator-=(difference_type __n)
requires random_access_range<_Base>
2025 constexpr decltype(
auto)
2026 operator[](difference_type __n)
const
2027 requires random_access_range<_Base>
2028 {
return std::__invoke(*_M_parent->_M_fun, _M_current[__n]); }
2030 friend constexpr bool
2031 operator==(
const _Iterator& __x,
const _Iterator& __y)
2032 requires equality_comparable<_Base_iter>
2033 {
return __x._M_current == __y._M_current; }
2035 friend constexpr bool
2036 operator<(
const _Iterator& __x,
const _Iterator& __y)
2037 requires random_access_range<_Base>
2038 {
return __x._M_current < __y._M_current; }
2040 friend constexpr bool
2041 operator>(
const _Iterator& __x,
const _Iterator& __y)
2042 requires random_access_range<_Base>
2043 {
return __y < __x; }
2045 friend constexpr bool
2046 operator<=(
const _Iterator& __x,
const _Iterator& __y)
2047 requires random_access_range<_Base>
2048 {
return !(__y < __x); }
2050 friend constexpr bool
2051 operator>=(
const _Iterator& __x,
const _Iterator& __y)
2052 requires random_access_range<_Base>
2053 {
return !(__x < __y); }
2055#ifdef __cpp_lib_three_way_comparison
2056 friend constexpr auto
2057 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
2058 requires random_access_range<_Base>
2059 && three_way_comparable<_Base_iter>
2060 {
return __x._M_current <=> __y._M_current; }
2063 friend constexpr _Iterator
2064 operator+(_Iterator __i, difference_type __n)
2065 requires random_access_range<_Base>
2066 {
return {__i._M_parent, __i._M_current + __n}; }
2068 friend constexpr _Iterator
2069 operator+(difference_type __n, _Iterator __i)
2070 requires random_access_range<_Base>
2071 {
return {__i._M_parent, __i._M_current + __n}; }
2073 friend constexpr _Iterator
2074 operator-(_Iterator __i, difference_type __n)
2075 requires random_access_range<_Base>
2076 {
return {__i._M_parent, __i._M_current - __n}; }
2080 friend constexpr difference_type
2081 operator-(
const _Iterator& __x,
const _Iterator& __y)
2082 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
2083 {
return __x._M_current - __y._M_current; }
2085 friend constexpr decltype(
auto)
2086 iter_move(
const _Iterator& __i)
noexcept(
noexcept(*__i))
2088 if constexpr (is_lvalue_reference_v<
decltype(*__i)>)
2094 friend _Iterator<!_Const>;
2095 template<
bool>
friend struct _Sentinel;
2098 template<
bool _Const>
2102 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
2103 using _Base = transform_view::_Base<_Const>;
2105 template<
bool _Const2>
2107 __distance_from(
const _Iterator<_Const2>& __i)
const
2108 {
return _M_end - __i._M_current; }
2110 template<
bool _Const2>
2112 __equal(
const _Iterator<_Const2>& __i)
const
2113 {
return __i._M_current == _M_end; }
2115 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2118 _Sentinel() =
default;
2121 _Sentinel(sentinel_t<_Base> __end)
2126 _Sentinel(_Sentinel<!_Const> __i)
2128 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2132 constexpr sentinel_t<_Base>
2136 template<
bool _Const2>
2137 requires sentinel_for<sentinel_t<_Base>,
2138 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
2139 friend constexpr bool
2140 operator==(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
2141 {
return __y.__equal(__x); }
2143 template<
bool _Const2,
2144 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
2145 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2146 friend constexpr range_difference_t<_Base2>
2147 operator-(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
2148 {
return -__y.__distance_from(__x); }
2150 template<
bool _Const2,
2151 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
2152 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2153 friend constexpr range_difference_t<_Base2>
2154 operator-(
const _Sentinel& __y,
const _Iterator<_Const2>& __x)
2155 {
return __y.__distance_from(__x); }
2157 friend _Sentinel<!_Const>;
2160 _Vp _M_base = _Vp();
2161 [[no_unique_address]] __detail::__box<_Fp> _M_fun;
2164 transform_view()
requires (default_initializable<_Vp>
2165 && default_initializable<_Fp>)
2169 transform_view(_Vp __base, _Fp __fun)
2174 base() const& requires copy_constructible<_Vp>
2175 {
return _M_base ; }
2181 constexpr _Iterator<false>
2183 {
return _Iterator<false>{
this, ranges::begin(_M_base)}; }
2185 constexpr _Iterator<true>
2187 requires range<const _Vp>
2188 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
2189 {
return _Iterator<true>{
this, ranges::begin(_M_base)}; }
2191 constexpr _Sentinel<false>
2193 {
return _Sentinel<false>{ranges::end(_M_base)}; }
2195 constexpr _Iterator<false>
2196 end()
requires common_range<_Vp>
2197 {
return _Iterator<false>{
this, ranges::end(_M_base)}; }
2199 constexpr _Sentinel<true>
2201 requires range<const _Vp>
2202 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
2203 {
return _Sentinel<true>{ranges::end(_M_base)}; }
2205 constexpr _Iterator<true>
2207 requires common_range<const _Vp>
2208 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
2209 {
return _Iterator<true>{
this, ranges::end(_M_base)}; }
2212 size()
requires sized_range<_Vp>
2213 {
return ranges::size(_M_base); }
2216 size() const requires sized_range<const _Vp>
2217 {
return ranges::size(_M_base); }
2220 template<
typename _Range,
typename _Fp>
2221 transform_view(_Range&&, _Fp) -> transform_view<views::all_t<_Range>, _Fp>;
2227 template<
typename _Range,
typename _Fp>
2228 concept __can_transform_view
2229 =
requires { transform_view(std::declval<_Range>(), std::declval<_Fp>()); };
2232 struct _Transform : __adaptor::_RangeAdaptor<_Transform>
2234 template<viewable_range _Range,
typename _Fp>
2235 requires __detail::__can_transform_view<_Range, _Fp>
2237 operator() [[nodiscard]] (_Range&& __r, _Fp&& __f)
const
2239 return transform_view(std::forward<_Range>(__r), std::forward<_Fp>(__f));
2242 using _RangeAdaptor<_Transform>::operator();
2243 static constexpr int _S_arity = 2;
2244 static constexpr bool _S_has_simple_extra_args =
true;
2247 inline constexpr _Transform transform;
2251 class take_view :
public view_interface<take_view<_Vp>>
2254 template<
bool _Const>
2255 using _CI = counted_iterator<
2256 iterator_t<__detail::__maybe_const_t<_Const, _Vp>>>;
2258 template<
bool _Const>
2262 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2263 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2266 _Sentinel() =
default;
2269 _Sentinel(sentinel_t<_Base> __end)
2274 _Sentinel(_Sentinel<!_Const> __s)
2275 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2279 constexpr sentinel_t<_Base>
2283 friend constexpr bool
2284 operator==(
const _CI<_Const>& __y,
const _Sentinel& __x)
2285 {
return __y.count() == 0 || __y.base() == __x._M_end; }
2287 template<
bool _OtherConst = !_Const,
2288 typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
2289 requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2290 friend constexpr bool
2291 operator==(
const _CI<_OtherConst>& __y,
const _Sentinel& __x)
2292 {
return __y.count() == 0 || __y.base() == __x._M_end; }
2294 friend _Sentinel<!_Const>;
2297 _Vp _M_base = _Vp();
2298 range_difference_t<_Vp> _M_count = 0;
2301 take_view()
requires default_initializable<_Vp> = default;
2304 take_view(_Vp __base, range_difference_t<_Vp> __count)
2305 : _M_base(
std::move(__base)), _M_count(
std::move(__count))
2309 base() const& requires copy_constructible<_Vp>
2317 begin()
requires (!__detail::__simple_view<_Vp>)
2319 if constexpr (sized_range<_Vp>)
2321 if constexpr (random_access_range<_Vp>)
2322 return ranges::begin(_M_base);
2326 return counted_iterator(ranges::begin(_M_base), __sz);
2330 return counted_iterator(ranges::begin(_M_base), _M_count);
2334 begin() const requires range<const _Vp>
2336 if constexpr (sized_range<const _Vp>)
2338 if constexpr (random_access_range<const _Vp>)
2339 return ranges::begin(_M_base);
2343 return counted_iterator(ranges::begin(_M_base), __sz);
2347 return counted_iterator(ranges::begin(_M_base), _M_count);
2351 end()
requires (!__detail::__simple_view<_Vp>)
2353 if constexpr (sized_range<_Vp>)
2355 if constexpr (random_access_range<_Vp>)
2356 return ranges::begin(_M_base) +
size();
2361 return _Sentinel<false>{ranges::end(_M_base)};
2365 end() const requires range<const _Vp>
2367 if constexpr (sized_range<const _Vp>)
2369 if constexpr (random_access_range<const _Vp>)
2370 return ranges::begin(_M_base) +
size();
2375 return _Sentinel<true>{ranges::end(_M_base)};
2379 size()
requires sized_range<_Vp>
2381 auto __n = ranges::size(_M_base);
2382 return std::min(__n,
static_cast<decltype(__n)
>(_M_count));
2386 size() const requires sized_range<const _Vp>
2388 auto __n = ranges::size(_M_base);
2389 return std::min(__n,
static_cast<decltype(__n)
>(_M_count));
2396 template<
typename _Range>
2397 take_view(_Range&&, range_difference_t<_Range>)
2398 -> take_view<views::all_t<_Range>>;
2400 template<
typename _Tp>
2401 inline constexpr bool enable_borrowed_range<take_view<_Tp>>
2402 = enable_borrowed_range<_Tp>;
2408 template<
typename _Range>
2409 inline constexpr bool __is_empty_view =
false;
2411 template<
typename _Tp>
2412 inline constexpr bool __is_empty_view<empty_view<_Tp>> =
true;
2414 template<
typename _Range>
2415 inline constexpr bool __is_basic_string_view =
false;
2417 template<
typename _CharT,
typename _Traits>
2418 inline constexpr bool __is_basic_string_view<basic_string_view<_CharT, _Traits>>
2421 using ranges::__detail::__is_subrange;
2423 template<
typename _Range>
2424 inline constexpr bool __is_iota_view =
false;
2426 template<
typename _Winc,
typename _Bound>
2427 inline constexpr bool __is_iota_view<iota_view<_Winc, _Bound>> =
true;
2429 template<
typename _Range>
2430 inline constexpr bool __is_repeat_view =
false;
2432 template<
typename _Range>
2434 __take_of_repeat_view(_Range&&, range_difference_t<_Range>);
2436 template<
typename _Range,
typename _Dp>
2437 concept __can_take_view
2438 =
requires { take_view(std::declval<_Range>(), std::declval<_Dp>()); };
2441 struct _Take : __adaptor::_RangeAdaptor<_Take>
2443 template<viewable_range _Range,
typename _Dp = range_difference_t<_Range>>
2444 requires __detail::__can_take_view<_Range, _Dp>
2446 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n)
const
2448 using _Tp = remove_cvref_t<_Range>;
2449 if constexpr (__detail::__is_empty_view<_Tp>)
2451 else if constexpr (random_access_range<_Tp>
2453 && (std::__detail::__is_span<_Tp>
2454 || __detail::__is_basic_string_view<_Tp>
2455 || __detail::__is_subrange<_Tp>
2456 || __detail::__is_iota_view<_Tp>))
2458 __n = std::min<_Dp>(ranges::distance(__r), __n);
2459 auto __begin = ranges::begin(__r);
2460 auto __end = __begin + __n;
2461 if constexpr (std::__detail::__is_span<_Tp>)
2462 return span<typename _Tp::element_type>(__begin, __end);
2463 else if constexpr (__detail::__is_basic_string_view<_Tp>)
2464 return _Tp(__begin, __end);
2465 else if constexpr (__detail::__is_subrange<_Tp>)
2466 return subrange<iterator_t<_Tp>>(__begin, __end);
2468 return iota_view(*__begin, *__end);
2470 else if constexpr (__detail::__is_repeat_view<_Tp>)
2471 return __detail::__take_of_repeat_view(std::forward<_Range>(__r), __n);
2473 return take_view(std::forward<_Range>(__r), __n);
2476 using _RangeAdaptor<_Take>::operator();
2477 static constexpr int _S_arity = 2;
2481 template<
typename _Tp>
2482 static constexpr bool _S_has_simple_extra_args
2483 = ranges::__detail::__is_integer_like<_Tp>;
2486 inline constexpr _Take take;
2489 template<view _Vp,
typename _Pred>
2490 requires input_range<_Vp> && is_object_v<_Pred>
2491 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2492 class take_while_view :
public view_interface<take_while_view<_Vp, _Pred>>
2494 template<
bool _Const>
2498 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2500 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2501 const _Pred* _M_pred =
nullptr;
2504 _Sentinel() =
default;
2507 _Sentinel(sentinel_t<_Base> __end,
const _Pred* __pred)
2508 : _M_end(__end), _M_pred(__pred)
2512 _Sentinel(_Sentinel<!_Const> __s)
2513 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2514 : _M_end(__s._M_end), _M_pred(__s._M_pred)
2517 constexpr sentinel_t<_Base>
2518 base()
const {
return _M_end; }
2520 friend constexpr bool
2521 operator==(
const iterator_t<_Base>& __x,
const _Sentinel& __y)
2522 {
return __y._M_end == __x || !
std::__invoke(*__y._M_pred, *__x); }
2524 template<
bool _OtherConst = !_Const,
2525 typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
2526 requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2527 friend constexpr bool
2528 operator==(
const iterator_t<_Base2>& __x,
const _Sentinel& __y)
2529 {
return __y._M_end == __x || !
std::__invoke(*__y._M_pred, *__x); }
2531 friend _Sentinel<!_Const>;
2534 _Vp _M_base = _Vp();
2535 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
2538 take_while_view()
requires (default_initializable<_Vp>
2539 && default_initializable<_Pred>)
2543 take_while_view(_Vp __base, _Pred __pred)
2548 base() const& requires copy_constructible<_Vp>
2555 constexpr const _Pred&
2557 {
return *_M_pred; }
2560 begin()
requires (!__detail::__simple_view<_Vp>)
2561 {
return ranges::begin(_M_base); }
2564 begin() const requires range<const _Vp>
2565 && indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
2566 {
return ranges::begin(_M_base); }
2569 end()
requires (!__detail::__simple_view<_Vp>)
2570 {
return _Sentinel<false>(ranges::end(_M_base),
2574 end() const requires range<const _Vp>
2575 && indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
2576 {
return _Sentinel<true>(ranges::end(_M_base),
2580 template<
typename _Range,
typename _Pred>
2581 take_while_view(_Range&&, _Pred)
2582 -> take_while_view<views::all_t<_Range>, _Pred>;
2588 template<
typename _Range,
typename _Pred>
2589 concept __can_take_while_view
2590 =
requires { take_while_view(std::declval<_Range>(), std::declval<_Pred>()); };
2593 struct _TakeWhile : __adaptor::_RangeAdaptor<_TakeWhile>
2595 template<viewable_range _Range,
typename _Pred>
2596 requires __detail::__can_take_while_view<_Range, _Pred>
2598 operator() [[nodiscard]] (_Range&& __r, _Pred&& __p)
const
2600 return take_while_view(std::forward<_Range>(__r), std::forward<_Pred>(__p));
2603 using _RangeAdaptor<_TakeWhile>::operator();
2604 static constexpr int _S_arity = 2;
2605 static constexpr bool _S_has_simple_extra_args =
true;
2608 inline constexpr _TakeWhile take_while;
2612 class drop_view :
public view_interface<drop_view<_Vp>>
2615 _Vp _M_base = _Vp();
2616 range_difference_t<_Vp> _M_count = 0;
2620 static constexpr bool _S_needs_cached_begin
2621 = !(random_access_range<const _Vp> && sized_range<const _Vp>);
2622 [[no_unique_address]]
2623 __detail::__maybe_present_t<_S_needs_cached_begin,
2624 __detail::_CachedPosition<_Vp>>
2628 drop_view()
requires default_initializable<_Vp> = default;
2631 drop_view(_Vp __base, range_difference_t<_Vp> __count)
2632 : _M_base(
std::move(__base)), _M_count(__count)
2633 { __glibcxx_assert(__count >= 0); }
2636 base() const& requires copy_constructible<_Vp>
2646 requires (!(__detail::__simple_view<_Vp>
2647 && random_access_range<const _Vp>
2648 && sized_range<const _Vp>))
2650 if constexpr (_S_needs_cached_begin)
2651 if (_M_cached_begin._M_has_value())
2652 return _M_cached_begin._M_get(_M_base);
2654 auto __it = ranges::next(ranges::begin(_M_base),
2655 _M_count, ranges::end(_M_base));
2656 if constexpr (_S_needs_cached_begin)
2657 _M_cached_begin._M_set(_M_base, __it);
2665 requires random_access_range<const _Vp> && sized_range<const _Vp>
2667 return ranges::begin(_M_base) + ranges::min(ranges::distance(_M_base),
2672 end()
requires (!__detail::__simple_view<_Vp>)
2673 {
return ranges::end(_M_base); }
2676 end() const requires range<const _Vp>
2677 {
return ranges::end(_M_base); }
2680 size()
requires sized_range<_Vp>
2682 const auto __s = ranges::size(_M_base);
2683 const auto __c =
static_cast<decltype(__s)
>(_M_count);
2684 return __s < __c ? 0 : __s - __c;
2688 size() const requires sized_range<const _Vp>
2690 const auto __s = ranges::size(_M_base);
2691 const auto __c =
static_cast<decltype(__s)
>(_M_count);
2692 return __s < __c ? 0 : __s - __c;
2696 template<
typename _Range>
2697 drop_view(_Range&&, range_difference_t<_Range>)
2698 -> drop_view<views::all_t<_Range>>;
2700 template<
typename _Tp>
2701 inline constexpr bool enable_borrowed_range<drop_view<_Tp>>
2702 = enable_borrowed_range<_Tp>;
2708 template<
typename _Range>
2710 __drop_of_repeat_view(_Range&&, range_difference_t<_Range>);
2712 template<
typename _Range,
typename _Dp>
2713 concept __can_drop_view
2714 =
requires { drop_view(std::declval<_Range>(), std::declval<_Dp>()); };
2717 struct _Drop : __adaptor::_RangeAdaptor<_Drop>
2719 template<viewable_range _Range,
typename _Dp = range_difference_t<_Range>>
2720 requires __detail::__can_drop_view<_Range, _Dp>
2722 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n)
const
2724 using _Tp = remove_cvref_t<_Range>;
2725 if constexpr (__detail::__is_empty_view<_Tp>)
2727 else if constexpr (random_access_range<_Tp>
2729 && (std::__detail::__is_span<_Tp>
2730 || __detail::__is_basic_string_view<_Tp>
2731 || __detail::__is_iota_view<_Tp>
2732 || __detail::__is_subrange<_Tp>))
2734 __n = std::min<_Dp>(ranges::distance(__r), __n);
2735 auto __begin = ranges::begin(__r) + __n;
2736 auto __end = ranges::end(__r);
2737 if constexpr (std::__detail::__is_span<_Tp>)
2738 return span<typename _Tp::element_type>(__begin, __end);
2739 else if constexpr (__detail::__is_subrange<_Tp>)
2741 if constexpr (_Tp::_S_store_size)
2743 using ranges::__detail::__to_unsigned_like;
2744 auto __m = ranges::distance(__r) - __n;
2745 return _Tp(__begin, __end, __to_unsigned_like(__m));
2748 return _Tp(__begin, __end);
2751 return _Tp(__begin, __end);
2753 else if constexpr (__detail::__is_repeat_view<_Tp>)
2754 return __detail::__drop_of_repeat_view(std::forward<_Range>(__r), __n);
2756 return drop_view(std::forward<_Range>(__r), __n);
2759 using _RangeAdaptor<_Drop>::operator();
2760 static constexpr int _S_arity = 2;
2761 template<
typename _Tp>
2762 static constexpr bool _S_has_simple_extra_args
2763 = _Take::_S_has_simple_extra_args<_Tp>;
2766 inline constexpr _Drop drop;
2769 template<view _Vp,
typename _Pred>
2770 requires input_range<_Vp> && is_object_v<_Pred>
2771 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2772 class drop_while_view :
public view_interface<drop_while_view<_Vp, _Pred>>
2775 _Vp _M_base = _Vp();
2776 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
2777 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
2780 drop_while_view()
requires (default_initializable<_Vp>
2781 && default_initializable<_Pred>)
2785 drop_while_view(_Vp __base, _Pred __pred)
2790 base() const& requires copy_constructible<_Vp>
2797 constexpr const _Pred&
2799 {
return *_M_pred; }
2804 if (_M_cached_begin._M_has_value())
2805 return _M_cached_begin._M_get(_M_base);
2807 __glibcxx_assert(_M_pred.has_value());
2808 auto __it = ranges::find_if_not(ranges::begin(_M_base),
2809 ranges::end(_M_base),
2810 std::cref(*_M_pred));
2811 _M_cached_begin._M_set(_M_base, __it);
2817 {
return ranges::end(_M_base); }
2820 template<
typename _Range,
typename _Pred>
2821 drop_while_view(_Range&&, _Pred)
2822 -> drop_while_view<views::all_t<_Range>, _Pred>;
2824 template<
typename _Tp,
typename _Pred>
2825 inline constexpr bool enable_borrowed_range<drop_while_view<_Tp, _Pred>>
2826 = enable_borrowed_range<_Tp>;
2832 template<
typename _Range,
typename _Pred>
2833 concept __can_drop_while_view
2834 =
requires { drop_while_view(std::declval<_Range>(), std::declval<_Pred>()); };
2837 struct _DropWhile : __adaptor::_RangeAdaptor<_DropWhile>
2839 template<viewable_range _Range,
typename _Pred>
2840 requires __detail::__can_drop_while_view<_Range, _Pred>
2842 operator() [[nodiscard]] (_Range&& __r, _Pred&& __p)
const
2844 return drop_while_view(std::forward<_Range>(__r),
2845 std::forward<_Pred>(__p));
2848 using _RangeAdaptor<_DropWhile>::operator();
2849 static constexpr int _S_arity = 2;
2850 static constexpr bool _S_has_simple_extra_args =
true;
2853 inline constexpr _DropWhile drop_while;
2858 template<
typename _Tp>
2860 __as_lvalue(_Tp&& __t)
2861 {
return static_cast<_Tp&
>(__t); }
2864 template<input_range _Vp>
2865 requires view<_Vp> && input_range<range_reference_t<_Vp>>
2866 class join_view :
public view_interface<join_view<_Vp>>
2869 using _InnerRange = range_reference_t<_Vp>;
2871 template<
bool _Const>
2872 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2874 template<
bool _Const>
2875 using _Outer_iter = iterator_t<_Base<_Const>>;
2877 template<
bool _Const>
2878 using _Inner_iter = iterator_t<range_reference_t<_Base<_Const>>>;
2880 template<
bool _Const>
2881 static constexpr bool _S_ref_is_glvalue
2882 = is_reference_v<range_reference_t<_Base<_Const>>>;
2884 template<
bool _Const>
2888 template<
bool _Const>
2889 requires _S_ref_is_glvalue<_Const>
2890 && forward_range<_Base<_Const>>
2891 && forward_range<range_reference_t<_Base<_Const>>>
2892 struct __iter_cat<_Const>
2895 static constexpr auto
2898 using _Outer_iter = join_view::_Outer_iter<_Const>;
2899 using _Inner_iter = join_view::_Inner_iter<_Const>;
2900 using _OuterCat =
typename iterator_traits<_Outer_iter>::iterator_category;
2901 using _InnerCat =
typename iterator_traits<_Inner_iter>::iterator_category;
2902 if constexpr (derived_from<_OuterCat, bidirectional_iterator_tag>
2903 && derived_from<_InnerCat, bidirectional_iterator_tag>
2904 && common_range<range_reference_t<_Base<_Const>>>)
2905 return bidirectional_iterator_tag{};
2906 else if constexpr (derived_from<_OuterCat, forward_iterator_tag>
2907 && derived_from<_InnerCat, forward_iterator_tag>)
2908 return forward_iterator_tag{};
2910 return input_iterator_tag{};
2913 using iterator_category =
decltype(_S_iter_cat());
2916 template<
bool _Const>
2919 template<
bool _Const>
2920 struct _Iterator : __iter_cat<_Const>
2923 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
2924 using _Base = join_view::_Base<_Const>;
2928 static constexpr bool _S_ref_is_glvalue
2929 = join_view::_S_ref_is_glvalue<_Const>;
2934 auto __update_inner = [
this] (
const iterator_t<_Base>& __x) ->
auto&& {
2935 if constexpr (_S_ref_is_glvalue)
2938 return _M_parent->_M_inner._M_emplace_deref(__x);
2941 _Outer_iter& __outer = _M_get_outer();
2942 for (; __outer != ranges::end(_M_parent->_M_base); ++__outer)
2944 auto&& __inner = __update_inner(__outer);
2945 _M_inner = ranges::begin(__inner);
2946 if (_M_inner != ranges::end(__inner))
2950 if constexpr (_S_ref_is_glvalue)
2954 static constexpr auto
2957 if constexpr (_S_ref_is_glvalue
2958 && bidirectional_range<_Base>
2959 && bidirectional_range<range_reference_t<_Base>>
2960 && common_range<range_reference_t<_Base>>)
2961 return bidirectional_iterator_tag{};
2962 else if constexpr (_S_ref_is_glvalue
2963 && forward_range<_Base>
2964 && forward_range<range_reference_t<_Base>>)
2965 return forward_iterator_tag{};
2967 return input_iterator_tag{};
2970 using _Outer_iter = join_view::_Outer_iter<_Const>;
2971 using _Inner_iter = join_view::_Inner_iter<_Const>;
2973 constexpr _Outer_iter&
2976 if constexpr (forward_range<_Base>)
2979 return *_M_parent->_M_outer;
2982 constexpr const _Outer_iter&
2983 _M_get_outer()
const
2985 if constexpr (forward_range<_Base>)
2988 return *_M_parent->_M_outer;
2992 _Iterator(_Parent* __parent, _Outer_iter __outer)
requires forward_range<_Base>
2993 : _M_outer(
std::move(__outer)), _M_parent(__parent)
2997 _Iterator(_Parent* __parent)
requires (!forward_range<_Base>)
2998 : _M_parent(__parent)
3001 [[no_unique_address]]
3002 __detail::__maybe_present_t<forward_range<_Base>, _Outer_iter> _M_outer;
3003 optional<_Inner_iter> _M_inner;
3004 _Parent* _M_parent =
nullptr;
3007 using iterator_concept =
decltype(_S_iter_concept());
3009 using value_type = range_value_t<range_reference_t<_Base>>;
3010 using difference_type
3011 = common_type_t<range_difference_t<_Base>,
3012 range_difference_t<range_reference_t<_Base>>>;
3014 _Iterator() =
default;
3017 _Iterator(_Iterator<!_Const> __i)
3019 && convertible_to<iterator_t<_Vp>, _Outer_iter>
3020 && convertible_to<iterator_t<_InnerRange>, _Inner_iter>
3022 _M_parent(__i._M_parent)
3025 constexpr decltype(
auto)
3027 {
return **_M_inner; }
3031 constexpr _Inner_iter
3033 requires __detail::__has_arrow<_Inner_iter>
3034 && copyable<_Inner_iter>
3035 {
return *_M_inner; }
3037 constexpr _Iterator&
3040 auto&& __inner_range = [
this] () ->
auto&& {
3041 if constexpr (_S_ref_is_glvalue)
3042 return *_M_get_outer();
3044 return *_M_parent->_M_inner;
3046 if (++*_M_inner == ranges::end(__inner_range))
3060 requires _S_ref_is_glvalue && forward_range<_Base>
3061 && forward_range<range_reference_t<_Base>>
3068 constexpr _Iterator&
3070 requires _S_ref_is_glvalue && bidirectional_range<_Base>
3071 && bidirectional_range<range_reference_t<_Base>>
3072 && common_range<range_reference_t<_Base>>
3074 if (_M_outer == ranges::end(_M_parent->_M_base))
3075 _M_inner = ranges::end(__detail::__as_lvalue(*--_M_outer));
3076 while (*_M_inner == ranges::begin(__detail::__as_lvalue(*_M_outer)))
3077 *_M_inner = ranges::end(__detail::__as_lvalue(*--_M_outer));
3084 requires _S_ref_is_glvalue && bidirectional_range<_Base>
3085 && bidirectional_range<range_reference_t<_Base>>
3086 && common_range<range_reference_t<_Base>>
3093 friend constexpr bool
3094 operator==(
const _Iterator& __x,
const _Iterator& __y)
3095 requires _S_ref_is_glvalue
3096 && forward_range<_Base>
3097 && equality_comparable<_Inner_iter>
3099 return (__x._M_outer == __y._M_outer
3100 && __x._M_inner == __y._M_inner);
3103 friend constexpr decltype(
auto)
3104 iter_move(
const _Iterator& __i)
3105 noexcept(
noexcept(ranges::iter_move(*__i._M_inner)))
3106 {
return ranges::iter_move(*__i._M_inner); }
3108 friend constexpr void
3109 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
3110 noexcept(
noexcept(ranges::iter_swap(*__x._M_inner, *__y._M_inner)))
3111 requires indirectly_swappable<_Inner_iter>
3112 {
return ranges::iter_swap(*__x._M_inner, *__y._M_inner); }
3114 friend _Iterator<!_Const>;
3115 template<
bool>
friend struct _Sentinel;
3118 template<
bool _Const>
3122 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
3123 using _Base = join_view::_Base<_Const>;
3125 template<
bool _Const2>
3127 __equal(
const _Iterator<_Const2>& __i)
const
3128 {
return __i._M_get_outer() == _M_end; }
3130 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
3133 _Sentinel() =
default;
3136 _Sentinel(_Parent* __parent)
3137 : _M_end(ranges::
end(__parent->_M_base))
3141 _Sentinel(_Sentinel<!_Const> __s)
3142 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
3146 template<
bool _Const2>
3147 requires sentinel_for<sentinel_t<_Base>,
3148 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
3149 friend constexpr bool
3150 operator==(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
3151 {
return __y.__equal(__x); }
3153 friend _Sentinel<!_Const>;
3156 _Vp _M_base = _Vp();
3157 [[no_unique_address]]
3158 __detail::__maybe_present_t<!forward_range<_Vp>,
3159 __detail::__non_propagating_cache<iterator_t<_Vp>>> _M_outer;
3160 [[no_unique_address]]
3161 __detail::__non_propagating_cache<remove_cv_t<_InnerRange>> _M_inner;
3164 join_view()
requires default_initializable<_Vp> = default;
3167 join_view(_Vp __base)
3168 : _M_base(
std::move(__base))
3172 base() const& requires copy_constructible<_Vp>
3182 if constexpr (forward_range<_Vp>)
3184 constexpr bool __use_const
3185 = (__detail::__simple_view<_Vp>
3186 && is_reference_v<range_reference_t<_Vp>>);
3187 return _Iterator<__use_const>{
this, ranges::begin(_M_base)};
3191 _M_outer = ranges::begin(_M_base);
3192 return _Iterator<false>{
this};
3198 requires forward_range<const _Vp>
3199 && is_reference_v<range_reference_t<const _Vp>>
3200 && input_range<range_reference_t<const _Vp>>
3202 return _Iterator<true>{
this, ranges::begin(_M_base)};
3208 if constexpr (forward_range<_Vp> && is_reference_v<_InnerRange>
3209 && forward_range<_InnerRange>
3210 && common_range<_Vp> && common_range<_InnerRange>)
3211 return _Iterator<__detail::__simple_view<_Vp>>{
this,
3212 ranges::end(_M_base)};
3214 return _Sentinel<__detail::__simple_view<_Vp>>{
this};
3219 requires forward_range<const _Vp>
3220 && is_reference_v<range_reference_t<const _Vp>>
3221 && input_range<range_reference_t<const _Vp>>
3223 if constexpr (is_reference_v<range_reference_t<const _Vp>>
3224 && forward_range<range_reference_t<const _Vp>>
3225 && common_range<const _Vp>
3226 && common_range<range_reference_t<const _Vp>>)
3227 return _Iterator<true>{
this, ranges::end(_M_base)};
3229 return _Sentinel<true>{
this};
3233 template<
typename _Range>
3234 explicit join_view(_Range&&) -> join_view<views::all_t<_Range>>;
3240 template<
typename _Range>
3241 concept __can_join_view
3242 =
requires { join_view<all_t<_Range>>{std::declval<_Range>()}; };
3245 struct _Join : __adaptor::_RangeAdaptorClosure<_Join>
3247 template<viewable_range _Range>
3248 requires __detail::__can_join_view<_Range>
3250 operator() [[nodiscard]] (_Range&& __r)
const
3254 return join_view<all_t<_Range>>{std::forward<_Range>(__r)};
3257 static constexpr bool _S_has_simple_call_op =
true;
3260 inline constexpr _Join join;
3266 struct __require_constant;
3268 template<
typename _Range>
3269 concept __tiny_range = sized_range<_Range>
3271 {
typename __require_constant<remove_reference_t<_Range>::size()>; }
3272 && (remove_reference_t<_Range>::size() <= 1);
3274 template<
typename _Base>
3275 struct __lazy_split_view_outer_iter_cat
3278 template<forward_range _Base>
3279 struct __lazy_split_view_outer_iter_cat<_Base>
3280 {
using iterator_category = input_iterator_tag; };
3282 template<
typename _Base>
3283 struct __lazy_split_view_inner_iter_cat
3286 template<forward_range _Base>
3287 struct __lazy_split_view_inner_iter_cat<_Base>
3290 static constexpr auto
3293 using _Cat =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
3294 if constexpr (derived_from<_Cat, forward_iterator_tag>)
3295 return forward_iterator_tag{};
3300 using iterator_category =
decltype(_S_iter_cat());
3304 template<input_range _Vp, forward_range _Pattern>
3305 requires view<_Vp> && view<_Pattern>
3306 && indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
3308 && (forward_range<_Vp> || __detail::__tiny_range<_Pattern>)
3309 class lazy_split_view : public view_interface<lazy_split_view<_Vp, _Pattern>>
3312 template<
bool _Const>
3313 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
3315 template<
bool _Const>
3318 template<
bool _Const>
3320 : __detail::__lazy_split_view_outer_iter_cat<_Base<_Const>>
3323 using _Parent = __detail::__maybe_const_t<_Const, lazy_split_view>;
3324 using _Base = lazy_split_view::_Base<_Const>;
3328 {
return __current() == ranges::end(_M_parent->_M_base) && !_M_trailing_empty; }
3335 __current() noexcept
3337 if constexpr (forward_range<_Vp>)
3340 return *_M_parent->_M_current;
3344 __current() const noexcept
3346 if constexpr (forward_range<_Vp>)
3349 return *_M_parent->_M_current;
3352 _Parent* _M_parent =
nullptr;
3354 [[no_unique_address]]
3355 __detail::__maybe_present_t<forward_range<_Vp>,
3356 iterator_t<_Base>> _M_current;
3357 bool _M_trailing_empty =
false;
3360 using iterator_concept = __conditional_t<forward_range<_Base>,
3361 forward_iterator_tag,
3362 input_iterator_tag>;
3364 using difference_type = range_difference_t<_Base>;
3366 struct value_type : view_interface<value_type>
3369 _OuterIter _M_i = _OuterIter();
3375 value_type(_OuterIter __i)
3382 constexpr _InnerIter<_Const>
3384 {
return _InnerIter<_Const>{_M_i}; }
3386 constexpr default_sentinel_t
3387 end() const noexcept
3391 _OuterIter() =
default;
3394 _OuterIter(_Parent* __parent)
requires (!forward_range<_Base>)
3395 : _M_parent(__parent)
3399 _OuterIter(_Parent* __parent, iterator_t<_Base> __current)
3400 requires forward_range<_Base>
3401 : _M_parent(__parent),
3406 _OuterIter(_OuterIter<!_Const> __i)
3408 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
3409 : _M_parent(__i._M_parent), _M_current(
std::move(__i._M_current)),
3410 _M_trailing_empty(__i._M_trailing_empty)
3413 constexpr value_type
3415 {
return value_type{*
this}; }
3417 constexpr _OuterIter&
3422 const auto __end = ranges::end(_M_parent->_M_base);
3423 if (__current() == __end)
3425 _M_trailing_empty =
false;
3428 const auto [__pbegin, __pend] = subrange{_M_parent->_M_pattern};
3429 if (__pbegin == __pend)
3431 else if constexpr (__detail::__tiny_range<_Pattern>)
3433 __current() = ranges::find(
std::move(__current()), __end,
3435 if (__current() != __end)
3438 if (__current() == __end)
3439 _M_trailing_empty =
true;
3446 = ranges::mismatch(__current(), __end, __pbegin, __pend);
3450 if (__current() == __end)
3451 _M_trailing_empty =
true;
3454 }
while (++__current() != __end);
3458 constexpr decltype(
auto)
3461 if constexpr (forward_range<_Base>)
3471 friend constexpr bool
3472 operator==(
const _OuterIter& __x,
const _OuterIter& __y)
3473 requires forward_range<_Base>
3475 return __x._M_current == __y._M_current
3476 && __x._M_trailing_empty == __y._M_trailing_empty;
3479 friend constexpr bool
3480 operator==(
const _OuterIter& __x, default_sentinel_t)
3481 {
return __x.__at_end(); };
3483 friend _OuterIter<!_Const>;
3484 friend _InnerIter<_Const>;
3487 template<
bool _Const>
3489 : __detail::__lazy_split_view_inner_iter_cat<_Base<_Const>>
3492 using _Base = lazy_split_view::_Base<_Const>;
3497 auto [__pcur, __pend] = subrange{_M_i._M_parent->_M_pattern};
3498 auto __end = ranges::end(_M_i._M_parent->_M_base);
3499 if constexpr (__detail::__tiny_range<_Pattern>)
3501 const auto& __cur = _M_i_current();
3504 if (__pcur == __pend)
3505 return _M_incremented;
3506 return *__cur == *__pcur;
3510 auto __cur = _M_i_current();
3513 if (__pcur == __pend)
3514 return _M_incremented;
3517 if (*__cur != *__pcur)
3519 if (++__pcur == __pend)
3521 }
while (++__cur != __end);
3527 _M_i_current() noexcept
3528 {
return _M_i.__current(); }
3531 _M_i_current() const noexcept
3532 {
return _M_i.__current(); }
3534 _OuterIter<_Const> _M_i = _OuterIter<_Const>();
3535 bool _M_incremented =
false;
3538 using iterator_concept
3539 =
typename _OuterIter<_Const>::iterator_concept;
3541 using value_type = range_value_t<_Base>;
3542 using difference_type = range_difference_t<_Base>;
3544 _InnerIter() =
default;
3547 _InnerIter(_OuterIter<_Const> __i)
3551 constexpr const iterator_t<_Base>&
3552 base() const& noexcept
3553 {
return _M_i_current(); }
3555 constexpr iterator_t<_Base>
3556 base() &&
requires forward_range<_Vp>
3559 constexpr decltype(
auto)
3561 {
return *_M_i_current(); }
3563 constexpr _InnerIter&
3566 _M_incremented =
true;
3567 if constexpr (!forward_range<_Base>)
3568 if constexpr (_Pattern::size() == 0)
3574 constexpr decltype(
auto)
3577 if constexpr (forward_range<_Base>)
3587 friend constexpr bool
3588 operator==(
const _InnerIter& __x,
const _InnerIter& __y)
3589 requires forward_range<_Base>
3590 {
return __x._M_i == __y._M_i; }
3592 friend constexpr bool
3593 operator==(
const _InnerIter& __x, default_sentinel_t)
3594 {
return __x.__at_end(); }
3596 friend constexpr decltype(
auto)
3597 iter_move(
const _InnerIter& __i)
3598 noexcept(
noexcept(ranges::iter_move(__i._M_i_current())))
3599 {
return ranges::iter_move(__i._M_i_current()); }
3601 friend constexpr void
3602 iter_swap(
const _InnerIter& __x,
const _InnerIter& __y)
3603 noexcept(
noexcept(ranges::iter_swap(__x._M_i_current(),
3604 __y._M_i_current())))
3605 requires indirectly_swappable<iterator_t<_Base>>
3606 { ranges::iter_swap(__x._M_i_current(), __y._M_i_current()); }
3609 _Vp _M_base = _Vp();
3610 _Pattern _M_pattern = _Pattern();
3611 [[no_unique_address]]
3612 __detail::__maybe_present_t<!forward_range<_Vp>,
3613 __detail::__non_propagating_cache<iterator_t<_Vp>>> _M_current;
3617 lazy_split_view()
requires (default_initializable<_Vp>
3618 && default_initializable<_Pattern>)
3622 lazy_split_view(_Vp __base, _Pattern __pattern)
3626 template<input_range _Range>
3627 requires constructible_from<_Vp, views::all_t<_Range>>
3628 && constructible_from<_Pattern, single_view<range_value_t<_Range>>>
3630 lazy_split_view(_Range&& __r, range_value_t<_Range> __e)
3631 : _M_base(views::all(
std::
forward<_Range>(__r))),
3632 _M_pattern(views::single(
std::
move(__e)))
3636 base() const& requires copy_constructible<_Vp>
3646 if constexpr (forward_range<_Vp>)
3648 constexpr bool __simple
3649 = __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
3650 return _OuterIter<__simple>{
this, ranges::begin(_M_base)};
3654 _M_current = ranges::begin(_M_base);
3655 return _OuterIter<false>{
this};
3660 begin() const requires forward_range<_Vp> && forward_range<const _Vp>
3662 return _OuterIter<true>{
this, ranges::begin(_M_base)};
3666 end()
requires forward_range<_Vp> && common_range<_Vp>
3668 constexpr bool __simple
3669 = __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
3670 return _OuterIter<__simple>{
this, ranges::end(_M_base)};
3676 if constexpr (forward_range<_Vp>
3677 && forward_range<const _Vp>
3678 && common_range<const _Vp>)
3679 return _OuterIter<true>{
this, ranges::end(_M_base)};
3685 template<
typename _Range,
typename _Pattern>
3686 lazy_split_view(_Range&&, _Pattern&&)
3687 -> lazy_split_view<views::all_t<_Range>, views::all_t<_Pattern>>;
3689 template<input_range _Range>
3690 lazy_split_view(_Range&&, range_value_t<_Range>)
3691 -> lazy_split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
3697 template<
typename _Range,
typename _Pattern>
3698 concept __can_lazy_split_view
3699 =
requires { lazy_split_view(std::declval<_Range>(), std::declval<_Pattern>()); };
3702 struct _LazySplit : __adaptor::_RangeAdaptor<_LazySplit>
3704 template<viewable_range _Range,
typename _Pattern>
3705 requires __detail::__can_lazy_split_view<_Range, _Pattern>
3707 operator() [[nodiscard]] (_Range&& __r, _Pattern&& __f)
const
3709 return lazy_split_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
3712 using _RangeAdaptor<_LazySplit>::operator();
3713 static constexpr int _S_arity = 2;
3718 template<
typename _Pattern>
3719 static constexpr bool _S_has_simple_extra_args
3720 = is_scalar_v<_Pattern> || (view<_Pattern>
3721 && copy_constructible<_Pattern>);
3724 inline constexpr _LazySplit lazy_split;
3727 template<forward_range _Vp, forward_range _Pattern>
3728 requires view<_Vp> && view<_Pattern>
3729 && indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
3731 class split_view :
public view_interface<split_view<_Vp, _Pattern>>
3734 _Vp _M_base = _Vp();
3735 _Pattern _M_pattern = _Pattern();
3736 __detail::__non_propagating_cache<subrange<iterator_t<_Vp>>> _M_cached_begin;
3742 split_view()
requires (default_initializable<_Vp>
3743 && default_initializable<_Pattern>)
3747 split_view(_Vp __base, _Pattern __pattern)
3751 template<forward_range _Range>
3752 requires constructible_from<_Vp, views::all_t<_Range>>
3753 && constructible_from<_Pattern, single_view<range_value_t<_Range>>>
3755 split_view(_Range&& __r, range_value_t<_Range> __e)
3756 : _M_base(views::all(
std::
forward<_Range>(__r))),
3757 _M_pattern(views::single(
std::
move(__e)))
3761 base() const& requires copy_constructible<_Vp>
3771 if (!_M_cached_begin)
3772 _M_cached_begin = _M_find_next(ranges::begin(_M_base));
3773 return {
this, ranges::begin(_M_base), *_M_cached_begin};
3779 if constexpr (common_range<_Vp>)
3780 return _Iterator{
this, ranges::end(_M_base), {}};
3782 return _Sentinel{
this};
3785 constexpr subrange<iterator_t<_Vp>>
3786 _M_find_next(iterator_t<_Vp> __it)
3788 auto [__b, __e] = ranges::search(subrange(__it, ranges::end(_M_base)), _M_pattern);
3789 if (__b != ranges::end(_M_base) && ranges::empty(_M_pattern))
3801 split_view* _M_parent =
nullptr;
3802 iterator_t<_Vp> _M_cur = iterator_t<_Vp>();
3803 subrange<iterator_t<_Vp>> _M_next = subrange<iterator_t<_Vp>>();
3804 bool _M_trailing_empty =
false;
3806 friend struct _Sentinel;
3809 using iterator_concept = forward_iterator_tag;
3810 using iterator_category = input_iterator_tag;
3811 using value_type = subrange<iterator_t<_Vp>>;
3812 using difference_type = range_difference_t<_Vp>;
3814 _Iterator() =
default;
3817 _Iterator(split_view* __parent,
3818 iterator_t<_Vp> __current,
3819 subrange<iterator_t<_Vp>> __next)
3820 : _M_parent(__parent),
3825 constexpr iterator_t<_Vp>
3829 constexpr value_type
3831 {
return {_M_cur, _M_next.begin()}; }
3833 constexpr _Iterator&
3836 _M_cur = _M_next.begin();
3837 if (_M_cur != ranges::end(_M_parent->_M_base))
3839 _M_cur = _M_next.end();
3840 if (_M_cur == ranges::end(_M_parent->_M_base))
3842 _M_trailing_empty =
true;
3843 _M_next = {_M_cur, _M_cur};
3846 _M_next = _M_parent->_M_find_next(_M_cur);
3849 _M_trailing_empty =
false;
3861 friend constexpr bool
3862 operator==(
const _Iterator& __x,
const _Iterator& __y)
3864 return __x._M_cur == __y._M_cur
3865 && __x._M_trailing_empty == __y._M_trailing_empty;
3872 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
3875 _M_equal(
const _Iterator& __x)
const
3876 {
return __x._M_cur == _M_end && !__x._M_trailing_empty; }
3879 _Sentinel() =
default;
3882 _Sentinel(split_view* __parent)
3883 : _M_end(ranges::
end(__parent->_M_base))
3886 friend constexpr bool
3887 operator==(
const _Iterator& __x,
const _Sentinel& __y)
3888 {
return __y._M_equal(__x); }
3892 template<
typename _Range,
typename _Pattern>
3893 split_view(_Range&&, _Pattern&&)
3894 -> split_view<views::all_t<_Range>, views::all_t<_Pattern>>;
3896 template<forward_range _Range>
3897 split_view(_Range&&, range_value_t<_Range>)
3898 -> split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
3904 template<
typename _Range,
typename _Pattern>
3905 concept __can_split_view
3906 =
requires { split_view(std::declval<_Range>(), std::declval<_Pattern>()); };
3909 struct _Split : __adaptor::_RangeAdaptor<_Split>
3911 template<viewable_range _Range,
typename _Pattern>
3912 requires __detail::__can_split_view<_Range, _Pattern>
3914 operator() [[nodiscard]] (_Range&& __r, _Pattern&& __f)
const
3916 return split_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
3919 using _RangeAdaptor<_Split>::operator();
3920 static constexpr int _S_arity = 2;
3921 template<
typename _Pattern>
3922 static constexpr bool _S_has_simple_extra_args
3923 = _LazySplit::_S_has_simple_extra_args<_Pattern>;
3926 inline constexpr _Split split;
3933 template<input_or_output_iterator _Iter>
3935 operator() [[nodiscard]] (_Iter __i, iter_difference_t<_Iter> __n)
const
3937 if constexpr (contiguous_iterator<_Iter>)
3939 else if constexpr (random_access_iterator<_Iter>)
3940 return subrange(__i, __i + __n);
3942 return subrange(counted_iterator(
std::move(__i), __n),
3947 inline constexpr _Counted counted{};
3951 requires (!common_range<_Vp>) && copyable<iterator_t<_Vp>>
3952 class common_view : public view_interface<common_view<_Vp>>
3955 _Vp _M_base = _Vp();
3958 common_view()
requires default_initializable<_Vp> = default;
3961 common_view(_Vp __r)
3962 : _M_base(
std::move(__r))
3966 base() const& requires copy_constructible<_Vp>
3976 begin()
requires (!__detail::__simple_view<_Vp>)
3978 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3979 return ranges::begin(_M_base);
3981 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
3982 (ranges::begin(_M_base));
3986 begin() const requires range<const _Vp>
3988 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
3989 return ranges::begin(_M_base);
3991 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
3992 (ranges::begin(_M_base));
3996 end()
requires (!__detail::__simple_view<_Vp>)
3998 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3999 return ranges::begin(_M_base) + ranges::size(_M_base);
4001 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
4002 (ranges::end(_M_base));
4006 end() const requires range<const _Vp>
4008 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
4009 return ranges::begin(_M_base) + ranges::size(_M_base);
4011 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
4012 (ranges::end(_M_base));
4016 size()
requires sized_range<_Vp>
4017 {
return ranges::size(_M_base); }
4020 size() const requires sized_range<const _Vp>
4021 {
return ranges::size(_M_base); }
4024 template<
typename _Range>
4025 common_view(_Range&&) -> common_view<views::all_t<_Range>>;
4027 template<
typename _Tp>
4028 inline constexpr bool enable_borrowed_range<common_view<_Tp>>
4029 = enable_borrowed_range<_Tp>;
4035 template<
typename _Range>
4036 concept __already_common = common_range<_Range>
4037 &&
requires { views::all(std::declval<_Range>()); };
4039 template<
typename _Range>
4040 concept __can_common_view
4041 =
requires { common_view{std::declval<_Range>()}; };
4044 struct _Common : __adaptor::_RangeAdaptorClosure<_Common>
4046 template<viewable_range _Range>
4047 requires __detail::__already_common<_Range>
4048 || __detail::__can_common_view<_Range>
4050 operator() [[nodiscard]] (_Range&& __r)
const
4052 if constexpr (__detail::__already_common<_Range>)
4053 return views::all(std::forward<_Range>(__r));
4055 return common_view{std::forward<_Range>(__r)};
4058 static constexpr bool _S_has_simple_call_op =
true;
4061 inline constexpr _Common common;
4065 requires bidirectional_range<_Vp>
4066 class reverse_view :
public view_interface<reverse_view<_Vp>>
4069 static constexpr bool _S_needs_cached_begin
4070 = !common_range<_Vp> && !(random_access_range<_Vp>
4071 && sized_sentinel_for<sentinel_t<_Vp>,
4074 _Vp _M_base = _Vp();
4075 [[no_unique_address]]
4076 __detail::__maybe_present_t<_S_needs_cached_begin,
4077 __detail::_CachedPosition<_Vp>>
4081 reverse_view()
requires default_initializable<_Vp> = default;
4084 reverse_view(_Vp __r)
4085 : _M_base(
std::move(__r))
4089 base() const& requires copy_constructible<_Vp>
4096 constexpr reverse_iterator<iterator_t<_Vp>>
4099 if constexpr (_S_needs_cached_begin)
4100 if (_M_cached_begin._M_has_value())
4103 auto __it = ranges::next(ranges::begin(_M_base), ranges::end(_M_base));
4104 if constexpr (_S_needs_cached_begin)
4105 _M_cached_begin._M_set(_M_base, __it);
4110 begin()
requires common_range<_Vp>
4114 begin() const requires common_range<const _Vp>
4117 constexpr reverse_iterator<iterator_t<_Vp>>
4122 end() const requires common_range<const _Vp>
4126 size()
requires sized_range<_Vp>
4127 {
return ranges::size(_M_base); }
4130 size() const requires sized_range<const _Vp>
4131 {
return ranges::size(_M_base); }
4134 template<
typename _Range>
4135 reverse_view(_Range&&) -> reverse_view<views::all_t<_Range>>;
4137 template<
typename _Tp>
4138 inline constexpr bool enable_borrowed_range<reverse_view<_Tp>>
4139 = enable_borrowed_range<_Tp>;
4146 inline constexpr bool __is_reversible_subrange =
false;
4148 template<
typename _Iter, subrange_kind _Kind>
4149 inline constexpr bool
4150 __is_reversible_subrange<subrange<reverse_iterator<_Iter>,
4151 reverse_iterator<_Iter>,
4155 inline constexpr bool __is_reverse_view =
false;
4157 template<
typename _Vp>
4158 inline constexpr bool __is_reverse_view<reverse_view<_Vp>> =
true;
4160 template<
typename _Range>
4161 concept __can_reverse_view
4162 =
requires { reverse_view{std::declval<_Range>()}; };
4165 struct _Reverse : __adaptor::_RangeAdaptorClosure<_Reverse>
4167 template<viewable_range _Range>
4168 requires __detail::__is_reverse_view<remove_cvref_t<_Range>>
4169 || __detail::__is_reversible_subrange<remove_cvref_t<_Range>>
4170 || __detail::__can_reverse_view<_Range>
4172 operator() [[nodiscard]] (_Range&& __r)
const
4174 using _Tp = remove_cvref_t<_Range>;
4175 if constexpr (__detail::__is_reverse_view<_Tp>)
4176 return std::forward<_Range>(__r).base();
4177 else if constexpr (__detail::__is_reversible_subrange<_Tp>)
4179 using _Iter =
decltype(ranges::begin(__r).base());
4180 if constexpr (sized_range<_Tp>)
4181 return subrange<_Iter, _Iter, subrange_kind::sized>
4182 {__r.end().base(), __r.begin().base(), __r.size()};
4184 return subrange<_Iter, _Iter, subrange_kind::unsized>
4185 {__r.end().base(), __r.begin().base()};
4188 return reverse_view{std::forward<_Range>(__r)};
4191 static constexpr bool _S_has_simple_call_op =
true;
4194 inline constexpr _Reverse reverse;
4199#if __cpp_lib_tuple_like
4200 template<
typename _Tp,
size_t _Nm>
4201 concept __has_tuple_element = __tuple_like<_Tp> && _Nm < tuple_size_v<_Tp>;
4203 template<
typename _Tp,
size_t _Nm>
4204 concept __has_tuple_element =
requires(_Tp __t)
4206 typename tuple_size<_Tp>::type;
4207 requires _Nm < tuple_size_v<_Tp>;
4208 typename tuple_element_t<_Nm, _Tp>;
4209 { std::get<_Nm>(__t) }
4210 -> convertible_to<const tuple_element_t<_Nm, _Tp>&>;
4214 template<
typename _Tp,
size_t _Nm>
4215 concept __returnable_element
4216 = is_reference_v<_Tp> || move_constructible<tuple_element_t<_Nm, _Tp>>;
4219 template<input_range _Vp,
size_t _Nm>
4221 && __detail::__has_tuple_element<range_value_t<_Vp>, _Nm>
4222 && __detail::__has_tuple_element<remove_reference_t<range_reference_t<_Vp>>,
4224 && __detail::__returnable_element<range_reference_t<_Vp>, _Nm>
4225 class elements_view :
public view_interface<elements_view<_Vp, _Nm>>
4228 elements_view()
requires default_initializable<_Vp> = default;
4231 elements_view(_Vp __base)
4232 : _M_base(
std::move(__base))
4236 base() const& requires copy_constructible<_Vp>
4244 begin()
requires (!__detail::__simple_view<_Vp>)
4245 {
return _Iterator<false>(ranges::begin(_M_base)); }
4248 begin() const requires range<const _Vp>
4249 {
return _Iterator<true>(ranges::begin(_M_base)); }
4252 end()
requires (!__detail::__simple_view<_Vp> && !common_range<_Vp>)
4253 {
return _Sentinel<false>{ranges::end(_M_base)}; }
4256 end()
requires (!__detail::__simple_view<_Vp> && common_range<_Vp>)
4257 {
return _Iterator<false>{ranges::end(_M_base)}; }
4260 end() const requires range<const _Vp>
4261 {
return _Sentinel<true>{ranges::end(_M_base)}; }
4264 end() const requires common_range<const _Vp>
4265 {
return _Iterator<true>{ranges::end(_M_base)}; }
4268 size()
requires sized_range<_Vp>
4269 {
return ranges::size(_M_base); }
4272 size() const requires sized_range<const _Vp>
4273 {
return ranges::size(_M_base); }
4276 template<
bool _Const>
4277 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
4279 template<
bool _Const>
4283 template<
bool _Const>
4284 requires forward_range<_Base<_Const>>
4285 struct __iter_cat<_Const>
4288 static auto _S_iter_cat()
4290 using _Base = elements_view::_Base<_Const>;
4291 using _Cat =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
4292 using _Res =
decltype((std::get<_Nm>(*
std::declval<iterator_t<_Base>>())));
4293 if constexpr (!is_lvalue_reference_v<_Res>)
4294 return input_iterator_tag{};
4295 else if constexpr (derived_from<_Cat, random_access_iterator_tag>)
4296 return random_access_iterator_tag{};
4301 using iterator_category =
decltype(_S_iter_cat());
4304 template<
bool _Const>
4307 template<
bool _Const>
4308 struct _Iterator : __iter_cat<_Const>
4311 using _Base = elements_view::_Base<_Const>;
4313 iterator_t<_Base> _M_current = iterator_t<_Base>();
4315 static constexpr decltype(
auto)
4316 _S_get_element(
const iterator_t<_Base>& __i)
4318 if constexpr (is_reference_v<range_reference_t<_Base>>)
4319 return std::get<_Nm>(*__i);
4322 using _Et = remove_cv_t<tuple_element_t<_Nm, range_reference_t<_Base>>>;
4323 return static_cast<_Et
>(std::get<_Nm>(*__i));
4330 if constexpr (random_access_range<_Base>)
4331 return random_access_iterator_tag{};
4332 else if constexpr (bidirectional_range<_Base>)
4333 return bidirectional_iterator_tag{};
4334 else if constexpr (forward_range<_Base>)
4335 return forward_iterator_tag{};
4337 return input_iterator_tag{};
4340 friend _Iterator<!_Const>;
4343 using iterator_concept =
decltype(_S_iter_concept());
4346 = remove_cvref_t<tuple_element_t<_Nm, range_value_t<_Base>>>;
4347 using difference_type = range_difference_t<_Base>;
4349 _Iterator()
requires default_initializable<iterator_t<_Base>> = default;
4352 _Iterator(iterator_t<_Base> __current)
4353 : _M_current(
std::move(__current))
4357 _Iterator(_Iterator<!_Const> __i)
4358 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
4362 constexpr const iterator_t<_Base>&
4363 base() const& noexcept
4364 {
return _M_current; }
4366 constexpr iterator_t<_Base>
4370 constexpr decltype(
auto)
4372 {
return _S_get_element(_M_current); }
4374 constexpr _Iterator&
4386 operator++(
int)
requires forward_range<_Base>
4393 constexpr _Iterator&
4394 operator--()
requires bidirectional_range<_Base>
4401 operator--(
int)
requires bidirectional_range<_Base>
4408 constexpr _Iterator&
4409 operator+=(difference_type __n)
4410 requires random_access_range<_Base>
4416 constexpr _Iterator&
4417 operator-=(difference_type __n)
4418 requires random_access_range<_Base>
4424 constexpr decltype(
auto)
4425 operator[](difference_type __n)
const
4426 requires random_access_range<_Base>
4427 {
return _S_get_element(_M_current + __n); }
4429 friend constexpr bool
4430 operator==(
const _Iterator& __x,
const _Iterator& __y)
4431 requires equality_comparable<iterator_t<_Base>>
4432 {
return __x._M_current == __y._M_current; }
4434 friend constexpr bool
4435 operator<(
const _Iterator& __x,
const _Iterator& __y)
4436 requires random_access_range<_Base>
4437 {
return __x._M_current < __y._M_current; }
4439 friend constexpr bool
4440 operator>(
const _Iterator& __x,
const _Iterator& __y)
4441 requires random_access_range<_Base>
4442 {
return __y._M_current < __x._M_current; }
4444 friend constexpr bool
4445 operator<=(
const _Iterator& __x,
const _Iterator& __y)
4446 requires random_access_range<_Base>
4447 {
return !(__y._M_current > __x._M_current); }
4449 friend constexpr bool
4450 operator>=(
const _Iterator& __x,
const _Iterator& __y)
4451 requires random_access_range<_Base>
4452 {
return !(__x._M_current > __y._M_current); }
4454#ifdef __cpp_lib_three_way_comparison
4455 friend constexpr auto
4456 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
4457 requires random_access_range<_Base>
4458 && three_way_comparable<iterator_t<_Base>>
4459 {
return __x._M_current <=> __y._M_current; }
4462 friend constexpr _Iterator
4463 operator+(
const _Iterator& __x, difference_type __y)
4464 requires random_access_range<_Base>
4465 {
return _Iterator{__x} += __y; }
4467 friend constexpr _Iterator
4468 operator+(difference_type __x,
const _Iterator& __y)
4469 requires random_access_range<_Base>
4470 {
return __y + __x; }
4472 friend constexpr _Iterator
4473 operator-(
const _Iterator& __x, difference_type __y)
4474 requires random_access_range<_Base>
4475 {
return _Iterator{__x} -= __y; }
4479 friend constexpr difference_type
4480 operator-(
const _Iterator& __x,
const _Iterator& __y)
4481 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
4482 {
return __x._M_current - __y._M_current; }
4484 template <
bool>
friend struct _Sentinel;
4487 template<
bool _Const>
4491 template<
bool _Const2>
4493 _M_equal(
const _Iterator<_Const2>& __x)
const
4494 {
return __x._M_current == _M_end; }
4496 template<
bool _Const2>
4498 _M_distance_from(
const _Iterator<_Const2>& __i)
const
4499 {
return _M_end - __i._M_current; }
4501 using _Base = elements_view::_Base<_Const>;
4502 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
4505 _Sentinel() =
default;
4508 _Sentinel(sentinel_t<_Base> __end)
4513 _Sentinel(_Sentinel<!_Const> __other)
4515 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
4519 constexpr sentinel_t<_Base>
4523 template<
bool _Const2>
4524 requires sentinel_for<sentinel_t<_Base>,
4525 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
4526 friend constexpr bool
4527 operator==(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
4528 {
return __y._M_equal(__x); }
4530 template<
bool _Const2,
4531 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
4532 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
4533 friend constexpr range_difference_t<_Base2>
4534 operator-(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
4535 {
return -__y._M_distance_from(__x); }
4537 template<
bool _Const2,
4538 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
4539 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
4540 friend constexpr range_difference_t<_Base2>
4541 operator-(
const _Sentinel& __x,
const _Iterator<_Const2>& __y)
4542 {
return __x._M_distance_from(__y); }
4544 friend _Sentinel<!_Const>;
4547 _Vp _M_base = _Vp();
4550 template<
typename _Tp,
size_t _Nm>
4551 inline constexpr bool enable_borrowed_range<elements_view<_Tp, _Nm>>
4552 = enable_borrowed_range<_Tp>;
4556 template<
typename _Range>
4557 using keys_view = elements_view<_Range, 0>;
4559 template<
typename _Range>
4560 using values_view = elements_view<_Range, 1>;
4566 template<
size_t _Nm,
typename _Range>
4567 concept __can_elements_view
4568 =
requires { elements_view<all_t<_Range>, _Nm>{std::declval<_Range>()}; };
4571 template<
size_t _Nm>
4572 struct _Elements : __adaptor::_RangeAdaptorClosure<_Elements<_Nm>>
4574 template<viewable_range _Range>
4575 requires __detail::__can_elements_view<_Nm, _Range>
4577 operator() [[nodiscard]] (_Range&& __r)
const
4579 return elements_view<all_t<_Range>, _Nm>{std::forward<_Range>(__r)};
4582 static constexpr bool _S_has_simple_call_op =
true;
4585 template<
size_t _Nm>
4586 inline constexpr _Elements<_Nm> elements;
4587 inline constexpr auto keys = elements<0>;
4588 inline constexpr auto values = elements<1>;
4591#ifdef __cpp_lib_ranges_zip
4594 template<
typename... _Rs>
4595 concept __zip_is_common = (
sizeof...(_Rs) == 1 && (common_range<_Rs> && ...))
4596 || (!(bidirectional_range<_Rs> && ...) && (common_range<_Rs> && ...))
4597 || ((random_access_range<_Rs> && ...) && (sized_range<_Rs> && ...));
4599 template<
typename _Fp,
typename _Tuple>
4601 __tuple_transform(_Fp&& __f, _Tuple&& __tuple)
4603 return std::apply([&]<
typename... _Ts>(_Ts&&... __elts) {
4604 return tuple<invoke_result_t<_Fp&, _Ts>...>
4606 }, std::forward<_Tuple>(__tuple));
4609 template<
typename _Fp,
typename _Tuple>
4611 __tuple_for_each(_Fp&& __f, _Tuple&& __tuple)
4613 std::apply([&]<
typename... _Ts>(_Ts&&... __elts) {
4615 }, std::forward<_Tuple>(__tuple));
4619 template<input_range... _Vs>
4620 requires (view<_Vs> && ...) && (
sizeof...(_Vs) > 0)
4621 class zip_view :
public view_interface<zip_view<_Vs...>>
4623 tuple<_Vs...> _M_views;
4625 template<
bool>
class _Iterator;
4626 template<
bool>
class _Sentinel;
4629 zip_view() =
default;
4632 zip_view(_Vs... __views)
4633 : _M_views(
std::
move(__views)...)
4637 begin()
requires (!(__detail::__simple_view<_Vs> && ...))
4638 {
return _Iterator<false>(__detail::__tuple_transform(ranges::begin, _M_views)); }
4641 begin() const requires (range<const _Vs> && ...)
4642 {
return _Iterator<true>(__detail::__tuple_transform(ranges::begin, _M_views)); }
4645 end()
requires (!(__detail::__simple_view<_Vs> && ...))
4647 if constexpr (!__detail::__zip_is_common<_Vs...>)
4648 return _Sentinel<false>(__detail::__tuple_transform(ranges::end, _M_views));
4649 else if constexpr ((random_access_range<_Vs> && ...))
4650 return begin() + iter_difference_t<_Iterator<false>>(
size());
4652 return _Iterator<false>(__detail::__tuple_transform(ranges::end, _M_views));
4656 end() const requires (range<const _Vs> && ...)
4658 if constexpr (!__detail::__zip_is_common<
const _Vs...>)
4659 return _Sentinel<true>(__detail::__tuple_transform(ranges::end, _M_views));
4660 else if constexpr ((random_access_range<const _Vs> && ...))
4661 return begin() + iter_difference_t<_Iterator<true>>(
size());
4663 return _Iterator<true>(__detail::__tuple_transform(ranges::end, _M_views));
4667 size()
requires (sized_range<_Vs> && ...)
4669 return std::apply([](
auto... sizes) {
4670 using _CT = __detail::__make_unsigned_like_t<
common_type_t<
decltype(sizes)...>>;
4671 return ranges::min({_CT(sizes)...});
4672 }, __detail::__tuple_transform(ranges::size, _M_views));
4676 size() const requires (sized_range<const _Vs> && ...)
4678 return std::apply([](
auto... sizes) {
4679 using _CT = __detail::__make_unsigned_like_t<
common_type_t<
decltype(sizes)...>>;
4680 return ranges::min({_CT(sizes)...});
4681 }, __detail::__tuple_transform(ranges::size, _M_views));
4685 template<
typename... _Rs>
4686 zip_view(_Rs&&...) -> zip_view<views::all_t<_Rs>...>;
4688 template<
typename... _Views>
4689 inline constexpr bool enable_borrowed_range<zip_view<_Views...>>
4690 = (enable_borrowed_range<_Views> && ...);
4694 template<
bool _Const,
typename... _Vs>
4695 concept __all_random_access
4696 = (random_access_range<__maybe_const_t<_Const, _Vs>> && ...);
4698 template<
bool _Const,
typename... _Vs>
4699 concept __all_bidirectional
4700 = (bidirectional_range<__maybe_const_t<_Const, _Vs>> && ...);
4702 template<
bool _Const,
typename... _Vs>
4703 concept __all_forward
4704 = (forward_range<__maybe_const_t<_Const, _Vs>> && ...);
4706 template<
bool _Const,
typename... _Views>
4707 struct __zip_view_iter_cat
4710 template<
bool _Const,
typename... _Views>
4711 requires __all_forward<_Const, _Views...>
4712 struct __zip_view_iter_cat<_Const, _Views...>
4713 {
using iterator_category = input_iterator_tag; };
4716 template<input_range... _Vs>
4717 requires (view<_Vs> && ...) && (
sizeof...(_Vs) > 0)
4718 template<
bool _Const>
4719 class zip_view<_Vs...>::_Iterator
4720 :
public __detail::__zip_view_iter_cat<_Const, _Vs...>
4722#ifdef _GLIBCXX_CLANG
4725 tuple<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>...> _M_current;
4728 _Iterator(
decltype(_M_current) __current)
4729 : _M_current(
std::
move(__current))
4735 if constexpr (__detail::__all_random_access<_Const, _Vs...>)
4736 return random_access_iterator_tag{};
4737 else if constexpr (__detail::__all_bidirectional<_Const, _Vs...>)
4738 return bidirectional_iterator_tag{};
4739 else if constexpr (__detail::__all_forward<_Const, _Vs...>)
4740 return forward_iterator_tag{};
4742 return input_iterator_tag{};
4745#ifndef _GLIBCXX_CLANG
4746 template<move_constructible _Fp, input_range... _Ws>
4747 requires (view<_Ws> && ...) && (
sizeof...(_Ws) > 0) && is_object_v<_Fp>
4748 && regular_invocable<_Fp&, range_reference_t<_Ws>...>
4749 && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Ws>...>>
4750 friend class zip_transform_view;
4755 using iterator_concept =
decltype(_S_iter_concept());
4757 = tuple<range_value_t<__detail::__maybe_const_t<_Const, _Vs>>...>;
4758 using difference_type
4759 = common_type_t<range_difference_t<__detail::__maybe_const_t<_Const, _Vs>>...>;
4761 _Iterator() =
default;
4764 _Iterator(_Iterator<!_Const> __i)
4766 && (convertible_to<iterator_t<_Vs>,
4767 iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4768 : _M_current(
std::
move(__i._M_current))
4774 auto __f = [](
auto& __i) ->
decltype(
auto) {
4777 return __detail::__tuple_transform(__f, _M_current);
4780 constexpr _Iterator&
4783 __detail::__tuple_for_each([](
auto& __i) { ++__i; }, _M_current);
4793 requires __detail::__all_forward<_Const, _Vs...>
4800 constexpr _Iterator&
4802 requires __detail::__all_bidirectional<_Const, _Vs...>
4804 __detail::__tuple_for_each([](
auto& __i) { --__i; }, _M_current);
4810 requires __detail::__all_bidirectional<_Const, _Vs...>
4817 constexpr _Iterator&
4818 operator+=(difference_type __x)
4819 requires __detail::__all_random_access<_Const, _Vs...>
4821 auto __f = [&]<
typename _It>(_It& __i) {
4822 __i += iter_difference_t<_It>(__x);
4824 __detail::__tuple_for_each(__f, _M_current);
4828 constexpr _Iterator&
4829 operator-=(difference_type __x)
4830 requires __detail::__all_random_access<_Const, _Vs...>
4832 auto __f = [&]<
typename _It>(_It& __i) {
4833 __i -= iter_difference_t<_It>(__x);
4835 __detail::__tuple_for_each(__f, _M_current);
4840 operator[](difference_type __n)
const
4841 requires __detail::__all_random_access<_Const, _Vs...>
4843 auto __f = [&]<
typename _It>(_It& __i) ->
decltype(
auto) {
4844 return __i[iter_difference_t<_It>(__n)];
4846 return __detail::__tuple_transform(__f, _M_current);
4849 friend constexpr bool
4850 operator==(
const _Iterator& __x,
const _Iterator& __y)
4851 requires (equality_comparable<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4853 if constexpr (__detail::__all_bidirectional<_Const, _Vs...>)
4854 return __x._M_current == __y._M_current;
4857 return ((std::get<_Is>(__x._M_current) == std::get<_Is>(__y._M_current)) || ...);
4861 friend constexpr auto
4862 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
4863 requires __detail::__all_random_access<_Const, _Vs...>
4864 {
return __x._M_current <=> __y._M_current; }
4866 friend constexpr _Iterator
4867 operator+(
const _Iterator& __i, difference_type __n)
4868 requires __detail::__all_random_access<_Const, _Vs...>
4875 friend constexpr _Iterator
4876 operator+(difference_type __n,
const _Iterator& __i)
4877 requires __detail::__all_random_access<_Const, _Vs...>
4884 friend constexpr _Iterator
4885 operator-(
const _Iterator& __i, difference_type __n)
4886 requires __detail::__all_random_access<_Const, _Vs...>
4893 friend constexpr difference_type
4894 operator-(
const _Iterator& __x,
const _Iterator& __y)
4895 requires (sized_sentinel_for<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>,
4896 iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4899 return ranges::min({difference_type(std::get<_Is>(__x._M_current)
4900 - std::get<_Is>(__y._M_current))...},
4902 [](difference_type __i) {
4903 return __detail::__to_unsigned_like(__i < 0 ? -__i : __i);
4908 friend constexpr auto
4909 iter_move(
const _Iterator& __i)
4910 {
return __detail::__tuple_transform(ranges::iter_move, __i._M_current); }
4912 friend constexpr void
4913 iter_swap(
const _Iterator& __l,
const _Iterator& __r)
4914 requires (indirectly_swappable<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4917 (ranges::iter_swap(std::get<_Is>(__l._M_current), std::get<_Is>(__r._M_current)), ...);
4921 friend class zip_view;
4924 template<input_range... _Vs>
4925 requires (view<_Vs> && ...) && (
sizeof...(_Vs) > 0)
4926 template<
bool _Const>
4927 class zip_view<_Vs...>::_Sentinel
4929 tuple<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>...> _M_end;
4932 _Sentinel(
decltype(_M_end) __end)
4936 friend class zip_view;
4939 _Sentinel() =
default;
4942 _Sentinel(_Sentinel<!_Const> __i)
4944 && (convertible_to<sentinel_t<_Vs>,
4945 sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4946 : _M_end(
std::
move(__i._M_end))
4949 template<
bool _OtherConst>
4950 requires (sentinel_for<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>,
4951 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vs>>> && ...)
4952 friend constexpr bool
4953 operator==(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
4956 return ((std::get<_Is>(__x._M_current) == std::get<_Is>(__y._M_end)) || ...);
4960 template<
bool _OtherConst>
4961 requires (sized_sentinel_for<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>,
4962 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vs>>> && ...)
4963 friend constexpr auto
4964 operator-(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
4967 = common_type_t<range_difference_t<__detail::__maybe_const_t<_OtherConst, _Vs>>...>;
4969 return ranges::min({_Ret(std::get<_Is>(__x._M_current) - std::get<_Is>(__y._M_end))...},
4972 return __detail::__to_unsigned_like(__i < 0 ? -__i : __i);
4977 template<
bool _OtherConst>
4978 requires (sized_sentinel_for<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>,
4979 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vs>>> && ...)
4980 friend constexpr auto
4981 operator-(
const _Sentinel& __y,
const _Iterator<_OtherConst>& __x)
4982 {
return -(__x - __y); }
4989 template<
typename... _Ts>
4990 concept __can_zip_view
4991 =
requires { zip_view<all_t<_Ts>...>(std::declval<_Ts>()...); };
4996 template<
typename... _Ts>
4997 requires (
sizeof...(_Ts) == 0 || __detail::__can_zip_view<_Ts...>)
4999 operator() [[nodiscard]] (_Ts&&... __ts)
const
5001 if constexpr (
sizeof...(_Ts) == 0)
5002 return views::empty<tuple<>>;
5004 return zip_view<all_t<_Ts>...>(std::forward<_Ts>(__ts)...);
5008 inline constexpr _Zip zip;
5013 template<
typename _Range,
bool _Const>
5014 using __range_iter_cat
5015 =
typename iterator_traits<iterator_t<__maybe_const_t<_Const, _Range>>>::iterator_category;
5018 template<move_constructible _Fp, input_range... _Vs>
5019 requires (view<_Vs> && ...) && (
sizeof...(_Vs) > 0) && is_object_v<_Fp>
5020 && regular_invocable<_Fp&, range_reference_t<_Vs>...>
5021 && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Vs>...>>
5022 class zip_transform_view :
public view_interface<zip_transform_view<_Fp, _Vs...>>
5024 [[no_unique_address]] __detail::__box<_Fp> _M_fun;
5025 zip_view<_Vs...> _M_zip;
5027 using _InnerView = zip_view<_Vs...>;
5029 template<
bool _Const>
5030 using __ziperator = iterator_t<__detail::__maybe_const_t<_Const, _InnerView>>;
5032 template<
bool _Const>
5033 using __zentinel = sentinel_t<__detail::__maybe_const_t<_Const, _InnerView>>;
5035 template<
bool _Const>
5036 using _Base = __detail::__maybe_const_t<_Const, _InnerView>;
5038 template<
bool _Const>
5042 template<
bool _Const>
5043 requires forward_range<_Base<_Const>>
5044 struct __iter_cat<_Const>
5050 using __detail::__maybe_const_t;
5051 using __detail::__range_iter_cat;
5052 using _Res = invoke_result_t<__maybe_const_t<_Const, _Fp>&,
5053 range_reference_t<__maybe_const_t<_Const, _Vs>>...>;
5056 if constexpr (!is_reference_v<_Res>)
5057 return input_iterator_tag{};
5058 else if constexpr ((derived_from<__range_iter_cat<_Vs, _Const>,
5059 random_access_iterator_tag> && ...))
5060 return random_access_iterator_tag{};
5061 else if constexpr ((derived_from<__range_iter_cat<_Vs, _Const>,
5062 bidirectional_iterator_tag> && ...))
5063 return bidirectional_iterator_tag{};
5064 else if constexpr ((derived_from<__range_iter_cat<_Vs, _Const>,
5065 forward_iterator_tag> && ...))
5066 return forward_iterator_tag{};
5068 return input_iterator_tag{};
5071 using iterator_category =
decltype(_S_iter_cat());
5074 template<
bool>
class _Iterator;
5075 template<
bool>
class _Sentinel;
5078 zip_transform_view() =
default;
5081 zip_transform_view(_Fp __fun, _Vs... __views)
5087 {
return _Iterator<false>(*
this, _M_zip.begin()); }
5091 requires range<const _InnerView>
5092 && regular_invocable<const _Fp&, range_reference_t<const _Vs>...>
5093 {
return _Iterator<true>(*
this, _M_zip.begin()); }
5098 if constexpr (common_range<_InnerView>)
5099 return _Iterator<false>(*
this, _M_zip.end());
5101 return _Sentinel<false>(_M_zip.end());
5106 requires range<const _InnerView>
5107 && regular_invocable<const _Fp&, range_reference_t<const _Vs>...>
5109 if constexpr (common_range<const _InnerView>)
5110 return _Iterator<true>(*
this, _M_zip.end());
5112 return _Sentinel<true>(_M_zip.end());
5116 size()
requires sized_range<_InnerView>
5117 {
return _M_zip.size(); }
5120 size() const requires sized_range<const _InnerView>
5121 {
return _M_zip.size(); }
5124 template<
class _Fp,
class... Rs>
5125 zip_transform_view(_Fp, Rs&&...) -> zip_transform_view<_Fp, views::all_t<Rs>...>;
5127 template<move_constructible _Fp, input_range... _Vs>
5128 requires (view<_Vs> && ...) && (
sizeof...(_Vs) > 0) && is_object_v<_Fp>
5129 && regular_invocable<_Fp&, range_reference_t<_Vs>...>
5130 && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Vs>...>>
5131 template<
bool _Const>
5132 class zip_transform_view<_Fp, _Vs...>::_Iterator :
public __iter_cat<_Const>
5134 using _Parent = __detail::__maybe_const_t<_Const, zip_transform_view>;
5136 _Parent* _M_parent =
nullptr;
5137 __ziperator<_Const> _M_inner;
5140 _Iterator(_Parent& __parent, __ziperator<_Const> __inner)
5144 friend class zip_transform_view;
5148 using iterator_concept =
typename __ziperator<_Const>::iterator_concept;
5150 = remove_cvref_t<invoke_result_t<__detail::__maybe_const_t<_Const, _Fp>&,
5151 range_reference_t<__detail::__maybe_const_t<_Const, _Vs>>...>>;
5152 using difference_type = range_difference_t<_Base<_Const>>;
5154 _Iterator() =
default;
5157 _Iterator(_Iterator<!_Const> __i)
5158 requires _Const && convertible_to<__ziperator<false>, __ziperator<_Const>>
5159 : _M_parent(__i._M_parent), _M_inner(
std::move(__i._M_inner))
5162 constexpr decltype(
auto)
5165 return std::apply([&](
const auto&... __iters) ->
decltype(
auto) {
5167 }, _M_inner._M_current);
5170 constexpr _Iterator&
5182 operator++(
int)
requires forward_range<_Base<_Const>>
5189 constexpr _Iterator&
5190 operator--()
requires bidirectional_range<_Base<_Const>>
5197 operator--(
int)
requires bidirectional_range<_Base<_Const>>
5204 constexpr _Iterator&
5205 operator+=(difference_type __x)
requires random_access_range<_Base<_Const>>
5211 constexpr _Iterator&
5212 operator-=(difference_type __x)
requires random_access_range<_Base<_Const>>
5218 constexpr decltype(
auto)
5219 operator[](difference_type __n)
const requires random_access_range<_Base<_Const>>
5221 return std::apply([&]<
typename... _Is>(
const _Is&... __iters) ->
decltype(
auto) {
5222 return std::__invoke(*_M_parent->_M_fun, __iters[iter_difference_t<_Is>(__n)]...);
5223 }, _M_inner._M_current);
5226 friend constexpr bool
5227 operator==(
const _Iterator& __x,
const _Iterator& __y)
5228 requires equality_comparable<__ziperator<_Const>>
5229 {
return __x._M_inner == __y._M_inner; }
5231 friend constexpr auto
5232 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
5233 requires random_access_range<_Base<_Const>>
5234 {
return __x._M_inner <=> __y._M_inner; }
5236 friend constexpr _Iterator
5237 operator+(
const _Iterator& __i, difference_type __n)
5238 requires random_access_range<_Base<_Const>>
5239 {
return _Iterator(*__i._M_parent, __i._M_inner + __n); }
5241 friend constexpr _Iterator
5242 operator+(difference_type __n,
const _Iterator& __i)
5243 requires random_access_range<_Base<_Const>>
5244 {
return _Iterator(*__i._M_parent, __i._M_inner + __n); }
5246 friend constexpr _Iterator
5247 operator-(
const _Iterator& __i, difference_type __n)
5248 requires random_access_range<_Base<_Const>>
5249 {
return _Iterator(*__i._M_parent, __i._M_inner - __n); }
5251 friend constexpr difference_type
5252 operator-(
const _Iterator& __x,
const _Iterator& __y)
5253 requires sized_sentinel_for<__ziperator<_Const>, __ziperator<_Const>>
5254 {
return __x._M_inner - __y._M_inner; }
5257 template<move_constructible _Fp, input_range... _Vs>
5258 requires (view<_Vs> && ...) && (
sizeof...(_Vs) > 0) && is_object_v<_Fp>
5259 && regular_invocable<_Fp&, range_reference_t<_Vs>...>
5260 && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Vs>...>>
5261 template<
bool _Const>
5262 class zip_transform_view<_Fp, _Vs...>::_Sentinel
5264 __zentinel<_Const> _M_inner;
5267 _Sentinel(__zentinel<_Const> __inner)
5271 friend class zip_transform_view;
5274 _Sentinel() =
default;
5277 _Sentinel(_Sentinel<!_Const> __i)
5278 requires _Const && convertible_to<__zentinel<false>, __zentinel<_Const>>
5282 template<
bool _OtherConst>
5283 requires sentinel_for<__zentinel<_Const>, __ziperator<_OtherConst>>
5284 friend constexpr bool
5285 operator==(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
5286 {
return __x._M_inner == __y._M_inner; }
5288 template<
bool _OtherConst>
5289 requires sized_sentinel_for<__zentinel<_Const>, __ziperator<_OtherConst>>
5290 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
5291 operator-(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
5292 {
return __x._M_inner - __y._M_inner; }
5294 template<
bool _OtherConst>
5295 requires sized_sentinel_for<__zentinel<_Const>, __ziperator<_OtherConst>>
5296 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
5297 operator-(
const _Sentinel& __x,
const _Iterator<_OtherConst>& __y)
5298 {
return __x._M_inner - __y._M_inner; }
5305 template<
typename _Fp,
typename... _Ts>
5306 concept __can_zip_transform_view
5307 =
requires { zip_transform_view(std::declval<_Fp>(), std::declval<_Ts>()...); };
5310 struct _ZipTransform
5312 template<
typename _Fp,
typename... _Ts>
5313 requires (
sizeof...(_Ts) == 0) || __detail::__can_zip_transform_view<_Fp, _Ts...>
5315 operator() [[nodiscard]] (_Fp&& __f, _Ts&&... __ts)
const
5317 if constexpr (
sizeof...(_Ts) == 0)
5318 return views::empty<decay_t<invoke_result_t<decay_t<_Fp>&>>>;
5320 return zip_transform_view(std::forward<_Fp>(__f), std::forward<_Ts>(__ts)...);
5324 inline constexpr _ZipTransform zip_transform;
5327 template<forward_range _Vp,
size_t _Nm>
5328 requires view<_Vp> && (_Nm > 0)
5329 class adjacent_view : public view_interface<adjacent_view<_Vp, _Nm>>
5331 _Vp _M_base = _Vp();
5333 template<
bool>
class _Iterator;
5334 template<
bool>
class _Sentinel;
5336 struct __as_sentinel
5340 adjacent_view()
requires default_initializable<_Vp> = default;
5343 adjacent_view(_Vp __base)
5344 : _M_base(
std::move(__base))
5350 base() const & requires copy_constructible<_Vp>
5358 begin()
requires (!__detail::__simple_view<_Vp>)
5359 {
return _Iterator<false>(ranges::begin(_M_base), ranges::end(_M_base)); }
5362 begin() const requires range<const _Vp>
5363 {
return _Iterator<true>(ranges::begin(_M_base), ranges::end(_M_base)); }
5366 end()
requires (!__detail::__simple_view<_Vp>)
5368 if constexpr (common_range<_Vp>)
5369 return _Iterator<false>(__as_sentinel{}, ranges::begin(_M_base), ranges::end(_M_base));
5371 return _Sentinel<false>(ranges::end(_M_base));
5375 end() const requires range<const _Vp>
5377 if constexpr (common_range<const _Vp>)
5378 return _Iterator<true>(__as_sentinel{}, ranges::begin(_M_base), ranges::end(_M_base));
5380 return _Sentinel<true>(ranges::end(_M_base));
5384 size()
requires sized_range<_Vp>
5386 using _ST =
decltype(ranges::size(_M_base));
5387 using _CT = common_type_t<_ST, size_t>;
5388 auto __sz =
static_cast<_CT
>(ranges::size(_M_base));
5389 __sz -= std::min<_CT>(__sz, _Nm - 1);
5390 return static_cast<_ST
>(__sz);
5394 size() const requires sized_range<const _Vp>
5396 using _ST =
decltype(ranges::size(_M_base));
5397 using _CT = common_type_t<_ST, size_t>;
5398 auto __sz =
static_cast<_CT
>(ranges::size(_M_base));
5399 __sz -= std::min<_CT>(__sz, _Nm - 1);
5400 return static_cast<_ST
>(__sz);
5404 template<
typename _Vp,
size_t _Nm>
5405 inline constexpr bool enable_borrowed_range<adjacent_view<_Vp, _Nm>>
5406 = enable_borrowed_range<_Vp>;
5411 template<
typename _Tp,
size_t _Nm>
5416 template<
typename _Fp,
size_t _Nm>
5419 template<
typename... _Ts>
5420 static invoke_result_t<_Fp, _Ts...>
5421 __tuple_apply(
const tuple<_Ts...>&);
5423 template<
typename _Tp>
5424 decltype(__tuple_apply(
std::declval<__repeated_tuple<_Tp, _Nm>>()))
5429 template<forward_range _Vp,
size_t _Nm>
5430 requires view<_Vp> && (_Nm > 0)
5431 template<bool _Const>
5432 class adjacent_view<_Vp, _Nm>::_Iterator
5434#ifdef _GLIBCXX_CLANG
5437 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
5438 array<iterator_t<_Base>, _Nm> _M_current = array<iterator_t<_Base>, _Nm>();
5441 _Iterator(iterator_t<_Base> __first, sentinel_t<_Base> __last)
5443 for (
auto& __i : _M_current)
5446 ranges::advance(__first, 1, __last);
5451 _Iterator(__as_sentinel, iterator_t<_Base> __first, iterator_t<_Base> __last)
5453 if constexpr (!bidirectional_range<_Base>)
5454 for (
auto& __it : _M_current)
5457 for (
size_t __i = 0; __i < _Nm; ++__i)
5459 _M_current[_Nm - 1 - __i] = __last;
5460 ranges::advance(__last, -1, __first);
5467 if constexpr (random_access_range<_Base>)
5468 return random_access_iterator_tag{};
5469 else if constexpr (bidirectional_range<_Base>)
5470 return bidirectional_iterator_tag{};
5472 return forward_iterator_tag{};
5475 friend class adjacent_view;
5477#ifndef _GLIBCXX_CLANG
5478 template<forward_range _Wp, move_constructible _Fp,
size_t _Mm>
5479 requires view<_Wp> && (_Mm > 0) && is_object_v<_Fp>
5480 && regular_invocable<__detail::__unarize<_Fp&, _Mm>, range_reference_t<_Wp>>
5481 && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Mm>,
5482 range_reference_t<_Wp>>>
5483 friend class adjacent_transform_view;
5487 using iterator_category = input_iterator_tag;
5488 using iterator_concept =
decltype(_S_iter_concept());
5490 pair<range_value_t<_Base>, range_value_t<_Base>>,
5491 __detail::__repeated_tuple<range_value_t<_Base>, _Nm>>;
5492 using difference_type = range_difference_t<_Base>;
5494 _Iterator() =
default;
5497 _Iterator(_Iterator<!_Const> __i)
5498 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
5500 for (
size_t __j = 0; __j < _Nm; ++__j)
5501 _M_current[__j] =
std::move(__i._M_current[__j]);
5507 auto __f = [](
auto& __i) ->
decltype(
auto) {
return *__i; };
5508 return __detail::__tuple_transform(__f, _M_current);
5511 constexpr _Iterator&
5514 for (
auto& __i : _M_current)
5527 constexpr _Iterator&
5528 operator--()
requires bidirectional_range<_Base>
5530 for (
auto& __i : _M_current)
5536 operator--(
int)
requires bidirectional_range<_Base>
5543 constexpr _Iterator&
5544 operator+=(difference_type __x)
5545 requires random_access_range<_Base>
5547 for (
auto& __i : _M_current)
5552 constexpr _Iterator&
5553 operator-=(difference_type __x)
5554 requires random_access_range<_Base>
5556 for (
auto& __i : _M_current)
5562 operator[](difference_type __n)
const
5563 requires random_access_range<_Base>
5565 auto __f = [&](
auto& __i) ->
decltype(
auto) {
return __i[__n]; };
5566 return __detail::__tuple_transform(__f, _M_current);
5569 friend constexpr bool
5570 operator==(
const _Iterator& __x,
const _Iterator& __y)
5571 {
return __x._M_current.back() == __y._M_current.back(); }
5573 friend constexpr bool
5574 operator<(
const _Iterator& __x,
const _Iterator& __y)
5575 requires random_access_range<_Base>
5576 {
return __x._M_current.back() < __y._M_current.back(); }
5578 friend constexpr bool
5579 operator>(
const _Iterator& __x,
const _Iterator& __y)
5580 requires random_access_range<_Base>
5581 {
return __y < __x; }
5583 friend constexpr bool
5584 operator<=(
const _Iterator& __x,
const _Iterator& __y)
5585 requires random_access_range<_Base>
5586 {
return !(__y < __x); }
5588 friend constexpr bool
5589 operator>=(
const _Iterator& __x,
const _Iterator& __y)
5590 requires random_access_range<_Base>
5591 {
return !(__x < __y); }
5593 friend constexpr auto
5594 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
5595 requires random_access_range<_Base>
5596 && three_way_comparable<iterator_t<_Base>>
5597 {
return __x._M_current.back() <=> __y._M_current.back(); }
5599 friend constexpr _Iterator
5600 operator+(
const _Iterator& __i, difference_type __n)
5601 requires random_access_range<_Base>
5608 friend constexpr _Iterator
5609 operator+(difference_type __n,
const _Iterator& __i)
5610 requires random_access_range<_Base>
5617 friend constexpr _Iterator
5618 operator-(
const _Iterator& __i, difference_type __n)
5619 requires random_access_range<_Base>
5626 friend constexpr difference_type
5627 operator-(
const _Iterator& __x,
const _Iterator& __y)
5628 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
5629 {
return __x._M_current.back() - __y._M_current.back(); }
5631 friend constexpr auto
5632 iter_move(
const _Iterator& __i)
5633 {
return __detail::__tuple_transform(ranges::iter_move, __i._M_current); }
5635 friend constexpr void
5636 iter_swap(
const _Iterator& __l,
const _Iterator& __r)
5637 requires indirectly_swappable<iterator_t<_Base>>
5639 for (
size_t __i = 0; __i < _Nm; __i++)
5640 ranges::iter_swap(__l._M_current[__i], __r._M_current[__i]);
5644 template<forward_range _Vp,
size_t _Nm>
5645 requires view<_Vp> && (_Nm > 0)
5646 template<bool _Const>
5647 class adjacent_view<_Vp, _Nm>::_Sentinel
5649 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
5651 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
5654 _Sentinel(sentinel_t<_Base> __end)
5658 friend class adjacent_view;
5661 _Sentinel() =
default;
5664 _Sentinel(_Sentinel<!_Const> __i)
5665 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
5669 template<
bool _OtherConst>
5670 requires sentinel_for<sentinel_t<_Base>,
5671 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
5672 friend constexpr bool
5673 operator==(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
5674 {
return __x._M_current.back() == __y._M_end; }
5676 template<
bool _OtherConst>
5677 requires sized_sentinel_for<sentinel_t<_Base>,
5678 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
5679 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _Vp>>
5680 operator-(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
5681 {
return __x._M_current.back() - __y._M_end; }
5683 template<
bool _OtherConst>
5684 requires sized_sentinel_for<sentinel_t<_Base>,
5685 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
5686 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _Vp>>
5687 operator-(
const _Sentinel& __y,
const _Iterator<_OtherConst>& __x)
5688 {
return __y._M_end - __x._M_current.back(); }
5695 template<
size_t _Nm,
typename _Range>
5696 concept __can_adjacent_view
5697 =
requires { adjacent_view<all_t<_Range>, _Nm>(std::declval<_Range>()); };
5700 template<
size_t _Nm>
5701 struct _Adjacent : __adaptor::_RangeAdaptorClosure<_Adjacent<_Nm>>
5703 template<viewable_range _Range>
5704 requires (_Nm == 0) || __detail::__can_adjacent_view<_Nm, _Range>
5706 operator() [[nodiscard]] (_Range&& __r)
const
5708 if constexpr (_Nm == 0)
5709 return views::empty<tuple<>>;
5711 return adjacent_view<all_t<_Range>, _Nm>(std::forward<_Range>(__r));
5715 template<
size_t _Nm>
5716 inline constexpr _Adjacent<_Nm> adjacent;
5718 inline constexpr auto pairwise = adjacent<2>;
5721 template<forward_range _Vp, move_constructible _Fp,
size_t _Nm>
5722 requires view<_Vp> && (_Nm > 0) && is_object_v<_Fp>
5723 && regular_invocable<__detail::__unarize<_Fp&, _Nm>, range_reference_t<_Vp>>
5724 && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Nm>,
5725 range_reference_t<_Vp>>>
5726 class adjacent_transform_view : public view_interface<adjacent_transform_view<_Vp, _Fp, _Nm>>
5728 [[no_unique_address]] __detail::__box<_Fp> _M_fun;
5729 adjacent_view<_Vp, _Nm> _M_inner;
5731 using _InnerView = adjacent_view<_Vp, _Nm>;
5733 template<
bool _Const>
5734 using _InnerIter = iterator_t<__detail::__maybe_const_t<_Const, _InnerView>>;
5736 template<
bool _Const>
5737 using _InnerSent = sentinel_t<__detail::__maybe_const_t<_Const, _InnerView>>;
5739 template<
bool>
class _Iterator;
5740 template<
bool>
class _Sentinel;
5743 adjacent_transform_view() =
default;
5746 adjacent_transform_view(_Vp __base, _Fp __fun)
5754 base() const & requires copy_constructible<_Vp>
5755 {
return _M_inner.base(); }
5763 {
return _Iterator<false>(*
this, _M_inner.begin()); }
5767 requires range<const _InnerView>
5768 && regular_invocable<__detail::__unarize<const _Fp&, _Nm>,
5769 range_reference_t<const _Vp>>
5770 {
return _Iterator<true>(*
this, _M_inner.begin()); }
5775 if constexpr (common_range<_InnerView>)
5776 return _Iterator<false>(*
this, _M_inner.end());
5778 return _Sentinel<false>(_M_inner.end());
5783 requires range<const _InnerView>
5784 && regular_invocable<__detail::__unarize<const _Fp&, _Nm>,
5785 range_reference_t<const _Vp>>
5787 if constexpr (common_range<const _InnerView>)
5788 return _Iterator<true>(*
this, _M_inner.end());
5790 return _Sentinel<true>(_M_inner.end());
5794 size()
requires sized_range<_InnerView>
5795 {
return _M_inner.size(); }
5798 size() const requires sized_range<const _InnerView>
5799 {
return _M_inner.size(); }
5802 template<forward_range _Vp, move_constructible _Fp,
size_t _Nm>
5803 requires view<_Vp> && (_Nm > 0) && is_object_v<_Fp>
5804 && regular_invocable<__detail::__unarize<_Fp&, _Nm>, range_reference_t<_Vp>>
5805 && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Nm>,
5806 range_reference_t<_Vp>>>
5807 template<bool _Const>
5808 class adjacent_transform_view<_Vp, _Fp, _Nm>::_Iterator
5810 using _Parent = __detail::__maybe_const_t<_Const, adjacent_transform_view>;
5811 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
5813 _Parent* _M_parent =
nullptr;
5814 _InnerIter<_Const> _M_inner;
5817 _Iterator(_Parent& __parent, _InnerIter<_Const> __inner)
5824 using __detail::__maybe_const_t;
5825 using __detail::__unarize;
5826 using _Res = invoke_result_t<__unarize<__maybe_const_t<_Const, _Fp>&, _Nm>,
5827 range_reference_t<_Base>>;
5828 using _Cat =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
5831 if constexpr (!is_reference_v<_Res>)
5832 return input_iterator_tag{};
5833 else if constexpr (derived_from<_Cat, random_access_iterator_tag>)
5834 return random_access_iterator_tag{};
5835 else if constexpr (derived_from<_Cat, bidirectional_iterator_tag>)
5836 return bidirectional_iterator_tag{};
5837 else if constexpr (derived_from<_Cat, forward_iterator_tag>)
5838 return forward_iterator_tag{};
5840 return input_iterator_tag{};
5843 friend class adjacent_transform_view;
5846 using iterator_category =
decltype(_S_iter_cat());
5847 using iterator_concept =
typename _InnerIter<_Const>::iterator_concept;
5849 = remove_cvref_t<invoke_result_t
5850 <__detail::__unarize<__detail::__maybe_const_t<_Const, _Fp>&, _Nm>,
5851 range_reference_t<_Base>>>;
5852 using difference_type = range_difference_t<_Base>;
5854 _Iterator() =
default;
5857 _Iterator(_Iterator<!_Const> __i)
5858 requires _Const && convertible_to<_InnerIter<false>, _InnerIter<_Const>>
5859 : _M_parent(__i._M_parent), _M_inner(
std::move(__i._M_inner))
5862 constexpr decltype(
auto)
5865 return std::apply([&](
const auto&... __iters) ->
decltype(
auto) {
5867 }, _M_inner._M_current);
5870 constexpr _Iterator&
5885 constexpr _Iterator&
5886 operator--()
requires bidirectional_range<_Base>
5893 operator--(
int)
requires bidirectional_range<_Base>
5900 constexpr _Iterator&
5901 operator+=(difference_type __x)
requires random_access_range<_Base>
5907 constexpr _Iterator&
5908 operator-=(difference_type __x)
requires random_access_range<_Base>
5914 constexpr decltype(
auto)
5915 operator[](difference_type __n)
const requires random_access_range<_Base>
5917 return std::apply([&](
const auto&... __iters) ->
decltype(
auto) {
5919 }, _M_inner._M_current);
5922 friend constexpr bool
5923 operator==(
const _Iterator& __x,
const _Iterator& __y)
5924 {
return __x._M_inner == __y._M_inner; }
5926 friend constexpr bool
5927 operator<(
const _Iterator& __x,
const _Iterator& __y)
5928 requires random_access_range<_Base>
5929 {
return __x._M_inner < __y._M_inner; }
5931 friend constexpr bool
5932 operator>(
const _Iterator& __x,
const _Iterator& __y)
5933 requires random_access_range<_Base>
5934 {
return __x._M_inner > __y._M_inner; }
5936 friend constexpr bool
5937 operator<=(
const _Iterator& __x,
const _Iterator& __y)
5938 requires random_access_range<_Base>
5939 {
return __x._M_inner <= __y._M_inner; }
5941 friend constexpr bool
5942 operator>=(
const _Iterator& __x,
const _Iterator& __y)
5943 requires random_access_range<_Base>
5944 {
return __x._M_inner >= __y._M_inner; }
5946 friend constexpr auto
5947 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
5948 requires random_access_range<_Base> &&
5949 three_way_comparable<_InnerIter<_Const>>
5950 {
return __x._M_inner <=> __y._M_inner; }
5952 friend constexpr _Iterator
5953 operator+(
const _Iterator& __i, difference_type __n)
5954 requires random_access_range<_Base>
5955 {
return _Iterator(*__i._M_parent, __i._M_inner + __n); }
5957 friend constexpr _Iterator
5958 operator+(difference_type __n,
const _Iterator& __i)
5959 requires random_access_range<_Base>
5960 {
return _Iterator(*__i._M_parent, __i._M_inner + __n); }
5962 friend constexpr _Iterator
5963 operator-(
const _Iterator& __i, difference_type __n)
5964 requires random_access_range<_Base>
5965 {
return _Iterator(*__i._M_parent, __i._M_inner - __n); }
5967 friend constexpr difference_type
5968 operator-(
const _Iterator& __x,
const _Iterator& __y)
5969 requires sized_sentinel_for<_InnerIter<_Const>, _InnerIter<_Const>>
5970 {
return __x._M_inner - __y._M_inner; }
5973 template<forward_range _Vp, move_constructible _Fp,
size_t _Nm>
5974 requires view<_Vp> && (_Nm > 0) && is_object_v<_Fp>
5975 && regular_invocable<__detail::__unarize<_Fp&, _Nm>, range_reference_t<_Vp>>
5976 && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Nm>,
5977 range_reference_t<_Vp>>>
5978 template<bool _Const>
5979 class adjacent_transform_view<_Vp, _Fp, _Nm>::_Sentinel
5981 _InnerSent<_Const> _M_inner;
5984 _Sentinel(_InnerSent<_Const> __inner)
5988 friend class adjacent_transform_view;
5991 _Sentinel() =
default;
5994 _Sentinel(_Sentinel<!_Const> __i)
5995 requires _Const && convertible_to<_InnerSent<false>, _InnerSent<_Const>>
5999 template<
bool _OtherConst>
6000 requires sentinel_for<_InnerSent<_Const>, _InnerIter<_OtherConst>>
6001 friend constexpr bool
6002 operator==(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
6003 {
return __x._M_inner == __y._M_inner; }
6005 template<
bool _OtherConst>
6006 requires sized_sentinel_for<_InnerSent<_Const>, _InnerIter<_OtherConst>>
6007 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
6008 operator-(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
6009 {
return __x._M_inner - __y._M_inner; }
6011 template<
bool _OtherConst>
6012 requires sized_sentinel_for<_InnerSent<_Const>, _InnerIter<_OtherConst>>
6013 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
6014 operator-(
const _Sentinel& __x,
const _Iterator<_OtherConst>& __y)
6015 {
return __x._M_inner - __y._M_inner; }
6022 template<
size_t _Nm,
typename _Range,
typename _Fp>
6023 concept __can_adjacent_transform_view
6024 =
requires { adjacent_transform_view<all_t<_Range>, decay_t<_Fp>, _Nm>
6025 (std::declval<_Range>(), std::declval<_Fp>()); };
6028 template<
size_t _Nm>
6029 struct _AdjacentTransform : __adaptor::_RangeAdaptor<_AdjacentTransform<_Nm>>
6031 template<viewable_range _Range,
typename _Fp>
6032 requires (_Nm == 0) || __detail::__can_adjacent_transform_view<_Nm, _Range, _Fp>
6034 operator() [[nodiscard]] (_Range&& __r, _Fp&& __f)
const
6036 if constexpr (_Nm == 0)
6037 return zip_transform(std::forward<_Fp>(__f));
6039 return adjacent_transform_view<all_t<_Range>, decay_t<_Fp>, _Nm>
6040 (std::forward<_Range>(__r), std::forward<_Fp>(__f));
6043 using __adaptor::_RangeAdaptor<_AdjacentTransform>::operator();
6044 static constexpr int _S_arity = 2;
6045 static constexpr bool _S_has_simple_extra_args =
true;
6048 template<
size_t _Nm>
6049 inline constexpr _AdjacentTransform<_Nm> adjacent_transform;
6051 inline constexpr auto pairwise_transform = adjacent_transform<2>;
6055#ifdef __cpp_lib_ranges_chunk
6058 template<
typename _Tp>
6059 constexpr _Tp __div_ceil(_Tp __num, _Tp __denom)
6061 _Tp __r = __num / __denom;
6062 if (__num % __denom)
6069 requires input_range<_Vp>
6070 class chunk_view :
public view_interface<chunk_view<_Vp>>
6073 range_difference_t<_Vp> _M_n;
6074 range_difference_t<_Vp> _M_remainder = 0;
6075 __detail::__non_propagating_cache<iterator_t<_Vp>> _M_current;
6082 chunk_view(_Vp __base, range_difference_t<_Vp> __n)
6084 { __glibcxx_assert(__n >= 0); }
6087 base() const & requires copy_constructible<_Vp>
6094 constexpr _OuterIter
6097 _M_current = ranges::begin(_M_base);
6098 _M_remainder = _M_n;
6099 return _OuterIter(*
this);
6102 constexpr default_sentinel_t
6103 end() const noexcept
6107 size()
requires sized_range<_Vp>
6109 return __detail::__to_unsigned_like(__detail::__div_ceil
6110 (ranges::distance(_M_base), _M_n));
6114 size() const requires sized_range<const _Vp>
6116 return __detail::__to_unsigned_like(__detail::__div_ceil
6117 (ranges::distance(_M_base), _M_n));
6121 template<
typename _Range>
6122 chunk_view(_Range&&, range_difference_t<_Range>) -> chunk_view<views::all_t<_Range>>;
6125 requires input_range<_Vp>
6126 class chunk_view<_Vp>::_OuterIter
6128 chunk_view* _M_parent;
6131 _OuterIter(chunk_view& __parent) noexcept
6138 using iterator_concept = input_iterator_tag;
6139 using difference_type = range_difference_t<_Vp>;
6143 _OuterIter(_OuterIter&&) =
default;
6144 _OuterIter& operator=(_OuterIter&&) =
default;
6146 constexpr value_type
6149 __glibcxx_assert(*
this != default_sentinel);
6150 return value_type(*_M_parent);
6153 constexpr _OuterIter&
6156 __glibcxx_assert(*
this != default_sentinel);
6157 ranges::advance(*_M_parent->_M_current, _M_parent->_M_remainder,
6158 ranges::end(_M_parent->_M_base));
6159 _M_parent->_M_remainder = _M_parent->_M_n;
6167 friend constexpr bool
6168 operator==(
const _OuterIter& __x, default_sentinel_t)
6170 return *__x._M_parent->_M_current == ranges::end(__x._M_parent->_M_base)
6171 && __x._M_parent->_M_remainder != 0;
6174 friend constexpr difference_type
6175 operator-(default_sentinel_t,
const _OuterIter& __x)
6176 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6178 const auto __dist = ranges::end(__x._M_parent->_M_base) - *__x._M_parent->_M_current;
6180 if (__dist < __x._M_parent->_M_remainder)
6181 return __dist == 0 ? 0 : 1;
6183 return 1 + __detail::__div_ceil(__dist - __x._M_parent->_M_remainder,
6184 __x._M_parent->_M_n);
6187 friend constexpr difference_type
6188 operator-(
const _OuterIter& __x, default_sentinel_t __y)
6189 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6190 {
return -(__y - __x); }
6194 requires input_range<_Vp>
6195 struct chunk_view<_Vp>::_OuterIter::value_type : view_interface<value_type>
6198 chunk_view* _M_parent;
6201 value_type(chunk_view& __parent) noexcept
6208 constexpr _InnerIter
6209 begin() const noexcept
6210 {
return _InnerIter(*_M_parent); }
6212 constexpr default_sentinel_t
6213 end() const noexcept
6218 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6220 return __detail::__to_unsigned_like
6221 (ranges::min(_M_parent->_M_remainder,
6222 ranges::end(_M_parent->_M_base) - *_M_parent->_M_current));
6227 requires input_range<_Vp>
6228 class chunk_view<_Vp>::_InnerIter
6230 chunk_view* _M_parent;
6233 _InnerIter(chunk_view& __parent) noexcept
6237 friend _OuterIter::value_type;
6240 using iterator_concept = input_iterator_tag;
6241 using difference_type = range_difference_t<_Vp>;
6242 using value_type = range_value_t<_Vp>;
6244 _InnerIter(_InnerIter&&) =
default;
6245 _InnerIter& operator=(_InnerIter&&) =
default;
6247 constexpr const iterator_t<_Vp>&
6249 {
return *_M_parent->_M_current; }
6251 constexpr range_reference_t<_Vp>
6254 __glibcxx_assert(*
this != default_sentinel);
6255 return **_M_parent->_M_current;
6258 constexpr _InnerIter&
6261 __glibcxx_assert(*
this != default_sentinel);
6262 ++*_M_parent->_M_current;
6263 if (*_M_parent->_M_current == ranges::end(_M_parent->_M_base))
6264 _M_parent->_M_remainder = 0;
6266 --_M_parent->_M_remainder;
6274 friend constexpr bool
6275 operator==(
const _InnerIter& __x, default_sentinel_t)
noexcept
6276 {
return __x._M_parent->_M_remainder == 0; }
6278 friend constexpr difference_type
6279 operator-(default_sentinel_t,
const _InnerIter& __x)
6280 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6282 return ranges::min(__x._M_parent->_M_remainder,
6283 ranges::end(__x._M_parent->_M_base) - *__x._M_parent->_M_current);
6286 friend constexpr difference_type
6287 operator-(
const _InnerIter& __x, default_sentinel_t __y)
6288 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6289 {
return -(__y - __x); }
6293 friend constexpr range_rvalue_reference_t<_Vp>
6294 iter_move(
const _InnerIter& __i)
6295 noexcept(
noexcept(ranges::iter_move(*__i._M_parent->_M_current)))
6296 {
return ranges::iter_move(*__i._M_parent->_M_current); }
6298 friend constexpr void
6299 iter_swap(
const _InnerIter& __x,
const _InnerIter& __y)
6300 noexcept(
noexcept(ranges::iter_swap(*__x._M_parent->_M_current,
6301 *__x._M_parent->_M_current)))
6302 requires indirectly_swappable<iterator_t<_Vp>>
6303 {
return ranges::iter_swap(*__x._M_parent->_M_current, *__y._M_parent->_M_current); }
6307 requires forward_range<_Vp>
6308 class chunk_view<_Vp> :
public view_interface<chunk_view<_Vp>>
6311 range_difference_t<_Vp> _M_n;
6312 template<
bool>
class _Iterator;
6316 chunk_view(_Vp __base, range_difference_t<_Vp> __n)
6318 { __glibcxx_assert(__n > 0); }
6321 base() const & requires copy_constructible<_Vp>
6329 begin()
requires (!__detail::__simple_view<_Vp>)
6330 {
return _Iterator<false>(
this, ranges::begin(_M_base)); }
6333 begin() const requires forward_range<const _Vp>
6334 {
return _Iterator<true>(
this, ranges::begin(_M_base)); }
6337 end()
requires (!__detail::__simple_view<_Vp>)
6339 if constexpr (common_range<_Vp> && sized_range<_Vp>)
6341 auto __missing = (_M_n - ranges::distance(_M_base) % _M_n) % _M_n;
6342 return _Iterator<false>(
this, ranges::end(_M_base), __missing);
6344 else if constexpr (common_range<_Vp> && !bidirectional_range<_Vp>)
6345 return _Iterator<false>(
this, ranges::end(_M_base));
6351 end() const requires forward_range<const _Vp>
6353 if constexpr (common_range<const _Vp> && sized_range<const _Vp>)
6355 auto __missing = (_M_n - ranges::distance(_M_base) % _M_n) % _M_n;
6356 return _Iterator<true>(
this, ranges::end(_M_base), __missing);
6358 else if constexpr (common_range<const _Vp> && !bidirectional_range<const _Vp>)
6359 return _Iterator<true>(
this, ranges::end(_M_base));
6365 size()
requires sized_range<_Vp>
6367 return __detail::__to_unsigned_like(__detail::__div_ceil
6368 (ranges::distance(_M_base), _M_n));
6372 size() const requires sized_range<const _Vp>
6374 return __detail::__to_unsigned_like(__detail::__div_ceil
6375 (ranges::distance(_M_base), _M_n));
6379 template<
typename _Vp>
6380 inline constexpr bool enable_borrowed_range<chunk_view<_Vp>>
6381 = forward_range<_Vp> && enable_borrowed_range<_Vp>;
6384 requires forward_range<_Vp>
6385 template<
bool _Const>
6386 class chunk_view<_Vp>::_Iterator
6388 using _Parent = __detail::__maybe_const_t<_Const, chunk_view>;
6389 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
6391 iterator_t<_Base> _M_current = iterator_t<_Base>();
6392 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
6393 range_difference_t<_Base> _M_n = 0;
6394 range_difference_t<_Base> _M_missing = 0;
6397 _Iterator(_Parent* __parent, iterator_t<_Base> __current,
6398 range_difference_t<_Base> __missing = 0)
6399 : _M_current(__current), _M_end(ranges::
end(__parent->_M_base)),
6400 _M_n(__parent->_M_n), _M_missing(__missing)
6406 if constexpr (random_access_range<_Base>)
6407 return random_access_iterator_tag{};
6408 else if constexpr (bidirectional_range<_Base>)
6409 return bidirectional_iterator_tag{};
6411 return forward_iterator_tag{};
6417 using iterator_category = input_iterator_tag;
6418 using iterator_concept =
decltype(_S_iter_cat());
6419 using value_type =
decltype(views::take(subrange(_M_current, _M_end), _M_n));
6420 using difference_type = range_difference_t<_Base>;
6422 _Iterator() =
default;
6424 constexpr _Iterator(_Iterator<!_Const> __i)
6426 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
6427 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
6429 _M_n(__i._M_n), _M_missing(__i._M_missing)
6432 constexpr iterator_t<_Base>
6434 {
return _M_current; }
6436 constexpr value_type
6439 __glibcxx_assert(_M_current != _M_end);
6440 return views::take(subrange(_M_current, _M_end), _M_n);
6443 constexpr _Iterator&
6446 __glibcxx_assert(_M_current != _M_end);
6447 _M_missing = ranges::advance(_M_current, _M_n, _M_end);
6459 constexpr _Iterator&
6460 operator--()
requires bidirectional_range<_Base>
6462 ranges::advance(_M_current, _M_missing - _M_n);
6468 operator--(
int)
requires bidirectional_range<_Base>
6475 constexpr _Iterator&
6476 operator+=(difference_type __x)
6477 requires random_access_range<_Base>
6481 __glibcxx_assert(ranges::distance(_M_current, _M_end) > _M_n * (__x - 1));
6482 _M_missing = ranges::advance(_M_current, _M_n * __x, _M_end);
6486 ranges::advance(_M_current, _M_n * __x + _M_missing);
6492 constexpr _Iterator&
6493 operator-=(difference_type __x)
6494 requires random_access_range<_Base>
6495 {
return *
this += -__x; }
6497 constexpr value_type
6498 operator[](difference_type __n)
const
6499 requires random_access_range<_Base>
6500 {
return *(*
this + __n); }
6502 friend constexpr bool
6503 operator==(
const _Iterator& __x,
const _Iterator& __y)
6504 {
return __x._M_current == __y._M_current; }
6506 friend constexpr bool
6507 operator==(
const _Iterator& __x, default_sentinel_t)
6508 {
return __x._M_current == __x._M_end; }
6510 friend constexpr bool
6511 operator<(
const _Iterator& __x,
const _Iterator& __y)
6512 requires random_access_range<_Base>
6513 {
return __x._M_current > __y._M_current; }
6515 friend constexpr bool
6516 operator>(
const _Iterator& __x,
const _Iterator& __y)
6517 requires random_access_range<_Base>
6518 {
return __y < __x; }
6520 friend constexpr bool
6521 operator<=(
const _Iterator& __x,
const _Iterator& __y)
6522 requires random_access_range<_Base>
6523 {
return !(__y < __x); }
6525 friend constexpr bool
6526 operator>=(
const _Iterator& __x,
const _Iterator& __y)
6527 requires random_access_range<_Base>
6528 {
return !(__x < __y); }
6530 friend constexpr auto
6531 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
6532 requires random_access_range<_Base>
6533 && three_way_comparable<iterator_t<_Base>>
6534 {
return __x._M_current <=> __y._M_current; }
6536 friend constexpr _Iterator
6537 operator+(
const _Iterator& __i, difference_type __n)
6538 requires random_access_range<_Base>
6545 friend constexpr _Iterator
6546 operator+(difference_type __n,
const _Iterator& __i)
6547 requires random_access_range<_Base>
6554 friend constexpr _Iterator
6555 operator-(
const _Iterator& __i, difference_type __n)
6556 requires random_access_range<_Base>
6563 friend constexpr difference_type
6564 operator-(
const _Iterator& __x,
const _Iterator& __y)
6565 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
6567 return (__x._M_current - __y._M_current
6568 + __x._M_missing - __y._M_missing) / __x._M_n;
6571 friend constexpr difference_type
6572 operator-(default_sentinel_t __y,
const _Iterator& __x)
6573 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
6574 {
return __detail::__div_ceil(__x._M_end - __x._M_current, __x._M_n); }
6576 friend constexpr difference_type
6577 operator-(
const _Iterator& __x, default_sentinel_t __y)
6578 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
6579 {
return -(__y - __x); }
6586 template<
typename _Range,
typename _Dp>
6587 concept __can_chunk_view
6588 =
requires { chunk_view(std::declval<_Range>(), std::declval<_Dp>()); };
6591 struct _Chunk : __adaptor::_RangeAdaptor<_Chunk>
6593 template<viewable_range _Range,
typename _Dp = range_difference_t<_Range>>
6594 requires __detail::__can_chunk_view<_Range, _Dp>
6596 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n)
const
6597 {
return chunk_view(std::forward<_Range>(__r), __n); }
6599 using __adaptor::_RangeAdaptor<_Chunk>::operator();
6600 static constexpr int _S_arity = 2;
6601 static constexpr bool _S_has_simple_extra_args =
true;
6604 inline constexpr _Chunk chunk;
6608#ifdef __cpp_lib_ranges_slide
6611 template<
typename _Vp>
6612 concept __slide_caches_nothing = random_access_range<_Vp> && sized_range<_Vp>;
6614 template<
typename _Vp>
6615 concept __slide_caches_last
6616 = !__slide_caches_nothing<_Vp> && bidirectional_range<_Vp> && common_range<_Vp>;
6618 template<
typename _Vp>
6619 concept __slide_caches_first
6620 = !__slide_caches_nothing<_Vp> && !__slide_caches_last<_Vp>;
6623 template<forward_range _Vp>
6625 class slide_view :
public view_interface<slide_view<_Vp>>
6628 range_difference_t<_Vp> _M_n;
6629 [[no_unique_address]]
6630 __detail::__maybe_present_t<__detail::__slide_caches_first<_Vp>,
6631 __detail::_CachedPosition<_Vp>, 0> _M_cached_begin;
6632 [[no_unique_address]]
6633 __detail::__maybe_present_t<__detail::__slide_caches_last<_Vp>,
6634 __detail::_CachedPosition<_Vp>, 1> _M_cached_end;
6636 template<
bool>
class _Iterator;
6641 slide_view(_Vp __base, range_difference_t<_Vp> __n)
6643 { __glibcxx_assert(__n > 0); }
6648 base() const & requires copy_constructible<_Vp>
6656 begin()
requires (!(__detail::__simple_view<_Vp>
6657 && __detail::__slide_caches_nothing<const _Vp>))
6659 if constexpr (__detail::__slide_caches_first<_Vp>)
6661 iterator_t<_Vp> __it;
6662 if (_M_cached_begin._M_has_value())
6663 __it = _M_cached_begin._M_get(_M_base);
6666 __it = ranges::next(ranges::begin(_M_base), _M_n - 1, ranges::end(_M_base));
6667 _M_cached_begin._M_set(_M_base, __it);
6669 return _Iterator<false>(ranges::begin(_M_base),
std::move(__it), _M_n);
6672 return _Iterator<false>(ranges::begin(_M_base), _M_n);
6676 begin() const requires __detail::__slide_caches_nothing<const _Vp>
6677 {
return _Iterator<true>(ranges::begin(_M_base), _M_n); }
6680 end()
requires (!(__detail::__simple_view<_Vp>
6681 && __detail::__slide_caches_nothing<const _Vp>))
6683 if constexpr (__detail::__slide_caches_nothing<_Vp>)
6684 return _Iterator<false>(ranges::begin(_M_base) + range_difference_t<_Vp>(
size()),
6686 else if constexpr (__detail::__slide_caches_last<_Vp>)
6688 iterator_t<_Vp> __it;
6689 if (_M_cached_end._M_has_value())
6690 __it = _M_cached_end._M_get(_M_base);
6693 __it = ranges::prev(ranges::end(_M_base), _M_n - 1, ranges::begin(_M_base));
6694 _M_cached_end._M_set(_M_base, __it);
6696 return _Iterator<false>(
std::move(__it), _M_n);
6698 else if constexpr (common_range<_Vp>)
6699 return _Iterator<false>(ranges::end(_M_base), ranges::end(_M_base), _M_n);
6701 return _Sentinel(ranges::end(_M_base));
6705 end() const requires __detail::__slide_caches_nothing<const _Vp>
6706 {
return begin() + range_difference_t<const _Vp>(
size()); }
6709 size()
requires sized_range<_Vp>
6711 auto __sz = ranges::distance(_M_base) - _M_n + 1;
6714 return __detail::__to_unsigned_like(__sz);
6718 size() const requires sized_range<const _Vp>
6720 auto __sz = ranges::distance(_M_base) - _M_n + 1;
6723 return __detail::__to_unsigned_like(__sz);
6727 template<
typename _Range>
6728 slide_view(_Range&&, range_difference_t<_Range>) -> slide_view<views::all_t<_Range>>;
6730 template<
typename _Vp>
6731 inline constexpr bool enable_borrowed_range<slide_view<_Vp>>
6732 = enable_borrowed_range<_Vp>;
6734 template<forward_range _Vp>
6736 template<
bool _Const>
6737 class slide_view<_Vp>::_Iterator
6739 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
6740 static constexpr bool _S_last_elt_present
6741 = __detail::__slide_caches_first<_Base>;
6743 iterator_t<_Base> _M_current = iterator_t<_Base>();
6744 [[no_unique_address]]
6745 __detail::__maybe_present_t<_S_last_elt_present, iterator_t<_Base>>
6746 _M_last_elt =
decltype(_M_last_elt)();
6747 range_difference_t<_Base> _M_n = 0;
6750 _Iterator(iterator_t<_Base> __current, range_difference_t<_Base> __n)
6751 requires (!_S_last_elt_present)
6752 : _M_current(__current), _M_n(__n)
6756 _Iterator(iterator_t<_Base> __current, iterator_t<_Base> __last_elt,
6757 range_difference_t<_Base> __n)
6758 requires _S_last_elt_present
6759 : _M_current(__current), _M_last_elt(__last_elt), _M_n(__n)
6765 if constexpr (random_access_range<_Base>)
6766 return random_access_iterator_tag{};
6767 else if constexpr (bidirectional_range<_Base>)
6768 return bidirectional_iterator_tag{};
6770 return forward_iterator_tag{};
6774 friend slide_view::_Sentinel;
6777 using iterator_category = input_iterator_tag;
6778 using iterator_concept =
decltype(_S_iter_concept());
6779 using value_type =
decltype(views::counted(_M_current, _M_n));
6780 using difference_type = range_difference_t<_Base>;
6782 _Iterator() =
default;
6785 _Iterator(_Iterator<!_Const> __i)
6786 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
6787 : _M_current(
std::move(__i._M_current)), _M_n(__i._M_n)
6792 {
return views::counted(_M_current, _M_n); }
6794 constexpr _Iterator&
6798 if constexpr (_S_last_elt_present)
6811 constexpr _Iterator&
6812 operator--()
requires bidirectional_range<_Base>
6815 if constexpr (_S_last_elt_present)
6821 operator--(
int)
requires bidirectional_range<_Base>
6828 constexpr _Iterator&
6829 operator+=(difference_type __x)
6830 requires random_access_range<_Base>
6833 if constexpr (_S_last_elt_present)
6838 constexpr _Iterator&
6839 operator-=(difference_type __x)
6840 requires random_access_range<_Base>
6843 if constexpr (_S_last_elt_present)
6849 operator[](difference_type __n)
const
6850 requires random_access_range<_Base>
6851 {
return views::counted(_M_current + __n, _M_n); }
6853 friend constexpr bool
6854 operator==(
const _Iterator& __x,
const _Iterator& __y)
6856 if constexpr (_S_last_elt_present)
6857 return __x._M_last_elt == __y._M_last_elt;
6859 return __x._M_current == __y._M_current;
6862 friend constexpr bool
6863 operator<(
const _Iterator& __x,
const _Iterator& __y)
6864 requires random_access_range<_Base>
6865 {
return __x._M_current < __y._M_current; }
6867 friend constexpr bool
6868 operator>(
const _Iterator& __x,
const _Iterator& __y)
6869 requires random_access_range<_Base>
6870 {
return __y < __x; }
6872 friend constexpr bool
6873 operator<=(
const _Iterator& __x,
const _Iterator& __y)
6874 requires random_access_range<_Base>
6875 {
return !(__y < __x); }
6877 friend constexpr bool
6878 operator>=(
const _Iterator& __x,
const _Iterator& __y)
6879 requires random_access_range<_Base>
6880 {
return !(__x < __y); }
6882 friend constexpr auto
6883 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
6884 requires random_access_range<_Base>
6885 && three_way_comparable<iterator_t<_Base>>
6886 {
return __x._M_current <=> __y._M_current; }
6888 friend constexpr _Iterator
6889 operator+(
const _Iterator& __i, difference_type __n)
6890 requires random_access_range<_Base>
6897 friend constexpr _Iterator
6898 operator+(difference_type __n,
const _Iterator& __i)
6899 requires random_access_range<_Base>
6906 friend constexpr _Iterator
6907 operator-(
const _Iterator& __i, difference_type __n)
6908 requires random_access_range<_Base>
6915 friend constexpr difference_type
6916 operator-(
const _Iterator& __x,
const _Iterator& __y)
6917 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
6919 if constexpr (_S_last_elt_present)
6920 return __x._M_last_elt - __y._M_last_elt;
6922 return __x._M_current - __y._M_current;
6926 template<forward_range _Vp>
6928 class slide_view<_Vp>::_Sentinel
6930 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
6933 _Sentinel(sentinel_t<_Vp> __end)
6940 _Sentinel() =
default;
6942 friend constexpr bool
6943 operator==(
const _Iterator<false>& __x,
const _Sentinel& __y)
6944 {
return __x._M_last_elt == __y._M_end; }
6946 friend constexpr range_difference_t<_Vp>
6947 operator-(
const _Iterator<false>& __x,
const _Sentinel& __y)
6948 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6949 {
return __x._M_last_elt - __y._M_end; }
6951 friend constexpr range_difference_t<_Vp>
6952 operator-(
const _Sentinel& __y,
const _Iterator<false>& __x)
6953 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6954 {
return __y._M_end -__x._M_last_elt; }
6961 template<
typename _Range,
typename _Dp>
6962 concept __can_slide_view
6963 =
requires { slide_view(std::declval<_Range>(), std::declval<_Dp>()); };
6966 struct _Slide : __adaptor::_RangeAdaptor<_Slide>
6968 template<viewable_range _Range,
typename _Dp = range_difference_t<_Range>>
6969 requires __detail::__can_slide_view<_Range, _Dp>
6971 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n)
const
6972 {
return slide_view(std::forward<_Range>(__r), __n); }
6974 using __adaptor::_RangeAdaptor<_Slide>::operator();
6975 static constexpr int _S_arity = 2;
6976 static constexpr bool _S_has_simple_extra_args =
true;
6979 inline constexpr _Slide slide;
6983#ifdef __cpp_lib_ranges_chunk_by
6984 template<forward_range _Vp,
6985 indirect_binary_predicate<iterator_t<_Vp>, iterator_t<_Vp>> _Pred>
6986 requires view<_Vp> && is_object_v<_Pred>
6987 class chunk_by_view :
public view_interface<chunk_by_view<_Vp, _Pred>>
6989 _Vp _M_base = _Vp();
6990 __detail::__box<_Pred> _M_pred;
6991 __detail::_CachedPosition<_Vp> _M_cached_begin;
6993 constexpr iterator_t<_Vp>
6994 _M_find_next(iterator_t<_Vp> __current)
6996 __glibcxx_assert(_M_pred.has_value());
6997 auto __pred = [
this]<
typename _Tp,
typename _Up>(_Tp&& __x, _Up&& __y) {
6998 return !bool((*_M_pred)(std::forward<_Tp>(__x), std::forward<_Up>(__y)));
7000 auto __it = ranges::adjacent_find(__current, ranges::end(_M_base), __pred);
7001 return ranges::next(__it, 1, ranges::end(_M_base));
7004 constexpr iterator_t<_Vp>
7005 _M_find_prev(iterator_t<_Vp> __current)
requires bidirectional_range<_Vp>
7007 __glibcxx_assert(_M_pred.has_value());
7008 auto __pred = [
this]<
typename _Tp,
typename _Up>(_Tp&& __x, _Up&& __y) {
7009 return !bool((*_M_pred)(std::forward<_Up>(__y), std::forward<_Tp>(__x)));
7013 __glibcxx_assert(__rbegin != __rend);
7014 auto __it = ranges::adjacent_find(__rbegin, __rend, __pred).base();
7015 return ranges::prev(__it, 1, ranges::begin(_M_base));
7021 chunk_by_view()
requires (default_initializable<_Vp>
7022 && default_initializable<_Pred>)
7026 chunk_by_view(_Vp __base, _Pred __pred)
7031 base() const & requires copy_constructible<_Vp>
7038 constexpr const _Pred&
7040 {
return *_M_pred; }
7045 __glibcxx_assert(_M_pred.has_value());
7046 iterator_t<_Vp> __it;
7047 if (_M_cached_begin._M_has_value())
7048 __it = _M_cached_begin._M_get(_M_base);
7051 __it = _M_find_next(ranges::begin(_M_base));
7052 _M_cached_begin._M_set(_M_base, __it);
7054 return _Iterator(*
this, ranges::begin(_M_base), __it);
7060 if constexpr (common_range<_Vp>)
7061 return _Iterator(*
this, ranges::end(_M_base), ranges::end(_M_base));
7067 template<
typename _Range,
typename _Pred>
7068 chunk_by_view(_Range&&, _Pred) -> chunk_by_view<views::all_t<_Range>, _Pred>;
7070 template<forward_range _Vp,
7071 indirect_binary_predicate<iterator_t<_Vp>, iterator_t<_Vp>> _Pred>
7072 requires view<_Vp> && is_object_v<_Pred>
7073 class chunk_by_view<_Vp, _Pred>::_Iterator
7075 chunk_by_view* _M_parent =
nullptr;
7076 iterator_t<_Vp> _M_current = iterator_t<_Vp>();
7077 iterator_t<_Vp> _M_next = iterator_t<_Vp>();
7080 _Iterator(chunk_by_view& __parent, iterator_t<_Vp> __current, iterator_t<_Vp> __next)
7081 : _M_parent(
std::
__addressof(__parent)), _M_current(__current), _M_next(__next)
7087 if constexpr (bidirectional_range<_Vp>)
7088 return bidirectional_iterator_tag{};
7090 return forward_iterator_tag{};
7093 friend chunk_by_view;
7096 using value_type = subrange<iterator_t<_Vp>>;
7097 using difference_type = range_difference_t<_Vp>;
7098 using iterator_category = input_iterator_tag;
7099 using iterator_concept =
decltype(_S_iter_concept());
7101 _Iterator() =
default;
7103 constexpr value_type
7106 __glibcxx_assert(_M_current != _M_next);
7107 return ranges::subrange(_M_current, _M_next);
7110 constexpr _Iterator&
7113 __glibcxx_assert(_M_current != _M_next);
7114 _M_current = _M_next;
7115 _M_next = _M_parent->_M_find_next(_M_current);
7127 constexpr _Iterator&
7128 operator--()
requires bidirectional_range<_Vp>
7130 _M_next = _M_current;
7131 _M_current = _M_parent->_M_find_prev(_M_next);
7136 operator--(
int)
requires bidirectional_range<_Vp>
7143 friend constexpr bool
7144 operator==(
const _Iterator& __x,
const _Iterator& __y)
7145 {
return __x._M_current == __y._M_current; }
7147 friend constexpr bool
7148 operator==(
const _Iterator& __x, default_sentinel_t)
7149 {
return __x._M_current == __x._M_next; }
7156 template<
typename _Range,
typename _Pred>
7157 concept __can_chunk_by_view
7158 =
requires { chunk_by_view(std::declval<_Range>(), std::declval<_Pred>()); };
7161 struct _ChunkBy : __adaptor::_RangeAdaptor<_ChunkBy>
7163 template<viewable_range _Range,
typename _Pred>
7164 requires __detail::__can_chunk_by_view<_Range, _Pred>
7166 operator() [[nodiscard]] (_Range&& __r, _Pred&& __pred)
const
7167 {
return chunk_by_view(std::forward<_Range>(__r), std::forward<_Pred>(__pred)); }
7169 using __adaptor::_RangeAdaptor<_ChunkBy>::operator();
7170 static constexpr int _S_arity = 2;
7171 static constexpr bool _S_has_simple_extra_args =
true;
7174 inline constexpr _ChunkBy chunk_by;
7178#ifdef __cpp_lib_ranges_join_with
7181 template<
typename _Range,
typename _Pattern>
7182 concept __compatible_joinable_ranges
7183 = common_with<range_value_t<_Range>, range_value_t<_Pattern>>
7184 && common_reference_with<range_reference_t<_Range>,
7185 range_reference_t<_Pattern>>
7186 && common_reference_with<range_rvalue_reference_t<_Range>,
7187 range_rvalue_reference_t<_Pattern>>;
7189 template<
typename _Range>
7190 concept __bidirectional_common = bidirectional_range<_Range> && common_range<_Range>;
7193 template<input_range _Vp, forward_range _Pattern>
7194 requires view<_Vp> && view<_Pattern>
7195 && input_range<range_reference_t<_Vp>>
7196 && __detail::__compatible_joinable_ranges<range_reference_t<_Vp>, _Pattern>
7197 class join_with_view :
public view_interface<join_with_view<_Vp, _Pattern>>
7199 using _InnerRange = range_reference_t<_Vp>;
7201 _Vp _M_base = _Vp();
7202 [[no_unique_address]]
7203 __detail::__maybe_present_t<!forward_range<_Vp>,
7204 __detail::__non_propagating_cache<iterator_t<_Vp>>> _M_outer_it;
7205 __detail::__non_propagating_cache<remove_cv_t<_InnerRange>> _M_inner;
7206 _Pattern _M_pattern = _Pattern();
7208 template<
bool _Const>
using _Base = __detail::__maybe_const_t<_Const, _Vp>;
7209 template<
bool _Const>
using _InnerBase = range_reference_t<_Base<_Const>>;
7210 template<
bool _Const>
using _PatternBase = __detail::__maybe_const_t<_Const, _Pattern>;
7212 template<
bool _Const>
using _OuterIter = iterator_t<_Base<_Const>>;
7213 template<
bool _Const>
using _InnerIter = iterator_t<_InnerBase<_Const>>;
7214 template<
bool _Const>
using _PatternIter = iterator_t<_PatternBase<_Const>>;
7216 template<
bool _Const>
7217 static constexpr bool _S_ref_is_glvalue = is_reference_v<_InnerBase<_Const>>;
7219 template<
bool _Const>
7223 template<
bool _Const>
7224 requires _S_ref_is_glvalue<_Const>
7225 && forward_range<_Base<_Const>>
7226 && forward_range<_InnerBase<_Const>>
7227 struct __iter_cat<_Const>
7233 using _OuterIter = join_with_view::_OuterIter<_Const>;
7234 using _InnerIter = join_with_view::_InnerIter<_Const>;
7235 using _PatternIter = join_with_view::_PatternIter<_Const>;
7236 using _OuterCat =
typename iterator_traits<_OuterIter>::iterator_category;
7237 using _InnerCat =
typename iterator_traits<_InnerIter>::iterator_category;
7238 using _PatternCat =
typename iterator_traits<_PatternIter>::iterator_category;
7241 if constexpr (!is_reference_v<common_reference_t<iter_reference_t<_InnerIter>,
7242 iter_reference_t<_PatternIter>>>)
7243 return input_iterator_tag{};
7244 else if constexpr (derived_from<_OuterCat, bidirectional_iterator_tag>
7245 && derived_from<_InnerCat, bidirectional_iterator_tag>
7246 && derived_from<_PatternCat, bidirectional_iterator_tag>
7247 && common_range<_InnerBase<_Const>>
7248 && common_range<_PatternBase<_Const>>)
7249 return bidirectional_iterator_tag{};
7250 else if constexpr (derived_from<_OuterCat, forward_iterator_tag>
7251 && derived_from<_InnerCat, forward_iterator_tag>
7252 && derived_from<_PatternCat, forward_iterator_tag>)
7253 return forward_iterator_tag{};
7255 return input_iterator_tag{};
7258 using iterator_category =
decltype(_S_iter_cat());
7261 template<
bool>
struct _Iterator;
7262 template<
bool>
struct _Sentinel;
7265 join_with_view()
requires (default_initializable<_Vp>
7266 && default_initializable<_Pattern>)
7270 join_with_view(_Vp __base, _Pattern __pattern)
7274 template<input_range _Range>
7275 requires constructible_from<_Vp, views::all_t<_Range>>
7276 && constructible_from<_Pattern, single_view<range_value_t<_InnerRange>>>
7278 join_with_view(_Range&& __r, range_value_t<_InnerRange> __e)
7279 : _M_base(views::all(
std::
forward<_Range>(__r))),
7280 _M_pattern(views::single(
std::
move(__e)))
7284 base() const& requires copy_constructible<_Vp>
7294 if constexpr (forward_range<_Vp>)
7296 constexpr bool __use_const = is_reference_v<_InnerRange>
7297 && __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
7298 return _Iterator<__use_const>{*
this, ranges::begin(_M_base)};
7302 _M_outer_it = ranges::begin(_M_base);
7303 return _Iterator<false>{*
this};
7309 requires forward_range<const _Vp>
7310 && forward_range<const _Pattern>
7311 && is_reference_v<range_reference_t<const _Vp>>
7312 && input_range<range_reference_t<const _Vp>>
7313 {
return _Iterator<true>{*
this, ranges::begin(_M_base)}; }
7318 constexpr bool __use_const
7319 = __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
7320 if constexpr (is_reference_v<_InnerRange>
7321 && forward_range<_Vp> && common_range<_Vp>
7322 && forward_range<_InnerRange> && common_range<_InnerRange>)
7323 return _Iterator<__use_const>{*
this, ranges::end(_M_base)};
7325 return _Sentinel<__use_const>{*
this};
7330 requires forward_range<const _Vp>
7331 && forward_range<const _Pattern>
7332 && is_reference_v<range_reference_t<const _Vp>>
7333 && input_range<range_reference_t<const _Vp>>
7335 using _InnerConstRange = range_reference_t<const _Vp>;
7336 if constexpr (forward_range<_InnerConstRange>
7337 && common_range<const _Vp>
7338 && common_range<_InnerConstRange>)
7339 return _Iterator<true>{*
this, ranges::end(_M_base)};
7341 return _Sentinel<true>{*
this};
7345 template<
typename _Range,
typename _Pattern>
7346 join_with_view(_Range&&, _Pattern&&)
7347 -> join_with_view<views::all_t<_Range>, views::all_t<_Pattern>>;
7349 template<input_range _Range>
7350 join_with_view(_Range&&, range_value_t<range_reference_t<_Range>>)
7351 -> join_with_view<views::all_t<_Range>,
7352 single_view<range_value_t<range_reference_t<_Range>>>>;
7354 template<input_range _Vp, forward_range _Pattern>
7355 requires view<_Vp> && view<_Pattern>
7356 && input_range<range_reference_t<_Vp>>
7357 && __detail::__compatible_joinable_ranges<range_reference_t<_Vp>, _Pattern>
7358 template<
bool _Const>
7359 class join_with_view<_Vp, _Pattern>::_Iterator :
public __iter_cat<_Const>
7361 using _Parent = __detail::__maybe_const_t<_Const, join_with_view>;
7362 using _Base = join_with_view::_Base<_Const>;
7363 using _InnerBase = join_with_view::_InnerBase<_Const>;
7364 using _PatternBase = join_with_view::_PatternBase<_Const>;
7366 using _OuterIter = join_with_view::_OuterIter<_Const>;
7367 using _InnerIter = join_with_view::_InnerIter<_Const>;
7368 using _PatternIter = join_with_view::_PatternIter<_Const>;
7370 static constexpr bool _S_ref_is_glvalue = join_with_view::_S_ref_is_glvalue<_Const>;
7372 _Parent* _M_parent =
nullptr;
7373 [[no_unique_address]]
7374 __detail::__maybe_present_t<forward_range<_Base>, _OuterIter> _M_outer_it;
7375 variant<_PatternIter, _InnerIter> _M_inner_it;
7377 constexpr _OuterIter&
7380 if constexpr (forward_range<_Base>)
7383 return *_M_parent->_M_outer_it;
7386 constexpr const _OuterIter&
7387 _M_get_outer()
const
7389 if constexpr (forward_range<_Base>)
7392 return *_M_parent->_M_outer_it;
7396 _Iterator(_Parent& __parent, _OuterIter __outer)
7397 requires forward_range<_Base>
7400 if (_M_get_outer() != ranges::end(_M_parent->_M_base))
7402 auto&& __inner = _M_update_inner();
7403 _M_inner_it.template emplace<1>(ranges::begin(__inner));
7409 _Iterator(_Parent& __parent)
7410 requires (!forward_range<_Base>)
7413 if (_M_get_outer() != ranges::end(_M_parent->_M_base))
7415 auto&& __inner = _M_update_inner();
7416 _M_inner_it.template emplace<1>(ranges::begin(__inner));
7424 _OuterIter& __outer = _M_get_outer();
7425 if constexpr (_S_ref_is_glvalue)
7426 return __detail::__as_lvalue(*__outer);
7428 return _M_parent->_M_inner._M_emplace_deref(__outer);
7434 if constexpr (_S_ref_is_glvalue)
7435 return __detail::__as_lvalue(*_M_get_outer());
7437 return *_M_parent->_M_inner;
7445 if (_M_inner_it.index() == 0)
7447 if (std::get<0>(_M_inner_it) != ranges::end(_M_parent->_M_pattern))
7450 auto&& __inner = _M_update_inner();
7451 _M_inner_it.template emplace<1>(ranges::begin(__inner));
7455 auto&& __inner = _M_get_inner();
7456 if (std::get<1>(_M_inner_it) != ranges::end(__inner))
7459 if (++_M_get_outer() == ranges::end(_M_parent->_M_base))
7461 if constexpr (_S_ref_is_glvalue)
7462 _M_inner_it.template emplace<0>();
7466 _M_inner_it.template emplace<0>(ranges::begin(_M_parent->_M_pattern));
7474 if constexpr (_S_ref_is_glvalue
7475 && bidirectional_range<_Base>
7476 && __detail::__bidirectional_common<_InnerBase>
7477 && __detail::__bidirectional_common<_PatternBase>)
7478 return bidirectional_iterator_tag{};
7479 else if constexpr (_S_ref_is_glvalue
7480 && forward_range<_Base>
7481 && forward_range<_InnerBase>)
7482 return forward_iterator_tag{};
7484 return input_iterator_tag{};
7487 friend join_with_view;
7490 using iterator_concept =
decltype(_S_iter_concept());
7492 using value_type = common_type_t<iter_value_t<_InnerIter>,
7493 iter_value_t<_PatternIter>>;
7494 using difference_type = common_type_t<iter_difference_t<_OuterIter>,
7495 iter_difference_t<_InnerIter>,
7496 iter_difference_t<_PatternIter>>;
7498 _Iterator() =
default;
7501 _Iterator(_Iterator<!_Const> __i)
7503 && convertible_to<iterator_t<_Vp>, _OuterIter>
7504 && convertible_to<iterator_t<_InnerRange>, _InnerIter>
7505 && convertible_to<iterator_t<_Pattern>, _PatternIter>
7506 : _M_parent(__i._M_parent),
7509 if (__i._M_inner_it.index() == 0)
7510 _M_inner_it.template emplace<0>(std::get<0>(
std::move(__i._M_inner_it)));
7512 _M_inner_it.template emplace<1>(std::get<1>(
std::move(__i._M_inner_it)));
7515 constexpr common_reference_t<iter_reference_t<_InnerIter>,
7516 iter_reference_t<_PatternIter>>
7519 if (_M_inner_it.index() == 0)
7520 return *std::get<0>(_M_inner_it);
7522 return *std::get<1>(_M_inner_it);
7525 constexpr _Iterator&
7528 if (_M_inner_it.index() == 0)
7529 ++std::get<0>(_M_inner_it);
7531 ++std::get<1>(_M_inner_it);
7542 requires _S_ref_is_glvalue
7543 && forward_iterator<_OuterIter> && forward_iterator<_InnerIter>
7545 _Iterator __tmp = *
this;
7550 constexpr _Iterator&
7552 requires _S_ref_is_glvalue
7553 && bidirectional_range<_Base>
7554 && __detail::__bidirectional_common<_InnerBase>
7555 && __detail::__bidirectional_common<_PatternBase>
7557 if (_M_outer_it == ranges::end(_M_parent->_M_base))
7559 auto&& __inner = *--_M_outer_it;
7560 _M_inner_it.template emplace<1>(ranges::end(__inner));
7565 if (_M_inner_it.index() == 0)
7567 auto& __it = std::get<0>(_M_inner_it);
7568 if (__it == ranges::begin(_M_parent->_M_pattern))
7570 auto&& __inner = *--_M_outer_it;
7571 _M_inner_it.template emplace<1>(ranges::end(__inner));
7578 auto& __it = std::get<1>(_M_inner_it);
7579 auto&& __inner = *_M_outer_it;
7580 if (__it == ranges::begin(__inner))
7581 _M_inner_it.template emplace<0>(ranges::end(_M_parent->_M_pattern));
7587 if (_M_inner_it.index() == 0)
7588 --std::get<0>(_M_inner_it);
7590 --std::get<1>(_M_inner_it);
7596 requires _S_ref_is_glvalue && bidirectional_range<_Base>
7597 && __detail::__bidirectional_common<_InnerBase>
7598 && __detail::__bidirectional_common<_PatternBase>
7600 _Iterator __tmp = *
this;
7605 friend constexpr bool
7606 operator==(
const _Iterator& __x,
const _Iterator& __y)
7607 requires _S_ref_is_glvalue
7608 && forward_range<_Base> && equality_comparable<_InnerIter>
7609 {
return __x._M_outer_it == __y._M_outer_it && __x._M_inner_it ==__y._M_inner_it; }
7611 friend constexpr common_reference_t<iter_rvalue_reference_t<_InnerIter>,
7612 iter_rvalue_reference_t<_PatternIter>>
7613 iter_move(
const _Iterator& __x)
7615 if (__x._M_inner_it.index() == 0)
7616 return ranges::iter_move(std::get<0>(__x._M_inner_it));
7618 return ranges::iter_move(std::get<1>(__x._M_inner_it));
7621 friend constexpr void
7622 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
7623 requires indirectly_swappable<_InnerIter, _PatternIter>
7625 if (__x._M_inner_it.index() == 0)
7627 if (__y._M_inner_it.index() == 0)
7628 ranges::iter_swap(std::get<0>(__x._M_inner_it), std::get<0>(__y._M_inner_it));
7630 ranges::iter_swap(std::get<0>(__x._M_inner_it), std::get<1>(__y._M_inner_it));
7634 if (__y._M_inner_it.index() == 0)
7635 ranges::iter_swap(std::get<1>(__x._M_inner_it), std::get<0>(__y._M_inner_it));
7637 ranges::iter_swap(std::get<1>(__x._M_inner_it), std::get<1>(__y._M_inner_it));
7642 template<input_range _Vp, forward_range _Pattern>
7643 requires view<_Vp> && view<_Pattern>
7644 && input_range<range_reference_t<_Vp>>
7645 && __detail::__compatible_joinable_ranges<range_reference_t<_Vp>, _Pattern>
7646 template<
bool _Const>
7647 class join_with_view<_Vp, _Pattern>::_Sentinel
7649 using _Parent = __detail::__maybe_const_t<_Const, join_with_view>;
7650 using _Base = join_with_view::_Base<_Const>;
7652 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
7655 _Sentinel(_Parent& __parent)
7656 : _M_end(ranges::
end(__parent._M_base))
7659 friend join_with_view;
7662 _Sentinel() =
default;
7665 _Sentinel(_Sentinel<!_Const> __s)
7666 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
7670 template<
bool _OtherConst>
7671 requires sentinel_for<sentinel_t<_Base>,
7672 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
7673 friend constexpr bool
7674 operator==(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
7675 {
return __x._M_get_outer() == __y._M_end; }
7682 template<
typename _Range,
typename _Pattern>
7683 concept __can_join_with_view
7684 =
requires { join_with_view(std::declval<_Range>(), std::declval<_Pattern>()); };
7687 struct _JoinWith : __adaptor::_RangeAdaptor<_JoinWith>
7689 template<viewable_range _Range,
typename _Pattern>
7690 requires __detail::__can_join_with_view<_Range, _Pattern>
7692 operator() [[nodiscard]] (_Range&& __r, _Pattern&& __f)
const
7694 return join_with_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
7697 using _RangeAdaptor<_JoinWith>::operator();
7698 static constexpr int _S_arity = 2;
7699 template<
typename _Pattern>
7700 static constexpr bool _S_has_simple_extra_args
7701 = _LazySplit::_S_has_simple_extra_args<_Pattern>;
7704 inline constexpr _JoinWith join_with;
7708#ifdef __cpp_lib_ranges_repeat
7709 template<move_constructible _Tp, semiregular _Bound = unreachable_sentinel_t>
7710 requires is_object_v<_Tp> && same_as<_Tp, remove_cv_t<_Tp>>
7711 && (__detail::__is_integer_like<_Bound> || same_as<_Bound, unreachable_sentinel_t>)
7712 class repeat_view : public view_interface<repeat_view<_Tp, _Bound>>
7714 __detail::__box<_Tp> _M_value;
7715 [[no_unique_address]] _Bound _M_bound = _Bound();
7719 template<
typename _Range>
7720 friend constexpr auto
7721 views::__detail::__take_of_repeat_view(_Range&&, range_difference_t<_Range>);
7723 template<
typename _Range>
7724 friend constexpr auto
7725 views::__detail::__drop_of_repeat_view(_Range&&, range_difference_t<_Range>);
7728 repeat_view()
requires default_initializable<_Tp> = default;
7731 repeat_view(const _Tp& __value, _Bound __bound = _Bound())
7732 requires copy_constructible<_Tp>
7733 : _M_value(__value), _M_bound(__bound)
7735 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7736 __glibcxx_assert(__bound >= 0);
7740 repeat_view(_Tp&& __value, _Bound __bound = _Bound())
7741 : _M_value(
std::
move(__value)), _M_bound(__bound)
7744 template<
typename... _Args,
typename... _BoundArgs>
7745 requires constructible_from<_Tp, _Args...>
7746 && constructible_from<_Bound, _BoundArgs...>
7748 repeat_view(piecewise_construct_t,
7749 tuple<_Args...> __args,
7750 tuple<_BoundArgs...> __bound_args = tuple<>{})
7751 : _M_value(
std::make_from_tuple<_Tp>(
std::
move(__args))),
7752 _M_bound(
std::make_from_tuple<_Bound>(
std::
move(__bound_args)))
7760 end() const requires (!same_as<_Bound, unreachable_sentinel_t>)
7763 constexpr unreachable_sentinel_t
7764 end() const noexcept
7765 {
return unreachable_sentinel; }
7768 size() const requires (!same_as<_Bound, unreachable_sentinel_t>)
7769 {
return __detail::__to_unsigned_like(_M_bound); }
7774 template<
typename _Tp,
typename _Bound = unreachable_sentinel_t>
7775 repeat_view(_Tp, _Bound = _Bound()) -> repeat_view<_Tp, _Bound>;
7777 template<move_constructible _Tp, semiregular _Bound>
7778 requires is_object_v<_Tp> && same_as<_Tp, remove_cv_t<_Tp>>
7779 && (__detail::__is_integer_like<_Bound> || same_as<_Bound, unreachable_sentinel_t>)
7780 class repeat_view<_Tp, _Bound>::_Iterator
7783 = __conditional_t<same_as<_Bound, unreachable_sentinel_t>, ptrdiff_t, _Bound>;
7785 const _Tp* _M_value =
nullptr;
7786 __index_type _M_current = __index_type();
7789 _Iterator(
const _Tp* __value, __index_type __bound = __index_type())
7790 : _M_value(__value), _M_current(__bound)
7792 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7793 __glibcxx_assert(__bound >= 0);
7799 using iterator_concept = random_access_iterator_tag;
7800 using iterator_category = random_access_iterator_tag;
7801 using value_type = _Tp;
7802 using difference_type = __conditional_t<__detail::__is_signed_integer_like<__index_type>,
7804 __detail::__iota_diff_t<__index_type>>;
7806 _Iterator() =
default;
7808 constexpr const _Tp&
7810 {
return *_M_value; }
7812 constexpr _Iterator&
7827 constexpr _Iterator&
7830 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7831 __glibcxx_assert(_M_current > 0);
7844 constexpr _Iterator&
7845 operator+=(difference_type __n)
7847 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7848 __glibcxx_assert(_M_current + __n >= 0);
7853 constexpr _Iterator&
7854 operator-=(difference_type __n)
7856 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7857 __glibcxx_assert(_M_current - __n >= 0);
7862 constexpr const _Tp&
7863 operator[](difference_type __n)
const noexcept
7864 {
return *(*
this + __n); }
7866 friend constexpr bool
7867 operator==(
const _Iterator& __x,
const _Iterator& __y)
7868 {
return __x._M_current == __y._M_current; }
7870 friend constexpr auto
7871 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
7872 {
return __x._M_current <=> __y._M_current; }
7874 friend constexpr _Iterator
7875 operator+(_Iterator __i, difference_type __n)
7881 friend constexpr _Iterator
7882 operator+(difference_type __n, _Iterator __i)
7883 {
return __i + __n; }
7885 friend constexpr _Iterator
7886 operator-(_Iterator __i, difference_type __n)
7892 friend constexpr difference_type
7893 operator-(
const _Iterator& __x,
const _Iterator& __y)
7895 return (
static_cast<difference_type
>(__x._M_current)
7896 -
static_cast<difference_type
>(__y._M_current));
7904 template<
typename _Tp,
typename _Bound>
7905 inline constexpr bool __is_repeat_view<repeat_view<_Tp, _Bound>> =
true;
7907 template<
typename _Tp>
7908 concept __can_repeat_view
7909 =
requires { repeat_view(std::declval<_Tp>()); };
7911 template<
typename _Tp,
typename _Bound>
7912 concept __can_bounded_repeat_view
7913 =
requires { repeat_view(std::declval<_Tp>(), std::declval<_Bound>()); };
7918 template<
typename _Tp>
7919 requires __detail::__can_repeat_view<_Tp>
7921 operator() [[nodiscard]] (_Tp&& __value)
const
7925 return repeat_view<decay_t<_Tp>>(std::forward<_Tp>(__value));
7928 template<
typename _Tp,
typename _Bound>
7929 requires __detail::__can_bounded_repeat_view<_Tp, _Bound>
7931 operator() [[nodiscard]] (_Tp&& __value, _Bound __bound)
const
7932 {
return repeat_view(std::forward<_Tp>(__value), __bound); }
7935 inline constexpr _Repeat repeat;
7939 template<
typename _Range>
7941 __take_of_repeat_view(_Range&& __r, range_difference_t<_Range> __n)
7943 using _Tp = remove_cvref_t<_Range>;
7944 static_assert(__is_repeat_view<_Tp>);
7945 if constexpr (sized_range<_Tp>)
7946 return views::repeat(*std::forward<_Range>(__r)._M_value,
7947 std::min(ranges::distance(__r), __n));
7949 return views::repeat(*std::forward<_Range>(__r)._M_value, __n);
7952 template<
typename _Range>
7954 __drop_of_repeat_view(_Range&& __r, range_difference_t<_Range> __n)
7956 using _Tp = remove_cvref_t<_Range>;
7957 static_assert(__is_repeat_view<_Tp>);
7958 if constexpr (sized_range<_Tp>)
7960 auto __sz = ranges::distance(__r);
7961 return views::repeat(*std::forward<_Range>(__r)._M_value,
7971#ifdef __cpp_lib_ranges_stride
7972 template<input_range _Vp>
7974 class stride_view :
public view_interface<stride_view<_Vp>>
7977 range_difference_t<_Vp> _M_stride;
7979 template<
bool _Const>
using _Base = __detail::__maybe_const_t<_Const, _Vp>;
7981 template<
bool _Const>
7985 template<
bool _Const>
7986 requires forward_range<_Base<_Const>>
7987 struct __iter_cat<_Const>
7993 using _Cat =
typename iterator_traits<iterator_t<_Base<_Const>>>::iterator_category;
7994 if constexpr (derived_from<_Cat, random_access_iterator_tag>)
7995 return random_access_iterator_tag{};
8000 using iterator_category =
decltype(_S_iter_cat());
8003 template<
bool>
class _Iterator;
8007 stride_view(_Vp __base, range_difference_t<_Vp> __stride)
8009 { __glibcxx_assert(__stride > 0); }
8012 base() const& requires copy_constructible<_Vp>
8019 constexpr range_difference_t<_Vp>
8020 stride() const noexcept
8021 {
return _M_stride; }
8024 begin()
requires (!__detail::__simple_view<_Vp>)
8025 {
return _Iterator<false>(
this, ranges::begin(_M_base)); }
8028 begin() const requires range<const _Vp>
8029 {
return _Iterator<true>(
this, ranges::begin(_M_base)); }
8032 end()
requires (!__detail::__simple_view<_Vp>)
8034 if constexpr (common_range<_Vp> && sized_range<_Vp> && forward_range<_Vp>)
8036 auto __missing = (_M_stride - ranges::distance(_M_base) % _M_stride) % _M_stride;
8037 return _Iterator<false>(
this, ranges::end(_M_base), __missing);
8039 else if constexpr (common_range<_Vp> && !bidirectional_range<_Vp>)
8040 return _Iterator<false>(
this, ranges::end(_M_base));
8046 end() const requires range<const _Vp>
8048 if constexpr (common_range<const _Vp> && sized_range<const _Vp>
8049 && forward_range<const _Vp>)
8051 auto __missing = (_M_stride - ranges::distance(_M_base) % _M_stride) % _M_stride;
8052 return _Iterator<true>(
this, ranges::end(_M_base), __missing);
8054 else if constexpr (common_range<const _Vp> && !bidirectional_range<const _Vp>)
8055 return _Iterator<true>(
this, ranges::end(_M_base));
8061 size()
requires sized_range<_Vp>
8063 return __detail::__to_unsigned_like
8064 (__detail::__div_ceil(ranges::distance(_M_base), _M_stride));
8068 size() const requires sized_range<const _Vp>
8070 return __detail::__to_unsigned_like
8071 (__detail::__div_ceil(ranges::distance(_M_base), _M_stride));
8075 template<
typename _Range>
8076 stride_view(_Range&&, range_difference_t<_Range>) -> stride_view<views::all_t<_Range>>;
8078 template<
typename _Vp>
8079 inline constexpr bool enable_borrowed_range<stride_view<_Vp>>
8080 = enable_borrowed_range<_Vp>;
8082 template<input_range _Vp>
8084 template<
bool _Const>
8085 class stride_view<_Vp>::_Iterator :
public __iter_cat<_Const>
8087 using _Parent = __detail::__maybe_const_t<_Const, stride_view>;
8088 using _Base = stride_view::_Base<_Const>;
8090 iterator_t<_Base> _M_current = iterator_t<_Base>();
8091 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
8092 range_difference_t<_Base> _M_stride = 0;
8093 range_difference_t<_Base> _M_missing = 0;
8096 _Iterator(_Parent* __parent, iterator_t<_Base> __current,
8097 range_difference_t<_Base> __missing = 0)
8098 : _M_current(
std::
move(__current)), _M_end(ranges::
end(__parent->_M_base)),
8099 _M_stride(__parent->_M_stride), _M_missing(__missing)
8105 if constexpr (random_access_range<_Base>)
8106 return random_access_iterator_tag{};
8107 else if constexpr (bidirectional_range<_Base>)
8108 return bidirectional_iterator_tag{};
8109 else if constexpr (forward_range<_Base>)
8110 return forward_iterator_tag{};
8112 return input_iterator_tag{};
8118 using difference_type = range_difference_t<_Base>;
8119 using value_type = range_value_t<_Base>;
8120 using iterator_concept =
decltype(_S_iter_concept());
8123 _Iterator()
requires default_initializable<iterator_t<_Base>> = default;
8126 _Iterator(_Iterator<!_Const> __other)
8128 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
8129 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
8130 : _M_current(
std::move(__other._M_current)), _M_end(
std::move(__other._M_end)),
8131 _M_stride(__other._M_stride), _M_missing(__other._M_missing)
8134 constexpr iterator_t<_Base>
8138 constexpr const iterator_t<_Base>&
8139 base() const & noexcept
8140 {
return _M_current; }
8142 constexpr decltype(
auto)
8144 {
return *_M_current; }
8146 constexpr _Iterator&
8149 __glibcxx_assert(_M_current != _M_end);
8150 _M_missing = ranges::advance(_M_current, _M_stride, _M_end);
8159 operator++(
int)
requires forward_range<_Base>
8166 constexpr _Iterator&
8167 operator--()
requires bidirectional_range<_Base>
8169 ranges::advance(_M_current, _M_missing - _M_stride);
8175 operator--(
int)
requires bidirectional_range<_Base>
8182 constexpr _Iterator&
8183 operator+=(difference_type __n)
requires random_access_range<_Base>
8187 __glibcxx_assert(ranges::distance(_M_current, _M_end) > _M_stride * (__n - 1));
8188 _M_missing = ranges::advance(_M_current, _M_stride * __n, _M_end);
8192 ranges::advance(_M_current, _M_stride * __n + _M_missing);
8198 constexpr _Iterator&
8199 operator-=(difference_type __n)
requires random_access_range<_Base>
8200 {
return *
this += -__n; }
8202 constexpr decltype(
auto)
operator[](difference_type __n)
const
8203 requires random_access_range<_Base>
8204 {
return *(*
this + __n); }
8206 friend constexpr bool
8207 operator==(
const _Iterator& __x, default_sentinel_t)
8208 {
return __x._M_current == __x._M_end; }
8210 friend constexpr bool
8211 operator==(
const _Iterator& __x,
const _Iterator& __y)
8212 requires equality_comparable<iterator_t<_Base>>
8213 {
return __x._M_current == __y._M_current; }
8215 friend constexpr bool
8216 operator<(
const _Iterator& __x,
const _Iterator& __y)
8217 requires random_access_range<_Base>
8218 {
return __x._M_current < __y._M_current; }
8220 friend constexpr bool
8221 operator>(
const _Iterator& __x,
const _Iterator& __y)
8222 requires random_access_range<_Base>
8223 {
return __y._M_current < __x._M_current; }
8225 friend constexpr bool
8226 operator<=(
const _Iterator& __x,
const _Iterator& __y)
8227 requires random_access_range<_Base>
8228 {
return !(__y._M_current < __x._M_current); }
8230 friend constexpr bool
8231 operator>=(
const _Iterator& __x,
const _Iterator& __y)
8232 requires random_access_range<_Base>
8233 {
return !(__x._M_current < __y._M_current); }
8235 friend constexpr auto
8236 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
8237 requires random_access_range<_Base> && three_way_comparable<iterator_t<_Base>>
8238 {
return __x._M_current <=> __y._M_current; }
8240 friend constexpr _Iterator
8241 operator+(
const _Iterator& __i, difference_type __n)
8242 requires random_access_range<_Base>
8249 friend constexpr _Iterator
8250 operator+(difference_type __n,
const _Iterator& __i)
8251 requires random_access_range<_Base>
8252 {
return __i + __n; }
8254 friend constexpr _Iterator
8255 operator-(
const _Iterator& __i, difference_type __n)
8256 requires random_access_range<_Base>
8263 friend constexpr difference_type
8264 operator-(
const _Iterator& __x,
const _Iterator& __y)
8265 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
8267 auto __n = __x._M_current - __y._M_current;
8268 if constexpr (forward_range<_Base>)
8269 return (__n + __x._M_missing - __y._M_missing) / __x._M_stride;
8271 return -__detail::__div_ceil(-__n, __x._M_stride);
8273 return __detail::__div_ceil(__n, __x._M_stride);
8276 friend constexpr difference_type
8277 operator-(default_sentinel_t __y,
const _Iterator& __x)
8278 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
8279 {
return __detail::__div_ceil(__x._M_end - __x._M_current, __x._M_stride); }
8281 friend constexpr difference_type
8282 operator-(
const _Iterator& __x, default_sentinel_t __y)
8283 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
8284 {
return -(__y - __x); }
8286 friend constexpr range_rvalue_reference_t<_Base>
8287 iter_move(
const _Iterator& __i)
8288 noexcept(
noexcept(ranges::iter_move(__i._M_current)))
8289 {
return ranges::iter_move(__i._M_current); }
8291 friend constexpr void
8292 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
8293 noexcept(
noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
8294 requires indirectly_swappable<iterator_t<_Base>>
8295 { ranges::iter_swap(__x._M_current, __y._M_current); }
8302 template<
typename _Range,
typename _Dp>
8303 concept __can_stride_view
8304 =
requires { stride_view(std::declval<_Range>(), std::declval<_Dp>()); };
8307 struct _Stride : __adaptor::_RangeAdaptor<_Stride>
8309 template<viewable_range _Range,
typename _Dp = range_difference_t<_Range>>
8310 requires __detail::__can_stride_view<_Range, _Dp>
8312 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n)
const
8313 {
return stride_view(std::forward<_Range>(__r), __n); }
8315 using __adaptor::_RangeAdaptor<_Stride>::operator();
8316 static constexpr int _S_arity = 2;
8317 static constexpr bool _S_has_simple_extra_args =
true;
8320 inline constexpr _Stride stride;
8324#ifdef __cpp_lib_ranges_cartesian_product
8327 template<
bool _Const,
typename _First,
typename... _Vs>
8328 concept __cartesian_product_is_random_access
8329 = (random_access_range<__maybe_const_t<_Const, _First>>
8331 && (random_access_range<__maybe_const_t<_Const, _Vs>>
8332 && sized_range<__maybe_const_t<_Const, _Vs>>));
8334 template<
typename _Range>
8335 concept __cartesian_product_common_arg
8336 = common_range<_Range> || (sized_range<_Range> && random_access_range<_Range>);
8338 template<
bool _Const,
typename _First,
typename... _Vs>
8339 concept __cartesian_product_is_bidirectional
8340 = (bidirectional_range<__maybe_const_t<_Const, _First>>
8342 && (bidirectional_range<__maybe_const_t<_Const, _Vs>>
8343 && __cartesian_product_common_arg<__maybe_const_t<_Const, _Vs>>));
8345 template<
typename _First,
typename... _Vs>
8346 concept __cartesian_product_is_common = __cartesian_product_common_arg<_First>;
8348 template<
typename... _Vs>
8349 concept __cartesian_product_is_sized = (sized_range<_Vs> && ...);
8351 template<
bool _Const,
template<
typename>
class FirstSent,
typename _First,
typename... _Vs>
8352 concept __cartesian_is_sized_sentinel
8353 = (sized_sentinel_for<FirstSent<__maybe_const_t<_Const, _First>>,
8354 iterator_t<__maybe_const_t<_Const, _First>>>
8356 && (sized_range<__maybe_const_t<_Const, _Vs>>
8357 && sized_sentinel_for<iterator_t<__maybe_const_t<_Const, _Vs>>,
8358 iterator_t<__maybe_const_t<_Const, _Vs>>>));
8360 template<__cartesian_product_common_arg _Range>
8362 __cartesian_common_arg_end(_Range& __r)
8364 if constexpr (common_range<_Range>)
8365 return ranges::end(__r);
8367 return ranges::begin(__r) + ranges::distance(__r);
8371 template<input_range _First, forward_range... _Vs>
8372 requires (view<_First> && ... && view<_Vs>)
8373 class cartesian_product_view : public view_interface<cartesian_product_view<_First, _Vs...>>
8375 tuple<_First, _Vs...> _M_bases;
8377 template<
bool>
class _Iterator;
8380 _S_difference_type()
8386 range_difference_t<_First>,
8387 range_difference_t<_Vs>...>{};
8391 cartesian_product_view() =
default;
8394 cartesian_product_view(_First __first, _Vs... __rest)
8398 constexpr _Iterator<false>
8399 begin()
requires (!__detail::__simple_view<_First> || ... || !__detail::__simple_view<_Vs>)
8400 {
return _Iterator<false>(*
this, __detail::__tuple_transform(ranges::begin, _M_bases)); }
8402 constexpr _Iterator<true>
8403 begin() const requires (range<const _First> && ... && range<const _Vs>)
8404 {
return _Iterator<true>(*
this, __detail::__tuple_transform(ranges::begin, _M_bases)); }
8406 constexpr _Iterator<false>
8407 end()
requires ((!__detail::__simple_view<_First> || ... || !__detail::__simple_view<_Vs>)
8408 && __detail::__cartesian_product_is_common<_First, _Vs...>)
8411 using _Ret = tuple<iterator_t<_First>, iterator_t<_Vs>...>;
8412 bool __empty_tail = (ranges::empty(std::get<1 + _Is>(_M_bases)) || ...);
8413 auto& __first = std::get<0>(_M_bases);
8414 return _Ret{(__empty_tail
8415 ? ranges::begin(__first)
8416 : __detail::__cartesian_common_arg_end(__first)),
8417 ranges::
begin(
std::get<1 + _Is>(_M_bases))...};
8420 return _Iterator<false>{*
this,
std::move(__its)};
8423 constexpr _Iterator<true>
8424 end() const requires __detail::__cartesian_product_is_common<const _First, const _Vs...>
8427 using _Ret = tuple<iterator_t<const _First>, iterator_t<const _Vs>...>;
8428 bool __empty_tail = (ranges::empty(std::get<1 + _Is>(_M_bases)) || ...);
8429 auto& __first = std::get<0>(_M_bases);
8430 return _Ret{(__empty_tail
8431 ? ranges::begin(__first)
8432 : __detail::__cartesian_common_arg_end(__first)),
8433 ranges::
begin(
std::get<1 + _Is>(_M_bases))...};
8436 return _Iterator<true>{*
this,
std::move(__its)};
8439 constexpr default_sentinel_t
8440 end() const noexcept
8444 size()
requires __detail::__cartesian_product_is_sized<_First, _Vs...>
8446 using _ST = __detail::__make_unsigned_like_t<
decltype(_S_difference_type())>;
8448 auto __size =
static_cast<_ST
>(1);
8449#ifdef _GLIBCXX_ASSERTIONS
8450 if constexpr (integral<_ST>)
8453 = (__builtin_mul_overflow(__size,
8454 static_cast<_ST
>(ranges::size(std::get<_Is>(_M_bases))),
8457 __glibcxx_assert(!__overflow);
8461 __size = (
static_cast<_ST
>(ranges::size(std::get<_Is>(_M_bases))) * ...);
8467 size() const requires __detail::__cartesian_product_is_sized<const _First, const _Vs...>
8469 using _ST = __detail::__make_unsigned_like_t<
decltype(_S_difference_type())>;
8471 auto __size =
static_cast<_ST
>(1);
8472#ifdef _GLIBCXX_ASSERTIONS
8473 if constexpr (integral<_ST>)
8476 = (__builtin_mul_overflow(__size,
8477 static_cast<_ST
>(ranges::size(std::get<_Is>(_M_bases))),
8480 __glibcxx_assert(!__overflow);
8484 __size = (
static_cast<_ST
>(ranges::size(std::get<_Is>(_M_bases))) * ...);
8490 template<
typename... _Vs>
8491 cartesian_product_view(_Vs&&...) -> cartesian_product_view<views::all_t<_Vs>...>;
8493 template<input_range _First, forward_range... _Vs>
8494 requires (view<_First> && ... && view<_Vs>)
8495 template<bool _Const>
8496 class cartesian_product_view<_First, _Vs...>::_Iterator
8498 using _Parent = __maybe_const_t<_Const, cartesian_product_view>;
8499 _Parent* _M_parent =
nullptr;
8500 tuple<iterator_t<__maybe_const_t<_Const, _First>>,
8501 iterator_t<__maybe_const_t<_Const, _Vs>>...> _M_current;
8504 _Iterator(_Parent& __parent,
decltype(_M_current) __current)
8506 _M_current(
std::
move(__current))
8512 if constexpr (__detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>)
8513 return random_access_iterator_tag{};
8514 else if constexpr (__detail::__cartesian_product_is_bidirectional<_Const, _First, _Vs...>)
8515 return bidirectional_iterator_tag{};
8516 else if constexpr (forward_range<__maybe_const_t<_Const, _First>>)
8517 return forward_iterator_tag{};
8519 return input_iterator_tag{};
8522 friend cartesian_product_view;
8525 using iterator_category = input_iterator_tag;
8526 using iterator_concept =
decltype(_S_iter_concept());
8528 = tuple<range_value_t<__maybe_const_t<_Const, _First>>,
8529 range_value_t<__maybe_const_t<_Const, _Vs>>...>;
8531 = tuple<range_reference_t<__maybe_const_t<_Const, _First>>,
8532 range_reference_t<__maybe_const_t<_Const, _Vs>>...>;
8533 using difference_type =
decltype(cartesian_product_view::_S_difference_type());
8535 _Iterator() =
default;
8538 _Iterator(_Iterator<!_Const> __i)
8540 && (convertible_to<iterator_t<_First>, iterator_t<const _First>>
8541 && ... && convertible_to<iterator_t<_Vs>, iterator_t<const _Vs>>)
8543 _M_current(
std::
move(__i._M_current))
8549 auto __f = [](
auto& __i) ->
decltype(
auto) {
8552 return __detail::__tuple_transform(__f, _M_current);
8555 constexpr _Iterator&
8567 operator++(
int)
requires forward_range<__maybe_const_t<_Const, _First>>
8574 constexpr _Iterator&
8576 requires __detail::__cartesian_product_is_bidirectional<_Const, _First, _Vs...>
8584 requires __detail::__cartesian_product_is_bidirectional<_Const, _First, _Vs...>
8591 constexpr _Iterator&
8592 operator+=(difference_type __x)
8593 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8599 constexpr _Iterator&
8600 operator-=(difference_type __x)
8601 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8602 {
return *
this += -__x; }
8605 operator[](difference_type __n)
const
8606 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8607 {
return *((*this) + __n); }
8609 friend constexpr bool
8610 operator==(
const _Iterator& __x,
const _Iterator& __y)
8611 requires equality_comparable<iterator_t<__maybe_const_t<_Const, _First>>>
8612 {
return __x._M_current == __y._M_current; }
8614 friend constexpr bool
8615 operator==(
const _Iterator& __x, default_sentinel_t)
8618 return ((std::get<_Is>(__x._M_current)
8619 == ranges::end(std::get<_Is>(__x._M_parent->_M_bases)))
8624 friend constexpr auto
8625 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
8626 requires __detail::__all_random_access<_Const, _First, _Vs...>
8627 {
return __x._M_current <=> __y._M_current; }
8629 friend constexpr _Iterator
8630 operator+(_Iterator __x, difference_type __y)
8631 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8632 {
return __x += __y; }
8634 friend constexpr _Iterator
8635 operator+(difference_type __x, _Iterator __y)
8636 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8637 {
return __y += __x; }
8639 friend constexpr _Iterator
8640 operator-(_Iterator __x, difference_type __y)
8641 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8642 {
return __x -= __y; }
8644 friend constexpr difference_type
8645 operator-(
const _Iterator& __x,
const _Iterator& __y)
8646 requires __detail::__cartesian_is_sized_sentinel<_Const, iterator_t, _First, _Vs...>
8647 {
return __x._M_distance_from(__y._M_current); }
8649 friend constexpr difference_type
8650 operator-(
const _Iterator& __i, default_sentinel_t)
8651 requires __detail::__cartesian_is_sized_sentinel<_Const, sentinel_t, _First, _Vs...>
8654 return tuple{ranges::end(std::get<0>(__i._M_parent->_M_bases)),
8655 ranges::begin(std::get<1 + _Is>(__i._M_parent->_M_bases))...};
8657 return __i._M_distance_from(__end_tuple);
8660 friend constexpr difference_type
8661 operator-(default_sentinel_t,
const _Iterator& __i)
8662 requires __detail::__cartesian_is_sized_sentinel<_Const, sentinel_t, _First, _Vs...>
8665 friend constexpr auto
8666 iter_move(
const _Iterator& __i)
8667 {
return __detail::__tuple_transform(ranges::iter_move, __i._M_current); }
8669 friend constexpr void
8670 iter_swap(
const _Iterator& __l,
const _Iterator& __r)
8671 requires (indirectly_swappable<iterator_t<__maybe_const_t<_Const, _First>>>
8673 && indirectly_swappable<iterator_t<__maybe_const_t<_Const, _Vs>>>)
8676 (ranges::iter_swap(std::get<_Is>(__l._M_current), std::get<_Is>(__r._M_current)), ...);
8681 template<
size_t _Nm =
sizeof...(_Vs)>
8685 auto& __it = std::get<_Nm>(_M_current);
8687 if constexpr (_Nm > 0)
8688 if (__it == ranges::end(std::get<_Nm>(_M_parent->_M_bases)))
8690 __it = ranges::begin(std::get<_Nm>(_M_parent->_M_bases));
8695 template<
size_t _Nm =
sizeof...(_Vs)>
8699 auto& __it = std::get<_Nm>(_M_current);
8700 if constexpr (_Nm > 0)
8701 if (__it == ranges::begin(std::get<_Nm>(_M_parent->_M_bases)))
8703 __it = __detail::__cartesian_common_arg_end(std::get<_Nm>(_M_parent->_M_bases));
8709 template<
size_t _Nm =
sizeof...(_Vs)>
8711 _M_advance(difference_type __x)
8712 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8721 auto& __r = std::get<_Nm>(_M_parent->_M_bases);
8722 auto& __it = std::get<_Nm>(_M_current);
8723 if constexpr (_Nm == 0)
8725#ifdef _GLIBCXX_ASSERTIONS
8726 if constexpr (sized_range<__maybe_const_t<_Const, _First>>)
8728 auto __size = ranges::ssize(__r);
8729 auto __begin = ranges::begin(__r);
8730 auto __offset = __it - __begin;
8731 __glibcxx_assert(__offset + __x >= 0 && __offset + __x <= __size);
8738 auto __size = ranges::ssize(__r);
8739 auto __begin = ranges::begin(__r);
8740 auto __offset = __it - __begin;
8742 __x = __offset / __size;
8746 __offset = __size + __offset;
8749 __it = __begin + __offset;
8750 _M_advance<_Nm - 1>(__x);
8755 template<
typename _Tuple>
8756 constexpr difference_type
8757 _M_distance_from(
const _Tuple& __t)
const
8760 auto __sum =
static_cast<difference_type
>(0);
8761#ifdef _GLIBCXX_ASSERTIONS
8762 if constexpr (integral<difference_type>)
8765 = (__builtin_add_overflow(__sum, _M_scaled_distance<_Is>(__t), &__sum)
8767 __glibcxx_assert(!__overflow);
8771 __sum = (_M_scaled_distance<_Is>(__t) + ...);
8776 template<
size_t _Nm,
typename _Tuple>
8777 constexpr difference_type
8778 _M_scaled_distance(
const _Tuple& __t)
const
8780 auto __dist =
static_cast<difference_type
>(std::get<_Nm>(_M_current)
8781 - std::get<_Nm>(__t));
8782#ifdef _GLIBCXX_ASSERTIONS
8783 if constexpr (integral<difference_type>)
8785 bool __overflow = __builtin_mul_overflow(__dist, _M_scaled_size<_Nm+1>(), &__dist);
8786 __glibcxx_assert(!__overflow);
8790 __dist *= _M_scaled_size<_Nm+1>();
8794 template<
size_t _Nm>
8795 constexpr difference_type
8796 _M_scaled_size()
const
8798 if constexpr (_Nm <=
sizeof...(_Vs))
8800 auto __size =
static_cast<difference_type
>(ranges::size
8801 (std::get<_Nm>(_M_parent->_M_bases)));
8802#ifdef _GLIBCXX_ASSERTIONS
8803 if constexpr (integral<difference_type>)
8805 bool __overflow = __builtin_mul_overflow(__size, _M_scaled_size<_Nm+1>(), &__size);
8806 __glibcxx_assert(!__overflow);
8810 __size *= _M_scaled_size<_Nm+1>();
8814 return static_cast<difference_type
>(1);
8822 template<
typename... _Ts>
8823 concept __can_cartesian_product_view
8824 =
requires { cartesian_product_view<all_t<_Ts>...>(std::declval<_Ts>()...); };
8827 struct _CartesianProduct
8829 template<
typename... _Ts>
8830 requires (
sizeof...(_Ts) == 0 || __detail::__can_cartesian_product_view<_Ts...>)
8832 operator() [[nodiscard]] (_Ts&&... __ts)
const
8834 if constexpr (
sizeof...(_Ts) == 0)
8835 return views::single(tuple{});
8837 return cartesian_product_view<all_t<_Ts>...>(std::forward<_Ts>(__ts)...);
8841 inline constexpr _CartesianProduct cartesian_product;
8845#ifdef __cpp_lib_ranges_as_rvalue
8846 template<input_range _Vp>
8848 class as_rvalue_view :
public view_interface<as_rvalue_view<_Vp>>
8850 _Vp _M_base = _Vp();
8853 as_rvalue_view()
requires default_initializable<_Vp> = default;
8856 as_rvalue_view(_Vp __base)
8857 : _M_base(
std::move(__base))
8861 base() const& requires copy_constructible<_Vp>
8869 begin()
requires (!__detail::__simple_view<_Vp>)
8870 {
return move_iterator(ranges::begin(_M_base)); }
8873 begin() const requires range<const _Vp>
8874 {
return move_iterator(ranges::begin(_M_base)); }
8877 end()
requires (!__detail::__simple_view<_Vp>)
8879 if constexpr (common_range<_Vp>)
8880 return move_iterator(ranges::end(_M_base));
8882 return move_sentinel(ranges::end(_M_base));
8886 end() const requires range<const _Vp>
8888 if constexpr (common_range<const _Vp>)
8889 return move_iterator(ranges::end(_M_base));
8891 return move_sentinel(ranges::end(_M_base));
8895 size()
requires sized_range<_Vp>
8896 {
return ranges::size(_M_base); }
8899 size() const requires sized_range<const _Vp>
8900 {
return ranges::size(_M_base); }
8903 template<
typename _Range>
8904 as_rvalue_view(_Range&&) -> as_rvalue_view<views::all_t<_Range>>;
8906 template<
typename _Tp>
8907 inline constexpr bool enable_borrowed_range<as_rvalue_view<_Tp>>
8908 = enable_borrowed_range<_Tp>;
8914 template<
typename _Tp>
8915 concept __can_as_rvalue_view =
requires { as_rvalue_view(std::declval<_Tp>()); };
8918 struct _AsRvalue : __adaptor::_RangeAdaptorClosure<_AsRvalue>
8920 template<viewable_range _Range>
8921 requires __detail::__can_as_rvalue_view<_Range>
8923 operator() [[nodiscard]] (_Range&& __r)
const
8925 if constexpr (same_as<range_rvalue_reference_t<_Range>,
8926 range_reference_t<_Range>>)
8927 return views::all(std::forward<_Range>(__r));
8929 return as_rvalue_view(std::forward<_Range>(__r));
8933 inline constexpr _AsRvalue as_rvalue;
8937#ifdef __cpp_lib_ranges_enumerate
8940 template<
typename _Range>
8941 concept __range_with_movable_reference = input_range<_Range>
8942 && move_constructible<range_reference_t<_Range>>
8943 && move_constructible<range_rvalue_reference_t<_Range>>;
8947 requires __detail::__range_with_movable_reference<_Vp>
8948 class enumerate_view :
public view_interface<enumerate_view<_Vp>>
8950 _Vp _M_base = _Vp();
8952 template<
bool _Const>
class _Iterator;
8953 template<
bool _Const>
class _Sentinel;
8956 enumerate_view()
requires default_initializable<_Vp> = default;
8959 enumerate_view(_Vp __base)
8960 : _M_base(
std::move(__base))
8964 begin()
requires (!__detail::__simple_view<_Vp>)
8965 {
return _Iterator<false>(ranges::begin(_M_base), 0); }
8968 begin() const requires __detail::__range_with_movable_reference<const _Vp>
8969 {
return _Iterator<true>(ranges::begin(_M_base), 0); }
8972 end()
requires (!__detail::__simple_view<_Vp>)
8974 if constexpr (common_range<_Vp> && sized_range<_Vp>)
8975 return _Iterator<false>(ranges::end(_M_base), ranges::distance(_M_base));
8977 return _Sentinel<false>(ranges::end(_M_base));
8981 end() const requires __detail::__range_with_movable_reference<const _Vp>
8983 if constexpr (common_range<const _Vp> && sized_range<const _Vp>)
8984 return _Iterator<true>(ranges::end(_M_base), ranges::distance(_M_base));
8986 return _Sentinel<true>(ranges::end(_M_base));
8990 size()
requires sized_range<_Vp>
8991 {
return ranges::size(_M_base); }
8994 size() const requires sized_range<const _Vp>
8995 {
return ranges::size(_M_base); }
8998 base() const & requires copy_constructible<_Vp>
9006 template<
typename _Range>
9007 enumerate_view(_Range&&) -> enumerate_view<views::all_t<_Range>>;
9009 template<
typename _Tp>
9010 inline constexpr bool enable_borrowed_range<enumerate_view<_Tp>>
9011 = enable_borrowed_range<_Tp>;
9014 requires __detail::__range_with_movable_reference<_Vp>
9015 template<
bool _Const>
9016 class enumerate_view<_Vp>::_Iterator
9018 using _Base = __maybe_const_t<_Const, _Vp>;
9023 if constexpr (random_access_range<_Base>)
9024 return random_access_iterator_tag{};
9025 else if constexpr (bidirectional_range<_Base>)
9026 return bidirectional_iterator_tag{};
9027 else if constexpr (forward_range<_Base>)
9028 return forward_iterator_tag{};
9030 return input_iterator_tag{};
9033 friend enumerate_view;
9036 using iterator_category = input_iterator_tag;
9037 using iterator_concept =
decltype(_S_iter_concept());
9038 using difference_type = range_difference_t<_Base>;
9039 using value_type = tuple<difference_type, range_value_t<_Base>>;
9042 using __reference_type = tuple<difference_type, range_reference_t<_Base>>;
9044 iterator_t<_Base> _M_current = iterator_t<_Base>();
9045 difference_type _M_pos = 0;
9048 _Iterator(iterator_t<_Base> __current, difference_type __pos)
9049 : _M_current(
std::
move(__current)), _M_pos(__pos)
9053 _Iterator()
requires default_initializable<iterator_t<_Base>> = default;
9056 _Iterator(_Iterator<!_Const> __i)
9057 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
9058 : _M_current(
std::move(__i._M_current)), _M_pos(__i._M_pos)
9061 constexpr const iterator_t<_Base> &
9062 base() const & noexcept
9063 {
return _M_current; }
9065 constexpr iterator_t<_Base>
9069 constexpr difference_type
9070 index() const noexcept
9075 {
return __reference_type(_M_pos, *_M_current); }
9077 constexpr _Iterator&
9090 operator++(
int)
requires forward_range<_Base>
9097 constexpr _Iterator&
9098 operator--()
requires bidirectional_range<_Base>
9106 operator--(
int)
requires bidirectional_range<_Base>
9113 constexpr _Iterator&
9114 operator+=(difference_type __n)
requires random_access_range<_Base>
9121 constexpr _Iterator&
9122 operator-=(difference_type __n)
requires random_access_range<_Base>
9130 operator[](difference_type __n)
const requires random_access_range<_Base>
9131 {
return __reference_type(_M_pos + __n, _M_current[__n]); }
9133 friend constexpr bool
9134 operator==(
const _Iterator& __x,
const _Iterator& __y)
noexcept
9135 {
return __x._M_pos == __y._M_pos; }
9137 friend constexpr strong_ordering
9138 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
noexcept
9139 {
return __x._M_pos <=> __y._M_pos; }
9141 friend constexpr _Iterator
9142 operator+(
const _Iterator& __x, difference_type __y)
9143 requires random_access_range<_Base>
9144 {
return (
auto(__x) += __y); }
9146 friend constexpr _Iterator
9147 operator+(difference_type __x,
const _Iterator& __y)
9148 requires random_access_range<_Base>
9149 {
return auto(__y) += __x; }
9151 friend constexpr _Iterator
9152 operator-(
const _Iterator& __x, difference_type __y)
9153 requires random_access_range<_Base>
9154 {
return auto(__x) -= __y; }
9156 friend constexpr difference_type
9157 operator-(
const _Iterator& __x,
const _Iterator& __y)
9158 {
return __x._M_pos - __y._M_pos; }
9160 friend constexpr auto
9161 iter_move(
const _Iterator& __i)
9162 noexcept(
noexcept(ranges::iter_move(__i._M_current))
9163 && is_nothrow_move_constructible_v<range_rvalue_reference_t<_Base>>)
9165 return tuple<difference_type, range_rvalue_reference_t<_Base>>
9166 (__i._M_pos, ranges::iter_move(__i._M_current));
9171 requires __detail::__range_with_movable_reference<_Vp>
9172 template<
bool _Const>
9173 class enumerate_view<_Vp>::_Sentinel
9175 using _Base = __maybe_const_t<_Const, _Vp>;
9177 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
9180 _Sentinel(sentinel_t<_Base> __end)
9184 friend enumerate_view;
9187 _Sentinel() =
default;
9190 _Sentinel(_Sentinel<!_Const> __other)
9191 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
9195 constexpr sentinel_t<_Base>
9199 template<
bool _OtherConst>
9200 requires sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const_t<_OtherConst, _Vp>>>
9201 friend constexpr bool
9202 operator==(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
9203 {
return __x._M_current == __y._M_end; }
9205 template<
bool _OtherConst>
9206 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const_t<_OtherConst, _Vp>>>
9207 friend constexpr range_difference_t<__maybe_const_t<_OtherConst, _Vp>>
9208 operator-(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
9209 {
return __x._M_current - __y._M_end; }
9211 template<
bool _OtherConst>
9212 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const_t<_OtherConst, _Vp>>>
9213 friend constexpr range_difference_t<__maybe_const_t<_OtherConst, _Vp>>
9214 operator-(
const _Sentinel& __x,
const _Iterator<_OtherConst>& __y)
9215 {
return __x._M_end - __y._M_current; }
9222 template<
typename _Tp>
9223 concept __can_enumerate_view
9224 =
requires { enumerate_view<all_t<_Tp>>(std::declval<_Tp>()); };
9227 struct _Enumerate : __adaptor::_RangeAdaptorClosure<_Enumerate>
9229 template<viewable_range _Range>
9230 requires __detail::__can_enumerate_view<_Range>
9232 operator() [[nodiscard]] (_Range&& __r)
const
9233 {
return enumerate_view<all_t<_Range>>(std::forward<_Range>(__r)); }
9236 inline constexpr _Enumerate enumerate;
9240#ifdef __cpp_lib_ranges_as_const
9242 requires input_range<_Vp>
9243 class as_const_view :
public view_interface<as_const_view<_Vp>>
9245 _Vp _M_base = _Vp();
9248 as_const_view()
requires default_initializable<_Vp> = default;
9251 as_const_view(_Vp __base)
9252 noexcept(is_nothrow_move_constructible_v<_Vp>)
9253 : _M_base(
std::move(__base))
9258 noexcept(is_nothrow_copy_constructible_v<_Vp>)
9259 requires copy_constructible<_Vp>
9264 noexcept(is_nothrow_move_constructible_v<_Vp>)
9268 begin()
requires (!__detail::__simple_view<_Vp>)
9269 {
return ranges::cbegin(_M_base); }
9272 begin() const requires range<const _Vp>
9273 {
return ranges::cbegin(_M_base); }
9276 end()
requires (!__detail::__simple_view<_Vp>)
9277 {
return ranges::cend(_M_base); }
9280 end() const requires range<const _Vp>
9281 {
return ranges::cend(_M_base); }
9284 size()
requires sized_range<_Vp>
9285 {
return ranges::size(_M_base); }
9288 size() const requires sized_range<const _Vp>
9289 {
return ranges::size(_M_base); }
9292 template<
typename _Range>
9293 as_const_view(_Range&&) -> as_const_view<views::all_t<_Range>>;
9295 template<
typename _Tp>
9296 inline constexpr bool enable_borrowed_range<as_const_view<_Tp>>
9297 = enable_borrowed_range<_Tp>;
9303 template<
typename _Tp>
9304 inline constexpr bool __is_ref_view =
false;
9306 template<
typename _Range>
9307 inline constexpr bool __is_ref_view<ref_view<_Range>> =
true;
9309 template<
typename _Range>
9310 concept __can_as_const_view =
requires { as_const_view(std::declval<_Range>()); };
9313 struct _AsConst : __adaptor::_RangeAdaptorClosure<_AsConst>
9315 template<viewable_range _Range>
9317 operator()(_Range&& __r)
const
9318 noexcept(
noexcept(as_const_view(std::declval<_Range>())))
9319 requires __detail::__can_as_const_view<_Range>
9321 using _Tp = remove_cvref_t<_Range>;
9322 using element_type = remove_reference_t<range_reference_t<_Range>>;
9323 if constexpr (constant_range<views::all_t<_Range>>)
9324 return views::all(std::forward<_Range>(__r));
9325 else if constexpr (__detail::__is_empty_view<_Tp>)
9326 return views::empty<const element_type>;
9327 else if constexpr (std::__detail::__is_span<_Tp>)
9328 return span<const element_type, _Tp::extent>(std::forward<_Range>(__r));
9329 else if constexpr (__detail::__is_ref_view<_Tp>
9330 && constant_range<const element_type>)
9331 return ref_view(
static_cast<const element_type&
>
9332 (std::forward<_Range>(__r).base()));
9333 else if constexpr (is_lvalue_reference_v<_Range>
9334 && constant_range<const _Tp>
9336 return ref_view(
static_cast<const _Tp&
>(__r));
9338 return as_const_view(std::forward<_Range>(__r));
9342 inline constexpr _AsConst as_const;
9347 namespace views = ranges::views;
9349#if __cpp_lib_ranges_to_container
9355 template<
typename _Container>
9356 constexpr bool __reservable_container
9357 = sized_range<_Container>
9358 &&
requires(_Container& __c, range_size_t<_Container> __n) {
9360 { __c.capacity() } -> same_as<
decltype(__n)>;
9361 { __c.max_size() } -> same_as<
decltype(__n)>;
9364 template<
typename _Cont,
typename _Range>
9365 constexpr bool __toable =
requires {
9366 requires (!input_range<_Cont>
9367 || convertible_to<range_reference_t<_Range>,
9368 range_value_t<_Cont>>);
9389 template<
typename _Cont, input_range _Rg,
typename... _Args>
9390 requires (!view<_Cont>)
9392 to [[nodiscard]] (_Rg&& __r, _Args&&... __args)
9394 static_assert(!is_const_v<_Cont> && !is_volatile_v<_Cont>);
9395 static_assert(is_class_v<_Cont>);
9397 if constexpr (__detail::__toable<_Cont, _Rg>)
9399 if constexpr (constructible_from<_Cont, _Rg, _Args...>)
9400 return _Cont(std::forward<_Rg>(__r),
9401 std::forward<_Args>(__args)...);
9402 else if constexpr (constructible_from<_Cont, from_range_t, _Rg, _Args...>)
9403 return _Cont(from_range, std::forward<_Rg>(__r),
9404 std::forward<_Args>(__args)...);
9405 else if constexpr (
requires {
requires common_range<_Rg>;
9406 typename __iter_category_t<iterator_t<_Rg>>;
9407 requires derived_from<__iter_category_t<iterator_t<_Rg>>,
9408 input_iterator_tag>;
9409 requires constructible_from<_Cont, iterator_t<_Rg>,
9410 sentinel_t<_Rg>, _Args...>;
9412 return _Cont(ranges::begin(__r), ranges::end(__r),
9413 std::forward<_Args>(__args)...);
9416 static_assert(constructible_from<_Cont, _Args...>);
9417 _Cont __c(std::forward<_Args>(__args)...);
9418 if constexpr (sized_range<_Rg>
9419 && __detail::__reservable_container<_Cont>)
9420 __c.reserve(
static_cast<range_size_t<_Cont>
>(ranges::size(__r)));
9424 auto __it = ranges::begin(__r);
9425 const auto __sent = ranges::end(__r);
9426 while (__it != __sent)
9428 if constexpr (
requires { __c.emplace_back(*__it); })
9429 __c.emplace_back(*__it);
9430 else if constexpr (
requires { __c.push_back(*__it); })
9431 __c.push_back(*__it);
9432 else if constexpr (
requires { __c.emplace(__c.end(), *__it); })
9433 __c.emplace(__c.end(), *__it);
9435 __c.insert(__c.end(), *__it);
9443 static_assert(input_range<range_reference_t<_Rg>>);
9446 return ranges::to<_Cont>(ref_view(__r) | views::transform(
9447 []<
typename _Elt>(_Elt&& __elem) {
9448 using _ValT = range_value_t<_Cont>;
9449 return ranges::to<_ValT>(std::forward<_Elt>(__elem));
9450 }), std::forward<_Args>(__args)...);
9457 template<
typename _Rg>
9460 using iterator_category = input_iterator_tag;
9461 using value_type = range_value_t<_Rg>;
9462 using difference_type = ptrdiff_t;
9463 using pointer = add_pointer_t<range_reference_t<_Rg>>;
9464 using reference = range_reference_t<_Rg>;
9466 pointer operator->()
const;
9467 _InputIter& operator++();
9468 _InputIter operator++(
int);
9469 bool operator==(
const _InputIter&)
const;
9472 template<
template<
typename...>
typename _Cont, input_range _Rg,
9475 =
decltype(_Cont(std::declval<_Rg>(), std::declval<_Args>()...));
9477 template<
template<
typename...>
typename _Cont, input_range _Rg,
9480 =
decltype(_Cont(from_range, std::declval<_Rg>(),
9481 std::declval<_Args>()...));
9483 template<
template<
typename...>
typename _Cont, input_range _Rg,
9488 std::declval<_Args>()...));
9493 template<
template<
typename...>
typename _Cont, input_range _Rg,
9496 to [[nodiscard]] (_Rg&& __r, _Args&&... __args)
9498 using __detail::_DeduceExpr1;
9499 using __detail::_DeduceExpr2;
9500 using __detail::_DeduceExpr3;
9501 if constexpr (
requires {
typename _DeduceExpr1<_Cont, _Rg, _Args...>; })
9502 return ranges::to<_DeduceExpr1<_Cont, _Rg, _Args...>>(
9503 std::forward<_Rg>(__r), std::forward<_Args>(__args)...);
9504 else if constexpr (
requires {
typename _DeduceExpr2<_Cont, _Rg, _Args...>; })
9505 return ranges::to<_DeduceExpr2<_Cont, _Rg, _Args...>>(
9506 std::forward<_Rg>(__r), std::forward<_Args>(__args)...);
9507 else if constexpr (
requires {
typename _DeduceExpr3<_Cont, _Rg, _Args...>; })
9508 return ranges::to<_DeduceExpr3<_Cont, _Rg, _Args...>>(
9509 std::forward<_Rg>(__r), std::forward<_Args>(__args)...);
9511 static_assert(
false);
9517 template<
typename _Cont>
9520 template<
typename _Range,
typename... _Args>
9521 requires requires { ranges::to<_Cont>(std::declval<_Range>(),
9522 std::declval<_Args>()...); }
9524 operator()(_Range&& __r, _Args&&... __args)
const
9526 return ranges::to<_Cont>(std::forward<_Range>(__r),
9527 std::forward<_Args>(__args)...);
9548 template<
typename _Cont,
typename... _Args>
9549 requires (!view<_Cont>)
9551 to [[nodiscard]] (_Args&&... __args)
9553 using __detail::_To;
9554 using views::__adaptor::_Partial;
9555 return _Partial<_To<_Cont>, decay_t<_Args>...>{0, std::forward<_Args>(__args)...};
9561 template<
template<
typename...>
typename _Cont>
9564 template<
typename _Range,
typename... _Args>
9565 requires requires { ranges::to<_Cont>(std::declval<_Range>(),
9566 std::declval<_Args>()...); }
9568 operator()(_Range&& __r, _Args&&... __args)
const
9570 return ranges::to<_Cont>(std::forward<_Range>(__r),
9571 std::forward<_Args>(__args)...);
9594 template<
template<
typename...>
typename _Cont,
typename... _Args>
9596 to [[nodiscard]] (_Args&&... __args)
9598 using __detail::_To2;
9599 using views::__adaptor::_Partial;
9600 return _Partial<_To2<_Cont>, decay_t<_Args>...>{0, std::forward<_Args>(__args)...};
9606#if __cpp_lib_ranges_concat
9611 template<
typename... _Rs>
9612 using __concat_reference_t = common_reference_t<range_reference_t<_Rs>...>;
9614 template<
typename... _Rs>
9615 using __concat_value_t = common_type_t<range_value_t<_Rs>...>;
9617 template<
typename... _Rs>
9618 using __concat_rvalue_reference_t
9619 = common_reference_t<range_rvalue_reference_t<_Rs>...>;
9621 template<
typename _Ref,
typename _RRef,
typename _It>
9622 concept __concat_indirectly_readable_impl =
requires(
const _It __it) {
9623 { *__it } -> convertible_to<_Ref>;
9624 { ranges::iter_move(__it) } -> convertible_to<_RRef>;
9627 template<
typename... _Rs>
9628 concept __concat_indirectly_readable
9629 = common_reference_with<__concat_reference_t<_Rs...>&&, __concat_value_t<_Rs...>&>
9630 && common_reference_with<__concat_reference_t<_Rs...>&&,
9631 __concat_rvalue_reference_t<_Rs...>&&>
9632 && common_reference_with<__concat_rvalue_reference_t<_Rs...>&&,
9633 __concat_value_t<_Rs...>
const&>
9634 && (__concat_indirectly_readable_impl<__concat_reference_t<_Rs...>,
9635 __concat_rvalue_reference_t<_Rs...>,
9639 template<
typename... _Rs>
9640 concept __concatable =
requires {
9641 typename __concat_reference_t<_Rs...>;
9642 typename __concat_value_t<_Rs...>;
9643 typename __concat_rvalue_reference_t<_Rs...>;
9644 } && __concat_indirectly_readable<_Rs...>;
9646 template<
bool _Const,
typename _Range,
typename... _Rs>
9647 struct __all_but_last_common
9649 static inline constexpr bool value
9650 =
requires {
requires (common_range<__maybe_const_t<_Const, _Range>>
9651 && __all_but_last_common<_Const, _Rs...>::value); };
9654 template<
bool _Const,
typename _Range>
9655 struct __all_but_last_common<_Const, _Range>
9656 {
static inline constexpr bool value =
true; };
9658 template<
bool _Const,
typename... _Rs>
9659 concept __concat_is_random_access = __all_random_access<_Const, _Rs...>
9660 && __all_but_last_common<_Const, _Rs...>::value;
9662 template<
bool _Const,
typename... _Rs>
9663 concept __concat_is_bidirectional = __all_bidirectional<_Const, _Rs...>
9664 && __all_but_last_common<_Const, _Rs...>::value;
9666 template<
typename _Range,
typename... _Rs>
9667 struct __last_is_common
9668 {
static inline constexpr bool value = __last_is_common<_Rs...>::value; };
9670 template<
typename _Range>
9671 struct __last_is_common<_Range>
9672 {
static inline constexpr bool value = common_range<_Range>; };
9675 template<input_range... _Vs>
9676 requires (view<_Vs> && ...) && (
sizeof...(_Vs) > 0) && __detail::__concatable<_Vs...>
9677 class concat_view :
public view_interface<concat_view<_Vs...>>
9679 tuple<_Vs...> _M_views;
9681 template<
bool _Const>
class iterator;
9684 constexpr concat_view() =
default;
9687 concat_view(_Vs... __views)
9688 : _M_views(
std::
move(__views)...)
9691 constexpr iterator<false>
9692 begin()
requires (!(__detail::__simple_view<_Vs> && ...))
9694 iterator<false> __it(
this, in_place_index<0>, ranges::begin(std::get<0>(_M_views)));
9695 __it.template _M_satisfy<0>();
9699 constexpr iterator<true>
9700 begin() const requires (range<const _Vs> && ...) && __detail::__concatable<const _Vs...>
9702 iterator<true> __it(
this, in_place_index<0>, ranges::begin(std::get<0>(_M_views)));
9703 __it.template _M_satisfy<0>();
9708 end()
requires (!(__detail::__simple_view<_Vs> && ...))
9710 if constexpr ((semiregular<iterator_t<_Vs>> && ...)
9711 && __detail::__last_is_common<_Vs...>::value)
9713 constexpr auto __n =
sizeof...(_Vs);
9714 return iterator<false>(
this, in_place_index<__n - 1>,
9715 ranges::end(std::get<__n - 1>(_M_views)));
9722 end() const requires (range<const _Vs> && ...) && __detail::__concatable<const _Vs...>
9724 if constexpr ((semiregular<iterator_t<const _Vs>> && ...)
9725 && __detail::__last_is_common<
const _Vs...>::value)
9727 constexpr auto __n =
sizeof...(_Vs);
9728 return iterator<true>(
this, in_place_index<__n - 1>,
9729 ranges::end(std::get<__n - 1>(_M_views)));
9736 size()
requires (sized_range<_Vs>&&...)
9738 return std::apply([](
auto... __sizes) {
9739 using _CT = __detail::__make_unsigned_like_t<
common_type_t<
decltype(__sizes)...>>;
9740 return (_CT(__sizes) + ...);
9741 }, __detail::__tuple_transform(ranges::size, _M_views));
9745 size() const requires (sized_range<const _Vs>&&...)
9747 return std::apply([](
auto... __sizes) {
9748 using _CT = __detail::__make_unsigned_like_t<
common_type_t<
decltype(__sizes)...>>;
9749 return (_CT(__sizes) + ...);
9750 }, __detail::__tuple_transform(ranges::size, _M_views));
9754 template<
typename... _Rs>
9755 concat_view(_Rs&&...) -> concat_view<views::all_t<_Rs>...>;
9759 template<
bool _Const,
typename... _Vs>
9760 struct __concat_view_iter_cat
9763 template<
bool _Const,
typename... _Vs>
9764 requires __detail::__all_forward<_Const, _Vs...>
9765 struct __concat_view_iter_cat<_Const, _Vs...>
9770 if constexpr (!is_reference_v<__concat_reference_t<__maybe_const_t<_Const, _Vs>...>>)
9771 return input_iterator_tag{};
9773 return []<
typename... _Cats>(_Cats... __cats) {
9774 if constexpr ((derived_from<_Cats, random_access_iterator_tag> && ...)
9775 && __concat_is_random_access<_Const, _Vs...>)
9776 return random_access_iterator_tag{};
9777 else if constexpr ((derived_from<_Cats, bidirectional_iterator_tag> && ...)
9778 && __concat_is_bidirectional<_Const, _Vs...>)
9779 return bidirectional_iterator_tag{};
9780 else if constexpr ((derived_from<_Cats, forward_iterator_tag> && ...))
9781 return forward_iterator_tag{};
9783 return input_iterator_tag{};
9784 }(
typename iterator_traits<iterator_t<__maybe_const_t<_Const, _Vs>>>
9785 ::iterator_category{}...);
9790 template<input_range... _Vs>
9791 requires (view<_Vs> && ...) && (
sizeof...(_Vs) > 0) && __detail::__concatable<_Vs...>
9792 template<
bool _Const>
9793 class concat_view<_Vs...>::iterator
9794 :
public __detail::__concat_view_iter_cat<_Const, _Vs...>
9799 if constexpr (__detail::__concat_is_random_access<_Const, _Vs...>)
9800 return random_access_iterator_tag{};
9801 else if constexpr (__detail::__concat_is_bidirectional<_Const, _Vs...>)
9802 return bidirectional_iterator_tag{};
9803 else if constexpr (__detail::__all_forward<_Const, _Vs...>)
9804 return forward_iterator_tag{};
9806 return input_iterator_tag{};
9810 friend iterator<!_Const>;
9814 using iterator_concept =
decltype(_S_iter_concept());
9815 using value_type = __detail::__concat_value_t<__maybe_const_t<_Const, _Vs>...>;
9816 using difference_type = common_type_t<range_difference_t<__maybe_const_t<_Const, _Vs>>...>;
9819 using __base_iter = variant<iterator_t<__maybe_const_t<_Const, _Vs>>...>;
9821 __maybe_const_t<_Const, concat_view>* _M_parent =
nullptr;
9824 template<
size_t _Nm>
9828 if constexpr (_Nm < (
sizeof...(_Vs) - 1))
9830 if (std::get<_Nm>(_M_it) == ranges::end(std::get<_Nm>(_M_parent->_M_views)))
9832 _M_it.template emplace<_Nm + 1>(ranges::begin
9833 (std::get<_Nm + 1>(_M_parent->_M_views)));
9834 _M_satisfy<_Nm + 1>();
9839 template<
size_t _Nm>
9843 if constexpr (_Nm == 0)
9844 --std::get<0>(_M_it);
9847 if (std::get<_Nm>(_M_it) == ranges::begin(std::get<_Nm>(_M_parent->_M_views)))
9849 _M_it.template emplace<_Nm - 1>(ranges::end
9850 (std::get<_Nm - 1>(_M_parent->_M_views)));
9854 --std::get<_Nm>(_M_it);
9858 template<
size_t _Nm>
9860 _M_advance_fwd(difference_type __offset, difference_type __steps)
9862 using _Dt = iter_difference_t<variant_alternative_t<_Nm, __base_iter>>;
9863 if constexpr (_Nm ==
sizeof...(_Vs) - 1)
9864 std::get<_Nm>(_M_it) +=
static_cast<_Dt
>(__steps);
9867 auto __n_size = ranges::distance(std::get<_Nm>(_M_parent->_M_views));
9868 if (__offset + __steps < __n_size)
9869 std::get<_Nm>(_M_it) +=
static_cast<_Dt
>(__steps);
9872 _M_it.template emplace<_Nm + 1>(ranges::begin
9873 (std::get<_Nm + 1>(_M_parent->_M_views)));
9874 _M_advance_fwd<_Nm + 1>(0, __offset + __steps - __n_size);
9879 template<
size_t _Nm>
9881 _M_advance_bwd(difference_type __offset, difference_type __steps)
9883 using _Dt = iter_difference_t<variant_alternative_t<_Nm, __base_iter>>;
9884 if constexpr (_Nm == 0)
9885 std::get<_Nm>(_M_it) -=
static_cast<_Dt
>(__steps);
9887 if (__offset >= __steps)
9888 std::get<_Nm>(_M_it) -=
static_cast<_Dt
>(__steps);
9891 auto __prev_size = ranges::distance(std::get<_Nm - 1>(_M_parent->_M_views));
9892 _M_it.template emplace<_Nm - 1>(ranges::end
9893 (std::get<_Nm - 1>(_M_parent->_M_views)));
9894 _M_advance_bwd<_Nm - 1>(__prev_size, __steps - __offset);
9902 template<
typename _Fp>
9903 static constexpr auto
9904 _S_invoke_with_runtime_index(_Fp&& __f,
size_t __index)
9906 return [&__f, __index]<
size_t _Idx>(
this auto&& __self) {
9907 if (_Idx == __index)
9908 return __f.template operator()<_Idx>();
9909 if constexpr (_Idx + 1 <
sizeof...(_Vs))
9910 return __self.template operator()<_Idx + 1>();
9911 }.template operator()<0>();
9914 template<
typename _Fp>
9916 _M_invoke_with_runtime_index(_Fp&& __f)
9917 {
return _S_invoke_with_runtime_index(std::forward<_Fp>(__f), _M_it.index()); }
9919 template<
typename... _Args>
9921 iterator(__maybe_const_t<_Const, concat_view>* __parent, _Args&&... __args)
9922 requires constructible_from<__base_iter, _Args&&...>
9923 : _M_parent(__parent), _M_it(std::forward<_Args>(__args)...)
9927 iterator() =
default;
9930 iterator(iterator<!_Const> __it)
9931 requires _Const && (convertible_to<iterator_t<_Vs>, iterator_t<const _Vs>> && ...)
9932 : _M_parent(__it._M_parent)
9934 _M_invoke_with_runtime_index([
this, &__it]<
size_t _Idx>() {
9935 _M_it.template emplace<_Idx>(std::get<_Idx>(
std::move(__it._M_it)));
9939 constexpr decltype(
auto)
9942 __glibcxx_assert(!_M_it.valueless_by_exception());
9943 using reference = __detail::__concat_reference_t<__maybe_const_t<_Const, _Vs>...>;
9944 return std::visit([](
auto&& __it) -> reference {
return *__it; }, _M_it);
9950 _M_invoke_with_runtime_index([
this]<
size_t _Idx>() {
9951 ++std::get<_Idx>(_M_it);
9963 requires __detail::__all_forward<_Const, _Vs...>
9972 requires __detail::__concat_is_bidirectional<_Const, _Vs...>
9974 __glibcxx_assert(!_M_it.valueless_by_exception());
9975 _M_invoke_with_runtime_index([
this]<
size_t _Idx>() {
9983 requires __detail::__concat_is_bidirectional<_Const, _Vs...>
9991 operator+=(difference_type __n)
9992 requires __detail::__concat_is_random_access<_Const, _Vs...>
9994 __glibcxx_assert(!_M_it.valueless_by_exception());
9995 _M_invoke_with_runtime_index([
this, __n]<
size_t _Idx>() {
9996 auto __begin = ranges::begin(std::get<_Idx>(_M_parent->_M_views));
9998 _M_advance_fwd<_Idx>(std::get<_Idx>(_M_it) - __begin, __n);
10000 _M_advance_bwd<_Idx>(std::get<_Idx>(_M_it) - __begin, -__n);
10005 constexpr iterator&
10006 operator-=(difference_type __n)
10007 requires __detail::__concat_is_random_access<_Const, _Vs...>
10013 constexpr decltype(
auto)
10014 operator[](difference_type __n)
const
10015 requires __detail::__concat_is_random_access<_Const, _Vs...>
10016 {
return *((*this) + __n); }
10018 friend constexpr bool
10019 operator==(
const iterator& __x,
const iterator& __y)
10020 requires (equality_comparable<iterator_t<__maybe_const_t<_Const, _Vs>>> && ...)
10022 __glibcxx_assert(!__x._M_it.valueless_by_exception());
10023 __glibcxx_assert(!__y._M_it.valueless_by_exception());
10024 return __x._M_it == __y._M_it;
10027 friend constexpr bool
10028 operator==(
const iterator& __it, default_sentinel_t)
10030 __glibcxx_assert(!__it._M_it.valueless_by_exception());
10031 constexpr auto __last_idx =
sizeof...(_Vs) - 1;
10032 return (__it._M_it.index() == __last_idx
10033 && (std::get<__last_idx>(__it._M_it)
10034 == ranges::end(std::get<__last_idx>(__it._M_parent->_M_views))));
10037 friend constexpr bool
10038 operator<(
const iterator& __x,
const iterator& __y)
10039 requires __detail::__all_random_access<_Const, _Vs...>
10040 {
return __x._M_it < __y._M_it; }
10042 friend constexpr bool
10043 operator>(
const iterator& __x,
const iterator& __y)
10044 requires __detail::__all_random_access<_Const, _Vs...>
10045 {
return __x._M_it > __y._M_it; }
10047 friend constexpr bool
10048 operator<=(
const iterator& __x,
const iterator& __y)
10049 requires __detail::__all_random_access<_Const, _Vs...>
10050 {
return __x._M_it <= __y._M_it; }
10052 friend constexpr bool
10053 operator>=(
const iterator& __x,
const iterator& __y)
10054 requires __detail::__all_random_access<_Const, _Vs...>
10055 {
return __x._M_it >= __y._M_it; }
10057 friend constexpr auto
10058 operator<=>(
const iterator& __x,
const iterator& __y)
10059 requires __detail::__all_random_access<_Const, _Vs...>
10060 && (three_way_comparable<iterator_t<__maybe_const_t<_Const, _Vs>>> && ...)
10061 {
return __x._M_it <=> __y._M_it; }
10063 friend constexpr iterator
10064 operator+(
const iterator& __it, difference_type __n)
10065 requires __detail::__concat_is_random_access<_Const, _Vs...>
10066 {
return auto(__it) += __n; }
10068 friend constexpr iterator
10069 operator+(difference_type __n,
const iterator& __it)
10070 requires __detail::__concat_is_random_access<_Const, _Vs...>
10071 {
return __it + __n; }
10073 friend constexpr iterator
10074 operator-(
const iterator& __it, difference_type __n)
10075 requires __detail::__concat_is_random_access<_Const, _Vs...>
10076 {
return auto(__it) -= __n; }
10078 friend constexpr difference_type
10079 operator-(
const iterator& __x,
const iterator& __y)
10080 requires __detail::__concat_is_random_access<_Const, _Vs...>
10082 return _S_invoke_with_runtime_index([&]<
size_t _Ix>() -> difference_type {
10083 return _S_invoke_with_runtime_index([&]<
size_t _Iy>() -> difference_type {
10084 if constexpr (_Ix > _Iy)
10086 auto __dy = ranges::distance(std::get<_Iy>(__y._M_it),
10087 ranges::end(std::get<_Iy>(__y._M_parent
10089 auto __dx = ranges::distance(ranges::begin(std::get<_Ix>(__x._M_parent
10091 std::get<_Ix>(__x._M_it));
10092 difference_type __s = 0;
10093 [&]<
size_t _Idx = _Iy + 1>(
this auto&& __self) {
10094 if constexpr (_Idx < _Ix)
10096 __s += ranges::size(std::get<_Idx>(__x._M_parent->_M_views));
10097 __self.template operator()<_Idx + 1>();
10100 return __dy + __s + __dx;
10102 else if constexpr (_Ix < _Iy)
10103 return -(__y - __x);
10105 return std::get<_Ix>(__x._M_it) - std::get<_Iy>(__y._M_it);
10106 }, __y._M_it.index());
10107 }, __x._M_it.index());
10110 friend constexpr difference_type
10111 operator-(
const iterator& __x, default_sentinel_t)
10112 requires __detail::__concat_is_random_access<_Const, _Vs...>
10113 && __detail::__last_is_common<__maybe_const_t<_Const, _Vs>...>::value
10115 return _S_invoke_with_runtime_index([&]<
size_t _Ix>() -> difference_type {
10116 auto __dx = ranges::distance(std::get<_Ix>(__x._M_it),
10117 ranges::end(std::get<_Ix>(__x._M_parent->_M_views)));
10118 difference_type __s = 0;
10119 [&]<
size_t _Idx = _Ix + 1>(
this auto&& __self) {
10120 if constexpr (_Idx <
sizeof...(_Vs))
10122 __s += ranges::size(std::get<_Idx>(__x._M_parent->_M_views));
10123 __self.template operator()<_Idx + 1>();
10126 return -(__dx + __s);
10127 }, __x._M_it.index());
10130 friend constexpr difference_type
10131 operator-(default_sentinel_t,
const iterator& __x)
10132 requires __detail::__concat_is_random_access<_Const, _Vs...>
10133 && __detail::__last_is_common<__maybe_const_t<_Const, _Vs>...>::value
10136 friend constexpr decltype(
auto)
10137 iter_move(
const iterator& __it)
10139 using _Res = __detail::__concat_rvalue_reference_t<__maybe_const_t<_Const, _Vs>...>;
10140 return std::visit([](
const auto& __i) -> _Res {
10141 return ranges::iter_move(__i);
10145 friend constexpr void
10146 iter_swap(
const iterator& __x,
const iterator& __y)
10147 requires swappable_with<iter_reference_t<iterator>, iter_reference_t<iterator>>
10148 && (... && indirectly_swappable<iterator_t<__maybe_const_t<_Const, _Vs>>>)
10150 std::visit([&]<
typename _Tp,
typename _Up>(
const _Tp& __it1,
const _Up& __it2) {
10151 if constexpr (is_same_v<_Tp, _Up>)
10152 ranges::iter_swap(__it1, __it2);
10154 ranges::swap(*__it1, *__it2);
10155 }, __x._M_it, __y._M_it);
10163 template<
typename... _Ts>
10164 concept __can_concat_view =
requires { concat_view(std::declval<_Ts>()...); };
10169 template<
typename... _Ts>
10170 requires __detail::__can_concat_view<_Ts...>
10172 operator() [[nodiscard]] (_Ts&&... __ts)
const
10174 if constexpr (
sizeof...(_Ts) == 1)
10175 return views::all(std::forward<_Ts>(__ts)...);
10177 return concat_view(std::forward<_Ts>(__ts)...);
10181 inline constexpr _Concat concat;
10187_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.
constexpr _Tp * to_address(_Tp *__ptr) noexcept
Obtain address referenced by a pointer to an object.
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)