30#ifndef _GLIBCXX_RANGES
31#define _GLIBCXX_RANGES 1
33#if __cplusplus > 201703L
35#pragma GCC system_header
48#if __cplusplus > 202002L
54#define __glibcxx_want_ranges
55#define __glibcxx_want_ranges_as_const
56#define __glibcxx_want_ranges_as_rvalue
57#define __glibcxx_want_ranges_cartesian_product
58#define __glibcxx_want_ranges_chunk
59#define __glibcxx_want_ranges_chunk_by
60#define __glibcxx_want_ranges_enumerate
61#define __glibcxx_want_ranges_iota
62#define __glibcxx_want_ranges_join_with
63#define __glibcxx_want_ranges_repeat
64#define __glibcxx_want_ranges_slide
65#define __glibcxx_want_ranges_stride
66#define __glibcxx_want_ranges_to_container
67#define __glibcxx_want_ranges_zip
70#ifdef __glibcxx_generator
71# include <bits/elements_of.h>
80namespace std _GLIBCXX_VISIBILITY(default)
82_GLIBCXX_BEGIN_NAMESPACE_VERSION
97 template<
typename _Tp>
requires is_object_v<_Tp>
99 :
public view_interface<empty_view<_Tp>>
102 static constexpr _Tp*
begin() noexcept {
return nullptr; }
103 static constexpr _Tp*
end() noexcept {
return nullptr; }
104 static constexpr _Tp*
data() noexcept {
return nullptr; }
105 static constexpr size_t size() noexcept {
return 0; }
106 static constexpr bool empty() noexcept {
return true; }
109 template<
typename _Tp>
110 inline constexpr bool enable_borrowed_range<empty_view<_Tp>> =
true;
114#if __cpp_lib_ranges >= 202207L
116 template<
typename _Tp>
117 concept __boxable = move_constructible<_Tp> && is_object_v<_Tp>;
119 template<
typename _Tp>
120 concept __boxable = copy_constructible<_Tp> && is_object_v<_Tp>;
123 template<__boxable _Tp>
124 struct __box : std::optional<_Tp>
126 using std::optional<_Tp>::optional;
130 noexcept(is_nothrow_default_constructible_v<_Tp>)
131 requires default_initializable<_Tp>
132 :
std::optional<_Tp>{std::in_place}
135 __box(
const __box&) =
default;
136 __box(__box&&) =
default;
138 using std::optional<_Tp>::operator=;
144 operator=(
const __box& __that)
145 noexcept(is_nothrow_copy_constructible_v<_Tp>)
146 requires (!copyable<_Tp>) && copy_constructible<_Tp>
151 this->emplace(*__that);
159 operator=(__box&& __that)
160 noexcept(is_nothrow_move_constructible_v<_Tp>)
161 requires (!movable<_Tp>)
174 template<
typename _Tp>
175 concept __boxable_copyable
176 = copy_constructible<_Tp>
177 && (copyable<_Tp> || (is_nothrow_move_constructible_v<_Tp>
178 && is_nothrow_copy_constructible_v<_Tp>));
179 template<
typename _Tp>
180 concept __boxable_movable
181 = (!copy_constructible<_Tp>)
182 && (movable<_Tp> || is_nothrow_move_constructible_v<_Tp>);
188 template<__boxable _Tp>
189 requires __boxable_copyable<_Tp> || __boxable_movable<_Tp>
193 [[no_unique_address]] _Tp _M_value = _Tp();
196 __box()
requires default_initializable<_Tp> = default;
199 __box(const _Tp& __t)
200 noexcept(is_nothrow_copy_constructible_v<_Tp>)
201 requires copy_constructible<_Tp>
207 noexcept(is_nothrow_move_constructible_v<_Tp>)
211 template<
typename... _Args>
212 requires constructible_from<_Tp, _Args...>
214 __box(in_place_t, _Args&&... __args)
215 noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
216 : _M_value(std::forward<_Args>(__args)...)
219 __box(
const __box&) =
default;
220 __box(__box&&) =
default;
221 __box& operator=(
const __box&)
requires copyable<_Tp> =
default;
222 __box& operator=(__box&&)
requires movable<_Tp> = default;
227 operator=(const __box& __that) noexcept
228 requires (!copyable<_Tp>) && copy_constructible<_Tp>
230 static_assert(is_nothrow_copy_constructible_v<_Tp>);
241 operator=(__box&& __that)
noexcept
242 requires (!movable<_Tp>)
244 static_assert(is_nothrow_move_constructible_v<_Tp>);
254 has_value() const noexcept
269 constexpr const _Tp&&
274 operator->() noexcept
278 operator->() const noexcept
284#if __cpp_lib_ranges >= 202207L
285 template<move_constructible _Tp>
287 template<copy_constructible _Tp>
289 requires is_object_v<_Tp>
290 class single_view :
public view_interface<single_view<_Tp>>
293 single_view()
requires default_initializable<_Tp> = default;
296 single_view(const _Tp& __t)
297 noexcept(is_nothrow_copy_constructible_v<_Tp>)
298 requires copy_constructible<_Tp>
303 single_view(_Tp&& __t)
304 noexcept(is_nothrow_move_constructible_v<_Tp>)
310 template<
typename... _Args>
311 requires constructible_from<_Tp, _Args...>
313 single_view(in_place_t, _Args&&... __args)
314 noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
315 : _M_value{in_place, std::forward<_Args>(__args)...}
323 begin() const noexcept
328 {
return data() + 1; }
332 {
return data() + 1; }
336 static constexpr bool
340 static constexpr size_t
346 {
return _M_value.operator->(); }
349 data() const noexcept
350 {
return _M_value.operator->(); }
353 [[no_unique_address]] __detail::__box<_Tp> _M_value;
356 template<
typename _Tp>
357 single_view(_Tp) -> single_view<_Tp>;
361 template<
typename _Wp>
362 constexpr auto __to_signed_like(_Wp __w)
noexcept
364 if constexpr (!integral<_Wp>)
365 return iter_difference_t<_Wp>();
366 else if constexpr (
sizeof(iter_difference_t<_Wp>) >
sizeof(_Wp))
367 return iter_difference_t<_Wp>(__w);
368 else if constexpr (
sizeof(ptrdiff_t) >
sizeof(_Wp))
369 return ptrdiff_t(__w);
370 else if constexpr (
sizeof(
long long) >
sizeof(_Wp))
371 return (
long long)(__w);
372#ifdef __SIZEOF_INT128__
373 else if constexpr (__SIZEOF_INT128__ >
sizeof(_Wp))
374 return __int128(__w);
377 return __max_diff_type(__w);
380 template<
typename _Wp>
381 using __iota_diff_t =
decltype(__to_signed_like(std::declval<_Wp>()));
383 template<
typename _It>
384 concept __decrementable = incrementable<_It>
387 { --__i } -> same_as<_It&>;
388 { __i-- } -> same_as<_It>;
391 template<
typename _It>
392 concept __advanceable = __decrementable<_It> && totally_ordered<_It>
393 &&
requires( _It __i,
const _It __j,
const __iota_diff_t<_It> __n)
395 { __i += __n } -> same_as<_It&>;
396 { __i -= __n } -> same_as<_It&>;
400 { __j - __j } -> convertible_to<__iota_diff_t<_It>>;
403 template<
typename _Winc>
404 struct __iota_view_iter_cat
407 template<incrementable _Winc>
408 struct __iota_view_iter_cat<_Winc>
409 {
using iterator_category = input_iterator_tag; };
412 template<weakly_incrementable _Winc,
413 semiregular _Bound = unreachable_sentinel_t>
414 requires std::__detail::__weakly_eq_cmp_with<_Winc, _Bound>
416 class iota_view :
public view_interface<iota_view<_Winc, _Bound>>
421 struct _Iterator : __detail::__iota_view_iter_cat<_Winc>
427 using namespace __detail;
428 if constexpr (__advanceable<_Winc>)
429 return random_access_iterator_tag{};
430 else if constexpr (__decrementable<_Winc>)
431 return bidirectional_iterator_tag{};
432 else if constexpr (incrementable<_Winc>)
433 return forward_iterator_tag{};
435 return input_iterator_tag{};
439 using iterator_concept =
decltype(_S_iter_concept());
441 using value_type = _Winc;
442 using difference_type = __detail::__iota_diff_t<_Winc>;
444 _Iterator()
requires default_initializable<_Winc> = default;
447 _Iterator(_Winc __value)
448 : _M_value(__value) { }
451 operator*() const noexcept(is_nothrow_copy_constructible_v<_Winc>)
466 operator++(
int)
requires incrementable<_Winc>
474 operator--()
requires __detail::__decrementable<_Winc>
481 operator--(
int)
requires __detail::__decrementable<_Winc>
489 operator+=(difference_type __n)
requires __detail::__advanceable<_Winc>
491 using __detail::__is_integer_like;
492 using __detail::__is_signed_integer_like;
493 if constexpr (__is_integer_like<_Winc>
494 && !__is_signed_integer_like<_Winc>)
496 if (__n >= difference_type(0))
497 _M_value +=
static_cast<_Winc
>(__n);
499 _M_value -=
static_cast<_Winc
>(-__n);
507 operator-=(difference_type __n)
requires __detail::__advanceable<_Winc>
509 using __detail::__is_integer_like;
510 using __detail::__is_signed_integer_like;
511 if constexpr (__is_integer_like<_Winc>
512 && !__is_signed_integer_like<_Winc>)
514 if (__n >= difference_type(0))
515 _M_value -=
static_cast<_Winc
>(__n);
517 _M_value +=
static_cast<_Winc
>(-__n);
525 operator[](difference_type __n)
const
526 requires __detail::__advanceable<_Winc>
527 {
return _Winc(_M_value + __n); }
529 friend constexpr bool
530 operator==(
const _Iterator& __x,
const _Iterator& __y)
531 requires equality_comparable<_Winc>
532 {
return __x._M_value == __y._M_value; }
534 friend constexpr bool
535 operator<(
const _Iterator& __x,
const _Iterator& __y)
536 requires totally_ordered<_Winc>
537 {
return __x._M_value < __y._M_value; }
539 friend constexpr bool
540 operator>(
const _Iterator& __x,
const _Iterator& __y)
541 requires totally_ordered<_Winc>
542 {
return __y < __x; }
544 friend constexpr bool
545 operator<=(
const _Iterator& __x,
const _Iterator& __y)
546 requires totally_ordered<_Winc>
547 {
return !(__y < __x); }
549 friend constexpr bool
550 operator>=(
const _Iterator& __x,
const _Iterator& __y)
551 requires totally_ordered<_Winc>
552 {
return !(__x < __y); }
554#ifdef __cpp_lib_three_way_comparison
555 friend constexpr auto
556 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
557 requires totally_ordered<_Winc> && three_way_comparable<_Winc>
558 {
return __x._M_value <=> __y._M_value; }
561 friend constexpr _Iterator
562 operator+(_Iterator __i, difference_type __n)
563 requires __detail::__advanceable<_Winc>
569 friend constexpr _Iterator
570 operator+(difference_type __n, _Iterator __i)
571 requires __detail::__advanceable<_Winc>
572 {
return __i += __n; }
574 friend constexpr _Iterator
575 operator-(_Iterator __i, difference_type __n)
576 requires __detail::__advanceable<_Winc>
582 friend constexpr difference_type
583 operator-(
const _Iterator& __x,
const _Iterator& __y)
584 requires __detail::__advanceable<_Winc>
586 using __detail::__is_integer_like;
587 using __detail::__is_signed_integer_like;
588 using _Dt = difference_type;
589 if constexpr (__is_integer_like<_Winc>)
591 if constexpr (__is_signed_integer_like<_Winc>)
592 return _Dt(_Dt(__x._M_value) - _Dt(__y._M_value));
594 return (__y._M_value > __x._M_value)
595 ? _Dt(-_Dt(__y._M_value - __x._M_value))
596 : _Dt(__x._M_value - __y._M_value);
599 return __x._M_value - __y._M_value;
603 _Winc _M_value = _Winc();
613 _M_equal(
const _Iterator& __x)
const
614 {
return __x._M_value == _M_bound; }
617 _M_distance_from(
const _Iterator& __x)
const
618 {
return _M_bound - __x._M_value; }
620 _Bound _M_bound = _Bound();
623 _Sentinel() =
default;
626 _Sentinel(_Bound __bound)
627 : _M_bound(__bound) { }
629 friend constexpr bool
630 operator==(
const _Iterator& __x,
const _Sentinel& __y)
631 {
return __y._M_equal(__x); }
633 friend constexpr iter_difference_t<_Winc>
634 operator-(
const _Iterator& __x,
const _Sentinel& __y)
635 requires sized_sentinel_for<_Bound, _Winc>
636 {
return -__y._M_distance_from(__x); }
638 friend constexpr iter_difference_t<_Winc>
639 operator-(
const _Sentinel& __x,
const _Iterator& __y)
640 requires sized_sentinel_for<_Bound, _Winc>
641 {
return __x._M_distance_from(__y); }
646 _Winc _M_value = _Winc();
647 [[no_unique_address]] _Bound _M_bound = _Bound();
650 iota_view()
requires default_initializable<_Winc> = default;
653 iota_view(_Winc __value)
658 iota_view(type_identity_t<_Winc> __value,
659 type_identity_t<_Bound> __bound)
660 : _M_value(__value), _M_bound(__bound)
662 if constexpr (totally_ordered_with<_Winc, _Bound>)
663 __glibcxx_assert(
bool(__value <= __bound) );
667 iota_view(_Iterator __first, _Iterator __last)
668 requires same_as<_Winc, _Bound>
669 : iota_view(__first._M_value, __last._M_value)
673 iota_view(_Iterator __first, unreachable_sentinel_t __last)
674 requires same_as<_Bound, unreachable_sentinel_t>
675 : iota_view(__first._M_value, __last)
679 iota_view(_Iterator __first, _Sentinel __last)
680 requires (!same_as<_Winc, _Bound>) && (!same_as<_Bound, unreachable_sentinel_t>)
681 : iota_view(__first._M_value, __last._M_bound)
685 begin()
const {
return _Iterator{_M_value}; }
690 if constexpr (same_as<_Bound, unreachable_sentinel_t>)
691 return unreachable_sentinel;
693 return _Sentinel{_M_bound};
697 end() const requires same_as<_Winc, _Bound>
698 {
return _Iterator{_M_bound}; }
704 {
return _M_value == _M_bound; }
708 requires (same_as<_Winc, _Bound> && __detail::__advanceable<_Winc>)
709 || (integral<_Winc> && integral<_Bound>)
710 || sized_sentinel_for<_Bound, _Winc>
712 using __detail::__is_integer_like;
713 using __detail::__to_unsigned_like;
714 if constexpr (integral<_Winc> && integral<_Bound>)
717 return _Up(_M_bound) - _Up(_M_value);
719 else if constexpr (__is_integer_like<_Winc>)
720 return __to_unsigned_like(_M_bound) - __to_unsigned_like(_M_value);
722 return __to_unsigned_like(_M_bound - _M_value);
726 template<
typename _Winc,
typename _Bound>
727 requires (!__detail::__is_integer_like<_Winc>
728 || !__detail::__is_integer_like<_Bound>
729 || (__detail::__is_signed_integer_like<_Winc>
730 == __detail::__is_signed_integer_like<_Bound>))
731 iota_view(_Winc, _Bound) -> iota_view<_Winc, _Bound>;
733 template<
typename _Winc,
typename _Bound>
734 inline constexpr bool
735 enable_borrowed_range<iota_view<_Winc, _Bound>> =
true;
739 template<
typename _Tp>
740 inline constexpr empty_view<_Tp>
empty{};
744 template<
typename _Tp>
745 concept __can_single_view
746 =
requires { single_view<decay_t<_Tp>>(std::declval<_Tp>()); };
751 template<__detail::__can_single_view _Tp>
753 operator() [[nodiscard]] (_Tp&& __e)
const
754 noexcept(
noexcept(single_view<decay_t<_Tp>>(std::forward<_Tp>(__e))))
755 {
return single_view<decay_t<_Tp>>(std::forward<_Tp>(__e)); }
758 inline constexpr _Single single{};
762 template<
typename... _Args>
763 concept __can_iota_view =
requires { iota_view(std::declval<_Args>()...); };
768 template<__detail::__can_iota_view _Tp>
770 operator() [[nodiscard]] (_Tp&& __e)
const
771 {
return iota_view(std::forward<_Tp>(__e)); }
773 template<
typename _Tp,
typename _Up>
774 requires __detail::__can_iota_view<_Tp, _Up>
776 operator() [[nodiscard]] (_Tp&& __e, _Up&& __f)
const
777 {
return iota_view(std::forward<_Tp>(__e), std::forward<_Up>(__f)); }
780 inline constexpr _Iota
iota{};
786 template<
typename _Val,
typename _CharT,
typename _Traits>
787 concept __stream_extractable
788 =
requires(basic_istream<_CharT, _Traits>& is, _Val& t) { is >> t; };
791 template<movable _Val,
typename _CharT,
792 typename _Traits = char_traits<_CharT>>
793 requires default_initializable<_Val>
794 && __detail::__stream_extractable<_Val, _CharT, _Traits>
795 class basic_istream_view
796 :
public view_interface<basic_istream_view<_Val, _CharT, _Traits>>
800 basic_istream_view(basic_istream<_CharT, _Traits>& __stream)
807 *_M_stream >> _M_object;
808 return _Iterator{
this};
811 constexpr default_sentinel_t
816 basic_istream<_CharT, _Traits>* _M_stream;
817 _Val _M_object = _Val();
822 using iterator_concept = input_iterator_tag;
823 using difference_type = ptrdiff_t;
824 using value_type = _Val;
827 _Iterator(basic_istream_view* __parent) noexcept
828 : _M_parent(__parent)
831 _Iterator(
const _Iterator&) =
delete;
832 _Iterator(_Iterator&&) =
default;
833 _Iterator& operator=(
const _Iterator&) =
delete;
834 _Iterator& operator=(_Iterator&&) =
default;
839 *_M_parent->_M_stream >> _M_parent->_M_object;
849 {
return _M_parent->_M_object; }
852 operator==(
const _Iterator& __x, default_sentinel_t)
853 {
return __x._M_at_end(); }
856 basic_istream_view* _M_parent;
860 {
return !*_M_parent->_M_stream; }
866 template<
typename _Val>
867 using istream_view = basic_istream_view<_Val, char>;
869 template<
typename _Val>
870 using wistream_view = basic_istream_view<_Val, wchar_t>;
876 template<
typename _Tp,
typename _Up>
877 concept __can_istream_view =
requires (_Up __e) {
878 basic_istream_view<_Tp, typename _Up::char_type, typename _Up::traits_type>(__e);
882 template<
typename _Tp>
885 template<
typename _CharT,
typename _Traits>
887 operator() [[nodiscard]] (basic_istream<_CharT, _Traits>& __e)
const
889 {
return basic_istream_view<_Tp, _CharT, _Traits>(__e); }
892 template<
typename _Tp>
893 inline constexpr _Istream<_Tp>
istream;
901 template<
typename _Tp,
int _Disc>
910 template<
bool _Present,
typename _Tp,
int _Disc = 0>
911 using __maybe_present_t = __conditional_t<_Present, _Tp, _Absent<_Tp, _Disc>>;
914 template<
bool _Const,
typename _Tp>
915 using __maybe_const_t = __conditional_t<_Const, const _Tp, _Tp>;
920using __detail::__maybe_const_t;
922namespace views::__adaptor
925 template<
typename _Adaptor,
typename... _Args>
926 concept __adaptor_invocable
927 =
requires { std::declval<_Adaptor>()(declval<_Args>()...); };
931 template<
typename _Adaptor,
typename... _Args>
932 concept __adaptor_partial_app_viable = (_Adaptor::_S_arity > 1)
933 && (
sizeof...(_Args) == _Adaptor::_S_arity - 1)
934 && (constructible_from<decay_t<_Args>, _Args> && ...);
936 template<
typename _Adaptor,
typename... _Args>
939 template<
typename _Lhs,
typename _Rhs>
947 template<
typename _Derived>
948 struct _RangeAdaptorClosure
951 template<
typename _Tp,
typename _Up>
952 requires (!same_as<_Tp, _RangeAdaptorClosure<_Up>>)
953 void __is_range_adaptor_closure_fn
954 (
const _Tp&,
const _RangeAdaptorClosure<_Up>&);
956 template<
typename _Tp>
957 concept __is_range_adaptor_closure
958 =
requires (_Tp __t) { __adaptor::__is_range_adaptor_closure_fn(__t, __t); };
960#pragma GCC diagnostic push
961#pragma GCC diagnostic ignored "-Wdangling-reference"
963 template<
typename _Self,
typename _Range>
964 requires __is_range_adaptor_closure<_Self>
965 && __adaptor_invocable<_Self, _Range>
968 {
return std::forward<_Self>(__self)(std::forward<_Range>(__r)); }
972 template<
typename _Lhs,
typename _Rhs>
973 requires __is_range_adaptor_closure<_Lhs>
974 && __is_range_adaptor_closure<_Rhs>
978 return _Pipe<decay_t<_Lhs>, decay_t<_Rhs>>{std::forward<_Lhs>(__lhs),
979 std::forward<_Rhs>(__rhs)};
981#pragma GCC diagnostic pop
994 template<
typename _Derived>
999 template<
typename... _Args>
1000 requires __adaptor_partial_app_viable<_Derived, _Args...>
1002 operator()(_Args&&... __args)
const
1004 return _Partial<_Derived, decay_t<_Args>...>{0, std::forward<_Args>(__args)...};
1011 template<
typename _Adaptor>
1012 concept __closure_has_simple_call_op = _Adaptor::_S_has_simple_call_op;
1016 template<
typename _Adaptor,
typename... _Args>
1017 concept __adaptor_has_simple_extra_args = _Adaptor::_S_has_simple_extra_args
1018 || _Adaptor::template _S_has_simple_extra_args<_Args...>;
1022 template<
typename _Adaptor,
typename... _Args>
1023 struct _Partial : _RangeAdaptorClosure<_Partial<_Adaptor, _Args...>>
1025 tuple<_Args...> _M_args;
1029 template<
typename... _Ts>
1031 _Partial(
int, _Ts&&... __args)
1037#if __cpp_explicit_this_parameter
1038 template<
typename _Self,
typename _Range>
1039 requires __adaptor_invocable<_Adaptor, _Range, __like_t<_Self, _Args>...>
1041 operator()(
this _Self&& __self, _Range&& __r)
1043 auto __forwarder = [&__r] (
auto&&... __args) {
1044 return _Adaptor{}(std::forward<_Range>(__r),
1045 std::forward<decltype(__args)>(__args)...);
1047 return std::apply(__forwarder, __like_t<_Self, _Partial>(__self)._M_args);
1050 template<
typename _Range>
1051 requires __adaptor_invocable<_Adaptor, _Range,
const _Args&...>
1053 operator()(_Range&& __r)
const &
1055 auto __forwarder = [&__r] (
const auto&... __args) {
1056 return _Adaptor{}(std::forward<_Range>(__r), __args...);
1058 return std::apply(__forwarder, _M_args);
1061 template<
typename _Range>
1062 requires __adaptor_invocable<_Adaptor, _Range, _Args...>
1064 operator()(_Range&& __r) &&
1066 auto __forwarder = [&__r] (
auto&... __args) {
1067 return _Adaptor{}(std::forward<_Range>(__r),
std::move(__args)...);
1069 return std::apply(__forwarder, _M_args);
1072 template<
typename _Range>
1074 operator()(_Range&& __r)
const && =
delete;
1080 template<
typename _Adaptor,
typename _Arg>
1081 struct _Partial<_Adaptor, _Arg> : _RangeAdaptorClosure<_Partial<_Adaptor, _Arg>>
1085 template<
typename _Tp>
1087 _Partial(
int, _Tp&& __arg)
1091#if __cpp_explicit_this_parameter
1092 template<
typename _Self,
typename _Range>
1093 requires __adaptor_invocable<_Adaptor, _Range, __like_t<_Self, _Arg>>
1095 operator()(
this _Self&& __self, _Range&& __r)
1097 return _Adaptor{}(std::forward<_Range>(__r),
1098 __like_t<_Self, _Partial>(__self)._M_arg);
1101 template<
typename _Range>
1102 requires __adaptor_invocable<_Adaptor, _Range, const _Arg&>
1104 operator()(_Range&& __r)
const &
1105 {
return _Adaptor{}(std::forward<_Range>(__r), _M_arg); }
1107 template<
typename _Range>
1108 requires __adaptor_invocable<_Adaptor, _Range, _Arg>
1110 operator()(_Range&& __r) &&
1111 {
return _Adaptor{}(std::forward<_Range>(__r),
std::move(_M_arg)); }
1113 template<
typename _Range>
1115 operator()(_Range&& __r)
const && =
delete;
1123 template<
typename _Adaptor,
typename... _Args>
1124 requires __adaptor_has_simple_extra_args<_Adaptor, _Args...>
1125 && (is_trivially_copyable_v<_Args> && ...)
1126 struct _Partial<_Adaptor, _Args...> : _RangeAdaptorClosure<_Partial<_Adaptor, _Args...>>
1128 tuple<_Args...> _M_args;
1130 template<
typename... _Ts>
1132 _Partial(
int, _Ts&&... __args)
1138 template<
typename _Range>
1139 requires __adaptor_invocable<_Adaptor, _Range,
const _Args&...>
1141 operator()(_Range&& __r)
const
1143 auto __forwarder = [&__r] (
const auto&... __args) {
1144 return _Adaptor{}(std::forward<_Range>(__r), __args...);
1146 return std::apply(__forwarder, _M_args);
1149 static constexpr bool _S_has_simple_call_op =
true;
1154 template<
typename _Adaptor,
typename _Arg>
1155 requires __adaptor_has_simple_extra_args<_Adaptor, _Arg>
1156 && is_trivially_copyable_v<_Arg>
1157 struct _Partial<_Adaptor, _Arg> : _RangeAdaptorClosure<_Partial<_Adaptor, _Arg>>
1161 template<
typename _Tp>
1163 _Partial(
int, _Tp&& __arg)
1167 template<
typename _Range>
1168 requires __adaptor_invocable<_Adaptor, _Range, const _Arg&>
1170 operator()(_Range&& __r)
const
1171 {
return _Adaptor{}(std::forward<_Range>(__r), _M_arg); }
1173 static constexpr bool _S_has_simple_call_op =
true;
1176 template<
typename _Lhs,
typename _Rhs,
typename _Range>
1177 concept __pipe_invocable
1178 =
requires { std::declval<_Rhs>()(std::declval<_Lhs>()(std::declval<_Range>())); };
1182 template<
typename _Lhs,
typename _Rhs>
1183 struct _Pipe : _RangeAdaptorClosure<_Pipe<_Lhs, _Rhs>>
1185 [[no_unique_address]] _Lhs _M_lhs;
1186 [[no_unique_address]] _Rhs _M_rhs;
1188 template<
typename _Tp,
typename _Up>
1190 _Pipe(_Tp&& __lhs, _Up&& __rhs)
1196#if __cpp_explicit_this_parameter
1197 template<
typename _Self,
typename _Range>
1198 requires __pipe_invocable<__like_t<_Self, _Lhs>, __like_t<_Self, _Rhs>, _Range>
1200 operator()(
this _Self&& __self, _Range&& __r)
1202 return (__like_t<_Self, _Pipe>(__self)._M_rhs
1203 (__like_t<_Self, _Pipe>(__self)._M_lhs
1204 (std::forward<_Range>(__r))));
1207 template<
typename _Range>
1208 requires __pipe_invocable<const _Lhs&, const _Rhs&, _Range>
1210 operator()(_Range&& __r)
const &
1211 {
return _M_rhs(_M_lhs(std::forward<_Range>(__r))); }
1213 template<
typename _Range>
1214 requires __pipe_invocable<_Lhs, _Rhs, _Range>
1216 operator()(_Range&& __r) &&
1219 template<
typename _Range>
1221 operator()(_Range&& __r)
const && =
delete;
1229 template<
typename _Lhs,
typename _Rhs>
1230 requires __closure_has_simple_call_op<_Lhs>
1231 && __closure_has_simple_call_op<_Rhs>
1232 struct _Pipe<_Lhs, _Rhs> : _RangeAdaptorClosure<_Pipe<_Lhs, _Rhs>>
1234 [[no_unique_address]] _Lhs _M_lhs;
1235 [[no_unique_address]] _Rhs _M_rhs;
1237 template<
typename _Tp,
typename _Up>
1239 _Pipe(_Tp&& __lhs, _Up&& __rhs)
1243 template<
typename _Range>
1244 requires __pipe_invocable<const _Lhs&, const _Rhs&, _Range>
1246 operator()(_Range&& __r)
const
1247 {
return _M_rhs(_M_lhs(std::forward<_Range>(__r))); }
1249 static constexpr bool _S_has_simple_call_op =
true;
1253#if __cpp_lib_ranges >= 202202L
1255 template<
typename _Derived>
1256 requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
1257 class range_adaptor_closure
1258 :
public views::__adaptor::_RangeAdaptorClosure<_Derived>
1262 template<range _Range>
requires is_object_v<_Range>
1263 class ref_view :
public view_interface<ref_view<_Range>>
1268 static void _S_fun(_Range&);
1269 static void _S_fun(_Range&&) =
delete;
1272 template<__detail::__different_from<ref_view> _Tp>
1273 requires convertible_to<_Tp, _Range&>
1274 &&
requires { _S_fun(declval<_Tp>()); }
1277 noexcept(
noexcept(
static_cast<_Range&
>(std::declval<_Tp>())))
1285 constexpr iterator_t<_Range>
1289 constexpr sentinel_t<_Range>
1298 size() const requires sized_range<_Range>
1302 data() const requires contiguous_range<_Range>
1306 template<
typename _Range>
1307 ref_view(_Range&) -> ref_view<_Range>;
1309 template<
typename _Tp>
1310 inline constexpr bool enable_borrowed_range<ref_view<_Tp>> =
true;
1312 template<range _Range>
1313 requires movable<_Range>
1314 && (!__detail::__is_initializer_list<remove_cv_t<_Range>>)
1315 class owning_view :
public view_interface<owning_view<_Range>>
1318 _Range _M_r = _Range();
1321 owning_view()
requires default_initializable<_Range> = default;
1324 owning_view(_Range&& __t)
1325 noexcept(is_nothrow_move_constructible_v<_Range>)
1329 owning_view(owning_view&&) =
default;
1330 owning_view& operator=(owning_view&&) =
default;
1336 constexpr const _Range&
1337 base() const& noexcept
1344 constexpr const _Range&&
1345 base() const&& noexcept
1348 constexpr iterator_t<_Range>
1352 constexpr sentinel_t<_Range>
1357 begin() const requires range<const _Range>
1361 end() const requires range<const _Range>
1373 size()
requires sized_range<_Range>
1377 size() const requires sized_range<const _Range>
1381 data()
requires contiguous_range<_Range>
1385 data() const requires contiguous_range<const _Range>
1389 template<
typename _Tp>
1390 inline constexpr bool enable_borrowed_range<owning_view<_Tp>>
1391 = enable_borrowed_range<_Tp>;
1397 template<
typename _Range>
1398 concept __can_ref_view =
requires { ref_view{std::declval<_Range>()}; };
1400 template<
typename _Range>
1401 concept __can_owning_view =
requires { owning_view{std::declval<_Range>()}; };
1404 struct _All : __adaptor::_RangeAdaptorClosure<_All>
1406 template<
typename _Range>
1407 static constexpr bool
1410 if constexpr (view<decay_t<_Range>>)
1411 return is_nothrow_constructible_v<decay_t<_Range>, _Range>;
1412 else if constexpr (__detail::__can_ref_view<_Range>)
1415 return noexcept(owning_view{std::declval<_Range>()});
1418 template<viewable_range _Range>
1419 requires view<decay_t<_Range>>
1420 || __detail::__can_ref_view<_Range>
1421 || __detail::__can_owning_view<_Range>
1423 operator() [[nodiscard]] (_Range&& __r)
const
1424 noexcept(_S_noexcept<_Range>())
1426 if constexpr (view<decay_t<_Range>>)
1427 return std::forward<_Range>(__r);
1428 else if constexpr (__detail::__can_ref_view<_Range>)
1429 return ref_view{std::forward<_Range>(__r)};
1431 return owning_view{std::forward<_Range>(__r)};
1434 static constexpr bool _S_has_simple_call_op =
true;
1437 inline constexpr _All all;
1439 template<viewable_range _Range>
1440 using all_t =
decltype(all(std::declval<_Range>()));
1445 template<
typename _Tp>
1446 struct __non_propagating_cache
1454 template<
typename _Tp>
1455 requires is_object_v<_Tp>
1456 struct __non_propagating_cache<_Tp>
1457 :
protected _Optional_base<_Tp>
1459 __non_propagating_cache() =
default;
1462 __non_propagating_cache(
const __non_propagating_cache&)
noexcept
1466 __non_propagating_cache(__non_propagating_cache&& __other)
noexcept
1467 { __other._M_reset(); }
1469 constexpr __non_propagating_cache&
1470 operator=(
const __non_propagating_cache& __other)
noexcept
1477 constexpr __non_propagating_cache&
1478 operator=(__non_propagating_cache&& __other)
noexcept
1485 constexpr __non_propagating_cache&
1486 operator=(_Tp __val)
1489 this->_M_payload._M_construct(
std::move(__val));
1494 operator bool() const noexcept
1495 {
return this->_M_is_engaged(); }
1499 {
return this->_M_get(); }
1501 constexpr const _Tp&
1503 {
return this->_M_get(); }
1505 template<
typename _Iter>
1507 _M_emplace_deref(
const _Iter& __i)
1510 auto __f = [] (
auto& __x) {
return *__x; };
1511 this->_M_payload._M_apply(_Optional_func{__f}, __i);
1512 return this->_M_get();
1516 template<range _Range>
1517 struct _CachedPosition
1520 _M_has_value()
const
1523 constexpr iterator_t<_Range>
1524 _M_get(
const _Range&)
const
1526 __glibcxx_assert(
false);
1527 __builtin_unreachable();
1531 _M_set(
const _Range&,
const iterator_t<_Range>&)
const
1535 template<forward_range _Range>
1536 struct _CachedPosition<_Range>
1537 :
protected __non_propagating_cache<iterator_t<_Range>>
1540 _M_has_value()
const
1541 {
return this->_M_is_engaged(); }
1543 constexpr iterator_t<_Range>
1544 _M_get(
const _Range&)
const
1546 __glibcxx_assert(_M_has_value());
1551 _M_set(
const _Range&,
const iterator_t<_Range>& __it)
1553 __glibcxx_assert(!_M_has_value());
1556 this->_M_payload._M_engaged =
true;
1560 template<random_access_range _Range>
1561 requires (
sizeof(range_difference_t<_Range>)
1562 <=
sizeof(iterator_t<_Range>))
1563 struct _CachedPosition<_Range>
1566 range_difference_t<_Range> _M_offset = -1;
1569 _CachedPosition() =
default;
1572 _CachedPosition(
const _CachedPosition&) =
default;
1575 _CachedPosition(_CachedPosition&& __other)
noexcept
1578 constexpr _CachedPosition&
1579 operator=(
const _CachedPosition&) =
default;
1581 constexpr _CachedPosition&
1582 operator=(_CachedPosition&& __other)
noexcept
1585 _M_offset = __other._M_offset;
1586 __other._M_offset = -1;
1591 _M_has_value()
const
1592 {
return _M_offset >= 0; }
1594 constexpr iterator_t<_Range>
1595 _M_get(_Range& __r)
const
1597 __glibcxx_assert(_M_has_value());
1602 _M_set(_Range& __r,
const iterator_t<_Range>& __it)
1604 __glibcxx_assert(!_M_has_value());
1612 template<
typename _Base>
1613 struct __filter_view_iter_cat
1616 template<forward_range _Base>
1617 struct __filter_view_iter_cat<_Base>
1623 using _Cat =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
1624 if constexpr (derived_from<_Cat, bidirectional_iterator_tag>)
1625 return bidirectional_iterator_tag{};
1626 else if constexpr (derived_from<_Cat, forward_iterator_tag>)
1627 return forward_iterator_tag{};
1632 using iterator_category =
decltype(_S_iter_cat());
1636 template<input_range _Vp,
1637 indirect_unary_predicate<iterator_t<_Vp>> _Pred>
1638 requires view<_Vp> && is_object_v<_Pred>
1639 class filter_view :
public view_interface<filter_view<_Vp, _Pred>>
1644 struct _Iterator : __detail::__filter_view_iter_cat<_Vp>
1647 static constexpr auto
1650 if constexpr (bidirectional_range<_Vp>)
1651 return bidirectional_iterator_tag{};
1652 else if constexpr (forward_range<_Vp>)
1653 return forward_iterator_tag{};
1655 return input_iterator_tag{};
1660 using _Vp_iter = iterator_t<_Vp>;
1662 _Vp_iter _M_current = _Vp_iter();
1663 filter_view* _M_parent =
nullptr;
1666 using iterator_concept =
decltype(_S_iter_concept());
1668 using value_type = range_value_t<_Vp>;
1669 using difference_type = range_difference_t<_Vp>;
1671 _Iterator()
requires default_initializable<_Vp_iter> = default;
1674 _Iterator(filter_view* __parent, _Vp_iter __current)
1675 : _M_current(
std::
move(__current)),
1679 constexpr const _Vp_iter&
1680 base() const & noexcept
1681 {
return _M_current; }
1687 constexpr range_reference_t<_Vp>
1689 {
return *_M_current; }
1693 requires __detail::__has_arrow<_Vp_iter>
1694 && copyable<_Vp_iter>
1695 {
return _M_current; }
1697 constexpr _Iterator&
1700 _M_current = ranges::find_if(
std::move(++_M_current),
1702 std::ref(*_M_parent->_M_pred));
1711 operator++(
int)
requires forward_range<_Vp>
1718 constexpr _Iterator&
1719 operator--()
requires bidirectional_range<_Vp>
1728 operator--(
int)
requires bidirectional_range<_Vp>
1735 friend constexpr bool
1736 operator==(
const _Iterator& __x,
const _Iterator& __y)
1737 requires equality_comparable<_Vp_iter>
1738 {
return __x._M_current == __y._M_current; }
1740 friend constexpr range_rvalue_reference_t<_Vp>
1741 iter_move(
const _Iterator& __i)
1742 noexcept(
noexcept(ranges::iter_move(__i._M_current)))
1743 {
return ranges::iter_move(__i._M_current); }
1745 friend constexpr void
1746 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
1747 noexcept(
noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1748 requires indirectly_swappable<_Vp_iter>
1749 { ranges::iter_swap(__x._M_current, __y._M_current); }
1755 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
1758 __equal(
const _Iterator& __i)
const
1759 {
return __i._M_current == _M_end; }
1762 _Sentinel() =
default;
1765 _Sentinel(filter_view* __parent)
1766 : _M_end(ranges::
end(__parent->_M_base))
1769 constexpr sentinel_t<_Vp>
1773 friend constexpr bool
1774 operator==(
const _Iterator& __x,
const _Sentinel& __y)
1775 {
return __y.__equal(__x); }
1778 _Vp _M_base = _Vp();
1779 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
1780 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
1783 filter_view()
requires (default_initializable<_Vp>
1784 && default_initializable<_Pred>)
1788 filter_view(_Vp
__base, _Pred __pred)
1793 base() const& requires copy_constructible<_Vp>
1800 constexpr const _Pred&
1802 {
return *_M_pred; }
1807 if (_M_cached_begin._M_has_value())
1808 return {
this, _M_cached_begin._M_get(_M_base)};
1810 __glibcxx_assert(_M_pred.has_value());
1813 std::ref(*_M_pred));
1814 _M_cached_begin._M_set(_M_base, __it);
1821 if constexpr (common_range<_Vp>)
1824 return _Sentinel{
this};
1828 template<
typename _Range,
typename _Pred>
1829 filter_view(_Range&&, _Pred) -> filter_view<views::all_t<_Range>, _Pred>;
1835 template<
typename _Range,
typename _Pred>
1836 concept __can_filter_view
1837 =
requires { filter_view(std::declval<_Range>(), std::declval<_Pred>()); };
1840 struct _Filter : __adaptor::_RangeAdaptor<_Filter>
1842 template<viewable_range _Range,
typename _Pred>
1843 requires __detail::__can_filter_view<_Range, _Pred>
1845 operator() [[nodiscard]] (_Range&& __r, _Pred&& __p)
const
1847 return filter_view(std::forward<_Range>(__r), std::forward<_Pred>(__p));
1850 using _RangeAdaptor<_Filter>::operator();
1851 static constexpr int _S_arity = 2;
1852 static constexpr bool _S_has_simple_extra_args =
true;
1855 inline constexpr _Filter filter;
1858#if __cpp_lib_ranges >= 202207L
1859 template<input_range _Vp, move_constructible _Fp>
1861 template<input_range _Vp, copy_constructible _Fp>
1863 requires view<_Vp> && is_object_v<_Fp>
1864 && regular_invocable<_Fp&, range_reference_t<_Vp>>
1865 && std::__detail::__can_reference<invoke_result_t<_Fp&,
1866 range_reference_t<_Vp>>>
1867 class transform_view :
public view_interface<transform_view<_Vp, _Fp>>
1870 template<
bool _Const>
1871 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
1873 template<
bool _Const>
1877 template<
bool _Const>
1878 requires forward_range<_Base<_Const>>
1879 struct __iter_cat<_Const>
1888 using _Base = transform_view::_Base<_Const>;
1889 using _Res = invoke_result_t<__maybe_const_t<_Const, _Fp>&,
1890 range_reference_t<_Base>>;
1891 if constexpr (is_lvalue_reference_v<_Res>)
1894 =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
1895 if constexpr (derived_from<_Cat, contiguous_iterator_tag>)
1896 return random_access_iterator_tag{};
1901 return input_iterator_tag{};
1904 using iterator_category =
decltype(_S_iter_cat());
1907 template<
bool _Const>
1910 template<
bool _Const>
1911 struct _Iterator : __iter_cat<_Const>
1914 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
1915 using _Base = transform_view::_Base<_Const>;
1920 if constexpr (random_access_range<_Base>)
1921 return random_access_iterator_tag{};
1922 else if constexpr (bidirectional_range<_Base>)
1923 return bidirectional_iterator_tag{};
1924 else if constexpr (forward_range<_Base>)
1925 return forward_iterator_tag{};
1927 return input_iterator_tag{};
1930 using _Base_iter = iterator_t<_Base>;
1932 _Base_iter _M_current = _Base_iter();
1933 _Parent* _M_parent =
nullptr;
1936 using iterator_concept =
decltype(_S_iter_concept());
1939 = remove_cvref_t<invoke_result_t<__maybe_const_t<_Const, _Fp>&,
1940 range_reference_t<_Base>>>;
1941 using difference_type = range_difference_t<_Base>;
1943 _Iterator()
requires default_initializable<_Base_iter> = default;
1946 _Iterator(_Parent* __parent, _Base_iter __current)
1947 : _M_current(
std::
move(__current)),
1952 _Iterator(_Iterator<!_Const> __i)
1954 && convertible_to<iterator_t<_Vp>, _Base_iter>
1955 : _M_current(
std::move(__i._M_current)), _M_parent(__i._M_parent)
1958 constexpr const _Base_iter&
1959 base() const & noexcept
1960 {
return _M_current; }
1962 constexpr _Base_iter
1966 constexpr decltype(
auto)
1968 noexcept(
noexcept(
std::__invoke(*_M_parent->_M_fun, *_M_current)))
1971 constexpr _Iterator&
1983 operator++(
int)
requires forward_range<_Base>
1990 constexpr _Iterator&
1991 operator--()
requires bidirectional_range<_Base>
1998 operator--(
int)
requires bidirectional_range<_Base>
2005 constexpr _Iterator&
2006 operator+=(difference_type __n)
requires random_access_range<_Base>
2012 constexpr _Iterator&
2013 operator-=(difference_type __n)
requires random_access_range<_Base>
2019 constexpr decltype(
auto)
2020 operator[](difference_type __n)
const
2021 requires random_access_range<_Base>
2022 {
return std::__invoke(*_M_parent->_M_fun, _M_current[__n]); }
2024 friend constexpr bool
2025 operator==(
const _Iterator& __x,
const _Iterator& __y)
2026 requires equality_comparable<_Base_iter>
2027 {
return __x._M_current == __y._M_current; }
2029 friend constexpr bool
2030 operator<(
const _Iterator& __x,
const _Iterator& __y)
2031 requires random_access_range<_Base>
2032 {
return __x._M_current < __y._M_current; }
2034 friend constexpr bool
2035 operator>(
const _Iterator& __x,
const _Iterator& __y)
2036 requires random_access_range<_Base>
2037 {
return __y < __x; }
2039 friend constexpr bool
2040 operator<=(
const _Iterator& __x,
const _Iterator& __y)
2041 requires random_access_range<_Base>
2042 {
return !(__y < __x); }
2044 friend constexpr bool
2045 operator>=(
const _Iterator& __x,
const _Iterator& __y)
2046 requires random_access_range<_Base>
2047 {
return !(__x < __y); }
2049#ifdef __cpp_lib_three_way_comparison
2050 friend constexpr auto
2051 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
2052 requires random_access_range<_Base>
2053 && three_way_comparable<_Base_iter>
2054 {
return __x._M_current <=> __y._M_current; }
2057 friend constexpr _Iterator
2058 operator+(_Iterator __i, difference_type __n)
2059 requires random_access_range<_Base>
2060 {
return {__i._M_parent, __i._M_current + __n}; }
2062 friend constexpr _Iterator
2063 operator+(difference_type __n, _Iterator __i)
2064 requires random_access_range<_Base>
2065 {
return {__i._M_parent, __i._M_current + __n}; }
2067 friend constexpr _Iterator
2068 operator-(_Iterator __i, difference_type __n)
2069 requires random_access_range<_Base>
2070 {
return {__i._M_parent, __i._M_current - __n}; }
2074 friend constexpr difference_type
2075 operator-(
const _Iterator& __x,
const _Iterator& __y)
2076 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
2077 {
return __x._M_current - __y._M_current; }
2079 friend constexpr decltype(
auto)
2080 iter_move(
const _Iterator& __i)
noexcept(
noexcept(*__i))
2082 if constexpr (is_lvalue_reference_v<
decltype(*__i)>)
2088 friend _Iterator<!_Const>;
2089 template<
bool>
friend struct _Sentinel;
2092 template<
bool _Const>
2096 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
2097 using _Base = transform_view::_Base<_Const>;
2099 template<
bool _Const2>
2101 __distance_from(
const _Iterator<_Const2>& __i)
const
2102 {
return _M_end - __i._M_current; }
2104 template<
bool _Const2>
2106 __equal(
const _Iterator<_Const2>& __i)
const
2107 {
return __i._M_current == _M_end; }
2109 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2112 _Sentinel() =
default;
2115 _Sentinel(sentinel_t<_Base> __end)
2120 _Sentinel(_Sentinel<!_Const> __i)
2122 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2126 constexpr sentinel_t<_Base>
2130 template<
bool _Const2>
2131 requires sentinel_for<sentinel_t<_Base>,
2132 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
2133 friend constexpr bool
2134 operator==(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
2135 {
return __y.__equal(__x); }
2137 template<
bool _Const2,
2138 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
2139 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2140 friend constexpr range_difference_t<_Base2>
2141 operator-(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
2142 {
return -__y.__distance_from(__x); }
2144 template<
bool _Const2,
2145 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
2146 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2147 friend constexpr range_difference_t<_Base2>
2148 operator-(
const _Sentinel& __y,
const _Iterator<_Const2>& __x)
2149 {
return __y.__distance_from(__x); }
2151 friend _Sentinel<!_Const>;
2154 _Vp _M_base = _Vp();
2155 [[no_unique_address]] __detail::__box<_Fp> _M_fun;
2158 transform_view()
requires (default_initializable<_Vp>
2159 && default_initializable<_Fp>)
2163 transform_view(_Vp
__base, _Fp __fun)
2168 base() const& requires copy_constructible<_Vp>
2169 {
return _M_base ; }
2175 constexpr _Iterator<false>
2179 constexpr _Iterator<true>
2181 requires range<const _Vp>
2182 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
2185 constexpr _Sentinel<false>
2187 {
return _Sentinel<false>{
ranges::end(_M_base)}; }
2189 constexpr _Iterator<false>
2190 end()
requires common_range<_Vp>
2191 {
return _Iterator<false>{
this,
ranges::end(_M_base)}; }
2193 constexpr _Sentinel<true>
2195 requires range<const _Vp>
2196 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
2199 constexpr _Iterator<true>
2201 requires common_range<const _Vp>
2202 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
2203 {
return _Iterator<true>{
this,
ranges::end(_M_base)}; }
2206 size()
requires sized_range<_Vp>
2210 size() const requires sized_range<const _Vp>
2214 template<
typename _Range,
typename _Fp>
2215 transform_view(_Range&&, _Fp) -> transform_view<views::all_t<_Range>, _Fp>;
2221 template<
typename _Range,
typename _Fp>
2222 concept __can_transform_view
2223 =
requires { transform_view(std::declval<_Range>(), std::declval<_Fp>()); };
2226 struct _Transform : __adaptor::_RangeAdaptor<_Transform>
2228 template<viewable_range _Range,
typename _Fp>
2229 requires __detail::__can_transform_view<_Range, _Fp>
2231 operator() [[nodiscard]] (_Range&& __r, _Fp&& __f)
const
2233 return transform_view(std::forward<_Range>(__r), std::forward<_Fp>(__f));
2236 using _RangeAdaptor<_Transform>::operator();
2237 static constexpr int _S_arity = 2;
2238 static constexpr bool _S_has_simple_extra_args =
true;
2241 inline constexpr _Transform transform;
2245 class take_view :
public view_interface<take_view<_Vp>>
2248 template<
bool _Const>
2249 using _CI = counted_iterator<
2250 iterator_t<__detail::__maybe_const_t<_Const, _Vp>>>;
2252 template<
bool _Const>
2256 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2257 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2260 _Sentinel() =
default;
2263 _Sentinel(sentinel_t<_Base> __end)
2268 _Sentinel(_Sentinel<!_Const> __s)
2269 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2273 constexpr sentinel_t<_Base>
2277 friend constexpr bool
2278 operator==(
const _CI<_Const>& __y,
const _Sentinel& __x)
2279 {
return __y.count() == 0 || __y.base() == __x._M_end; }
2281 template<
bool _OtherConst = !_Const,
2282 typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
2283 requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2284 friend constexpr bool
2285 operator==(
const _CI<_OtherConst>& __y,
const _Sentinel& __x)
2286 {
return __y.count() == 0 || __y.base() == __x._M_end; }
2288 friend _Sentinel<!_Const>;
2291 _Vp _M_base = _Vp();
2292 range_difference_t<_Vp> _M_count = 0;
2295 take_view()
requires default_initializable<_Vp> = default;
2298 take_view(_Vp
__base, range_difference_t<_Vp> __count)
2303 base() const& requires copy_constructible<_Vp>
2311 begin()
requires (!__detail::__simple_view<_Vp>)
2313 if constexpr (sized_range<_Vp>)
2315 if constexpr (random_access_range<_Vp>)
2328 begin() const requires range<const _Vp>
2330 if constexpr (sized_range<const _Vp>)
2332 if constexpr (random_access_range<const _Vp>)
2345 end()
requires (!__detail::__simple_view<_Vp>)
2347 if constexpr (sized_range<_Vp>)
2349 if constexpr (random_access_range<_Vp>)
2359 end() const requires range<const _Vp>
2361 if constexpr (sized_range<const _Vp>)
2363 if constexpr (random_access_range<const _Vp>)
2373 size()
requires sized_range<_Vp>
2376 return std::min(__n,
static_cast<decltype(__n)
>(_M_count));
2380 size() const requires sized_range<const _Vp>
2383 return std::min(__n,
static_cast<decltype(__n)
>(_M_count));
2390 template<
typename _Range>
2391 take_view(_Range&&, range_difference_t<_Range>)
2392 -> take_view<views::all_t<_Range>>;
2394 template<
typename _Tp>
2395 inline constexpr bool enable_borrowed_range<take_view<_Tp>>
2396 = enable_borrowed_range<_Tp>;
2402 template<
typename _Range>
2403 inline constexpr bool __is_empty_view =
false;
2405 template<
typename _Tp>
2406 inline constexpr bool __is_empty_view<empty_view<_Tp>> =
true;
2408 template<
typename _Range>
2409 inline constexpr bool __is_basic_string_view =
false;
2411 template<
typename _CharT,
typename _Traits>
2412 inline constexpr bool __is_basic_string_view<basic_string_view<_CharT, _Traits>>
2415 using ranges::__detail::__is_subrange;
2417 template<
typename _Range>
2418 inline constexpr bool __is_iota_view =
false;
2420 template<
typename _Winc,
typename _Bound>
2421 inline constexpr bool __is_iota_view<iota_view<_Winc, _Bound>> =
true;
2423 template<
typename _Range>
2424 inline constexpr bool __is_repeat_view =
false;
2426 template<
typename _Range>
2428 __take_of_repeat_view(_Range&&, range_difference_t<_Range>);
2430 template<
typename _Range,
typename _Dp>
2431 concept __can_take_view
2432 =
requires { take_view(std::declval<_Range>(), std::declval<_Dp>()); };
2435 struct _Take : __adaptor::_RangeAdaptor<_Take>
2437 template<viewable_range _Range,
typename _Dp = range_difference_t<_Range>>
2438 requires __detail::__can_take_view<_Range, _Dp>
2440 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n)
const
2442 using _Tp = remove_cvref_t<_Range>;
2443 if constexpr (__detail::__is_empty_view<_Tp>)
2445 else if constexpr (random_access_range<_Tp>
2447 && (std::__detail::__is_span<_Tp>
2448 || __detail::__is_basic_string_view<_Tp>
2449 || __detail::__is_subrange<_Tp>
2450 || __detail::__is_iota_view<_Tp>))
2454 auto __end = __begin + __n;
2455 if constexpr (std::__detail::__is_span<_Tp>)
2456 return span<typename _Tp::element_type>(__begin, __end);
2457 else if constexpr (__detail::__is_basic_string_view<_Tp>)
2458 return _Tp(__begin, __end);
2459 else if constexpr (__detail::__is_subrange<_Tp>)
2460 return subrange<iterator_t<_Tp>>(__begin, __end);
2462 return iota_view(*__begin, *__end);
2464 else if constexpr (__detail::__is_repeat_view<_Tp>)
2465 return __detail::__take_of_repeat_view(std::forward<_Range>(__r), __n);
2467 return take_view(std::forward<_Range>(__r), __n);
2470 using _RangeAdaptor<_Take>::operator();
2471 static constexpr int _S_arity = 2;
2475 template<
typename _Tp>
2476 static constexpr bool _S_has_simple_extra_args
2477 = ranges::__detail::__is_integer_like<_Tp>;
2480 inline constexpr _Take take;
2483 template<view _Vp,
typename _Pred>
2484 requires input_range<_Vp> && is_object_v<_Pred>
2485 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2486 class take_while_view :
public view_interface<take_while_view<_Vp, _Pred>>
2488 template<
bool _Const>
2492 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2494 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2495 const _Pred* _M_pred =
nullptr;
2498 _Sentinel() =
default;
2501 _Sentinel(sentinel_t<_Base> __end,
const _Pred* __pred)
2502 : _M_end(__end), _M_pred(__pred)
2506 _Sentinel(_Sentinel<!_Const> __s)
2507 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2508 : _M_end(__s._M_end), _M_pred(__s._M_pred)
2511 constexpr sentinel_t<_Base>
2512 base()
const {
return _M_end; }
2514 friend constexpr bool
2515 operator==(
const iterator_t<_Base>& __x,
const _Sentinel& __y)
2516 {
return __y._M_end == __x || !
std::__invoke(*__y._M_pred, *__x); }
2518 template<
bool _OtherConst = !_Const,
2519 typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
2520 requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2521 friend constexpr bool
2522 operator==(
const iterator_t<_Base2>& __x,
const _Sentinel& __y)
2523 {
return __y._M_end == __x || !
std::__invoke(*__y._M_pred, *__x); }
2525 friend _Sentinel<!_Const>;
2528 _Vp _M_base = _Vp();
2529 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
2532 take_while_view()
requires (default_initializable<_Vp>
2533 && default_initializable<_Pred>)
2537 take_while_view(_Vp
__base, _Pred __pred)
2542 base() const& requires copy_constructible<_Vp>
2549 constexpr const _Pred&
2551 {
return *_M_pred; }
2554 begin()
requires (!__detail::__simple_view<_Vp>)
2558 begin() const requires range<const _Vp>
2559 && indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
2563 end()
requires (!__detail::__simple_view<_Vp>)
2568 end() const requires range<const _Vp>
2569 && indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
2574 template<
typename _Range,
typename _Pred>
2575 take_while_view(_Range&&, _Pred)
2576 -> take_while_view<views::all_t<_Range>, _Pred>;
2582 template<
typename _Range,
typename _Pred>
2583 concept __can_take_while_view
2584 =
requires { take_while_view(std::declval<_Range>(), std::declval<_Pred>()); };
2587 struct _TakeWhile : __adaptor::_RangeAdaptor<_TakeWhile>
2589 template<viewable_range _Range,
typename _Pred>
2590 requires __detail::__can_take_while_view<_Range, _Pred>
2592 operator() [[nodiscard]] (_Range&& __r, _Pred&& __p)
const
2594 return take_while_view(std::forward<_Range>(__r), std::forward<_Pred>(__p));
2597 using _RangeAdaptor<_TakeWhile>::operator();
2598 static constexpr int _S_arity = 2;
2599 static constexpr bool _S_has_simple_extra_args =
true;
2602 inline constexpr _TakeWhile take_while;
2606 class drop_view :
public view_interface<drop_view<_Vp>>
2609 _Vp _M_base = _Vp();
2610 range_difference_t<_Vp> _M_count = 0;
2614 static constexpr bool _S_needs_cached_begin
2615 = !(random_access_range<const _Vp> && sized_range<const _Vp>);
2616 [[no_unique_address]]
2617 __detail::__maybe_present_t<_S_needs_cached_begin,
2618 __detail::_CachedPosition<_Vp>>
2622 drop_view()
requires default_initializable<_Vp> = default;
2625 drop_view(_Vp
__base, range_difference_t<_Vp> __count)
2627 { __glibcxx_assert(__count >= 0); }
2630 base() const& requires copy_constructible<_Vp>
2640 requires (!(__detail::__simple_view<_Vp>
2641 && random_access_range<const _Vp>
2642 && sized_range<const _Vp>))
2644 if constexpr (_S_needs_cached_begin)
2645 if (_M_cached_begin._M_has_value())
2646 return _M_cached_begin._M_get(_M_base);
2650 if constexpr (_S_needs_cached_begin)
2651 _M_cached_begin._M_set(_M_base, __it);
2659 requires random_access_range<const _Vp> && sized_range<const _Vp>
2666 end()
requires (!__detail::__simple_view<_Vp>)
2670 end() const requires range<const _Vp>
2674 size()
requires sized_range<_Vp>
2677 const auto __c =
static_cast<decltype(__s)
>(_M_count);
2678 return __s < __c ? 0 : __s - __c;
2682 size() const requires sized_range<const _Vp>
2685 const auto __c =
static_cast<decltype(__s)
>(_M_count);
2686 return __s < __c ? 0 : __s - __c;
2690 template<
typename _Range>
2691 drop_view(_Range&&, range_difference_t<_Range>)
2692 -> drop_view<views::all_t<_Range>>;
2694 template<
typename _Tp>
2695 inline constexpr bool enable_borrowed_range<drop_view<_Tp>>
2696 = enable_borrowed_range<_Tp>;
2702 template<
typename _Range>
2704 __drop_of_repeat_view(_Range&&, range_difference_t<_Range>);
2706 template<
typename _Range,
typename _Dp>
2707 concept __can_drop_view
2708 =
requires { drop_view(std::declval<_Range>(), std::declval<_Dp>()); };
2711 struct _Drop : __adaptor::_RangeAdaptor<_Drop>
2713 template<viewable_range _Range,
typename _Dp = range_difference_t<_Range>>
2714 requires __detail::__can_drop_view<_Range, _Dp>
2716 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n)
const
2718 using _Tp = remove_cvref_t<_Range>;
2719 if constexpr (__detail::__is_empty_view<_Tp>)
2721 else if constexpr (random_access_range<_Tp>
2723 && (std::__detail::__is_span<_Tp>
2724 || __detail::__is_basic_string_view<_Tp>
2725 || __detail::__is_iota_view<_Tp>
2726 || __detail::__is_subrange<_Tp>))
2731 if constexpr (std::__detail::__is_span<_Tp>)
2732 return span<typename _Tp::element_type>(__begin, __end);
2733 else if constexpr (__detail::__is_subrange<_Tp>)
2735 if constexpr (_Tp::_S_store_size)
2737 using ranges::__detail::__to_unsigned_like;
2739 return _Tp(__begin, __end, __to_unsigned_like(__m));
2742 return _Tp(__begin, __end);
2745 return _Tp(__begin, __end);
2747 else if constexpr (__detail::__is_repeat_view<_Tp>)
2748 return __detail::__drop_of_repeat_view(std::forward<_Range>(__r), __n);
2750 return drop_view(std::forward<_Range>(__r), __n);
2753 using _RangeAdaptor<_Drop>::operator();
2754 static constexpr int _S_arity = 2;
2755 template<
typename _Tp>
2756 static constexpr bool _S_has_simple_extra_args
2757 = _Take::_S_has_simple_extra_args<_Tp>;
2760 inline constexpr _Drop drop;
2763 template<view _Vp,
typename _Pred>
2764 requires input_range<_Vp> && is_object_v<_Pred>
2765 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2766 class drop_while_view :
public view_interface<drop_while_view<_Vp, _Pred>>
2769 _Vp _M_base = _Vp();
2770 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
2771 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
2774 drop_while_view()
requires (default_initializable<_Vp>
2775 && default_initializable<_Pred>)
2779 drop_while_view(_Vp
__base, _Pred __pred)
2784 base() const& requires copy_constructible<_Vp>
2791 constexpr const _Pred&
2793 {
return *_M_pred; }
2798 if (_M_cached_begin._M_has_value())
2799 return _M_cached_begin._M_get(_M_base);
2801 __glibcxx_assert(_M_pred.has_value());
2804 std::cref(*_M_pred));
2805 _M_cached_begin._M_set(_M_base, __it);
2814 template<
typename _Range,
typename _Pred>
2815 drop_while_view(_Range&&, _Pred)
2816 -> drop_while_view<views::all_t<_Range>, _Pred>;
2818 template<
typename _Tp,
typename _Pred>
2819 inline constexpr bool enable_borrowed_range<drop_while_view<_Tp, _Pred>>
2820 = enable_borrowed_range<_Tp>;
2826 template<
typename _Range,
typename _Pred>
2827 concept __can_drop_while_view
2828 =
requires { drop_while_view(std::declval<_Range>(), std::declval<_Pred>()); };
2831 struct _DropWhile : __adaptor::_RangeAdaptor<_DropWhile>
2833 template<viewable_range _Range,
typename _Pred>
2834 requires __detail::__can_drop_while_view<_Range, _Pred>
2836 operator() [[nodiscard]] (_Range&& __r, _Pred&& __p)
const
2838 return drop_while_view(std::forward<_Range>(__r),
2839 std::forward<_Pred>(__p));
2842 using _RangeAdaptor<_DropWhile>::operator();
2843 static constexpr int _S_arity = 2;
2844 static constexpr bool _S_has_simple_extra_args =
true;
2847 inline constexpr _DropWhile drop_while;
2852 template<
typename _Tp>
2854 __as_lvalue(_Tp&& __t)
2855 {
return static_cast<_Tp&
>(__t); }
2858 template<input_range _Vp>
2859 requires view<_Vp> && input_range<range_reference_t<_Vp>>
2860 class join_view :
public view_interface<join_view<_Vp>>
2863 using _InnerRange = range_reference_t<_Vp>;
2865 template<
bool _Const>
2866 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2868 template<
bool _Const>
2869 using _Outer_iter = iterator_t<_Base<_Const>>;
2871 template<
bool _Const>
2872 using _Inner_iter = iterator_t<range_reference_t<_Base<_Const>>>;
2874 template<
bool _Const>
2875 static constexpr bool _S_ref_is_glvalue
2876 = is_reference_v<range_reference_t<_Base<_Const>>>;
2878 template<
bool _Const>
2882 template<
bool _Const>
2883 requires _S_ref_is_glvalue<_Const>
2884 && forward_range<_Base<_Const>>
2885 && forward_range<range_reference_t<_Base<_Const>>>
2886 struct __iter_cat<_Const>
2889 static constexpr auto
2892 using _Outer_iter = join_view::_Outer_iter<_Const>;
2893 using _Inner_iter = join_view::_Inner_iter<_Const>;
2894 using _OuterCat =
typename iterator_traits<_Outer_iter>::iterator_category;
2895 using _InnerCat =
typename iterator_traits<_Inner_iter>::iterator_category;
2896 if constexpr (derived_from<_OuterCat, bidirectional_iterator_tag>
2897 && derived_from<_InnerCat, bidirectional_iterator_tag>
2898 && common_range<range_reference_t<_Base<_Const>>>)
2899 return bidirectional_iterator_tag{};
2900 else if constexpr (derived_from<_OuterCat, forward_iterator_tag>
2901 && derived_from<_InnerCat, forward_iterator_tag>)
2902 return forward_iterator_tag{};
2904 return input_iterator_tag{};
2907 using iterator_category =
decltype(_S_iter_cat());
2910 template<
bool _Const>
2913 template<
bool _Const>
2914 struct _Iterator : __iter_cat<_Const>
2917 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
2918 using _Base = join_view::_Base<_Const>;
2922 static constexpr bool _S_ref_is_glvalue
2923 = join_view::_S_ref_is_glvalue<_Const>;
2928 auto __update_inner = [
this] (
const iterator_t<_Base>& __x) ->
auto&& {
2929 if constexpr (_S_ref_is_glvalue)
2932 return _M_parent->_M_inner._M_emplace_deref(__x);
2935 _Outer_iter& __outer = _M_get_outer();
2936 for (; __outer !=
ranges::end(_M_parent->_M_base); ++__outer)
2938 auto&& __inner = __update_inner(__outer);
2944 if constexpr (_S_ref_is_glvalue)
2948 static constexpr auto
2951 if constexpr (_S_ref_is_glvalue
2952 && bidirectional_range<_Base>
2953 && bidirectional_range<range_reference_t<_Base>>
2954 && common_range<range_reference_t<_Base>>)
2955 return bidirectional_iterator_tag{};
2956 else if constexpr (_S_ref_is_glvalue
2957 && forward_range<_Base>
2958 && forward_range<range_reference_t<_Base>>)
2959 return forward_iterator_tag{};
2961 return input_iterator_tag{};
2964 using _Outer_iter = join_view::_Outer_iter<_Const>;
2965 using _Inner_iter = join_view::_Inner_iter<_Const>;
2967 constexpr _Outer_iter&
2970 if constexpr (forward_range<_Base>)
2973 return *_M_parent->_M_outer;
2976 constexpr const _Outer_iter&
2977 _M_get_outer()
const
2979 if constexpr (forward_range<_Base>)
2982 return *_M_parent->_M_outer;
2986 _Iterator(_Parent* __parent, _Outer_iter __outer)
requires forward_range<_Base>
2987 : _M_outer(
std::move(__outer)), _M_parent(__parent)
2991 _Iterator(_Parent* __parent)
requires (!forward_range<_Base>)
2992 : _M_parent(__parent)
2995 [[no_unique_address]]
2996 __detail::__maybe_present_t<forward_range<_Base>, _Outer_iter> _M_outer;
2997 optional<_Inner_iter> _M_inner;
2998 _Parent* _M_parent =
nullptr;
3001 using iterator_concept =
decltype(_S_iter_concept());
3003 using value_type = range_value_t<range_reference_t<_Base>>;
3004 using difference_type
3005 = common_type_t<range_difference_t<_Base>,
3006 range_difference_t<range_reference_t<_Base>>>;
3008 _Iterator() =
default;
3011 _Iterator(_Iterator<!_Const> __i)
3013 && convertible_to<iterator_t<_Vp>, _Outer_iter>
3014 && convertible_to<iterator_t<_InnerRange>, _Inner_iter>
3016 _M_parent(__i._M_parent)
3019 constexpr decltype(
auto)
3021 {
return **_M_inner; }
3025 constexpr _Inner_iter
3027 requires __detail::__has_arrow<_Inner_iter>
3028 && copyable<_Inner_iter>
3029 {
return *_M_inner; }
3031 constexpr _Iterator&
3034 auto&& __inner_range = [
this] () ->
auto&& {
3035 if constexpr (_S_ref_is_glvalue)
3036 return *_M_get_outer();
3038 return *_M_parent->_M_inner;
3054 requires _S_ref_is_glvalue && forward_range<_Base>
3055 && forward_range<range_reference_t<_Base>>
3062 constexpr _Iterator&
3064 requires _S_ref_is_glvalue && bidirectional_range<_Base>
3065 && bidirectional_range<range_reference_t<_Base>>
3066 && common_range<range_reference_t<_Base>>
3069 _M_inner =
ranges::end(__detail::__as_lvalue(*--_M_outer));
3070 while (*_M_inner ==
ranges::begin(__detail::__as_lvalue(*_M_outer)))
3071 *_M_inner =
ranges::end(__detail::__as_lvalue(*--_M_outer));
3078 requires _S_ref_is_glvalue && bidirectional_range<_Base>
3079 && bidirectional_range<range_reference_t<_Base>>
3080 && common_range<range_reference_t<_Base>>
3087 friend constexpr bool
3088 operator==(
const _Iterator& __x,
const _Iterator& __y)
3089 requires _S_ref_is_glvalue
3090 && forward_range<_Base>
3091 && equality_comparable<_Inner_iter>
3093 return (__x._M_outer == __y._M_outer
3094 && __x._M_inner == __y._M_inner);
3097 friend constexpr decltype(
auto)
3098 iter_move(
const _Iterator& __i)
3099 noexcept(
noexcept(ranges::iter_move(*__i._M_inner)))
3100 {
return ranges::iter_move(*__i._M_inner); }
3102 friend constexpr void
3103 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
3104 noexcept(
noexcept(ranges::iter_swap(*__x._M_inner, *__y._M_inner)))
3105 requires indirectly_swappable<_Inner_iter>
3106 {
return ranges::iter_swap(*__x._M_inner, *__y._M_inner); }
3108 friend _Iterator<!_Const>;
3109 template<
bool>
friend struct _Sentinel;
3112 template<
bool _Const>
3116 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
3117 using _Base = join_view::_Base<_Const>;
3119 template<
bool _Const2>
3121 __equal(
const _Iterator<_Const2>& __i)
const
3122 {
return __i._M_get_outer() == _M_end; }
3124 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
3127 _Sentinel() =
default;
3130 _Sentinel(_Parent* __parent)
3131 : _M_end(ranges::
end(__parent->_M_base))
3135 _Sentinel(_Sentinel<!_Const> __s)
3136 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
3140 template<
bool _Const2>
3141 requires sentinel_for<sentinel_t<_Base>,
3142 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
3143 friend constexpr bool
3144 operator==(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
3145 {
return __y.__equal(__x); }
3147 friend _Sentinel<!_Const>;
3150 _Vp _M_base = _Vp();
3151 [[no_unique_address]]
3152 __detail::__maybe_present_t<!forward_range<_Vp>,
3153 __detail::__non_propagating_cache<iterator_t<_Vp>>> _M_outer;
3154 [[no_unique_address]]
3155 __detail::__non_propagating_cache<remove_cv_t<_InnerRange>> _M_inner;
3158 join_view()
requires default_initializable<_Vp> = default;
3166 base() const& requires copy_constructible<_Vp>
3176 if constexpr (forward_range<_Vp>)
3178 constexpr bool __use_const
3179 = (__detail::__simple_view<_Vp>
3180 && is_reference_v<range_reference_t<_Vp>>);
3181 return _Iterator<__use_const>{
this,
ranges::begin(_M_base)};
3186 return _Iterator<false>{
this};
3192 requires forward_range<const _Vp>
3193 && is_reference_v<range_reference_t<const _Vp>>
3194 && input_range<range_reference_t<const _Vp>>
3202 if constexpr (forward_range<_Vp> && is_reference_v<_InnerRange>
3203 && forward_range<_InnerRange>
3204 && common_range<_Vp> && common_range<_InnerRange>)
3205 return _Iterator<__detail::__simple_view<_Vp>>{
this,
3208 return _Sentinel<__detail::__simple_view<_Vp>>{
this};
3213 requires forward_range<const _Vp>
3214 && is_reference_v<range_reference_t<const _Vp>>
3215 && input_range<range_reference_t<const _Vp>>
3217 if constexpr (is_reference_v<range_reference_t<const _Vp>>
3218 && forward_range<range_reference_t<const _Vp>>
3219 && common_range<const _Vp>
3220 && common_range<range_reference_t<const _Vp>>)
3221 return _Iterator<true>{
this,
ranges::end(_M_base)};
3223 return _Sentinel<true>{
this};
3227 template<
typename _Range>
3228 explicit join_view(_Range&&) -> join_view<views::all_t<_Range>>;
3234 template<
typename _Range>
3235 concept __can_join_view
3236 =
requires { join_view<all_t<_Range>>{std::declval<_Range>()}; };
3239 struct _Join : __adaptor::_RangeAdaptorClosure<_Join>
3241 template<viewable_range _Range>
3242 requires __detail::__can_join_view<_Range>
3244 operator() [[nodiscard]] (_Range&& __r)
const
3248 return join_view<all_t<_Range>>{std::forward<_Range>(__r)};
3251 static constexpr bool _S_has_simple_call_op =
true;
3254 inline constexpr _Join join;
3260 struct __require_constant;
3262 template<
typename _Range>
3263 concept __tiny_range = sized_range<_Range>
3268 template<
typename _Base>
3269 struct __lazy_split_view_outer_iter_cat
3272 template<forward_range _Base>
3273 struct __lazy_split_view_outer_iter_cat<_Base>
3274 {
using iterator_category = input_iterator_tag; };
3276 template<
typename _Base>
3277 struct __lazy_split_view_inner_iter_cat
3280 template<forward_range _Base>
3281 struct __lazy_split_view_inner_iter_cat<_Base>
3284 static constexpr auto
3287 using _Cat =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
3288 if constexpr (derived_from<_Cat, forward_iterator_tag>)
3289 return forward_iterator_tag{};
3294 using iterator_category =
decltype(_S_iter_cat());
3298 template<input_range _Vp, forward_range _Pattern>
3299 requires view<_Vp> && view<_Pattern>
3300 && indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
3302 && (forward_range<_Vp> || __detail::__tiny_range<_Pattern>)
3303 class lazy_split_view :
public view_interface<lazy_split_view<_Vp, _Pattern>>
3306 template<
bool _Const>
3307 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
3309 template<
bool _Const>
3312 template<
bool _Const>
3314 : __detail::__lazy_split_view_outer_iter_cat<_Base<_Const>>
3317 using _Parent = __detail::__maybe_const_t<_Const, lazy_split_view>;
3318 using _Base = lazy_split_view::_Base<_Const>;
3322 {
return __current() ==
ranges::end(_M_parent->_M_base) && !_M_trailing_empty; }
3329 __current() noexcept
3331 if constexpr (forward_range<_Vp>)
3334 return *_M_parent->_M_current;
3338 __current() const noexcept
3340 if constexpr (forward_range<_Vp>)
3343 return *_M_parent->_M_current;
3346 _Parent* _M_parent =
nullptr;
3348 [[no_unique_address]]
3349 __detail::__maybe_present_t<forward_range<_Vp>,
3350 iterator_t<_Base>> _M_current;
3351 bool _M_trailing_empty =
false;
3354 using iterator_concept = __conditional_t<forward_range<_Base>,
3355 forward_iterator_tag,
3356 input_iterator_tag>;
3358 using difference_type = range_difference_t<_Base>;
3360 struct value_type : view_interface<value_type>
3363 _OuterIter _M_i = _OuterIter();
3369 value_type(_OuterIter __i)
3376 constexpr _InnerIter<_Const>
3378 {
return _InnerIter<_Const>{_M_i}; }
3380 constexpr default_sentinel_t
3381 end() const noexcept
3385 _OuterIter() =
default;
3388 _OuterIter(_Parent* __parent)
requires (!forward_range<_Base>)
3389 : _M_parent(__parent)
3393 _OuterIter(_Parent* __parent, iterator_t<_Base> __current)
3394 requires forward_range<_Base>
3395 : _M_parent(__parent),
3400 _OuterIter(_OuterIter<!_Const> __i)
3402 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
3403 : _M_parent(__i._M_parent), _M_current(
std::move(__i._M_current)),
3404 _M_trailing_empty(__i._M_trailing_empty)
3407 constexpr value_type
3409 {
return value_type{*
this}; }
3411 constexpr _OuterIter&
3416 const auto __end =
ranges::end(_M_parent->_M_base);
3417 if (__current() == __end)
3419 _M_trailing_empty =
false;
3422 const auto [__pbegin, __pend] = subrange{_M_parent->_M_pattern};
3423 if (__pbegin == __pend)
3425 else if constexpr (__detail::__tiny_range<_Pattern>)
3427 __current() = ranges::find(
std::move(__current()), __end,
3429 if (__current() != __end)
3432 if (__current() == __end)
3433 _M_trailing_empty =
true;
3440 = ranges::mismatch(__current(), __end, __pbegin, __pend);
3444 if (__current() == __end)
3445 _M_trailing_empty =
true;
3448 }
while (++__current() != __end);
3452 constexpr decltype(
auto)
3455 if constexpr (forward_range<_Base>)
3465 friend constexpr bool
3466 operator==(
const _OuterIter& __x,
const _OuterIter& __y)
3467 requires forward_range<_Base>
3469 return __x._M_current == __y._M_current
3470 && __x._M_trailing_empty == __y._M_trailing_empty;
3473 friend constexpr bool
3474 operator==(
const _OuterIter& __x, default_sentinel_t)
3475 {
return __x.__at_end(); };
3477 friend _OuterIter<!_Const>;
3478 friend _InnerIter<_Const>;
3481 template<
bool _Const>
3483 : __detail::__lazy_split_view_inner_iter_cat<_Base<_Const>>
3486 using _Base = lazy_split_view::_Base<_Const>;
3491 auto [__pcur, __pend] = subrange{_M_i._M_parent->_M_pattern};
3492 auto __end =
ranges::end(_M_i._M_parent->_M_base);
3493 if constexpr (__detail::__tiny_range<_Pattern>)
3495 const auto& __cur = _M_i_current();
3498 if (__pcur == __pend)
3499 return _M_incremented;
3500 return *__cur == *__pcur;
3504 auto __cur = _M_i_current();
3507 if (__pcur == __pend)
3508 return _M_incremented;
3511 if (*__cur != *__pcur)
3513 if (++__pcur == __pend)
3515 }
while (++__cur != __end);
3521 _M_i_current() noexcept
3522 {
return _M_i.__current(); }
3525 _M_i_current() const noexcept
3526 {
return _M_i.__current(); }
3528 _OuterIter<_Const> _M_i = _OuterIter<_Const>();
3529 bool _M_incremented =
false;
3532 using iterator_concept
3533 =
typename _OuterIter<_Const>::iterator_concept;
3535 using value_type = range_value_t<_Base>;
3536 using difference_type = range_difference_t<_Base>;
3538 _InnerIter() =
default;
3541 _InnerIter(_OuterIter<_Const> __i)
3545 constexpr const iterator_t<_Base>&
3546 base() const& noexcept
3547 {
return _M_i_current(); }
3549 constexpr iterator_t<_Base>
3550 base() &&
requires forward_range<_Vp>
3553 constexpr decltype(
auto)
3555 {
return *_M_i_current(); }
3557 constexpr _InnerIter&
3560 _M_incremented =
true;
3561 if constexpr (!forward_range<_Base>)
3568 constexpr decltype(
auto)
3571 if constexpr (forward_range<_Base>)
3581 friend constexpr bool
3582 operator==(
const _InnerIter& __x,
const _InnerIter& __y)
3583 requires forward_range<_Base>
3584 {
return __x._M_i == __y._M_i; }
3586 friend constexpr bool
3587 operator==(
const _InnerIter& __x, default_sentinel_t)
3588 {
return __x.__at_end(); }
3590 friend constexpr decltype(
auto)
3591 iter_move(
const _InnerIter& __i)
3592 noexcept(
noexcept(ranges::iter_move(__i._M_i_current())))
3593 {
return ranges::iter_move(__i._M_i_current()); }
3595 friend constexpr void
3596 iter_swap(
const _InnerIter& __x,
const _InnerIter& __y)
3597 noexcept(
noexcept(ranges::iter_swap(__x._M_i_current(),
3598 __y._M_i_current())))
3599 requires indirectly_swappable<iterator_t<_Base>>
3600 { ranges::iter_swap(__x._M_i_current(), __y._M_i_current()); }
3603 _Vp _M_base = _Vp();
3604 _Pattern _M_pattern = _Pattern();
3605 [[no_unique_address]]
3606 __detail::__maybe_present_t<!forward_range<_Vp>,
3607 __detail::__non_propagating_cache<iterator_t<_Vp>>> _M_current;
3611 lazy_split_view()
requires (default_initializable<_Vp>
3612 && default_initializable<_Pattern>)
3616 lazy_split_view(_Vp
__base, _Pattern __pattern)
3620 template<input_range _Range>
3621 requires constructible_from<_Vp, views::all_t<_Range>>
3622 && constructible_from<_Pattern, single_view<range_value_t<_Range>>>
3624 lazy_split_view(_Range&& __r, range_value_t<_Range> __e)
3625 : _M_base(views::all(
std::
forward<_Range>(__r))),
3626 _M_pattern(views::single(
std::
move(__e)))
3630 base() const& requires copy_constructible<_Vp>
3640 if constexpr (forward_range<_Vp>)
3642 constexpr bool __simple
3643 = __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
3649 return _OuterIter<false>{
this};
3654 begin() const requires forward_range<_Vp> && forward_range<const _Vp>
3660 end()
requires forward_range<_Vp> && common_range<_Vp>
3662 constexpr bool __simple
3663 = __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
3664 return _OuterIter<__simple>{
this,
ranges::end(_M_base)};
3670 if constexpr (forward_range<_Vp>
3671 && forward_range<const _Vp>
3672 && common_range<const _Vp>)
3673 return _OuterIter<true>{
this,
ranges::end(_M_base)};
3679 template<
typename _Range,
typename _Pattern>
3680 lazy_split_view(_Range&&, _Pattern&&)
3681 -> lazy_split_view<views::all_t<_Range>, views::all_t<_Pattern>>;
3683 template<input_range _Range>
3684 lazy_split_view(_Range&&, range_value_t<_Range>)
3685 -> lazy_split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
3691 template<
typename _Range,
typename _Pattern>
3692 concept __can_lazy_split_view
3693 =
requires { lazy_split_view(std::declval<_Range>(), std::declval<_Pattern>()); };
3696 struct _LazySplit : __adaptor::_RangeAdaptor<_LazySplit>
3698 template<viewable_range _Range,
typename _Pattern>
3699 requires __detail::__can_lazy_split_view<_Range, _Pattern>
3701 operator() [[nodiscard]] (_Range&& __r, _Pattern&& __f)
const
3703 return lazy_split_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
3706 using _RangeAdaptor<_LazySplit>::operator();
3707 static constexpr int _S_arity = 2;
3712 template<
typename _Pattern>
3713 static constexpr bool _S_has_simple_extra_args
3714 = is_scalar_v<_Pattern> || (view<_Pattern>
3715 && copy_constructible<_Pattern>);
3718 inline constexpr _LazySplit lazy_split;
3721 template<forward_range _Vp, forward_range _Pattern>
3722 requires view<_Vp> && view<_Pattern>
3723 && indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
3725 class split_view :
public view_interface<split_view<_Vp, _Pattern>>
3728 _Vp _M_base = _Vp();
3729 _Pattern _M_pattern = _Pattern();
3730 __detail::__non_propagating_cache<subrange<iterator_t<_Vp>>> _M_cached_begin;
3736 split_view()
requires (default_initializable<_Vp>
3737 && default_initializable<_Pattern>)
3741 split_view(_Vp
__base, _Pattern __pattern)
3745 template<forward_range _Range>
3746 requires constructible_from<_Vp, views::all_t<_Range>>
3747 && constructible_from<_Pattern, single_view<range_value_t<_Range>>>
3749 split_view(_Range&& __r, range_value_t<_Range> __e)
3750 : _M_base(views::all(
std::
forward<_Range>(__r))),
3751 _M_pattern(views::single(
std::
move(__e)))
3755 base() const& requires copy_constructible<_Vp>
3765 if (!_M_cached_begin)
3773 if constexpr (common_range<_Vp>)
3776 return _Sentinel{
this};
3779 constexpr subrange<iterator_t<_Vp>>
3780 _M_find_next(iterator_t<_Vp> __it)
3782 auto [__b, __e] = ranges::search(subrange(__it,
ranges::end(_M_base)), _M_pattern);
3795 split_view* _M_parent =
nullptr;
3796 iterator_t<_Vp> _M_cur = iterator_t<_Vp>();
3797 subrange<iterator_t<_Vp>> _M_next = subrange<iterator_t<_Vp>>();
3798 bool _M_trailing_empty =
false;
3800 friend struct _Sentinel;
3803 using iterator_concept = forward_iterator_tag;
3804 using iterator_category = input_iterator_tag;
3805 using value_type = subrange<iterator_t<_Vp>>;
3806 using difference_type = range_difference_t<_Vp>;
3808 _Iterator() =
default;
3811 _Iterator(split_view* __parent,
3812 iterator_t<_Vp> __current,
3813 subrange<iterator_t<_Vp>> __next)
3814 : _M_parent(__parent),
3819 constexpr iterator_t<_Vp>
3823 constexpr value_type
3825 {
return {_M_cur, _M_next.begin()}; }
3827 constexpr _Iterator&
3830 _M_cur = _M_next.begin();
3833 _M_cur = _M_next.end();
3836 _M_trailing_empty =
true;
3837 _M_next = {_M_cur, _M_cur};
3840 _M_next = _M_parent->_M_find_next(_M_cur);
3843 _M_trailing_empty =
false;
3855 friend constexpr bool
3856 operator==(
const _Iterator& __x,
const _Iterator& __y)
3858 return __x._M_cur == __y._M_cur
3859 && __x._M_trailing_empty == __y._M_trailing_empty;
3866 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
3869 _M_equal(
const _Iterator& __x)
const
3870 {
return __x._M_cur == _M_end && !__x._M_trailing_empty; }
3873 _Sentinel() =
default;
3876 _Sentinel(split_view* __parent)
3877 : _M_end(ranges::
end(__parent->_M_base))
3880 friend constexpr bool
3881 operator==(
const _Iterator& __x,
const _Sentinel& __y)
3882 {
return __y._M_equal(__x); }
3886 template<
typename _Range,
typename _Pattern>
3887 split_view(_Range&&, _Pattern&&)
3888 -> split_view<views::all_t<_Range>, views::all_t<_Pattern>>;
3890 template<forward_range _Range>
3891 split_view(_Range&&, range_value_t<_Range>)
3892 -> split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
3898 template<
typename _Range,
typename _Pattern>
3899 concept __can_split_view
3900 =
requires { split_view(std::declval<_Range>(), std::declval<_Pattern>()); };
3903 struct _Split : __adaptor::_RangeAdaptor<_Split>
3905 template<viewable_range _Range,
typename _Pattern>
3906 requires __detail::__can_split_view<_Range, _Pattern>
3908 operator() [[nodiscard]] (_Range&& __r, _Pattern&& __f)
const
3910 return split_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
3913 using _RangeAdaptor<_Split>::operator();
3914 static constexpr int _S_arity = 2;
3915 template<
typename _Pattern>
3916 static constexpr bool _S_has_simple_extra_args
3917 = _LazySplit::_S_has_simple_extra_args<_Pattern>;
3920 inline constexpr _Split split;
3927 template<input_or_output_iterator _Iter>
3929 operator() [[nodiscard]] (_Iter __i, iter_difference_t<_Iter> __n)
const
3931 if constexpr (contiguous_iterator<_Iter>)
3932 return span(std::__to_address(__i), __n);
3933 else if constexpr (random_access_iterator<_Iter>)
3934 return subrange(__i, __i + __n);
3936 return subrange(counted_iterator(
std::move(__i), __n),
3941 inline constexpr _Counted counted{};
3945 requires (!common_range<_Vp>) && copyable<iterator_t<_Vp>>
3946 class common_view :
public view_interface<common_view<_Vp>>
3949 _Vp _M_base = _Vp();
3952 common_view()
requires default_initializable<_Vp> = default;
3955 common_view(_Vp __r)
3960 base() const& requires copy_constructible<_Vp>
3970 begin()
requires (!__detail::__simple_view<_Vp>)
3972 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3975 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
3980 begin() const requires range<const _Vp>
3982 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
3985 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
3990 end()
requires (!__detail::__simple_view<_Vp>)
3992 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3995 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
4000 end() const requires range<const _Vp>
4002 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
4005 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
4010 size()
requires sized_range<_Vp>
4014 size() const requires sized_range<const _Vp>
4018 template<
typename _Range>
4019 common_view(_Range&&) -> common_view<views::all_t<_Range>>;
4021 template<
typename _Tp>
4022 inline constexpr bool enable_borrowed_range<common_view<_Tp>>
4023 = enable_borrowed_range<_Tp>;
4029 template<
typename _Range>
4030 concept __already_common = common_range<_Range>
4031 &&
requires { views::all(std::declval<_Range>()); };
4033 template<
typename _Range>
4034 concept __can_common_view
4035 =
requires { common_view{std::declval<_Range>()}; };
4038 struct _Common : __adaptor::_RangeAdaptorClosure<_Common>
4040 template<viewable_range _Range>
4041 requires __detail::__already_common<_Range>
4042 || __detail::__can_common_view<_Range>
4044 operator() [[nodiscard]] (_Range&& __r)
const
4046 if constexpr (__detail::__already_common<_Range>)
4047 return views::all(std::forward<_Range>(__r));
4049 return common_view{std::forward<_Range>(__r)};
4052 static constexpr bool _S_has_simple_call_op =
true;
4055 inline constexpr _Common common;
4059 requires bidirectional_range<_Vp>
4060 class reverse_view :
public view_interface<reverse_view<_Vp>>
4063 static constexpr bool _S_needs_cached_begin
4064 = !common_range<_Vp> && !(random_access_range<_Vp>
4065 && sized_sentinel_for<sentinel_t<_Vp>,
4068 _Vp _M_base = _Vp();
4069 [[no_unique_address]]
4070 __detail::__maybe_present_t<_S_needs_cached_begin,
4071 __detail::_CachedPosition<_Vp>>
4075 reverse_view()
requires default_initializable<_Vp> = default;
4078 reverse_view(_Vp __r)
4083 base() const& requires copy_constructible<_Vp>
4090 constexpr reverse_iterator<iterator_t<_Vp>>
4093 if constexpr (_S_needs_cached_begin)
4094 if (_M_cached_begin._M_has_value())
4098 if constexpr (_S_needs_cached_begin)
4099 _M_cached_begin._M_set(_M_base, __it);
4104 begin()
requires common_range<_Vp>
4108 begin() const requires common_range<const _Vp>
4111 constexpr reverse_iterator<iterator_t<_Vp>>
4116 end() const requires common_range<const _Vp>
4120 size()
requires sized_range<_Vp>
4124 size() const requires sized_range<const _Vp>
4128 template<
typename _Range>
4129 reverse_view(_Range&&) -> reverse_view<views::all_t<_Range>>;
4131 template<
typename _Tp>
4132 inline constexpr bool enable_borrowed_range<reverse_view<_Tp>>
4133 = enable_borrowed_range<_Tp>;
4140 inline constexpr bool __is_reversible_subrange =
false;
4142 template<
typename _Iter, subrange_kind _Kind>
4143 inline constexpr bool
4144 __is_reversible_subrange<subrange<reverse_iterator<_Iter>,
4145 reverse_iterator<_Iter>,
4149 inline constexpr bool __is_reverse_view =
false;
4151 template<
typename _Vp>
4152 inline constexpr bool __is_reverse_view<reverse_view<_Vp>> =
true;
4154 template<
typename _Range>
4155 concept __can_reverse_view
4156 =
requires { reverse_view{std::declval<_Range>()}; };
4159 struct _Reverse : __adaptor::_RangeAdaptorClosure<_Reverse>
4161 template<viewable_range _Range>
4162 requires __detail::__is_reverse_view<remove_cvref_t<_Range>>
4163 || __detail::__is_reversible_subrange<remove_cvref_t<_Range>>
4164 || __detail::__can_reverse_view<_Range>
4166 operator() [[nodiscard]] (_Range&& __r)
const
4168 using _Tp = remove_cvref_t<_Range>;
4169 if constexpr (__detail::__is_reverse_view<_Tp>)
4170 return std::forward<_Range>(__r).base();
4171 else if constexpr (__detail::__is_reversible_subrange<_Tp>)
4174 if constexpr (sized_range<_Tp>)
4175 return subrange<_Iter, _Iter, subrange_kind::sized>
4176 {__r.end().base(), __r.begin().base(), __r.size()};
4178 return subrange<_Iter, _Iter, subrange_kind::unsized>
4179 {__r.end().base(), __r.begin().base()};
4182 return reverse_view{std::forward<_Range>(__r)};
4185 static constexpr bool _S_has_simple_call_op =
true;
4188 inline constexpr _Reverse reverse;
4193#if __cpp_lib_tuple_like
4194 template<
typename _Tp,
size_t _Nm>
4195 concept __has_tuple_element = __tuple_like<_Tp> && _Nm < tuple_size_v<_Tp>;
4197 template<
typename _Tp,
size_t _Nm>
4198 concept __has_tuple_element =
requires(_Tp __t)
4200 typename tuple_size<_Tp>::type;
4201 requires _Nm < tuple_size_v<_Tp>;
4202 typename tuple_element_t<_Nm, _Tp>;
4203 { std::get<_Nm>(__t) }
4204 -> convertible_to<const tuple_element_t<_Nm, _Tp>&>;
4208 template<
typename _Tp,
size_t _Nm>
4209 concept __returnable_element
4210 = is_reference_v<_Tp> || move_constructible<tuple_element_t<_Nm, _Tp>>;
4213 template<input_range _Vp,
size_t _Nm>
4215 && __detail::__has_tuple_element<range_value_t<_Vp>, _Nm>
4216 && __detail::__has_tuple_element<remove_reference_t<range_reference_t<_Vp>>,
4218 && __detail::__returnable_element<range_reference_t<_Vp>, _Nm>
4219 class elements_view :
public view_interface<elements_view<_Vp, _Nm>>
4222 elements_view()
requires default_initializable<_Vp> = default;
4225 elements_view(_Vp
__base)
4230 base() const& requires copy_constructible<_Vp>
4238 begin()
requires (!__detail::__simple_view<_Vp>)
4242 begin() const requires range<const _Vp>
4246 end()
requires (!__detail::__simple_view<_Vp> && !common_range<_Vp>)
4247 {
return _Sentinel<false>{
ranges::end(_M_base)}; }
4250 end()
requires (!__detail::__simple_view<_Vp> && common_range<_Vp>)
4251 {
return _Iterator<false>{
ranges::end(_M_base)}; }
4254 end() const requires range<const _Vp>
4258 end() const requires common_range<const _Vp>
4262 size()
requires sized_range<_Vp>
4266 size() const requires sized_range<const _Vp>
4270 template<
bool _Const>
4271 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
4273 template<
bool _Const>
4277 template<
bool _Const>
4278 requires forward_range<_Base<_Const>>
4279 struct __iter_cat<_Const>
4282 static auto _S_iter_cat()
4284 using _Base = elements_view::_Base<_Const>;
4285 using _Cat =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
4286 using _Res =
decltype((std::get<_Nm>(*
std::declval<iterator_t<_Base>>())));
4287 if constexpr (!is_lvalue_reference_v<_Res>)
4288 return input_iterator_tag{};
4289 else if constexpr (derived_from<_Cat, random_access_iterator_tag>)
4290 return random_access_iterator_tag{};
4295 using iterator_category =
decltype(_S_iter_cat());
4298 template<
bool _Const>
4301 template<
bool _Const>
4302 struct _Iterator : __iter_cat<_Const>
4305 using _Base = elements_view::_Base<_Const>;
4307 iterator_t<_Base> _M_current = iterator_t<_Base>();
4309 static constexpr decltype(
auto)
4310 _S_get_element(
const iterator_t<_Base>& __i)
4312 if constexpr (is_reference_v<range_reference_t<_Base>>)
4313 return std::get<_Nm>(*__i);
4316 using _Et = remove_cv_t<tuple_element_t<_Nm, range_reference_t<_Base>>>;
4317 return static_cast<_Et
>(std::get<_Nm>(*__i));
4324 if constexpr (random_access_range<_Base>)
4325 return random_access_iterator_tag{};
4326 else if constexpr (bidirectional_range<_Base>)
4327 return bidirectional_iterator_tag{};
4328 else if constexpr (forward_range<_Base>)
4329 return forward_iterator_tag{};
4331 return input_iterator_tag{};
4334 friend _Iterator<!_Const>;
4337 using iterator_concept =
decltype(_S_iter_concept());
4340 = remove_cvref_t<tuple_element_t<_Nm, range_value_t<_Base>>>;
4341 using difference_type = range_difference_t<_Base>;
4343 _Iterator()
requires default_initializable<iterator_t<_Base>> = default;
4346 _Iterator(iterator_t<_Base> __current)
4347 : _M_current(
std::
move(__current))
4351 _Iterator(_Iterator<!_Const> __i)
4352 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
4356 constexpr const iterator_t<_Base>&
4357 base() const& noexcept
4358 {
return _M_current; }
4360 constexpr iterator_t<_Base>
4364 constexpr decltype(
auto)
4366 {
return _S_get_element(_M_current); }
4368 constexpr _Iterator&
4380 operator++(
int)
requires forward_range<_Base>
4387 constexpr _Iterator&
4388 operator--()
requires bidirectional_range<_Base>
4395 operator--(
int)
requires bidirectional_range<_Base>
4402 constexpr _Iterator&
4403 operator+=(difference_type __n)
4404 requires random_access_range<_Base>
4410 constexpr _Iterator&
4411 operator-=(difference_type __n)
4412 requires random_access_range<_Base>
4418 constexpr decltype(
auto)
4419 operator[](difference_type __n)
const
4420 requires random_access_range<_Base>
4421 {
return _S_get_element(_M_current + __n); }
4423 friend constexpr bool
4424 operator==(
const _Iterator& __x,
const _Iterator& __y)
4425 requires equality_comparable<iterator_t<_Base>>
4426 {
return __x._M_current == __y._M_current; }
4428 friend constexpr bool
4429 operator<(
const _Iterator& __x,
const _Iterator& __y)
4430 requires random_access_range<_Base>
4431 {
return __x._M_current < __y._M_current; }
4433 friend constexpr bool
4434 operator>(
const _Iterator& __x,
const _Iterator& __y)
4435 requires random_access_range<_Base>
4436 {
return __y._M_current < __x._M_current; }
4438 friend constexpr bool
4439 operator<=(
const _Iterator& __x,
const _Iterator& __y)
4440 requires random_access_range<_Base>
4441 {
return !(__y._M_current > __x._M_current); }
4443 friend constexpr bool
4444 operator>=(
const _Iterator& __x,
const _Iterator& __y)
4445 requires random_access_range<_Base>
4446 {
return !(__x._M_current > __y._M_current); }
4448#ifdef __cpp_lib_three_way_comparison
4449 friend constexpr auto
4450 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
4451 requires random_access_range<_Base>
4452 && three_way_comparable<iterator_t<_Base>>
4453 {
return __x._M_current <=> __y._M_current; }
4456 friend constexpr _Iterator
4457 operator+(
const _Iterator& __x, difference_type __y)
4458 requires random_access_range<_Base>
4459 {
return _Iterator{__x} += __y; }
4461 friend constexpr _Iterator
4462 operator+(difference_type __x,
const _Iterator& __y)
4463 requires random_access_range<_Base>
4464 {
return __y + __x; }
4466 friend constexpr _Iterator
4467 operator-(
const _Iterator& __x, difference_type __y)
4468 requires random_access_range<_Base>
4469 {
return _Iterator{__x} -= __y; }
4473 friend constexpr difference_type
4474 operator-(
const _Iterator& __x,
const _Iterator& __y)
4475 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
4476 {
return __x._M_current - __y._M_current; }
4478 template <
bool>
friend struct _Sentinel;
4481 template<
bool _Const>
4485 template<
bool _Const2>
4487 _M_equal(
const _Iterator<_Const2>& __x)
const
4488 {
return __x._M_current == _M_end; }
4490 template<
bool _Const2>
4492 _M_distance_from(
const _Iterator<_Const2>& __i)
const
4493 {
return _M_end - __i._M_current; }
4495 using _Base = elements_view::_Base<_Const>;
4496 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
4499 _Sentinel() =
default;
4502 _Sentinel(sentinel_t<_Base> __end)
4507 _Sentinel(_Sentinel<!_Const> __other)
4509 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
4513 constexpr sentinel_t<_Base>
4517 template<
bool _Const2>
4518 requires sentinel_for<sentinel_t<_Base>,
4519 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
4520 friend constexpr bool
4521 operator==(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
4522 {
return __y._M_equal(__x); }
4524 template<
bool _Const2,
4525 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
4526 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
4527 friend constexpr range_difference_t<_Base2>
4528 operator-(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
4529 {
return -__y._M_distance_from(__x); }
4531 template<
bool _Const2,
4532 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
4533 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
4534 friend constexpr range_difference_t<_Base2>
4535 operator-(
const _Sentinel& __x,
const _Iterator<_Const2>& __y)
4536 {
return __x._M_distance_from(__y); }
4538 friend _Sentinel<!_Const>;
4541 _Vp _M_base = _Vp();
4544 template<
typename _Tp,
size_t _Nm>
4545 inline constexpr bool enable_borrowed_range<elements_view<_Tp, _Nm>>
4546 = enable_borrowed_range<_Tp>;
4548 template<
typename _Range>
4549 using keys_view = elements_view<views::all_t<_Range>, 0>;
4551 template<
typename _Range>
4552 using values_view = elements_view<views::all_t<_Range>, 1>;
4558 template<
size_t _Nm,
typename _Range>
4559 concept __can_elements_view
4560 =
requires { elements_view<all_t<_Range>, _Nm>{std::declval<_Range>()}; };
4563 template<
size_t _Nm>
4564 struct _Elements : __adaptor::_RangeAdaptorClosure<_Elements<_Nm>>
4566 template<viewable_range _Range>
4567 requires __detail::__can_elements_view<_Nm, _Range>
4569 operator() [[nodiscard]] (_Range&& __r)
const
4571 return elements_view<all_t<_Range>, _Nm>{std::forward<_Range>(__r)};
4574 static constexpr bool _S_has_simple_call_op =
true;
4577 template<
size_t _Nm>
4578 inline constexpr _Elements<_Nm> elements;
4579 inline constexpr auto keys = elements<0>;
4580 inline constexpr auto values = elements<1>;
4583#ifdef __cpp_lib_ranges_zip
4586 template<
typename... _Rs>
4587 concept __zip_is_common = (
sizeof...(_Rs) == 1 && (common_range<_Rs> && ...))
4588 || (!(bidirectional_range<_Rs> && ...) && (common_range<_Rs> && ...))
4589 || ((random_access_range<_Rs> && ...) && (sized_range<_Rs> && ...));
4591 template<
typename _Fp,
typename _Tuple>
4593 __tuple_transform(_Fp&& __f, _Tuple&& __tuple)
4595 return std::apply([&]<
typename... _Ts>(_Ts&&... __elts) {
4596 return tuple<invoke_result_t<_Fp&, _Ts>...>
4598 }, std::forward<_Tuple>(__tuple));
4601 template<
typename _Fp,
typename _Tuple>
4603 __tuple_for_each(_Fp&& __f, _Tuple&& __tuple)
4605 std::apply([&]<
typename... _Ts>(_Ts&&... __elts) {
4607 }, std::forward<_Tuple>(__tuple));
4611 template<input_range... _Vs>
4612 requires (view<_Vs> && ...) && (
sizeof...(_Vs) > 0)
4613 class zip_view :
public view_interface<zip_view<_Vs...>>
4615 tuple<_Vs...> _M_views;
4617 template<
bool>
class _Iterator;
4618 template<
bool>
class _Sentinel;
4621 zip_view() =
default;
4624 zip_view(_Vs... __views)
4625 : _M_views(
std::
move(__views)...)
4629 begin()
requires (!(__detail::__simple_view<_Vs> && ...))
4630 {
return _Iterator<false>(__detail::__tuple_transform(
ranges::begin, _M_views)); }
4633 begin() const requires (range<const _Vs> && ...)
4634 {
return _Iterator<true>(__detail::__tuple_transform(
ranges::begin, _M_views)); }
4637 end()
requires (!(__detail::__simple_view<_Vs> && ...))
4639 if constexpr (!__detail::__zip_is_common<_Vs...>)
4640 return _Sentinel<false>(__detail::__tuple_transform(
ranges::end, _M_views));
4641 else if constexpr ((random_access_range<_Vs> && ...))
4642 return begin() + iter_difference_t<_Iterator<false>>(
size());
4644 return _Iterator<false>(__detail::__tuple_transform(
ranges::end, _M_views));
4648 end() const requires (range<const _Vs> && ...)
4650 if constexpr (!__detail::__zip_is_common<
const _Vs...>)
4651 return _Sentinel<true>(__detail::__tuple_transform(
ranges::end, _M_views));
4652 else if constexpr ((random_access_range<const _Vs> && ...))
4653 return begin() + iter_difference_t<_Iterator<true>>(
size());
4655 return _Iterator<true>(__detail::__tuple_transform(
ranges::end, _M_views));
4659 size()
requires (sized_range<_Vs> && ...)
4661 return std::apply([](
auto... sizes) {
4662 using _CT = __detail::__make_unsigned_like_t<
common_type_t<
decltype(sizes)...>>;
4663 return ranges::min({_CT(sizes)...});
4664 }, __detail::__tuple_transform(
ranges::size, _M_views));
4668 size() const requires (sized_range<const _Vs> && ...)
4670 return std::apply([](
auto... sizes) {
4671 using _CT = __detail::__make_unsigned_like_t<
common_type_t<
decltype(sizes)...>>;
4672 return ranges::min({_CT(sizes)...});
4673 }, __detail::__tuple_transform(
ranges::size, _M_views));
4677 template<
typename... _Rs>
4678 zip_view(_Rs&&...) -> zip_view<views::all_t<_Rs>...>;
4680 template<
typename... _Views>
4681 inline constexpr bool enable_borrowed_range<zip_view<_Views...>>
4682 = (enable_borrowed_range<_Views> && ...);
4686 template<
bool _Const,
typename... _Vs>
4687 concept __all_random_access
4688 = (random_access_range<__maybe_const_t<_Const, _Vs>> && ...);
4690 template<
bool _Const,
typename... _Vs>
4691 concept __all_bidirectional
4692 = (bidirectional_range<__maybe_const_t<_Const, _Vs>> && ...);
4694 template<
bool _Const,
typename... _Vs>
4695 concept __all_forward
4696 = (forward_range<__maybe_const_t<_Const, _Vs>> && ...);
4698 template<
bool _Const,
typename... _Views>
4699 struct __zip_view_iter_cat
4702 template<
bool _Const,
typename... _Views>
4703 requires __all_forward<_Const, _Views...>
4704 struct __zip_view_iter_cat<_Const, _Views...>
4705 {
using iterator_category = input_iterator_tag; };
4708 template<input_range... _Vs>
4709 requires (view<_Vs> && ...) && (
sizeof...(_Vs) > 0)
4710 template<
bool _Const>
4711 class zip_view<_Vs...>::_Iterator
4712 :
public __detail::__zip_view_iter_cat<_Const, _Vs...>
4717 tuple<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>...> _M_current;
4720 _Iterator(
decltype(_M_current) __current)
4721 : _M_current(
std::
move(__current))
4727 if constexpr (__detail::__all_random_access<_Const, _Vs...>)
4728 return random_access_iterator_tag{};
4729 else if constexpr (__detail::__all_bidirectional<_Const, _Vs...>)
4730 return bidirectional_iterator_tag{};
4731 else if constexpr (__detail::__all_forward<_Const, _Vs...>)
4732 return forward_iterator_tag{};
4734 return input_iterator_tag{};
4738 template<move_constructible _Fp, input_range... _Ws>
4739 requires (view<_Ws> && ...) && (
sizeof...(_Ws) > 0) && is_object_v<_Fp>
4740 && regular_invocable<_Fp&, range_reference_t<_Ws>...>
4741 && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Ws>...>>
4742 friend class zip_transform_view;
4747 using iterator_concept =
decltype(_S_iter_concept());
4749 = tuple<range_value_t<__detail::__maybe_const_t<_Const, _Vs>>...>;
4750 using difference_type
4751 = common_type_t<range_difference_t<__detail::__maybe_const_t<_Const, _Vs>>...>;
4753 _Iterator() =
default;
4756 _Iterator(_Iterator<!_Const> __i)
4758 && (convertible_to<iterator_t<_Vs>,
4759 iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4760 : _M_current(
std::
move(__i._M_current))
4766 auto __f = [](
auto& __i) ->
decltype(
auto) {
4769 return __detail::__tuple_transform(__f, _M_current);
4772 constexpr _Iterator&
4775 __detail::__tuple_for_each([](
auto& __i) { ++__i; }, _M_current);
4785 requires __detail::__all_forward<_Const, _Vs...>
4792 constexpr _Iterator&
4794 requires __detail::__all_bidirectional<_Const, _Vs...>
4796 __detail::__tuple_for_each([](
auto& __i) { --__i; }, _M_current);
4802 requires __detail::__all_bidirectional<_Const, _Vs...>
4809 constexpr _Iterator&
4810 operator+=(difference_type __x)
4811 requires __detail::__all_random_access<_Const, _Vs...>
4813 auto __f = [&]<
typename _It>(_It& __i) {
4814 __i += iter_difference_t<_It>(__x);
4816 __detail::__tuple_for_each(__f, _M_current);
4820 constexpr _Iterator&
4821 operator-=(difference_type __x)
4822 requires __detail::__all_random_access<_Const, _Vs...>
4824 auto __f = [&]<
typename _It>(_It& __i) {
4825 __i -= iter_difference_t<_It>(__x);
4827 __detail::__tuple_for_each(__f, _M_current);
4832 operator[](difference_type __n)
const
4833 requires __detail::__all_random_access<_Const, _Vs...>
4835 auto __f = [&]<
typename _It>(_It& __i) ->
decltype(
auto) {
4836 return __i[iter_difference_t<_It>(__n)];
4838 return __detail::__tuple_transform(__f, _M_current);
4841 friend constexpr bool
4842 operator==(
const _Iterator& __x,
const _Iterator& __y)
4843 requires (equality_comparable<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4845 if constexpr (__detail::__all_bidirectional<_Const, _Vs...>)
4846 return __x._M_current == __y._M_current;
4848 return [&]<
size_t... _Is>(index_sequence<_Is...>) {
4849 return ((std::get<_Is>(__x._M_current) == std::get<_Is>(__y._M_current)) || ...);
4853 friend constexpr auto
4854 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
4855 requires __detail::__all_random_access<_Const, _Vs...>
4856 {
return __x._M_current <=> __y._M_current; }
4858 friend constexpr _Iterator
4859 operator+(
const _Iterator& __i, difference_type __n)
4860 requires __detail::__all_random_access<_Const, _Vs...>
4867 friend constexpr _Iterator
4868 operator+(difference_type __n,
const _Iterator& __i)
4869 requires __detail::__all_random_access<_Const, _Vs...>
4876 friend constexpr _Iterator
4877 operator-(
const _Iterator& __i, difference_type __n)
4878 requires __detail::__all_random_access<_Const, _Vs...>
4885 friend constexpr difference_type
4886 operator-(
const _Iterator& __x,
const _Iterator& __y)
4887 requires (sized_sentinel_for<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>,
4888 iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4891 return ranges::min({difference_type(std::get<_Is>(__x._M_current)
4892 - std::get<_Is>(__y._M_current))...},
4894 [](difference_type __i) {
4895 return __detail::__to_unsigned_like(__i < 0 ? -__i : __i);
4900 friend constexpr auto
4901 iter_move(
const _Iterator& __i)
4902 {
return __detail::__tuple_transform(ranges::iter_move, __i._M_current); }
4904 friend constexpr void
4905 iter_swap(
const _Iterator& __l,
const _Iterator& __r)
4906 requires (indirectly_swappable<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4909 (ranges::iter_swap(std::get<_Is>(__l._M_current), std::get<_Is>(__r._M_current)), ...);
4913 friend class zip_view;
4916 template<input_range... _Vs>
4917 requires (view<_Vs> && ...) && (
sizeof...(_Vs) > 0)
4918 template<
bool _Const>
4919 class zip_view<_Vs...>::_Sentinel
4921 tuple<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>...> _M_end;
4924 _Sentinel(
decltype(_M_end) __end)
4928 friend class zip_view;
4931 _Sentinel() =
default;
4934 _Sentinel(_Sentinel<!_Const> __i)
4936 && (convertible_to<sentinel_t<_Vs>,
4937 sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4938 : _M_end(
std::
move(__i._M_end))
4941 template<
bool _OtherConst>
4942 requires (sentinel_for<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>,
4943 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vs>>> && ...)
4944 friend constexpr bool
4945 operator==(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
4948 return ((std::get<_Is>(__x._M_current) == std::get<_Is>(__y._M_end)) || ...);
4952 template<
bool _OtherConst>
4953 requires (sized_sentinel_for<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>,
4954 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vs>>> && ...)
4955 friend constexpr auto
4956 operator-(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
4959 = common_type_t<range_difference_t<__detail::__maybe_const_t<_OtherConst, _Vs>>...>;
4961 return ranges::min({_Ret(std::get<_Is>(__x._M_current) - std::get<_Is>(__y._M_end))...},
4964 return __detail::__to_unsigned_like(__i < 0 ? -__i : __i);
4969 template<
bool _OtherConst>
4970 requires (sized_sentinel_for<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>,
4971 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vs>>> && ...)
4972 friend constexpr auto
4973 operator-(
const _Sentinel& __y,
const _Iterator<_OtherConst>& __x)
4974 {
return -(__x - __y); }
4981 template<
typename... _Ts>
4982 concept __can_zip_view
4983 =
requires { zip_view<all_t<_Ts>...>(std::declval<_Ts>()...); };
4988 template<
typename... _Ts>
4989 requires (
sizeof...(_Ts) == 0 || __detail::__can_zip_view<_Ts...>)
4991 operator() [[nodiscard]] (_Ts&&... __ts)
const
4993 if constexpr (
sizeof...(_Ts) == 0)
4994 return views::empty<tuple<>>;
4996 return zip_view<all_t<_Ts>...>(std::forward<_Ts>(__ts)...);
5000 inline constexpr _Zip zip;
5005 template<
typename _Range,
bool _Const>
5006 using __range_iter_cat
5007 =
typename iterator_traits<iterator_t<__maybe_const_t<_Const, _Range>>>::iterator_category;
5010 template<move_constructible _Fp, input_range... _Vs>
5011 requires (view<_Vs> && ...) && (
sizeof...(_Vs) > 0) && is_object_v<_Fp>
5012 && regular_invocable<_Fp&, range_reference_t<_Vs>...>
5013 && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Vs>...>>
5014 class zip_transform_view :
public view_interface<zip_transform_view<_Fp, _Vs...>>
5016 [[no_unique_address]] __detail::__box<_Fp> _M_fun;
5017 zip_view<_Vs...> _M_zip;
5019 using _InnerView = zip_view<_Vs...>;
5021 template<
bool _Const>
5022 using __ziperator = iterator_t<__detail::__maybe_const_t<_Const, _InnerView>>;
5024 template<
bool _Const>
5025 using __zentinel = sentinel_t<__detail::__maybe_const_t<_Const, _InnerView>>;
5027 template<
bool _Const>
5028 using _Base = __detail::__maybe_const_t<_Const, _InnerView>;
5030 template<
bool _Const>
5034 template<
bool _Const>
5035 requires forward_range<_Base<_Const>>
5036 struct __iter_cat<_Const>
5042 using __detail::__maybe_const_t;
5043 using __detail::__range_iter_cat;
5044 using _Res = invoke_result_t<__maybe_const_t<_Const, _Fp>&,
5045 range_reference_t<__maybe_const_t<_Const, _Vs>>...>;
5046 if constexpr (!is_lvalue_reference_v<_Res>)
5047 return input_iterator_tag{};
5048 else if constexpr ((derived_from<__range_iter_cat<_Vs, _Const>,
5049 random_access_iterator_tag> && ...))
5050 return random_access_iterator_tag{};
5051 else if constexpr ((derived_from<__range_iter_cat<_Vs, _Const>,
5052 bidirectional_iterator_tag> && ...))
5053 return bidirectional_iterator_tag{};
5054 else if constexpr ((derived_from<__range_iter_cat<_Vs, _Const>,
5055 forward_iterator_tag> && ...))
5056 return forward_iterator_tag{};
5058 return input_iterator_tag{};
5061 using iterator_category =
decltype(_S_iter_cat());
5064 template<
bool>
class _Iterator;
5065 template<
bool>
class _Sentinel;
5068 zip_transform_view() =
default;
5071 zip_transform_view(_Fp __fun, _Vs... __views)
5077 {
return _Iterator<false>(*
this, _M_zip.begin()); }
5081 requires range<const _InnerView>
5082 && regular_invocable<const _Fp&, range_reference_t<const _Vs>...>
5083 {
return _Iterator<true>(*
this, _M_zip.begin()); }
5088 if constexpr (common_range<_InnerView>)
5089 return _Iterator<false>(*
this, _M_zip.end());
5091 return _Sentinel<false>(_M_zip.end());
5096 requires range<const _InnerView>
5097 && regular_invocable<const _Fp&, range_reference_t<const _Vs>...>
5099 if constexpr (common_range<const _InnerView>)
5100 return _Iterator<true>(*
this, _M_zip.end());
5102 return _Sentinel<true>(_M_zip.end());
5106 size()
requires sized_range<_InnerView>
5107 {
return _M_zip.size(); }
5110 size() const requires sized_range<const _InnerView>
5111 {
return _M_zip.size(); }
5114 template<
class _Fp,
class... Rs>
5115 zip_transform_view(_Fp, Rs&&...) -> zip_transform_view<_Fp, views::all_t<Rs>...>;
5117 template<move_constructible _Fp, input_range... _Vs>
5118 requires (view<_Vs> && ...) && (
sizeof...(_Vs) > 0) && is_object_v<_Fp>
5119 && regular_invocable<_Fp&, range_reference_t<_Vs>...>
5120 && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Vs>...>>
5121 template<
bool _Const>
5122 class zip_transform_view<_Fp, _Vs...>::_Iterator :
public __iter_cat<_Const>
5124 using _Parent = __detail::__maybe_const_t<_Const, zip_transform_view>;
5126 _Parent* _M_parent =
nullptr;
5127 __ziperator<_Const> _M_inner;
5130 _Iterator(_Parent& __parent, __ziperator<_Const> __inner)
5134 friend class zip_transform_view;
5138 using iterator_concept =
typename __ziperator<_Const>::iterator_concept;
5140 = remove_cvref_t<invoke_result_t<__detail::__maybe_const_t<_Const, _Fp>&,
5141 range_reference_t<__detail::__maybe_const_t<_Const, _Vs>>...>>;
5142 using difference_type = range_difference_t<_Base<_Const>>;
5144 _Iterator() =
default;
5147 _Iterator(_Iterator<!_Const> __i)
5148 requires _Const && convertible_to<__ziperator<false>, __ziperator<_Const>>
5149 : _M_parent(__i._M_parent), _M_inner(
std::move(__i._M_inner))
5152 constexpr decltype(
auto)
5155 return std::apply([&](
const auto&... __iters) ->
decltype(
auto) {
5157 }, _M_inner._M_current);
5160 constexpr _Iterator&
5172 operator++(
int)
requires forward_range<_Base<_Const>>
5179 constexpr _Iterator&
5180 operator--()
requires bidirectional_range<_Base<_Const>>
5187 operator--(
int)
requires bidirectional_range<_Base<_Const>>
5194 constexpr _Iterator&
5195 operator+=(difference_type __x)
requires random_access_range<_Base<_Const>>
5201 constexpr _Iterator&
5202 operator-=(difference_type __x)
requires random_access_range<_Base<_Const>>
5208 constexpr decltype(
auto)
5209 operator[](difference_type __n)
const requires random_access_range<_Base<_Const>>
5211 return std::apply([&]<
typename... _Is>(
const _Is&... __iters) ->
decltype(
auto) {
5212 return std::__invoke(*_M_parent->_M_fun, __iters[iter_difference_t<_Is>(__n)]...);
5213 }, _M_inner._M_current);
5216 friend constexpr bool
5217 operator==(
const _Iterator& __x,
const _Iterator& __y)
5218 requires equality_comparable<__ziperator<_Const>>
5219 {
return __x._M_inner == __y._M_inner; }
5221 friend constexpr auto
5222 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
5223 requires random_access_range<_Base<_Const>>
5224 {
return __x._M_inner <=> __y._M_inner; }
5226 friend constexpr _Iterator
5227 operator+(
const _Iterator& __i, difference_type __n)
5228 requires random_access_range<_Base<_Const>>
5229 {
return _Iterator(*__i._M_parent, __i._M_inner + __n); }
5231 friend constexpr _Iterator
5232 operator+(difference_type __n,
const _Iterator& __i)
5233 requires random_access_range<_Base<_Const>>
5234 {
return _Iterator(*__i._M_parent, __i._M_inner + __n); }
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 difference_type
5242 operator-(
const _Iterator& __x,
const _Iterator& __y)
5243 requires sized_sentinel_for<__ziperator<_Const>, __ziperator<_Const>>
5244 {
return __x._M_inner - __y._M_inner; }
5247 template<move_constructible _Fp, input_range... _Vs>
5248 requires (view<_Vs> && ...) && (
sizeof...(_Vs) > 0) && is_object_v<_Fp>
5249 && regular_invocable<_Fp&, range_reference_t<_Vs>...>
5250 && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Vs>...>>
5251 template<
bool _Const>
5252 class zip_transform_view<_Fp, _Vs...>::_Sentinel
5254 __zentinel<_Const> _M_inner;
5257 _Sentinel(__zentinel<_Const> __inner)
5261 friend class zip_transform_view;
5264 _Sentinel() =
default;
5267 _Sentinel(_Sentinel<!_Const> __i)
5268 requires _Const && convertible_to<__zentinel<false>, __zentinel<_Const>>
5272 template<
bool _OtherConst>
5273 requires sentinel_for<__zentinel<_Const>, __ziperator<_OtherConst>>
5274 friend constexpr bool
5275 operator==(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
5276 {
return __x._M_inner == __y._M_inner; }
5278 template<
bool _OtherConst>
5279 requires sized_sentinel_for<__zentinel<_Const>, __ziperator<_OtherConst>>
5280 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
5281 operator-(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
5282 {
return __x._M_inner - __y._M_inner; }
5284 template<
bool _OtherConst>
5285 requires sized_sentinel_for<__zentinel<_Const>, __ziperator<_OtherConst>>
5286 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
5287 operator-(
const _Sentinel& __x,
const _Iterator<_OtherConst>& __y)
5288 {
return __x._M_inner - __y._M_inner; }
5295 template<
typename _Fp,
typename... _Ts>
5296 concept __can_zip_transform_view
5297 =
requires { zip_transform_view(std::declval<_Fp>(), std::declval<_Ts>()...); };
5300 struct _ZipTransform
5302 template<
typename _Fp,
typename... _Ts>
5303 requires (
sizeof...(_Ts) == 0) || __detail::__can_zip_transform_view<_Fp, _Ts...>
5305 operator() [[nodiscard]] (_Fp&& __f, _Ts&&... __ts)
const
5307 if constexpr (
sizeof...(_Ts) == 0)
5308 return views::empty<decay_t<invoke_result_t<decay_t<_Fp>&>>>;
5310 return zip_transform_view(std::forward<_Fp>(__f), std::forward<_Ts>(__ts)...);
5314 inline constexpr _ZipTransform zip_transform;
5317 template<forward_range _Vp,
size_t _Nm>
5318 requires view<_Vp> && (_Nm > 0)
5319 class adjacent_view :
public view_interface<adjacent_view<_Vp, _Nm>>
5321 _Vp _M_base = _Vp();
5323 template<
bool>
class _Iterator;
5324 template<
bool>
class _Sentinel;
5326 struct __as_sentinel
5330 adjacent_view()
requires default_initializable<_Vp> = default;
5333 adjacent_view(_Vp
__base)
5340 base() const & requires copy_constructible<_Vp>
5348 begin()
requires (!__detail::__simple_view<_Vp>)
5352 begin() const requires range<const _Vp>
5356 end()
requires (!__detail::__simple_view<_Vp>)
5358 if constexpr (common_range<_Vp>)
5365 end() const requires range<const _Vp>
5367 if constexpr (common_range<const _Vp>)
5374 size()
requires sized_range<_Vp>
5377 using _CT = common_type_t<_ST, size_t>;
5379 __sz -= std::min<_CT>(__sz, _Nm - 1);
5380 return static_cast<_ST
>(__sz);
5384 size() const requires sized_range<const _Vp>
5387 using _CT = common_type_t<_ST, size_t>;
5389 __sz -= std::min<_CT>(__sz, _Nm - 1);
5390 return static_cast<_ST
>(__sz);
5394 template<
typename _Vp,
size_t _Nm>
5395 inline constexpr bool enable_borrowed_range<adjacent_view<_Vp, _Nm>>
5396 = enable_borrowed_range<_Vp>;
5401 template<
typename _Tp,
size_t _Nm>
5406 template<
typename _Fp,
size_t _Nm>
5409 template<
typename... _Ts>
5410 static invoke_result_t<_Fp, _Ts...>
5411 __tuple_apply(
const tuple<_Ts...>&);
5413 template<
typename _Tp>
5414 decltype(__tuple_apply(
std::declval<__repeated_tuple<_Tp, _Nm>>()))
5419 template<forward_range _Vp,
size_t _Nm>
5420 requires view<_Vp> && (_Nm > 0)
5421 template<bool _Const>
5422 class adjacent_view<_Vp, _Nm>::_Iterator
5427 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
5428 array<iterator_t<_Base>, _Nm> _M_current = array<iterator_t<_Base>, _Nm>();
5431 _Iterator(iterator_t<_Base> __first, sentinel_t<_Base> __last)
5433 for (
auto& __i : _M_current)
5441 _Iterator(__as_sentinel, iterator_t<_Base> __first, iterator_t<_Base> __last)
5443 if constexpr (!bidirectional_range<_Base>)
5444 for (
auto& __it : _M_current)
5447 for (
size_t __i = 0; __i < _Nm; ++__i)
5449 _M_current[_Nm - 1 - __i] = __last;
5457 if constexpr (random_access_range<_Base>)
5458 return random_access_iterator_tag{};
5459 else if constexpr (bidirectional_range<_Base>)
5460 return bidirectional_iterator_tag{};
5462 return forward_iterator_tag{};
5465 friend class adjacent_view;
5468 template<forward_range _Wp, move_constructible _Fp,
size_t _Mm>
5469 requires view<_Wp> && (_Mm > 0) && is_object_v<_Fp>
5470 && regular_invocable<__detail::__unarize<_Fp&, _Mm>, range_reference_t<_Wp>>
5471 && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Mm>,
5472 range_reference_t<_Wp>>>
5473 friend class adjacent_transform_view;
5477 using iterator_category = input_iterator_tag;
5478 using iterator_concept =
decltype(_S_iter_concept());
5480 pair<range_value_t<_Base>, range_value_t<_Base>>,
5481 __detail::__repeated_tuple<range_value_t<_Base>, _Nm>>;
5482 using difference_type = range_difference_t<_Base>;
5484 _Iterator() =
default;
5487 _Iterator(_Iterator<!_Const> __i)
5488 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
5490 for (
size_t __j = 0; __j < _Nm; ++__j)
5491 _M_current[__j] =
std::move(__i._M_current[__j]);
5497 auto __f = [](
auto& __i) ->
decltype(
auto) {
return *__i; };
5498 return __detail::__tuple_transform(__f, _M_current);
5501 constexpr _Iterator&
5504 for (
auto& __i : _M_current)
5517 constexpr _Iterator&
5518 operator--()
requires bidirectional_range<_Base>
5520 for (
auto& __i : _M_current)
5526 operator--(
int)
requires bidirectional_range<_Base>
5533 constexpr _Iterator&
5534 operator+=(difference_type __x)
5535 requires random_access_range<_Base>
5537 for (
auto& __i : _M_current)
5542 constexpr _Iterator&
5543 operator-=(difference_type __x)
5544 requires random_access_range<_Base>
5546 for (
auto& __i : _M_current)
5552 operator[](difference_type __n)
const
5553 requires random_access_range<_Base>
5555 auto __f = [&](
auto& __i) ->
decltype(
auto) {
return __i[__n]; };
5556 return __detail::__tuple_transform(__f, _M_current);
5559 friend constexpr bool
5560 operator==(
const _Iterator& __x,
const _Iterator& __y)
5561 {
return __x._M_current.back() == __y._M_current.back(); }
5563 friend constexpr bool
5564 operator<(
const _Iterator& __x,
const _Iterator& __y)
5565 requires random_access_range<_Base>
5566 {
return __x._M_current.back() < __y._M_current.back(); }
5568 friend constexpr bool
5569 operator>(
const _Iterator& __x,
const _Iterator& __y)
5570 requires random_access_range<_Base>
5571 {
return __y < __x; }
5573 friend constexpr bool
5574 operator<=(
const _Iterator& __x,
const _Iterator& __y)
5575 requires random_access_range<_Base>
5576 {
return !(__y < __x); }
5578 friend constexpr bool
5579 operator>=(
const _Iterator& __x,
const _Iterator& __y)
5580 requires random_access_range<_Base>
5581 {
return !(__x < __y); }
5583 friend constexpr auto
5584 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
5585 requires random_access_range<_Base>
5586 && three_way_comparable<iterator_t<_Base>>
5587 {
return __x._M_current.back() <=> __y._M_current.back(); }
5589 friend constexpr _Iterator
5590 operator+(
const _Iterator& __i, difference_type __n)
5591 requires random_access_range<_Base>
5598 friend constexpr _Iterator
5599 operator+(difference_type __n,
const _Iterator& __i)
5600 requires random_access_range<_Base>
5607 friend constexpr _Iterator
5608 operator-(
const _Iterator& __i, difference_type __n)
5609 requires random_access_range<_Base>
5616 friend constexpr difference_type
5617 operator-(
const _Iterator& __x,
const _Iterator& __y)
5618 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
5619 {
return __x._M_current.back() - __y._M_current.back(); }
5621 friend constexpr auto
5622 iter_move(
const _Iterator& __i)
5623 {
return __detail::__tuple_transform(ranges::iter_move, __i._M_current); }
5625 friend constexpr void
5626 iter_swap(
const _Iterator& __l,
const _Iterator& __r)
5627 requires indirectly_swappable<iterator_t<_Base>>
5629 for (
size_t __i = 0; __i < _Nm; __i++)
5630 ranges::iter_swap(__l._M_current[__i], __r._M_current[__i]);
5634 template<forward_range _Vp,
size_t _Nm>
5635 requires view<_Vp> && (_Nm > 0)
5636 template<bool _Const>
5637 class adjacent_view<_Vp, _Nm>::_Sentinel
5639 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
5641 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
5644 _Sentinel(sentinel_t<_Base> __end)
5648 friend class adjacent_view;
5651 _Sentinel() =
default;
5654 _Sentinel(_Sentinel<!_Const> __i)
5655 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
5659 template<
bool _OtherConst>
5660 requires sentinel_for<sentinel_t<_Base>,
5661 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
5662 friend constexpr bool
5663 operator==(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
5664 {
return __x._M_current.back() == __y._M_end; }
5666 template<
bool _OtherConst>
5667 requires sized_sentinel_for<sentinel_t<_Base>,
5668 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
5669 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _Vp>>
5670 operator-(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
5671 {
return __x._M_current.back() - __y._M_end; }
5673 template<
bool _OtherConst>
5674 requires sized_sentinel_for<sentinel_t<_Base>,
5675 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
5676 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _Vp>>
5677 operator-(
const _Sentinel& __y,
const _Iterator<_OtherConst>& __x)
5678 {
return __y._M_end - __x._M_current.back(); }
5685 template<
size_t _Nm,
typename _Range>
5686 concept __can_adjacent_view
5687 =
requires { adjacent_view<all_t<_Range>, _Nm>(std::declval<_Range>()); };
5690 template<
size_t _Nm>
5691 struct _Adjacent : __adaptor::_RangeAdaptorClosure<_Adjacent<_Nm>>
5693 template<viewable_range _Range>
5694 requires (_Nm == 0) || __detail::__can_adjacent_view<_Nm, _Range>
5696 operator() [[nodiscard]] (_Range&& __r)
const
5698 if constexpr (_Nm == 0)
5701 return adjacent_view<all_t<_Range>, _Nm>(std::forward<_Range>(__r));
5705 template<
size_t _Nm>
5706 inline constexpr _Adjacent<_Nm> adjacent;
5708 inline constexpr auto pairwise = adjacent<2>;
5711 template<forward_range _Vp, move_constructible _Fp,
size_t _Nm>
5712 requires view<_Vp> && (_Nm > 0) && is_object_v<_Fp>
5713 && regular_invocable<__detail::__unarize<_Fp&, _Nm>, range_reference_t<_Vp>>
5714 && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Nm>,
5715 range_reference_t<_Vp>>>
5716 class adjacent_transform_view :
public view_interface<adjacent_transform_view<_Vp, _Fp, _Nm>>
5718 [[no_unique_address]] __detail::__box<_Fp> _M_fun;
5719 adjacent_view<_Vp, _Nm> _M_inner;
5721 using _InnerView = adjacent_view<_Vp, _Nm>;
5723 template<
bool _Const>
5724 using _InnerIter = iterator_t<__detail::__maybe_const_t<_Const, _InnerView>>;
5726 template<
bool _Const>
5727 using _InnerSent = sentinel_t<__detail::__maybe_const_t<_Const, _InnerView>>;
5729 template<
bool>
class _Iterator;
5730 template<
bool>
class _Sentinel;
5733 adjacent_transform_view() =
default;
5736 adjacent_transform_view(_Vp
__base, _Fp __fun)
5744 base() const & requires copy_constructible<_Vp>
5745 {
return _M_inner.base(); }
5753 {
return _Iterator<false>(*
this, _M_inner.begin()); }
5757 requires range<const _InnerView>
5758 && regular_invocable<__detail::__unarize<const _Fp&, _Nm>,
5759 range_reference_t<const _Vp>>
5760 {
return _Iterator<true>(*
this, _M_inner.begin()); }
5765 if constexpr (common_range<_InnerView>)
5766 return _Iterator<false>(*
this, _M_inner.end());
5768 return _Sentinel<false>(_M_inner.end());
5773 requires range<const _InnerView>
5774 && regular_invocable<__detail::__unarize<const _Fp&, _Nm>,
5775 range_reference_t<const _Vp>>
5777 if constexpr (common_range<const _InnerView>)
5778 return _Iterator<true>(*
this, _M_inner.end());
5780 return _Sentinel<true>(_M_inner.end());
5784 size()
requires sized_range<_InnerView>
5785 {
return _M_inner.size(); }
5788 size() const requires sized_range<const _InnerView>
5789 {
return _M_inner.size(); }
5792 template<forward_range _Vp, move_constructible _Fp,
size_t _Nm>
5793 requires view<_Vp> && (_Nm > 0) && is_object_v<_Fp>
5794 && regular_invocable<__detail::__unarize<_Fp&, _Nm>, range_reference_t<_Vp>>
5795 && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Nm>,
5796 range_reference_t<_Vp>>>
5797 template<bool _Const>
5798 class adjacent_transform_view<_Vp, _Fp, _Nm>::_Iterator
5800 using _Parent = __detail::__maybe_const_t<_Const, adjacent_transform_view>;
5801 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
5803 _Parent* _M_parent =
nullptr;
5804 _InnerIter<_Const> _M_inner;
5807 _Iterator(_Parent& __parent, _InnerIter<_Const> __inner)
5814 using __detail::__maybe_const_t;
5815 using __detail::__unarize;
5816 using _Res = invoke_result_t<__unarize<__maybe_const_t<_Const, _Fp>&, _Nm>,
5817 range_reference_t<_Base>>;
5818 using _Cat =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
5819 if constexpr (!is_lvalue_reference_v<_Res>)
5820 return input_iterator_tag{};
5821 else if constexpr (derived_from<_Cat, random_access_iterator_tag>)
5822 return random_access_iterator_tag{};
5823 else if constexpr (derived_from<_Cat, bidirectional_iterator_tag>)
5824 return bidirectional_iterator_tag{};
5825 else if constexpr (derived_from<_Cat, forward_iterator_tag>)
5826 return forward_iterator_tag{};
5828 return input_iterator_tag{};
5831 friend class adjacent_transform_view;
5834 using iterator_category =
decltype(_S_iter_cat());
5835 using iterator_concept =
typename _InnerIter<_Const>::iterator_concept;
5837 = remove_cvref_t<invoke_result_t
5838 <__detail::__unarize<__detail::__maybe_const_t<_Const, _Fp>&, _Nm>,
5839 range_reference_t<_Base>>>;
5840 using difference_type = range_difference_t<_Base>;
5842 _Iterator() =
default;
5845 _Iterator(_Iterator<!_Const> __i)
5846 requires _Const && convertible_to<_InnerIter<false>, _InnerIter<_Const>>
5847 : _M_parent(__i._M_parent), _M_inner(
std::move(__i._M_inner))
5850 constexpr decltype(
auto)
5853 return std::apply([&](
const auto&... __iters) ->
decltype(
auto) {
5855 }, _M_inner._M_current);
5858 constexpr _Iterator&
5873 constexpr _Iterator&
5874 operator--()
requires bidirectional_range<_Base>
5881 operator--(
int)
requires bidirectional_range<_Base>
5888 constexpr _Iterator&
5889 operator+=(difference_type __x)
requires random_access_range<_Base>
5895 constexpr _Iterator&
5896 operator-=(difference_type __x)
requires random_access_range<_Base>
5902 constexpr decltype(
auto)
5903 operator[](difference_type __n)
const requires random_access_range<_Base>
5905 return std::apply([&](
const auto&... __iters) ->
decltype(
auto) {
5907 }, _M_inner._M_current);
5910 friend constexpr bool
5911 operator==(
const _Iterator& __x,
const _Iterator& __y)
5912 {
return __x._M_inner == __y._M_inner; }
5914 friend constexpr bool
5915 operator<(
const _Iterator& __x,
const _Iterator& __y)
5916 requires random_access_range<_Base>
5917 {
return __x._M_inner < __y._M_inner; }
5919 friend constexpr bool
5920 operator>(
const _Iterator& __x,
const _Iterator& __y)
5921 requires random_access_range<_Base>
5922 {
return __x._M_inner > __y._M_inner; }
5924 friend constexpr bool
5925 operator<=(
const _Iterator& __x,
const _Iterator& __y)
5926 requires random_access_range<_Base>
5927 {
return __x._M_inner <= __y._M_inner; }
5929 friend constexpr bool
5930 operator>=(
const _Iterator& __x,
const _Iterator& __y)
5931 requires random_access_range<_Base>
5932 {
return __x._M_inner >= __y._M_inner; }
5934 friend constexpr auto
5935 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
5936 requires random_access_range<_Base> &&
5937 three_way_comparable<_InnerIter<_Const>>
5938 {
return __x._M_inner <=> __y._M_inner; }
5940 friend constexpr _Iterator
5941 operator+(
const _Iterator& __i, difference_type __n)
5942 requires random_access_range<_Base>
5943 {
return _Iterator(*__i._M_parent, __i._M_inner + __n); }
5945 friend constexpr _Iterator
5946 operator+(difference_type __n,
const _Iterator& __i)
5947 requires random_access_range<_Base>
5948 {
return _Iterator(*__i._M_parent, __i._M_inner + __n); }
5950 friend constexpr _Iterator
5951 operator-(
const _Iterator& __i, difference_type __n)
5952 requires random_access_range<_Base>
5953 {
return _Iterator(*__i._M_parent, __i._M_inner - __n); }
5955 friend constexpr difference_type
5956 operator-(
const _Iterator& __x,
const _Iterator& __y)
5957 requires sized_sentinel_for<_InnerIter<_Const>, _InnerIter<_Const>>
5958 {
return __x._M_inner - __y._M_inner; }
5961 template<forward_range _Vp, move_constructible _Fp,
size_t _Nm>
5962 requires view<_Vp> && (_Nm > 0) && is_object_v<_Fp>
5963 && regular_invocable<__detail::__unarize<_Fp&, _Nm>, range_reference_t<_Vp>>
5964 && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Nm>,
5965 range_reference_t<_Vp>>>
5966 template<bool _Const>
5967 class adjacent_transform_view<_Vp, _Fp, _Nm>::_Sentinel
5969 _InnerSent<_Const> _M_inner;
5972 _Sentinel(_InnerSent<_Const> __inner)
5976 friend class adjacent_transform_view;
5979 _Sentinel() =
default;
5982 _Sentinel(_Sentinel<!_Const> __i)
5983 requires _Const && convertible_to<_InnerSent<false>, _InnerSent<_Const>>
5987 template<
bool _OtherConst>
5988 requires sentinel_for<_InnerSent<_Const>, _InnerIter<_OtherConst>>
5989 friend constexpr bool
5990 operator==(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
5991 {
return __x._M_inner == __y._M_inner; }
5993 template<
bool _OtherConst>
5994 requires sized_sentinel_for<_InnerSent<_Const>, _InnerIter<_OtherConst>>
5995 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
5996 operator-(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
5997 {
return __x._M_inner - __y._M_inner; }
5999 template<
bool _OtherConst>
6000 requires sized_sentinel_for<_InnerSent<_Const>, _InnerIter<_OtherConst>>
6001 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
6002 operator-(
const _Sentinel& __x,
const _Iterator<_OtherConst>& __y)
6003 {
return __x._M_inner - __y._M_inner; }
6010 template<
size_t _Nm,
typename _Range,
typename _Fp>
6011 concept __can_adjacent_transform_view
6012 =
requires { adjacent_transform_view<all_t<_Range>, decay_t<_Fp>, _Nm>
6013 (std::declval<_Range>(), std::declval<_Fp>()); };
6016 template<
size_t _Nm>
6017 struct _AdjacentTransform : __adaptor::_RangeAdaptor<_AdjacentTransform<_Nm>>
6019 template<viewable_range _Range,
typename _Fp>
6020 requires (_Nm == 0) || __detail::__can_adjacent_transform_view<_Nm, _Range, _Fp>
6022 operator() [[nodiscard]] (_Range&& __r, _Fp&& __f)
const
6024 if constexpr (_Nm == 0)
6025 return zip_transform(std::forward<_Fp>(__f));
6027 return adjacent_transform_view<all_t<_Range>, decay_t<_Fp>, _Nm>
6028 (std::forward<_Range>(__r), std::forward<_Fp>(__f));
6031 using __adaptor::_RangeAdaptor<_AdjacentTransform>::operator();
6032 static constexpr int _S_arity = 2;
6033 static constexpr bool _S_has_simple_extra_args =
true;
6036 template<
size_t _Nm>
6037 inline constexpr _AdjacentTransform<_Nm> adjacent_transform;
6039 inline constexpr auto pairwise_transform = adjacent_transform<2>;
6043#ifdef __cpp_lib_ranges_chunk
6046 template<
typename _Tp>
6047 constexpr _Tp __div_ceil(_Tp __num, _Tp __denom)
6049 _Tp __r = __num / __denom;
6050 if (__num % __denom)
6057 requires input_range<_Vp>
6058 class chunk_view :
public view_interface<chunk_view<_Vp>>
6061 range_difference_t<_Vp> _M_n;
6062 range_difference_t<_Vp> _M_remainder = 0;
6063 __detail::__non_propagating_cache<iterator_t<_Vp>> _M_current;
6070 chunk_view(_Vp
__base, range_difference_t<_Vp> __n)
6072 { __glibcxx_assert(__n >= 0); }
6075 base() const & requires copy_constructible<_Vp>
6082 constexpr _OuterIter
6086 _M_remainder = _M_n;
6087 return _OuterIter(*
this);
6090 constexpr default_sentinel_t
6091 end() const noexcept
6095 size()
requires sized_range<_Vp>
6097 return __detail::__to_unsigned_like(__detail::__div_ceil
6102 size() const requires sized_range<const _Vp>
6104 return __detail::__to_unsigned_like(__detail::__div_ceil
6109 template<
typename _Range>
6110 chunk_view(_Range&&, range_difference_t<_Range>) -> chunk_view<views::all_t<_Range>>;
6113 requires input_range<_Vp>
6114 class chunk_view<_Vp>::_OuterIter
6116 chunk_view* _M_parent;
6119 _OuterIter(chunk_view& __parent) noexcept
6126 using iterator_concept = input_iterator_tag;
6127 using difference_type = range_difference_t<_Vp>;
6131 _OuterIter(_OuterIter&&) =
default;
6132 _OuterIter& operator=(_OuterIter&&) =
default;
6134 constexpr value_type
6138 return value_type(*_M_parent);
6141 constexpr _OuterIter&
6147 _M_parent->_M_remainder = _M_parent->_M_n;
6155 friend constexpr bool
6156 operator==(
const _OuterIter& __x, default_sentinel_t)
6158 return *__x._M_parent->_M_current ==
ranges::end(__x._M_parent->_M_base)
6159 && __x._M_parent->_M_remainder != 0;
6162 friend constexpr difference_type
6163 operator-(default_sentinel_t,
const _OuterIter& __x)
6164 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6166 const auto __dist =
ranges::end(__x._M_parent->_M_base) - *__x._M_parent->_M_current;
6168 if (__dist < __x._M_parent->_M_remainder)
6169 return __dist == 0 ? 0 : 1;
6171 return 1 + __detail::__div_ceil(__dist - __x._M_parent->_M_remainder,
6172 __x._M_parent->_M_n);
6175 friend constexpr difference_type
6176 operator-(
const _OuterIter& __x, default_sentinel_t __y)
6177 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6178 {
return -(__y - __x); }
6182 requires input_range<_Vp>
6183 struct chunk_view<_Vp>::_OuterIter::value_type : view_interface<value_type>
6186 chunk_view* _M_parent;
6189 value_type(chunk_view& __parent) noexcept
6196 constexpr _InnerIter
6197 begin() const noexcept
6198 {
return _InnerIter(*_M_parent); }
6200 constexpr default_sentinel_t
6201 end() const noexcept
6206 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6208 return __detail::__to_unsigned_like
6209 (ranges::min(_M_parent->_M_remainder,
6210 ranges::end(_M_parent->_M_base) - *_M_parent->_M_current));
6215 requires input_range<_Vp>
6216 class chunk_view<_Vp>::_InnerIter
6218 chunk_view* _M_parent;
6221 _InnerIter(chunk_view& __parent) noexcept
6225 friend _OuterIter::value_type;
6228 using iterator_concept = input_iterator_tag;
6229 using difference_type = range_difference_t<_Vp>;
6230 using value_type = range_value_t<_Vp>;
6232 _InnerIter(_InnerIter&&) =
default;
6233 _InnerIter& operator=(_InnerIter&&) =
default;
6235 constexpr const iterator_t<_Vp>&
6237 {
return *_M_parent->_M_current; }
6239 constexpr range_reference_t<_Vp>
6243 return **_M_parent->_M_current;
6246 constexpr _InnerIter&
6250 ++*_M_parent->_M_current;
6251 if (*_M_parent->_M_current ==
ranges::end(_M_parent->_M_base))
6252 _M_parent->_M_remainder = 0;
6254 --_M_parent->_M_remainder;
6262 friend constexpr bool
6263 operator==(
const _InnerIter& __x, default_sentinel_t)
noexcept
6264 {
return __x._M_parent->_M_remainder == 0; }
6266 friend constexpr difference_type
6267 operator-(default_sentinel_t,
const _InnerIter& __x)
6268 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6270 return ranges::min(__x._M_parent->_M_remainder,
6271 ranges::end(__x._M_parent->_M_base) - *__x._M_parent->_M_current);
6274 friend constexpr difference_type
6275 operator-(
const _InnerIter& __x, default_sentinel_t __y)
6276 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6277 {
return -(__y - __x); }
6281 friend constexpr range_rvalue_reference_t<_Vp>
6282 iter_move(
const _InnerIter& __i)
6283 noexcept(
noexcept(ranges::iter_move(*__i._M_parent->_M_current)))
6284 {
return ranges::iter_move(*__i._M_parent->_M_current); }
6286 friend constexpr void
6287 iter_swap(
const _InnerIter& __x,
const _InnerIter& __y)
6288 noexcept(
noexcept(ranges::iter_swap(*__x._M_parent->_M_current,
6289 *__x._M_parent->_M_current)))
6290 requires indirectly_swappable<iterator_t<_Vp>>
6291 {
return ranges::iter_swap(*__x._M_parent->_M_current, *__y._M_parent->_M_current); }
6295 requires forward_range<_Vp>
6296 class chunk_view<_Vp> :
public view_interface<chunk_view<_Vp>>
6299 range_difference_t<_Vp> _M_n;
6300 template<
bool>
class _Iterator;
6304 chunk_view(_Vp
__base, range_difference_t<_Vp> __n)
6306 { __glibcxx_assert(__n > 0); }
6309 base() const & requires copy_constructible<_Vp>
6317 begin()
requires (!__detail::__simple_view<_Vp>)
6321 begin() const requires forward_range<const _Vp>
6325 end()
requires (!__detail::__simple_view<_Vp>)
6327 if constexpr (common_range<_Vp> && sized_range<_Vp>)
6330 return _Iterator<false>(
this,
ranges::end(_M_base), __missing);
6332 else if constexpr (common_range<_Vp> && !bidirectional_range<_Vp>)
6333 return _Iterator<false>(
this,
ranges::end(_M_base));
6339 end() const requires forward_range<const _Vp>
6341 if constexpr (common_range<const _Vp> && sized_range<const _Vp>)
6344 return _Iterator<true>(
this,
ranges::end(_M_base), __missing);
6346 else if constexpr (common_range<const _Vp> && !bidirectional_range<const _Vp>)
6347 return _Iterator<true>(
this,
ranges::end(_M_base));
6353 size()
requires sized_range<_Vp>
6355 return __detail::__to_unsigned_like(__detail::__div_ceil
6360 size() const requires sized_range<const _Vp>
6362 return __detail::__to_unsigned_like(__detail::__div_ceil
6367 template<
typename _Vp>
6368 inline constexpr bool enable_borrowed_range<chunk_view<_Vp>>
6369 = forward_range<_Vp> && enable_borrowed_range<_Vp>;
6372 requires forward_range<_Vp>
6373 template<
bool _Const>
6374 class chunk_view<_Vp>::_Iterator
6376 using _Parent = __detail::__maybe_const_t<_Const, chunk_view>;
6377 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
6379 iterator_t<_Base> _M_current = iterator_t<_Base>();
6380 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
6381 range_difference_t<_Base> _M_n = 0;
6382 range_difference_t<_Base> _M_missing = 0;
6385 _Iterator(_Parent* __parent, iterator_t<_Base> __current,
6386 range_difference_t<_Base> __missing = 0)
6387 : _M_current(__current), _M_end(ranges::
end(__parent->_M_base)),
6388 _M_n(__parent->_M_n), _M_missing(__missing)
6394 if constexpr (random_access_range<_Base>)
6395 return random_access_iterator_tag{};
6396 else if constexpr (bidirectional_range<_Base>)
6397 return bidirectional_iterator_tag{};
6399 return forward_iterator_tag{};
6405 using iterator_category = input_iterator_tag;
6406 using iterator_concept =
decltype(_S_iter_cat());
6407 using value_type =
decltype(views::take(subrange(_M_current, _M_end), _M_n));
6408 using difference_type = range_difference_t<_Base>;
6410 _Iterator() =
default;
6412 constexpr _Iterator(_Iterator<!_Const> __i)
6414 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
6415 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
6417 _M_n(__i._M_n), _M_missing(__i._M_missing)
6420 constexpr iterator_t<_Base>
6422 {
return _M_current; }
6424 constexpr value_type
6427 __glibcxx_assert(_M_current != _M_end);
6428 return views::take(subrange(_M_current, _M_end), _M_n);
6431 constexpr _Iterator&
6434 __glibcxx_assert(_M_current != _M_end);
6447 constexpr _Iterator&
6448 operator--()
requires bidirectional_range<_Base>
6456 operator--(
int)
requires bidirectional_range<_Base>
6463 constexpr _Iterator&
6464 operator+=(difference_type __x)
6465 requires random_access_range<_Base>
6480 constexpr _Iterator&
6481 operator-=(difference_type __x)
6482 requires random_access_range<_Base>
6483 {
return *
this += -__x; }
6485 constexpr value_type
6486 operator[](difference_type __n)
const
6487 requires random_access_range<_Base>
6488 {
return *(*
this + __n); }
6490 friend constexpr bool
6491 operator==(
const _Iterator& __x,
const _Iterator& __y)
6492 {
return __x._M_current == __y._M_current; }
6494 friend constexpr bool
6495 operator==(
const _Iterator& __x, default_sentinel_t)
6496 {
return __x._M_current == __x._M_end; }
6498 friend constexpr bool
6499 operator<(
const _Iterator& __x,
const _Iterator& __y)
6500 requires random_access_range<_Base>
6501 {
return __x._M_current > __y._M_current; }
6503 friend constexpr bool
6504 operator>(
const _Iterator& __x,
const _Iterator& __y)
6505 requires random_access_range<_Base>
6506 {
return __y < __x; }
6508 friend constexpr bool
6509 operator<=(
const _Iterator& __x,
const _Iterator& __y)
6510 requires random_access_range<_Base>
6511 {
return !(__y < __x); }
6513 friend constexpr bool
6514 operator>=(
const _Iterator& __x,
const _Iterator& __y)
6515 requires random_access_range<_Base>
6516 {
return !(__x < __y); }
6518 friend constexpr auto
6519 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
6520 requires random_access_range<_Base>
6521 && three_way_comparable<iterator_t<_Base>>
6522 {
return __x._M_current <=> __y._M_current; }
6524 friend constexpr _Iterator
6525 operator+(
const _Iterator& __i, difference_type __n)
6526 requires random_access_range<_Base>
6533 friend constexpr _Iterator
6534 operator+(difference_type __n,
const _Iterator& __i)
6535 requires random_access_range<_Base>
6542 friend constexpr _Iterator
6543 operator-(
const _Iterator& __i, difference_type __n)
6544 requires random_access_range<_Base>
6551 friend constexpr difference_type
6552 operator-(
const _Iterator& __x,
const _Iterator& __y)
6553 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
6555 return (__x._M_current - __y._M_current
6556 + __x._M_missing - __y._M_missing) / __x._M_n;
6559 friend constexpr difference_type
6560 operator-(default_sentinel_t __y,
const _Iterator& __x)
6561 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
6562 {
return __detail::__div_ceil(__x._M_end - __x._M_current, __x._M_n); }
6564 friend constexpr difference_type
6565 operator-(
const _Iterator& __x, default_sentinel_t __y)
6566 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
6567 {
return -(__y - __x); }
6574 template<
typename _Range,
typename _Dp>
6575 concept __can_chunk_view
6576 =
requires { chunk_view(std::declval<_Range>(), std::declval<_Dp>()); };
6579 struct _Chunk : __adaptor::_RangeAdaptor<_Chunk>
6581 template<viewable_range _Range,
typename _Dp = range_difference_t<_Range>>
6582 requires __detail::__can_chunk_view<_Range, _Dp>
6584 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n)
const
6585 {
return chunk_view(std::forward<_Range>(__r), __n); }
6587 using __adaptor::_RangeAdaptor<_Chunk>::operator();
6588 static constexpr int _S_arity = 2;
6589 static constexpr bool _S_has_simple_extra_args =
true;
6592 inline constexpr _Chunk chunk;
6596#ifdef __cpp_lib_ranges_slide
6599 template<
typename _Vp>
6600 concept __slide_caches_nothing = random_access_range<_Vp> && sized_range<_Vp>;
6602 template<
typename _Vp>
6603 concept __slide_caches_last
6604 = !__slide_caches_nothing<_Vp> && bidirectional_range<_Vp> && common_range<_Vp>;
6606 template<
typename _Vp>
6607 concept __slide_caches_first
6608 = !__slide_caches_nothing<_Vp> && !__slide_caches_last<_Vp>;
6611 template<forward_range _Vp>
6613 class slide_view :
public view_interface<slide_view<_Vp>>
6616 range_difference_t<_Vp> _M_n;
6617 [[no_unique_address]]
6618 __detail::__maybe_present_t<__detail::__slide_caches_first<_Vp>,
6619 __detail::_CachedPosition<_Vp>, 0> _M_cached_begin;
6620 [[no_unique_address]]
6621 __detail::__maybe_present_t<__detail::__slide_caches_last<_Vp>,
6622 __detail::_CachedPosition<_Vp>, 1> _M_cached_end;
6624 template<
bool>
class _Iterator;
6629 slide_view(_Vp
__base, range_difference_t<_Vp> __n)
6631 { __glibcxx_assert(__n > 0); }
6636 base() const & requires copy_constructible<_Vp>
6644 begin()
requires (!(__detail::__simple_view<_Vp>
6645 && __detail::__slide_caches_nothing<const _Vp>))
6647 if constexpr (__detail::__slide_caches_first<_Vp>)
6649 iterator_t<_Vp> __it;
6650 if (_M_cached_begin._M_has_value())
6651 __it = _M_cached_begin._M_get(_M_base);
6655 _M_cached_begin._M_set(_M_base, __it);
6664 begin() const requires __detail::__slide_caches_nothing<const _Vp>
6668 end()
requires (!(__detail::__simple_view<_Vp>
6669 && __detail::__slide_caches_nothing<const _Vp>))
6671 if constexpr (__detail::__slide_caches_nothing<_Vp>)
6672 return _Iterator<false>(
ranges::begin(_M_base) + range_difference_t<_Vp>(
size()),
6674 else if constexpr (__detail::__slide_caches_last<_Vp>)
6676 iterator_t<_Vp> __it;
6677 if (_M_cached_end._M_has_value())
6678 __it = _M_cached_end._M_get(_M_base);
6682 _M_cached_end._M_set(_M_base, __it);
6684 return _Iterator<false>(
std::move(__it), _M_n);
6686 else if constexpr (common_range<_Vp>)
6693 end() const requires __detail::__slide_caches_nothing<const _Vp>
6694 {
return begin() + range_difference_t<const _Vp>(
size()); }
6697 size()
requires sized_range<_Vp>
6702 return __detail::__to_unsigned_like(__sz);
6706 size() const requires sized_range<const _Vp>
6711 return __detail::__to_unsigned_like(__sz);
6715 template<
typename _Range>
6716 slide_view(_Range&&, range_difference_t<_Range>) -> slide_view<views::all_t<_Range>>;
6718 template<
typename _Vp>
6719 inline constexpr bool enable_borrowed_range<slide_view<_Vp>>
6720 = enable_borrowed_range<_Vp>;
6722 template<forward_range _Vp>
6724 template<
bool _Const>
6725 class slide_view<_Vp>::_Iterator
6727 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
6728 static constexpr bool _S_last_elt_present
6729 = __detail::__slide_caches_first<_Base>;
6731 iterator_t<_Base> _M_current = iterator_t<_Base>();
6732 [[no_unique_address]]
6733 __detail::__maybe_present_t<_S_last_elt_present, iterator_t<_Base>>
6734 _M_last_elt =
decltype(_M_last_elt)();
6735 range_difference_t<_Base> _M_n = 0;
6738 _Iterator(iterator_t<_Base> __current, range_difference_t<_Base> __n)
6739 requires (!_S_last_elt_present)
6740 : _M_current(__current), _M_n(__n)
6744 _Iterator(iterator_t<_Base> __current, iterator_t<_Base> __last_elt,
6745 range_difference_t<_Base> __n)
6746 requires _S_last_elt_present
6747 : _M_current(__current), _M_last_elt(__last_elt), _M_n(__n)
6753 if constexpr (random_access_range<_Base>)
6754 return random_access_iterator_tag{};
6755 else if constexpr (bidirectional_range<_Base>)
6756 return bidirectional_iterator_tag{};
6758 return forward_iterator_tag{};
6762 friend slide_view::_Sentinel;
6765 using iterator_category = input_iterator_tag;
6766 using iterator_concept =
decltype(_S_iter_concept());
6767 using value_type =
decltype(views::counted(_M_current, _M_n));
6768 using difference_type = range_difference_t<_Base>;
6770 _Iterator() =
default;
6773 _Iterator(_Iterator<!_Const> __i)
6774 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
6775 : _M_current(
std::move(__i._M_current)), _M_n(__i._M_n)
6780 {
return views::counted(_M_current, _M_n); }
6782 constexpr _Iterator&
6786 if constexpr (_S_last_elt_present)
6799 constexpr _Iterator&
6800 operator--()
requires bidirectional_range<_Base>
6803 if constexpr (_S_last_elt_present)
6809 operator--(
int)
requires bidirectional_range<_Base>
6816 constexpr _Iterator&
6817 operator+=(difference_type __x)
6818 requires random_access_range<_Base>
6821 if constexpr (_S_last_elt_present)
6826 constexpr _Iterator&
6827 operator-=(difference_type __x)
6828 requires random_access_range<_Base>
6831 if constexpr (_S_last_elt_present)
6837 operator[](difference_type __n)
const
6838 requires random_access_range<_Base>
6839 {
return views::counted(_M_current + __n, _M_n); }
6841 friend constexpr bool
6842 operator==(
const _Iterator& __x,
const _Iterator& __y)
6844 if constexpr (_S_last_elt_present)
6845 return __x._M_last_elt == __y._M_last_elt;
6847 return __x._M_current == __y._M_current;
6850 friend constexpr bool
6851 operator<(
const _Iterator& __x,
const _Iterator& __y)
6852 requires random_access_range<_Base>
6853 {
return __x._M_current < __y._M_current; }
6855 friend constexpr bool
6856 operator>(
const _Iterator& __x,
const _Iterator& __y)
6857 requires random_access_range<_Base>
6858 {
return __y < __x; }
6860 friend constexpr bool
6861 operator<=(
const _Iterator& __x,
const _Iterator& __y)
6862 requires random_access_range<_Base>
6863 {
return !(__y < __x); }
6865 friend constexpr bool
6866 operator>=(
const _Iterator& __x,
const _Iterator& __y)
6867 requires random_access_range<_Base>
6868 {
return !(__x < __y); }
6870 friend constexpr auto
6871 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
6872 requires random_access_range<_Base>
6873 && three_way_comparable<iterator_t<_Base>>
6874 {
return __x._M_current <=> __y._M_current; }
6876 friend constexpr _Iterator
6877 operator+(
const _Iterator& __i, difference_type __n)
6878 requires random_access_range<_Base>
6885 friend constexpr _Iterator
6886 operator+(difference_type __n,
const _Iterator& __i)
6887 requires random_access_range<_Base>
6894 friend constexpr _Iterator
6895 operator-(
const _Iterator& __i, difference_type __n)
6896 requires random_access_range<_Base>
6903 friend constexpr difference_type
6904 operator-(
const _Iterator& __x,
const _Iterator& __y)
6905 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
6907 if constexpr (_S_last_elt_present)
6908 return __x._M_last_elt - __y._M_last_elt;
6910 return __x._M_current - __y._M_current;
6914 template<forward_range _Vp>
6916 class slide_view<_Vp>::_Sentinel
6918 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
6921 _Sentinel(sentinel_t<_Vp> __end)
6928 _Sentinel() =
default;
6930 friend constexpr bool
6931 operator==(
const _Iterator<false>& __x,
const _Sentinel& __y)
6932 {
return __x._M_last_elt == __y._M_end; }
6934 friend constexpr range_difference_t<_Vp>
6935 operator-(
const _Iterator<false>& __x,
const _Sentinel& __y)
6936 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6937 {
return __x._M_last_elt - __y._M_end; }
6939 friend constexpr range_difference_t<_Vp>
6940 operator-(
const _Sentinel& __y,
const _Iterator<false>& __x)
6941 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6942 {
return __y._M_end -__x._M_last_elt; }
6949 template<
typename _Range,
typename _Dp>
6950 concept __can_slide_view
6951 =
requires { slide_view(std::declval<_Range>(), std::declval<_Dp>()); };
6954 struct _Slide : __adaptor::_RangeAdaptor<_Slide>
6956 template<viewable_range _Range,
typename _Dp = range_difference_t<_Range>>
6957 requires __detail::__can_slide_view<_Range, _Dp>
6959 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n)
const
6960 {
return slide_view(std::forward<_Range>(__r), __n); }
6962 using __adaptor::_RangeAdaptor<_Slide>::operator();
6963 static constexpr int _S_arity = 2;
6964 static constexpr bool _S_has_simple_extra_args =
true;
6967 inline constexpr _Slide slide;
6971#ifdef __cpp_lib_ranges_chunk_by
6972 template<forward_range _Vp,
6973 indirect_binary_predicate<iterator_t<_Vp>, iterator_t<_Vp>> _Pred>
6974 requires view<_Vp> && is_object_v<_Pred>
6975 class chunk_by_view :
public view_interface<chunk_by_view<_Vp, _Pred>>
6977 _Vp _M_base = _Vp();
6978 __detail::__box<_Pred> _M_pred;
6979 __detail::_CachedPosition<_Vp> _M_cached_begin;
6981 constexpr iterator_t<_Vp>
6982 _M_find_next(iterator_t<_Vp> __current)
6984 __glibcxx_assert(_M_pred.has_value());
6985 auto __pred = [
this]<
typename _Tp,
typename _Up>(_Tp&& __x, _Up&& __y) {
6986 return !bool((*_M_pred)(std::forward<_Tp>(__x), std::forward<_Up>(__y)));
6988 auto __it = ranges::adjacent_find(__current,
ranges::end(_M_base), __pred);
6989 return ranges::next(__it, 1,
ranges::end(_M_base));
6992 constexpr iterator_t<_Vp>
6993 _M_find_prev(iterator_t<_Vp> __current)
requires bidirectional_range<_Vp>
6995 __glibcxx_assert(_M_pred.has_value());
6996 auto __pred = [
this]<
typename _Tp,
typename _Up>(_Tp&& __x, _Up&& __y) {
6997 return !bool((*_M_pred)(std::forward<_Up>(__y), std::forward<_Tp>(__x)));
7001 __glibcxx_assert(__rbegin != __rend);
7002 auto __it = ranges::adjacent_find(__rbegin, __rend, __pred).base();
7009 chunk_by_view()
requires (default_initializable<_Vp>
7010 && default_initializable<_Pred>)
7014 chunk_by_view(_Vp
__base, _Pred __pred)
7019 base() const & requires copy_constructible<_Vp>
7026 constexpr const _Pred&
7028 {
return *_M_pred; }
7033 __glibcxx_assert(_M_pred.has_value());
7034 iterator_t<_Vp> __it;
7035 if (_M_cached_begin._M_has_value())
7036 __it = _M_cached_begin._M_get(_M_base);
7040 _M_cached_begin._M_set(_M_base, __it);
7048 if constexpr (common_range<_Vp>)
7055 template<
typename _Range,
typename _Pred>
7056 chunk_by_view(_Range&&, _Pred) -> chunk_by_view<views::all_t<_Range>, _Pred>;
7058 template<forward_range _Vp,
7059 indirect_binary_predicate<iterator_t<_Vp>, iterator_t<_Vp>> _Pred>
7060 requires view<_Vp> && is_object_v<_Pred>
7061 class chunk_by_view<_Vp, _Pred>::_Iterator
7063 chunk_by_view* _M_parent =
nullptr;
7064 iterator_t<_Vp> _M_current = iterator_t<_Vp>();
7065 iterator_t<_Vp> _M_next = iterator_t<_Vp>();
7068 _Iterator(chunk_by_view& __parent, iterator_t<_Vp> __current, iterator_t<_Vp> __next)
7069 : _M_parent(
std::
__addressof(__parent)), _M_current(__current), _M_next(__next)
7075 if constexpr (bidirectional_range<_Vp>)
7076 return bidirectional_iterator_tag{};
7078 return forward_iterator_tag{};
7081 friend chunk_by_view;
7084 using value_type = subrange<iterator_t<_Vp>>;
7085 using difference_type = range_difference_t<_Vp>;
7086 using iterator_category = input_iterator_tag;
7087 using iterator_concept =
decltype(_S_iter_concept());
7089 _Iterator() =
default;
7091 constexpr value_type
7094 __glibcxx_assert(_M_current != _M_next);
7095 return ranges::subrange(_M_current, _M_next);
7098 constexpr _Iterator&
7101 __glibcxx_assert(_M_current != _M_next);
7102 _M_current = _M_next;
7103 _M_next = _M_parent->_M_find_next(_M_current);
7115 constexpr _Iterator&
7116 operator--()
requires bidirectional_range<_Vp>
7118 _M_next = _M_current;
7119 _M_current = _M_parent->_M_find_prev(_M_next);
7124 operator--(
int)
requires bidirectional_range<_Vp>
7131 friend constexpr bool
7132 operator==(
const _Iterator& __x,
const _Iterator& __y)
7133 {
return __x._M_current == __y._M_current; }
7135 friend constexpr bool
7136 operator==(
const _Iterator& __x, default_sentinel_t)
7137 {
return __x._M_current == __x._M_next; }
7144 template<
typename _Range,
typename _Pred>
7145 concept __can_chunk_by_view
7146 =
requires { chunk_by_view(std::declval<_Range>(), std::declval<_Pred>()); };
7149 struct _ChunkBy : __adaptor::_RangeAdaptor<_ChunkBy>
7151 template<viewable_range _Range,
typename _Pred>
7152 requires __detail::__can_chunk_by_view<_Range, _Pred>
7154 operator() [[nodiscard]] (_Range&& __r, _Pred&& __pred)
const
7155 {
return chunk_by_view(std::forward<_Range>(__r), std::forward<_Pred>(__pred)); }
7157 using __adaptor::_RangeAdaptor<_ChunkBy>::operator();
7158 static constexpr int _S_arity = 2;
7159 static constexpr bool _S_has_simple_extra_args =
true;
7162 inline constexpr _ChunkBy chunk_by;
7166#ifdef __cpp_lib_ranges_join_with
7169 template<
typename _Range,
typename _Pattern>
7170 concept __compatible_joinable_ranges
7171 = common_with<range_value_t<_Range>, range_value_t<_Pattern>>
7172 && common_reference_with<range_reference_t<_Range>,
7173 range_reference_t<_Pattern>>
7174 && common_reference_with<range_rvalue_reference_t<_Range>,
7175 range_rvalue_reference_t<_Pattern>>;
7177 template<
typename _Range>
7178 concept __bidirectional_common = bidirectional_range<_Range> && common_range<_Range>;
7181 template<input_range _Vp, forward_range _Pattern>
7182 requires view<_Vp> && view<_Pattern>
7183 && input_range<range_reference_t<_Vp>>
7184 && __detail::__compatible_joinable_ranges<range_reference_t<_Vp>, _Pattern>
7185 class join_with_view :
public view_interface<join_with_view<_Vp, _Pattern>>
7187 using _InnerRange = range_reference_t<_Vp>;
7189 _Vp _M_base = _Vp();
7190 [[no_unique_address]]
7191 __detail::__maybe_present_t<!forward_range<_Vp>,
7192 __detail::__non_propagating_cache<iterator_t<_Vp>>> _M_outer_it;
7193 __detail::__non_propagating_cache<remove_cv_t<_InnerRange>> _M_inner;
7194 _Pattern _M_pattern = _Pattern();
7196 template<
bool _Const>
using _Base = __detail::__maybe_const_t<_Const, _Vp>;
7197 template<
bool _Const>
using _InnerBase = range_reference_t<_Base<_Const>>;
7198 template<
bool _Const>
using _PatternBase = __detail::__maybe_const_t<_Const, _Pattern>;
7200 template<
bool _Const>
using _OuterIter = iterator_t<_Base<_Const>>;
7201 template<
bool _Const>
using _InnerIter = iterator_t<_InnerBase<_Const>>;
7202 template<
bool _Const>
using _PatternIter = iterator_t<_PatternBase<_Const>>;
7204 template<
bool _Const>
7205 static constexpr bool _S_ref_is_glvalue = is_reference_v<_InnerBase<_Const>>;
7207 template<
bool _Const>
7211 template<
bool _Const>
7212 requires _S_ref_is_glvalue<_Const>
7213 && forward_range<_Base<_Const>>
7214 && forward_range<_InnerBase<_Const>>
7215 struct __iter_cat<_Const>
7221 using _OuterIter = join_with_view::_OuterIter<_Const>;
7222 using _InnerIter = join_with_view::_InnerIter<_Const>;
7223 using _PatternIter = join_with_view::_PatternIter<_Const>;
7224 using _OuterCat =
typename iterator_traits<_OuterIter>::iterator_category;
7225 using _InnerCat =
typename iterator_traits<_InnerIter>::iterator_category;
7226 using _PatternCat =
typename iterator_traits<_PatternIter>::iterator_category;
7227 if constexpr (!is_lvalue_reference_v<common_reference_t<iter_reference_t<_InnerIter>,
7228 iter_reference_t<_PatternIter>>>)
7229 return input_iterator_tag{};
7230 else if constexpr (derived_from<_OuterCat, bidirectional_iterator_tag>
7231 && derived_from<_InnerCat, bidirectional_iterator_tag>
7232 && derived_from<_PatternCat, bidirectional_iterator_tag>
7233 && common_range<_InnerBase<_Const>>
7234 && common_range<_PatternBase<_Const>>)
7235 return bidirectional_iterator_tag{};
7236 else if constexpr (derived_from<_OuterCat, forward_iterator_tag>
7237 && derived_from<_InnerCat, forward_iterator_tag>
7238 && derived_from<_PatternCat, forward_iterator_tag>)
7239 return forward_iterator_tag{};
7241 return input_iterator_tag{};
7244 using iterator_category =
decltype(_S_iter_cat());
7247 template<
bool>
struct _Iterator;
7248 template<
bool>
struct _Sentinel;
7251 join_with_view()
requires (default_initializable<_Vp>
7252 && default_initializable<_Pattern>)
7256 join_with_view(_Vp
__base, _Pattern __pattern)
7260 template<input_range _Range>
7261 requires constructible_from<_Vp, views::all_t<_Range>>
7262 && constructible_from<_Pattern, single_view<range_value_t<_InnerRange>>>
7264 join_with_view(_Range&& __r, range_value_t<_InnerRange> __e)
7265 : _M_base(views::all(
std::
forward<_Range>(__r))),
7266 _M_pattern(views::single(
std::
move(__e)))
7270 base() const& requires copy_constructible<_Vp>
7280 if constexpr (forward_range<_Vp>)
7282 constexpr bool __use_const = is_reference_v<_InnerRange>
7283 && __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
7284 return _Iterator<__use_const>{*
this,
ranges::begin(_M_base)};
7289 return _Iterator<false>{*
this};
7295 requires forward_range<const _Vp>
7296 && forward_range<const _Pattern>
7297 && is_reference_v<range_reference_t<const _Vp>>
7298 && input_range<range_reference_t<const _Vp>>
7304 constexpr bool __use_const
7305 = __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
7306 if constexpr (is_reference_v<_InnerRange>
7307 && forward_range<_Vp> && common_range<_Vp>
7308 && forward_range<_InnerRange> && common_range<_InnerRange>)
7309 return _Iterator<__use_const>{*
this,
ranges::end(_M_base)};
7311 return _Sentinel<__use_const>{*
this};
7316 requires forward_range<const _Vp>
7317 && forward_range<const _Pattern>
7318 && is_reference_v<range_reference_t<const _Vp>>
7319 && input_range<range_reference_t<const _Vp>>
7321 using _InnerConstRange = range_reference_t<const _Vp>;
7322 if constexpr (forward_range<_InnerConstRange>
7323 && common_range<const _Vp>
7324 && common_range<_InnerConstRange>)
7325 return _Iterator<true>{*
this,
ranges::end(_M_base)};
7327 return _Sentinel<true>{*
this};
7331 template<
typename _Range,
typename _Pattern>
7332 join_with_view(_Range&&, _Pattern&&)
7333 -> join_with_view<views::all_t<_Range>, views::all_t<_Pattern>>;
7335 template<input_range _Range>
7336 join_with_view(_Range&&, range_value_t<range_reference_t<_Range>>)
7337 -> join_with_view<views::all_t<_Range>,
7338 single_view<range_value_t<range_reference_t<_Range>>>>;
7340 template<input_range _Vp, forward_range _Pattern>
7341 requires view<_Vp> && view<_Pattern>
7342 && input_range<range_reference_t<_Vp>>
7343 && __detail::__compatible_joinable_ranges<range_reference_t<_Vp>, _Pattern>
7344 template<
bool _Const>
7345 class join_with_view<_Vp, _Pattern>::_Iterator :
public __iter_cat<_Const>
7347 using _Parent = __detail::__maybe_const_t<_Const, join_with_view>;
7348 using _Base = join_with_view::_Base<_Const>;
7349 using _InnerBase = join_with_view::_InnerBase<_Const>;
7350 using _PatternBase = join_with_view::_PatternBase<_Const>;
7352 using _OuterIter = join_with_view::_OuterIter<_Const>;
7353 using _InnerIter = join_with_view::_InnerIter<_Const>;
7354 using _PatternIter = join_with_view::_PatternIter<_Const>;
7356 static constexpr bool _S_ref_is_glvalue = join_with_view::_S_ref_is_glvalue<_Const>;
7358 _Parent* _M_parent =
nullptr;
7359 [[no_unique_address]]
7360 __detail::__maybe_present_t<forward_range<_Base>, _OuterIter> _M_outer_it;
7361 variant<_PatternIter, _InnerIter> _M_inner_it;
7363 constexpr _OuterIter&
7366 if constexpr (forward_range<_Base>)
7369 return *_M_parent->_M_outer_it;
7372 constexpr const _OuterIter&
7373 _M_get_outer()
const
7375 if constexpr (forward_range<_Base>)
7378 return *_M_parent->_M_outer_it;
7382 _Iterator(_Parent& __parent, _OuterIter __outer)
7383 requires forward_range<_Base>
7386 if (_M_get_outer() !=
ranges::end(_M_parent->_M_base))
7388 auto&& __inner = _M_update_inner();
7395 _Iterator(_Parent& __parent)
7396 requires (!forward_range<_Base>)
7399 if (_M_get_outer() !=
ranges::end(_M_parent->_M_base))
7401 auto&& __inner = _M_update_inner();
7410 _OuterIter& __outer = _M_get_outer();
7411 if constexpr (_S_ref_is_glvalue)
7412 return __detail::__as_lvalue(*__outer);
7414 return _M_parent->_M_inner._M_emplace_deref(__outer);
7420 if constexpr (_S_ref_is_glvalue)
7421 return __detail::__as_lvalue(*_M_get_outer());
7423 return *_M_parent->_M_inner;
7431 if (_M_inner_it.index() == 0)
7433 if (std::get<0>(_M_inner_it) !=
ranges::end(_M_parent->_M_pattern))
7436 auto&& __inner = _M_update_inner();
7441 auto&& __inner = _M_get_inner();
7442 if (std::get<1>(_M_inner_it) !=
ranges::end(__inner))
7445 if (++_M_get_outer() ==
ranges::end(_M_parent->_M_base))
7447 if constexpr (_S_ref_is_glvalue)
7448 _M_inner_it.template emplace<0>();
7452 _M_inner_it.template emplace<0>(
ranges::begin(_M_parent->_M_pattern));
7460 if constexpr (_S_ref_is_glvalue
7461 && bidirectional_range<_Base>
7462 && __detail::__bidirectional_common<_InnerBase>
7463 && __detail::__bidirectional_common<_PatternBase>)
7464 return bidirectional_iterator_tag{};
7465 else if constexpr (_S_ref_is_glvalue
7466 && forward_range<_Base>
7467 && forward_range<_InnerBase>)
7468 return forward_iterator_tag{};
7470 return input_iterator_tag{};
7473 friend join_with_view;
7476 using iterator_concept =
decltype(_S_iter_concept());
7478 using value_type = common_type_t<iter_value_t<_InnerIter>,
7479 iter_value_t<_PatternIter>>;
7480 using difference_type = common_type_t<iter_difference_t<_OuterIter>,
7481 iter_difference_t<_InnerIter>,
7482 iter_difference_t<_PatternIter>>;
7484 _Iterator() =
default;
7487 _Iterator(_Iterator<!_Const> __i)
7489 && convertible_to<iterator_t<_Vp>, _OuterIter>
7490 && convertible_to<iterator_t<_InnerRange>, _InnerIter>
7491 && convertible_to<iterator_t<_Pattern>, _PatternIter>
7492 : _M_parent(__i._M_parent),
7495 if (__i._M_inner_it.index() == 0)
7496 _M_inner_it.template emplace<0>(std::get<0>(
std::move(__i._M_inner_it)));
7498 _M_inner_it.template emplace<1>(std::get<1>(
std::move(__i._M_inner_it)));
7501 constexpr common_reference_t<iter_reference_t<_InnerIter>,
7502 iter_reference_t<_PatternIter>>
7505 if (_M_inner_it.index() == 0)
7506 return *std::get<0>(_M_inner_it);
7508 return *std::get<1>(_M_inner_it);
7511 constexpr _Iterator&
7514 if (_M_inner_it.index() == 0)
7515 ++std::get<0>(_M_inner_it);
7517 ++std::get<1>(_M_inner_it);
7528 requires _S_ref_is_glvalue
7529 && forward_iterator<_OuterIter> && forward_iterator<_InnerIter>
7531 _Iterator __tmp = *
this;
7536 constexpr _Iterator&
7538 requires _S_ref_is_glvalue
7539 && bidirectional_range<_Base>
7540 && __detail::__bidirectional_common<_InnerBase>
7541 && __detail::__bidirectional_common<_PatternBase>
7543 if (_M_outer_it ==
ranges::end(_M_parent->_M_base))
7545 auto&& __inner = *--_M_outer_it;
7546 _M_inner_it.template emplace<1>(
ranges::end(__inner));
7551 if (_M_inner_it.index() == 0)
7553 auto& __it = std::get<0>(_M_inner_it);
7556 auto&& __inner = *--_M_outer_it;
7557 _M_inner_it.template emplace<1>(
ranges::end(__inner));
7564 auto& __it = std::get<1>(_M_inner_it);
7565 auto&& __inner = *_M_outer_it;
7567 _M_inner_it.template emplace<0>(
ranges::end(_M_parent->_M_pattern));
7573 if (_M_inner_it.index() == 0)
7574 --std::get<0>(_M_inner_it);
7576 --std::get<1>(_M_inner_it);
7582 requires _S_ref_is_glvalue && bidirectional_range<_Base>
7583 && __detail::__bidirectional_common<_InnerBase>
7584 && __detail::__bidirectional_common<_PatternBase>
7586 _Iterator __tmp = *
this;
7591 friend constexpr bool
7592 operator==(
const _Iterator& __x,
const _Iterator& __y)
7593 requires _S_ref_is_glvalue
7594 && forward_range<_Base> && equality_comparable<_InnerIter>
7595 {
return __x._M_outer_it == __y._M_outer_it && __x._M_inner_it ==__y._M_inner_it; }
7597 friend constexpr common_reference_t<iter_rvalue_reference_t<_InnerIter>,
7598 iter_rvalue_reference_t<_PatternIter>>
7599 iter_move(
const _Iterator& __x)
7601 if (__x._M_inner_it.index() == 0)
7602 return ranges::iter_move(std::get<0>(__x._M_inner_it));
7604 return ranges::iter_move(std::get<1>(__x._M_inner_it));
7607 friend constexpr void
7608 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
7609 requires indirectly_swappable<_InnerIter, _PatternIter>
7611 if (__x._M_inner_it.index() == 0)
7613 if (__y._M_inner_it.index() == 0)
7614 ranges::iter_swap(std::get<0>(__x._M_inner_it), std::get<0>(__y._M_inner_it));
7616 ranges::iter_swap(std::get<0>(__x._M_inner_it), std::get<1>(__y._M_inner_it));
7620 if (__y._M_inner_it.index() == 0)
7621 ranges::iter_swap(std::get<1>(__x._M_inner_it), std::get<0>(__y._M_inner_it));
7623 ranges::iter_swap(std::get<1>(__x._M_inner_it), std::get<1>(__y._M_inner_it));
7628 template<input_range _Vp, forward_range _Pattern>
7629 requires view<_Vp> && view<_Pattern>
7630 && input_range<range_reference_t<_Vp>>
7631 && __detail::__compatible_joinable_ranges<range_reference_t<_Vp>, _Pattern>
7632 template<
bool _Const>
7633 class join_with_view<_Vp, _Pattern>::_Sentinel
7635 using _Parent = __detail::__maybe_const_t<_Const, join_with_view>;
7636 using _Base = join_with_view::_Base<_Const>;
7638 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
7641 _Sentinel(_Parent& __parent)
7642 : _M_end(ranges::
end(__parent._M_base))
7645 friend join_with_view;
7648 _Sentinel() =
default;
7651 _Sentinel(_Sentinel<!_Const> __s)
7652 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
7656 template<
bool _OtherConst>
7657 requires sentinel_for<sentinel_t<_Base>,
7658 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
7659 friend constexpr bool
7660 operator==(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
7661 {
return __x._M_get_outer() == __y._M_end; }
7668 template<
typename _Range,
typename _Pattern>
7669 concept __can_join_with_view
7670 =
requires { join_with_view(std::declval<_Range>(), std::declval<_Pattern>()); };
7673 struct _JoinWith : __adaptor::_RangeAdaptor<_JoinWith>
7675 template<viewable_range _Range,
typename _Pattern>
7676 requires __detail::__can_join_with_view<_Range, _Pattern>
7678 operator() [[nodiscard]] (_Range&& __r, _Pattern&& __f)
const
7680 return join_with_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
7683 using _RangeAdaptor<_JoinWith>::operator();
7684 static constexpr int _S_arity = 2;
7685 template<
typename _Pattern>
7686 static constexpr bool _S_has_simple_extra_args
7687 = _LazySplit::_S_has_simple_extra_args<_Pattern>;
7690 inline constexpr _JoinWith join_with;
7694#ifdef __cpp_lib_ranges_repeat
7695 template<move_constructible _Tp, semiregular _Bound = unreachable_sentinel_t>
7696 requires is_object_v<_Tp> && same_as<_Tp, remove_cv_t<_Tp>>
7697 && (__detail::__is_integer_like<_Bound> || same_as<_Bound, unreachable_sentinel_t>)
7698 class repeat_view :
public view_interface<repeat_view<_Tp, _Bound>>
7700 __detail::__box<_Tp> _M_value;
7701 [[no_unique_address]] _Bound _M_bound = _Bound();
7705 template<
typename _Range>
7706 friend constexpr auto
7707 views::__detail::__take_of_repeat_view(_Range&&, range_difference_t<_Range>);
7709 template<
typename _Range>
7710 friend constexpr auto
7711 views::__detail::__drop_of_repeat_view(_Range&&, range_difference_t<_Range>);
7714 repeat_view()
requires default_initializable<_Tp> = default;
7717 repeat_view(const _Tp& __value, _Bound __bound = _Bound())
7718 requires copy_constructible<_Tp>
7719 : _M_value(__value), _M_bound(__bound)
7721 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7722 __glibcxx_assert(__bound >= 0);
7726 repeat_view(_Tp&& __value, _Bound __bound = _Bound())
7727 : _M_value(
std::
move(__value)), _M_bound(__bound)
7730 template<
typename... _Args,
typename... _BoundArgs>
7731 requires constructible_from<_Tp, _Args...>
7732 && constructible_from<_Bound, _BoundArgs...>
7734 repeat_view(piecewise_construct_t,
7735 tuple<_Args...> __args,
7736 tuple<_BoundArgs...> __bound_args = tuple<>{})
7737 : _M_value(std::make_from_tuple<_Tp>(
std::move(__args))),
7738 _M_bound(std::make_from_tuple<_Bound>(
std::move(__bound_args)))
7746 end() const requires (!same_as<_Bound, unreachable_sentinel_t>)
7749 constexpr unreachable_sentinel_t
7750 end() const noexcept
7751 {
return unreachable_sentinel; }
7754 size() const requires (!same_as<_Bound, unreachable_sentinel_t>)
7755 {
return __detail::__to_unsigned_like(_M_bound); }
7760 template<
typename _Tp,
typename _Bound = unreachable_sentinel_t>
7761 repeat_view(_Tp, _Bound = _Bound()) -> repeat_view<_Tp, _Bound>;
7763 template<move_constructible _Tp, semiregular _Bound>
7764 requires is_object_v<_Tp> && same_as<_Tp, remove_cv_t<_Tp>>
7765 && (__detail::__is_integer_like<_Bound> || same_as<_Bound, unreachable_sentinel_t>)
7766 class repeat_view<_Tp, _Bound>::_Iterator
7769 = __conditional_t<same_as<_Bound, unreachable_sentinel_t>, ptrdiff_t, _Bound>;
7771 const _Tp* _M_value =
nullptr;
7772 __index_type _M_current = __index_type();
7775 _Iterator(
const _Tp* __value, __index_type __bound = __index_type())
7776 : _M_value(__value), _M_current(__bound)
7778 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7779 __glibcxx_assert(__bound >= 0);
7785 using iterator_concept = random_access_iterator_tag;
7786 using iterator_category = random_access_iterator_tag;
7787 using value_type = _Tp;
7788 using difference_type = __conditional_t<__detail::__is_signed_integer_like<__index_type>,
7790 __detail::__iota_diff_t<__index_type>>;
7792 _Iterator() =
default;
7794 constexpr const _Tp&
7796 {
return *_M_value; }
7798 constexpr _Iterator&
7813 constexpr _Iterator&
7816 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7817 __glibcxx_assert(_M_current > 0);
7830 constexpr _Iterator&
7831 operator+=(difference_type __n)
7833 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7834 __glibcxx_assert(_M_current + __n >= 0);
7839 constexpr _Iterator&
7840 operator-=(difference_type __n)
7842 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7843 __glibcxx_assert(_M_current - __n >= 0);
7848 constexpr const _Tp&
7849 operator[](difference_type __n)
const noexcept
7850 {
return *(*
this + __n); }
7852 friend constexpr bool
7853 operator==(
const _Iterator& __x,
const _Iterator& __y)
7854 {
return __x._M_current == __y._M_current; }
7856 friend constexpr auto
7857 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
7858 {
return __x._M_current <=> __y._M_current; }
7860 friend constexpr _Iterator
7861 operator+(_Iterator __i, difference_type __n)
7867 friend constexpr _Iterator
7868 operator+(difference_type __n, _Iterator __i)
7869 {
return __i + __n; }
7871 friend constexpr _Iterator
7872 operator-(_Iterator __i, difference_type __n)
7878 friend constexpr difference_type
7879 operator-(
const _Iterator& __x,
const _Iterator& __y)
7881 return (
static_cast<difference_type
>(__x._M_current)
7882 -
static_cast<difference_type
>(__y._M_current));
7890 template<
typename _Tp,
typename _Bound>
7891 inline constexpr bool __is_repeat_view<repeat_view<_Tp, _Bound>> =
true;
7893 template<
typename _Tp>
7894 concept __can_repeat_view
7895 =
requires { repeat_view(std::declval<_Tp>()); };
7897 template<
typename _Tp,
typename _Bound>
7898 concept __can_bounded_repeat_view
7899 =
requires { repeat_view(std::declval<_Tp>(), std::declval<_Bound>()); };
7904 template<
typename _Tp>
7905 requires __detail::__can_repeat_view<_Tp>
7907 operator() [[nodiscard]] (_Tp&& __value)
const
7911 return repeat_view<decay_t<_Tp>>(std::forward<_Tp>(__value));
7914 template<
typename _Tp,
typename _Bound>
7915 requires __detail::__can_bounded_repeat_view<_Tp, _Bound>
7917 operator() [[nodiscard]] (_Tp&& __value, _Bound __bound)
const
7918 {
return repeat_view(std::forward<_Tp>(__value), __bound); }
7921 inline constexpr _Repeat repeat;
7925 template<
typename _Range>
7927 __take_of_repeat_view(_Range&& __r, range_difference_t<_Range> __n)
7929 using _Tp = remove_cvref_t<_Range>;
7930 static_assert(__is_repeat_view<_Tp>);
7931 if constexpr (sized_range<_Tp>)
7932 return views::repeat(*std::forward<_Range>(__r)._M_value,
7935 return views::repeat(*std::forward<_Range>(__r)._M_value, __n);
7938 template<
typename _Range>
7940 __drop_of_repeat_view(_Range&& __r, range_difference_t<_Range> __n)
7942 using _Tp = remove_cvref_t<_Range>;
7943 static_assert(__is_repeat_view<_Tp>);
7944 if constexpr (sized_range<_Tp>)
7947 return views::repeat(*std::forward<_Range>(__r)._M_value,
7957#ifdef __cpp_lib_ranges_stride
7958 template<input_range _Vp>
7960 class stride_view :
public view_interface<stride_view<_Vp>>
7963 range_difference_t<_Vp> _M_stride;
7965 template<
bool _Const>
using _Base = __detail::__maybe_const_t<_Const, _Vp>;
7967 template<
bool _Const>
7971 template<
bool _Const>
7972 requires forward_range<_Base<_Const>>
7973 struct __iter_cat<_Const>
7979 using _Cat =
typename iterator_traits<iterator_t<_Base<_Const>>>::iterator_category;
7980 if constexpr (derived_from<_Cat, random_access_iterator_tag>)
7981 return random_access_iterator_tag{};
7986 using iterator_category =
decltype(_S_iter_cat());
7989 template<
bool>
class _Iterator;
7993 stride_view(_Vp
__base, range_difference_t<_Vp> __stride)
7995 { __glibcxx_assert(__stride > 0); }
7998 base() const& requires copy_constructible<_Vp>
8005 constexpr range_difference_t<_Vp>
8006 stride() const noexcept
8007 {
return _M_stride; }
8010 begin()
requires (!__detail::__simple_view<_Vp>)
8014 begin() const requires range<const _Vp>
8018 end()
requires (!__detail::__simple_view<_Vp>)
8020 if constexpr (common_range<_Vp> && sized_range<_Vp> && forward_range<_Vp>)
8022 auto __missing = (_M_stride -
ranges::distance(_M_base) % _M_stride) % _M_stride;
8023 return _Iterator<false>(
this,
ranges::end(_M_base), __missing);
8025 else if constexpr (common_range<_Vp> && !bidirectional_range<_Vp>)
8026 return _Iterator<false>(
this,
ranges::end(_M_base));
8032 end() const requires range<const _Vp>
8034 if constexpr (common_range<const _Vp> && sized_range<const _Vp>
8035 && forward_range<const _Vp>)
8037 auto __missing = (_M_stride -
ranges::distance(_M_base) % _M_stride) % _M_stride;
8038 return _Iterator<true>(
this,
ranges::end(_M_base), __missing);
8040 else if constexpr (common_range<const _Vp> && !bidirectional_range<const _Vp>)
8041 return _Iterator<true>(
this,
ranges::end(_M_base));
8047 size()
requires sized_range<_Vp>
8049 return __detail::__to_unsigned_like
8054 size() const requires sized_range<const _Vp>
8056 return __detail::__to_unsigned_like
8061 template<
typename _Range>
8062 stride_view(_Range&&, range_difference_t<_Range>) -> stride_view<views::all_t<_Range>>;
8064 template<
typename _Vp>
8065 inline constexpr bool enable_borrowed_range<stride_view<_Vp>>
8066 = enable_borrowed_range<_Vp>;
8068 template<input_range _Vp>
8070 template<
bool _Const>
8071 class stride_view<_Vp>::_Iterator :
public __iter_cat<_Const>
8073 using _Parent = __detail::__maybe_const_t<_Const, stride_view>;
8074 using _Base = stride_view::_Base<_Const>;
8076 iterator_t<_Base> _M_current = iterator_t<_Base>();
8077 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
8078 range_difference_t<_Base> _M_stride = 0;
8079 range_difference_t<_Base> _M_missing = 0;
8082 _Iterator(_Parent* __parent, iterator_t<_Base> __current,
8083 range_difference_t<_Base> __missing = 0)
8084 : _M_current(
std::
move(__current)), _M_end(ranges::
end(__parent->_M_base)),
8085 _M_stride(__parent->_M_stride), _M_missing(__missing)
8091 if constexpr (random_access_range<_Base>)
8092 return random_access_iterator_tag{};
8093 else if constexpr (bidirectional_range<_Base>)
8094 return bidirectional_iterator_tag{};
8095 else if constexpr (forward_range<_Base>)
8096 return forward_iterator_tag{};
8098 return input_iterator_tag{};
8104 using difference_type = range_difference_t<_Base>;
8105 using value_type = range_value_t<_Base>;
8106 using iterator_concept =
decltype(_S_iter_concept());
8109 _Iterator()
requires default_initializable<iterator_t<_Base>> = default;
8112 _Iterator(_Iterator<!_Const> __other)
8114 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
8115 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
8116 : _M_current(
std::
move(__other._M_current)), _M_end(
std::
move(__other._M_end)),
8117 _M_stride(__other._M_stride), _M_missing(__other._M_missing)
8120 constexpr iterator_t<_Base>
8124 constexpr const iterator_t<_Base>&
8125 base() const & noexcept
8126 {
return _M_current; }
8128 constexpr decltype(
auto)
8130 {
return *_M_current; }
8132 constexpr _Iterator&
8135 __glibcxx_assert(_M_current != _M_end);
8145 operator++(
int)
requires forward_range<_Base>
8152 constexpr _Iterator&
8153 operator--()
requires bidirectional_range<_Base>
8161 operator--(
int)
requires bidirectional_range<_Base>
8168 constexpr _Iterator&
8169 operator+=(difference_type __n)
requires random_access_range<_Base>
8173 __glibcxx_assert(
ranges::distance(_M_current, _M_end) > _M_stride * (__n - 1));
8184 constexpr _Iterator&
8185 operator-=(difference_type __n)
requires random_access_range<_Base>
8186 {
return *
this += -__n; }
8188 constexpr decltype(
auto)
operator[](difference_type __n)
const
8189 requires random_access_range<_Base>
8190 {
return *(*
this + __n); }
8192 friend constexpr bool
8193 operator==(
const _Iterator& __x, default_sentinel_t)
8194 {
return __x._M_current == __x._M_end; }
8196 friend constexpr bool
8197 operator==(
const _Iterator& __x,
const _Iterator& __y)
8198 requires equality_comparable<iterator_t<_Base>>
8199 {
return __x._M_current == __y._M_current; }
8201 friend constexpr bool
8202 operator<(
const _Iterator& __x,
const _Iterator& __y)
8203 requires random_access_range<_Base>
8204 {
return __x._M_current < __y._M_current; }
8206 friend constexpr bool
8207 operator>(
const _Iterator& __x,
const _Iterator& __y)
8208 requires random_access_range<_Base>
8209 {
return __y._M_current < __x._M_current; }
8211 friend constexpr bool
8212 operator<=(
const _Iterator& __x,
const _Iterator& __y)
8213 requires random_access_range<_Base>
8214 {
return !(__y._M_current < __x._M_current); }
8216 friend constexpr bool
8217 operator>=(
const _Iterator& __x,
const _Iterator& __y)
8218 requires random_access_range<_Base>
8219 {
return !(__x._M_current < __y._M_current); }
8221 friend constexpr auto
8222 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
8223 requires random_access_range<_Base> && three_way_comparable<iterator_t<_Base>>
8224 {
return __x._M_current <=> __y._M_current; }
8226 friend constexpr _Iterator
8227 operator+(
const _Iterator& __i, difference_type __n)
8228 requires random_access_range<_Base>
8235 friend constexpr _Iterator
8236 operator+(difference_type __n,
const _Iterator& __i)
8237 requires random_access_range<_Base>
8238 {
return __i + __n; }
8240 friend constexpr _Iterator
8241 operator-(
const _Iterator& __i, difference_type __n)
8242 requires random_access_range<_Base>
8249 friend constexpr difference_type
8250 operator-(
const _Iterator& __x,
const _Iterator& __y)
8251 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
8253 auto __n = __x._M_current - __y._M_current;
8254 if constexpr (forward_range<_Base>)
8255 return (__n + __x._M_missing - __y._M_missing) / __x._M_stride;
8257 return -__detail::__div_ceil(-__n, __x._M_stride);
8259 return __detail::__div_ceil(__n, __x._M_stride);
8262 friend constexpr difference_type
8263 operator-(default_sentinel_t __y,
const _Iterator& __x)
8264 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
8265 {
return __detail::__div_ceil(__x._M_end - __x._M_current, __x._M_stride); }
8267 friend constexpr difference_type
8268 operator-(
const _Iterator& __x, default_sentinel_t __y)
8269 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
8270 {
return -(__y - __x); }
8272 friend constexpr range_rvalue_reference_t<_Base>
8273 iter_move(
const _Iterator& __i)
8274 noexcept(
noexcept(ranges::iter_move(__i._M_current)))
8275 {
return ranges::iter_move(__i._M_current); }
8277 friend constexpr void
8278 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
8279 noexcept(
noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
8280 requires indirectly_swappable<iterator_t<_Base>>
8281 { ranges::iter_swap(__x._M_current, __y._M_current); }
8288 template<
typename _Range,
typename _Dp>
8289 concept __can_stride_view
8290 =
requires { stride_view(std::declval<_Range>(), std::declval<_Dp>()); };
8293 struct _Stride : __adaptor::_RangeAdaptor<_Stride>
8295 template<viewable_range _Range,
typename _Dp = range_difference_t<_Range>>
8296 requires __detail::__can_stride_view<_Range, _Dp>
8298 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n)
const
8299 {
return stride_view(std::forward<_Range>(__r), __n); }
8301 using __adaptor::_RangeAdaptor<_Stride>::operator();
8302 static constexpr int _S_arity = 2;
8303 static constexpr bool _S_has_simple_extra_args =
true;
8306 inline constexpr _Stride stride;
8310#ifdef __cpp_lib_ranges_cartesian_product
8313 template<
bool _Const,
typename _First,
typename... _Vs>
8314 concept __cartesian_product_is_random_access
8315 = (random_access_range<__maybe_const_t<_Const, _First>>
8317 && (random_access_range<__maybe_const_t<_Const, _Vs>>
8318 && sized_range<__maybe_const_t<_Const, _Vs>>));
8320 template<
typename _Range>
8321 concept __cartesian_product_common_arg
8322 = common_range<_Range> || (sized_range<_Range> && random_access_range<_Range>);
8324 template<
bool _Const,
typename _First,
typename... _Vs>
8325 concept __cartesian_product_is_bidirectional
8326 = (bidirectional_range<__maybe_const_t<_Const, _First>>
8328 && (bidirectional_range<__maybe_const_t<_Const, _Vs>>
8329 && __cartesian_product_common_arg<__maybe_const_t<_Const, _Vs>>));
8331 template<
typename _First,
typename... _Vs>
8332 concept __cartesian_product_is_common = __cartesian_product_common_arg<_First>;
8334 template<
typename... _Vs>
8335 concept __cartesian_product_is_sized = (sized_range<_Vs> && ...);
8337 template<
bool _Const,
template<
typename>
class FirstSent,
typename _First,
typename... _Vs>
8338 concept __cartesian_is_sized_sentinel
8339 = (sized_sentinel_for<FirstSent<__maybe_const_t<_Const, _First>>,
8340 iterator_t<__maybe_const_t<_Const, _First>>>
8342 && (sized_range<__maybe_const_t<_Const, _Vs>>
8343 && sized_sentinel_for<iterator_t<__maybe_const_t<_Const, _Vs>>,
8344 iterator_t<__maybe_const_t<_Const, _Vs>>>));
8346 template<__cartesian_product_common_arg _Range>
8348 __cartesian_common_arg_end(_Range& __r)
8350 if constexpr (common_range<_Range>)
8357 template<input_range _First, forward_range... _Vs>
8358 requires (view<_First> && ... && view<_Vs>)
8359 class cartesian_product_view :
public view_interface<cartesian_product_view<_First, _Vs...>>
8361 tuple<_First, _Vs...> _M_bases;
8363 template<
bool>
class _Iterator;
8366 _S_difference_type()
8372 range_difference_t<_First>,
8373 range_difference_t<_Vs>...>{};
8377 cartesian_product_view() =
default;
8380 cartesian_product_view(_First __first, _Vs... __rest)
8384 constexpr _Iterator<false>
8385 begin()
requires (!__detail::__simple_view<_First> || ... || !__detail::__simple_view<_Vs>)
8386 {
return _Iterator<false>(*
this, __detail::__tuple_transform(
ranges::begin, _M_bases)); }
8388 constexpr _Iterator<true>
8389 begin() const requires (range<const _First> && ... && range<const _Vs>)
8390 {
return _Iterator<true>(*
this, __detail::__tuple_transform(
ranges::begin, _M_bases)); }
8392 constexpr _Iterator<false>
8393 end()
requires ((!__detail::__simple_view<_First> || ... || !__detail::__simple_view<_Vs>)
8394 && __detail::__cartesian_product_is_common<_First, _Vs...>)
8397 using _Ret = tuple<iterator_t<_First>, iterator_t<_Vs>...>;
8398 bool __empty_tail = (
ranges::empty(std::get<1 + _Is>(_M_bases)) || ...);
8399 auto& __first = std::get<0>(_M_bases);
8400 return _Ret{(__empty_tail
8402 : __detail::__cartesian_common_arg_end(__first)),
8403 ranges::
begin(
std::get<1 + _Is>(_M_bases))...};
8406 return _Iterator<false>{*
this,
std::move(__its)};
8409 constexpr _Iterator<true>
8410 end() const requires __detail::__cartesian_product_is_common<const _First, const _Vs...>
8413 using _Ret = tuple<iterator_t<const _First>, iterator_t<const _Vs>...>;
8414 bool __empty_tail = (
ranges::empty(std::get<1 + _Is>(_M_bases)) || ...);
8415 auto& __first = std::get<0>(_M_bases);
8416 return _Ret{(__empty_tail
8418 : __detail::__cartesian_common_arg_end(__first)),
8419 ranges::
begin(
std::get<1 + _Is>(_M_bases))...};
8422 return _Iterator<true>{*
this,
std::move(__its)};
8425 constexpr default_sentinel_t
8426 end() const noexcept
8430 size()
requires __detail::__cartesian_product_is_sized<_First, _Vs...>
8432 using _ST = __detail::__make_unsigned_like_t<
decltype(_S_difference_type())>;
8434 auto __size =
static_cast<_ST
>(1);
8435#ifdef _GLIBCXX_ASSERTIONS
8436 if constexpr (integral<_ST>)
8439 = (__builtin_mul_overflow(__size,
8440 static_cast<_ST
>(
ranges::size(std::get<_Is>(_M_bases))),
8443 __glibcxx_assert(!__overflow);
8447 __size = (
static_cast<_ST
>(
ranges::size(std::get<_Is>(_M_bases))) * ...);
8453 size() const requires __detail::__cartesian_product_is_sized<const _First, const _Vs...>
8455 using _ST = __detail::__make_unsigned_like_t<
decltype(_S_difference_type())>;
8457 auto __size =
static_cast<_ST
>(1);
8458#ifdef _GLIBCXX_ASSERTIONS
8459 if constexpr (integral<_ST>)
8462 = (__builtin_mul_overflow(__size,
8463 static_cast<_ST
>(
ranges::size(std::get<_Is>(_M_bases))),
8466 __glibcxx_assert(!__overflow);
8470 __size = (
static_cast<_ST
>(
ranges::size(std::get<_Is>(_M_bases))) * ...);
8476 template<
typename... _Vs>
8477 cartesian_product_view(_Vs&&...) -> cartesian_product_view<views::all_t<_Vs>...>;
8479 template<input_range _First, forward_range... _Vs>
8480 requires (view<_First> && ... && view<_Vs>)
8481 template<bool _Const>
8482 class cartesian_product_view<_First, _Vs...>::_Iterator
8484 using _Parent = __maybe_const_t<_Const, cartesian_product_view>;
8485 _Parent* _M_parent =
nullptr;
8486 tuple<iterator_t<__maybe_const_t<_Const, _First>>,
8487 iterator_t<__maybe_const_t<_Const, _Vs>>...> _M_current;
8490 _Iterator(_Parent& __parent,
decltype(_M_current) __current)
8492 _M_current(
std::
move(__current))
8498 if constexpr (__detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>)
8499 return random_access_iterator_tag{};
8500 else if constexpr (__detail::__cartesian_product_is_bidirectional<_Const, _First, _Vs...>)
8501 return bidirectional_iterator_tag{};
8502 else if constexpr (forward_range<__maybe_const_t<_Const, _First>>)
8503 return forward_iterator_tag{};
8505 return input_iterator_tag{};
8508 friend cartesian_product_view;
8511 using iterator_category = input_iterator_tag;
8512 using iterator_concept =
decltype(_S_iter_concept());
8514 = tuple<range_value_t<__maybe_const_t<_Const, _First>>,
8515 range_value_t<__maybe_const_t<_Const, _Vs>>...>;
8517 = tuple<range_reference_t<__maybe_const_t<_Const, _First>>,
8518 range_reference_t<__maybe_const_t<_Const, _Vs>>...>;
8519 using difference_type =
decltype(cartesian_product_view::_S_difference_type());
8521 _Iterator() =
default;
8524 _Iterator(_Iterator<!_Const> __i)
8526 && (convertible_to<iterator_t<_First>, iterator_t<const _First>>
8527 && ... && convertible_to<iterator_t<_Vs>, iterator_t<const _Vs>>)
8535 auto __f = [](
auto& __i) ->
decltype(
auto) {
8538 return __detail::__tuple_transform(__f, _M_current);
8541 constexpr _Iterator&
8553 operator++(
int)
requires forward_range<__maybe_const_t<_Const, _First>>
8560 constexpr _Iterator&
8562 requires __detail::__cartesian_product_is_bidirectional<_Const, _First, _Vs...>
8570 requires __detail::__cartesian_product_is_bidirectional<_Const, _First, _Vs...>
8577 constexpr _Iterator&
8578 operator+=(difference_type __x)
8579 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8585 constexpr _Iterator&
8586 operator-=(difference_type __x)
8587 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8588 {
return *
this += -__x; }
8591 operator[](difference_type __n)
const
8592 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8593 {
return *((*this) + __n); }
8595 friend constexpr bool
8596 operator==(
const _Iterator& __x,
const _Iterator& __y)
8597 requires equality_comparable<iterator_t<__maybe_const_t<_Const, _First>>>
8598 {
return __x._M_current == __y._M_current; }
8600 friend constexpr bool
8601 operator==(
const _Iterator& __x, default_sentinel_t)
8604 return ((std::get<_Is>(__x._M_current)
8605 ==
ranges::end(std::get<_Is>(__x._M_parent->_M_bases)))
8610 friend constexpr auto
8611 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
8612 requires __detail::__all_random_access<_Const, _First, _Vs...>
8613 {
return __x._M_current <=> __y._M_current; }
8615 friend constexpr _Iterator
8616 operator+(_Iterator __x, difference_type __y)
8617 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8618 {
return __x += __y; }
8620 friend constexpr _Iterator
8621 operator+(difference_type __x, _Iterator __y)
8622 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8623 {
return __y += __x; }
8625 friend constexpr _Iterator
8626 operator-(_Iterator __x, difference_type __y)
8627 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8628 {
return __x -= __y; }
8630 friend constexpr difference_type
8631 operator-(
const _Iterator& __x,
const _Iterator& __y)
8632 requires __detail::__cartesian_is_sized_sentinel<_Const, iterator_t, _First, _Vs...>
8633 {
return __x._M_distance_from(__y._M_current); }
8635 friend constexpr difference_type
8636 operator-(
const _Iterator& __i, default_sentinel_t)
8637 requires __detail::__cartesian_is_sized_sentinel<_Const, sentinel_t, _First, _Vs...>
8640 return tuple{
ranges::end(std::get<0>(__i._M_parent->_M_bases)),
8641 ranges::begin(std::get<1 + _Is>(__i._M_parent->_M_bases))...};
8643 return __i._M_distance_from(__end_tuple);
8646 friend constexpr difference_type
8647 operator-(default_sentinel_t,
const _Iterator& __i)
8648 requires __detail::__cartesian_is_sized_sentinel<_Const, sentinel_t, _First, _Vs...>
8651 friend constexpr auto
8652 iter_move(
const _Iterator& __i)
8653 {
return __detail::__tuple_transform(ranges::iter_move, __i._M_current); }
8655 friend constexpr void
8656 iter_swap(
const _Iterator& __l,
const _Iterator& __r)
8657 requires (indirectly_swappable<iterator_t<__maybe_const_t<_Const, _First>>>
8659 && indirectly_swappable<iterator_t<__maybe_const_t<_Const, _Vs>>>)
8662 (ranges::iter_swap(std::get<_Is>(__l._M_current), std::get<_Is>(__r._M_current)), ...);
8667 template<
size_t _Nm =
sizeof...(_Vs)>
8671 auto& __it = std::get<_Nm>(_M_current);
8673 if constexpr (_Nm > 0)
8674 if (__it ==
ranges::end(std::get<_Nm>(_M_parent->_M_bases)))
8681 template<
size_t _Nm =
sizeof...(_Vs)>
8685 auto& __it = std::get<_Nm>(_M_current);
8686 if constexpr (_Nm > 0)
8687 if (__it ==
ranges::begin(std::get<_Nm>(_M_parent->_M_bases)))
8689 __it = __detail::__cartesian_common_arg_end(std::get<_Nm>(_M_parent->_M_bases));
8695 template<
size_t _Nm =
sizeof...(_Vs)>
8697 _M_advance(difference_type __x)
8698 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8707 auto& __r = std::get<_Nm>(_M_parent->_M_bases);
8708 auto& __it = std::get<_Nm>(_M_current);
8709 if constexpr (_Nm == 0)
8711#ifdef _GLIBCXX_ASSERTIONS
8712 if constexpr (sized_range<__maybe_const_t<_Const, _First>>)
8714 auto __size = ranges::ssize(__r);
8716 auto __offset = __it - __begin;
8717 __glibcxx_assert(__offset + __x >= 0 && __offset + __x <= __size);
8724 auto __size = ranges::ssize(__r);
8726 auto __offset = __it - __begin;
8728 __x = __offset / __size;
8732 __offset = __size + __offset;
8735 __it = __begin + __offset;
8736 _M_advance<_Nm - 1>(__x);
8741 template<
typename _Tuple>
8742 constexpr difference_type
8743 _M_distance_from(
const _Tuple& __t)
const
8746 auto __sum =
static_cast<difference_type
>(0);
8747#ifdef _GLIBCXX_ASSERTIONS
8748 if constexpr (integral<difference_type>)
8751 = (__builtin_add_overflow(__sum, _M_scaled_distance<_Is>(__t), &__sum)
8753 __glibcxx_assert(!__overflow);
8757 __sum = (_M_scaled_distance<_Is>(__t) + ...);
8762 template<
size_t _Nm,
typename _Tuple>
8763 constexpr difference_type
8764 _M_scaled_distance(
const _Tuple& __t)
const
8766 auto __dist =
static_cast<difference_type
>(std::get<_Nm>(_M_current)
8767 - std::get<_Nm>(__t));
8768#ifdef _GLIBCXX_ASSERTIONS
8769 if constexpr (integral<difference_type>)
8771 bool __overflow = __builtin_mul_overflow(__dist, _M_scaled_size<_Nm+1>(), &__dist);
8772 __glibcxx_assert(!__overflow);
8776 __dist *= _M_scaled_size<_Nm+1>();
8780 template<
size_t _Nm>
8781 constexpr difference_type
8782 _M_scaled_size()
const
8784 if constexpr (_Nm <=
sizeof...(_Vs))
8786 auto __size =
static_cast<difference_type
>(
ranges::size
8787 (std::get<_Nm>(_M_parent->_M_bases)));
8788#ifdef _GLIBCXX_ASSERTIONS
8789 if constexpr (integral<difference_type>)
8791 bool __overflow = __builtin_mul_overflow(__size, _M_scaled_size<_Nm+1>(), &__size);
8792 __glibcxx_assert(!__overflow);
8796 __size *= _M_scaled_size<_Nm+1>();
8800 return static_cast<difference_type
>(1);
8808 template<
typename... _Ts>
8809 concept __can_cartesian_product_view
8810 =
requires { cartesian_product_view<all_t<_Ts>...>(std::declval<_Ts>()...); };
8813 struct _CartesianProduct
8815 template<
typename... _Ts>
8816 requires (
sizeof...(_Ts) == 0 || __detail::__can_cartesian_product_view<_Ts...>)
8818 operator() [[nodiscard]] (_Ts&&... __ts)
const
8820 if constexpr (
sizeof...(_Ts) == 0)
8821 return views::single(tuple{});
8823 return cartesian_product_view<all_t<_Ts>...>(std::forward<_Ts>(__ts)...);
8827 inline constexpr _CartesianProduct cartesian_product;
8831#ifdef __cpp_lib_ranges_as_rvalue
8832 template<input_range _Vp>
8834 class as_rvalue_view :
public view_interface<as_rvalue_view<_Vp>>
8836 _Vp _M_base = _Vp();
8839 as_rvalue_view()
requires default_initializable<_Vp> = default;
8842 as_rvalue_view(_Vp
__base)
8847 base() const& requires copy_constructible<_Vp>
8855 begin()
requires (!__detail::__simple_view<_Vp>)
8859 begin() const requires range<const _Vp>
8863 end()
requires (!__detail::__simple_view<_Vp>)
8865 if constexpr (common_range<_Vp>)
8872 end() const requires range<const _Vp>
8874 if constexpr (common_range<const _Vp>)
8881 size()
requires sized_range<_Vp>
8885 size() const requires sized_range<const _Vp>
8889 template<
typename _Range>
8890 as_rvalue_view(_Range&&) -> as_rvalue_view<views::all_t<_Range>>;
8892 template<
typename _Tp>
8893 inline constexpr bool enable_borrowed_range<as_rvalue_view<_Tp>>
8894 = enable_borrowed_range<_Tp>;
8900 template<
typename _Tp>
8901 concept __can_as_rvalue_view =
requires { as_rvalue_view(std::declval<_Tp>()); };
8904 struct _AsRvalue : __adaptor::_RangeAdaptorClosure<_AsRvalue>
8906 template<viewable_range _Range>
8907 requires __detail::__can_as_rvalue_view<_Range>
8909 operator() [[nodiscard]] (_Range&& __r)
const
8911 if constexpr (same_as<range_rvalue_reference_t<_Range>,
8912 range_reference_t<_Range>>)
8913 return views::all(std::forward<_Range>(__r));
8915 return as_rvalue_view(std::forward<_Range>(__r));
8919 inline constexpr _AsRvalue as_rvalue;
8923#ifdef __cpp_lib_ranges_enumerate
8926 template<
typename _Range>
8927 concept __range_with_movable_reference = input_range<_Range>
8928 && move_constructible<range_reference_t<_Range>>
8929 && move_constructible<range_rvalue_reference_t<_Range>>;
8933 requires __detail::__range_with_movable_reference<_Vp>
8934 class enumerate_view :
public view_interface<enumerate_view<_Vp>>
8936 _Vp _M_base = _Vp();
8938 template<
bool _Const>
class _Iterator;
8939 template<
bool _Const>
class _Sentinel;
8942 enumerate_view()
requires default_initializable<_Vp> = default;
8945 enumerate_view(_Vp
__base)
8950 begin()
requires (!__detail::__simple_view<_Vp>)
8954 begin() const requires __detail::__range_with_movable_reference<const _Vp>
8958 end()
requires (!__detail::__simple_view<_Vp>)
8960 if constexpr (common_range<_Vp> && sized_range<_Vp>)
8967 end() const requires __detail::__range_with_movable_reference<const _Vp>
8969 if constexpr (common_range<const _Vp> && sized_range<const _Vp>)
8976 size()
requires sized_range<_Vp>
8980 size() const requires sized_range<const _Vp>
8984 base() const & requires copy_constructible<_Vp>
8992 template<
typename _Range>
8993 enumerate_view(_Range&&) -> enumerate_view<views::all_t<_Range>>;
8995 template<
typename _Tp>
8996 inline constexpr bool enable_borrowed_range<enumerate_view<_Tp>>
8997 = enable_borrowed_range<_Tp>;
9000 requires __detail::__range_with_movable_reference<_Vp>
9001 template<
bool _Const>
9002 class enumerate_view<_Vp>::_Iterator
9004 using _Base = __maybe_const_t<_Const, _Vp>;
9009 if constexpr (random_access_range<_Base>)
9010 return random_access_iterator_tag{};
9011 else if constexpr (bidirectional_range<_Base>)
9012 return bidirectional_iterator_tag{};
9013 else if constexpr (forward_range<_Base>)
9014 return forward_iterator_tag{};
9016 return input_iterator_tag{};
9019 friend enumerate_view;
9022 using iterator_category = input_iterator_tag;
9023 using iterator_concept =
decltype(_S_iter_concept());
9024 using difference_type = range_difference_t<_Base>;
9025 using value_type = tuple<difference_type, range_value_t<_Base>>;
9028 using __reference_type = tuple<difference_type, range_reference_t<_Base>>;
9030 iterator_t<_Base> _M_current = iterator_t<_Base>();
9031 difference_type _M_pos = 0;
9034 _Iterator(iterator_t<_Base> __current, difference_type __pos)
9035 : _M_current(
std::
move(__current)), _M_pos(__pos)
9039 _Iterator()
requires default_initializable<iterator_t<_Base>> = default;
9042 _Iterator(_Iterator<!_Const> __i)
9043 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
9044 : _M_current(
std::
move(__i._M_current)), _M_pos(__i._M_pos)
9047 constexpr const iterator_t<_Base> &
9048 base() const & noexcept
9049 {
return _M_current; }
9051 constexpr iterator_t<_Base>
9055 constexpr difference_type
9056 index() const noexcept
9061 {
return __reference_type(_M_pos, *_M_current); }
9063 constexpr _Iterator&
9076 operator++(
int)
requires forward_range<_Base>
9083 constexpr _Iterator&
9084 operator--()
requires bidirectional_range<_Base>
9092 operator--(
int)
requires bidirectional_range<_Base>
9099 constexpr _Iterator&
9100 operator+=(difference_type __n)
requires random_access_range<_Base>
9107 constexpr _Iterator&
9108 operator-=(difference_type __n)
requires random_access_range<_Base>
9116 operator[](difference_type __n)
const requires random_access_range<_Base>
9117 {
return __reference_type(_M_pos + __n, _M_current[__n]); }
9119 friend constexpr bool
9120 operator==(
const _Iterator& __x,
const _Iterator& __y)
noexcept
9121 {
return __x._M_pos == __y._M_pos; }
9123 friend constexpr strong_ordering
9124 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
noexcept
9125 {
return __x._M_pos <=> __y._M_pos; }
9127 friend constexpr _Iterator
9128 operator+(
const _Iterator& __x, difference_type __y)
9129 requires random_access_range<_Base>
9130 {
return (
auto(__x) += __y); }
9132 friend constexpr _Iterator
9133 operator+(difference_type __x,
const _Iterator& __y)
9134 requires random_access_range<_Base>
9135 {
return auto(__y) += __x; }
9137 friend constexpr _Iterator
9138 operator-(
const _Iterator& __x, difference_type __y)
9139 requires random_access_range<_Base>
9140 {
return auto(__x) -= __y; }
9142 friend constexpr difference_type
9143 operator-(
const _Iterator& __x,
const _Iterator& __y)
9144 {
return __x._M_pos - __y._M_pos; }
9146 friend constexpr auto
9147 iter_move(
const _Iterator& __i)
9148 noexcept(
noexcept(ranges::iter_move(__i._M_current))
9149 && is_nothrow_move_constructible_v<range_rvalue_reference_t<_Base>>)
9151 return tuple<difference_type, range_rvalue_reference_t<_Base>>
9152 (__i._M_pos, ranges::iter_move(__i._M_current));
9157 requires __detail::__range_with_movable_reference<_Vp>
9158 template<
bool _Const>
9159 class enumerate_view<_Vp>::_Sentinel
9161 using _Base = __maybe_const_t<_Const, _Vp>;
9163 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
9166 _Sentinel(sentinel_t<_Base> __end)
9170 friend enumerate_view;
9173 _Sentinel() =
default;
9176 _Sentinel(_Sentinel<!_Const> __other)
9177 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
9181 constexpr sentinel_t<_Base>
9185 template<
bool _OtherConst>
9186 requires sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const_t<_OtherConst, _Vp>>>
9187 friend constexpr bool
9188 operator==(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
9189 {
return __x._M_current == __y._M_end; }
9191 template<
bool _OtherConst>
9192 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const_t<_OtherConst, _Vp>>>
9193 friend constexpr range_difference_t<__maybe_const_t<_OtherConst, _Vp>>
9194 operator-(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
9195 {
return __x._M_current - __y._M_end; }
9197 template<
bool _OtherConst>
9198 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const_t<_OtherConst, _Vp>>>
9199 friend constexpr range_difference_t<__maybe_const_t<_OtherConst, _Vp>>
9200 operator-(
const _Sentinel& __x,
const _Iterator<_OtherConst>& __y)
9201 {
return __x._M_end - __y._M_current; }
9208 template<
typename _Tp>
9209 concept __can_enumerate_view
9210 =
requires { enumerate_view<all_t<_Tp>>(std::declval<_Tp>()); };
9213 struct _Enumerate : __adaptor::_RangeAdaptorClosure<_Enumerate>
9215 template<viewable_range _Range>
9216 requires __detail::__can_enumerate_view<_Range>
9218 operator() [[nodiscard]] (_Range&& __r)
const
9219 {
return enumerate_view<all_t<_Range>>(std::forward<_Range>(__r)); }
9222 inline constexpr _Enumerate enumerate;
9226#ifdef __cpp_lib_ranges_as_const
9228 requires input_range<_Vp>
9229 class as_const_view :
public view_interface<as_const_view<_Vp>>
9231 _Vp _M_base = _Vp();
9234 as_const_view()
requires default_initializable<_Vp> = default;
9237 as_const_view(_Vp
__base)
9238 noexcept(is_nothrow_move_constructible_v<_Vp>)
9244 noexcept(is_nothrow_copy_constructible_v<_Vp>)
9245 requires copy_constructible<_Vp>
9250 noexcept(is_nothrow_move_constructible_v<_Vp>)
9254 begin()
requires (!__detail::__simple_view<_Vp>)
9258 begin() const requires range<const _Vp>
9262 end()
requires (!__detail::__simple_view<_Vp>)
9266 end() const requires range<const _Vp>
9270 size()
requires sized_range<_Vp>
9274 size() const requires sized_range<const _Vp>
9278 template<
typename _Range>
9279 as_const_view(_Range&&) -> as_const_view<views::all_t<_Range>>;
9281 template<
typename _Tp>
9282 inline constexpr bool enable_borrowed_range<as_const_view<_Tp>>
9283 = enable_borrowed_range<_Tp>;
9289 template<
typename _Tp>
9290 inline constexpr bool __is_ref_view =
false;
9292 template<
typename _Range>
9293 inline constexpr bool __is_ref_view<ref_view<_Range>> =
true;
9295 template<
typename _Range>
9296 concept __can_as_const_view =
requires { as_const_view(std::declval<_Range>()); };
9299 struct _AsConst : __adaptor::_RangeAdaptorClosure<_AsConst>
9301 template<viewable_range _Range>
9303 operator()(_Range&& __r)
const
9304 noexcept(
noexcept(as_const_view(std::declval<_Range>())))
9305 requires __detail::__can_as_const_view<_Range>
9307 using _Tp = remove_cvref_t<_Range>;
9308 using element_type = remove_reference_t<range_reference_t<_Range>>;
9309 if constexpr (constant_range<views::all_t<_Range>>)
9310 return views::all(std::forward<_Range>(__r));
9311 else if constexpr (__detail::__is_empty_view<_Tp>)
9312 return views::empty<const element_type>;
9313 else if constexpr (std::__detail::__is_span<_Tp>)
9314 return span<const element_type, _Tp::extent>(std::forward<_Range>(__r));
9315 else if constexpr (__detail::__is_ref_view<_Tp>
9316 && constant_range<const element_type>)
9317 return ref_view(
static_cast<const element_type&
>
9318 (std::forward<_Range>(__r).base()));
9319 else if constexpr (is_lvalue_reference_v<_Range>
9320 && constant_range<const _Tp>
9322 return ref_view(
static_cast<const _Tp&
>(__r));
9324 return as_const_view(std::forward<_Range>(__r));
9328 inline constexpr _AsConst as_const;
9333 namespace views = ranges::views;
9335#if __cpp_lib_ranges_to_container
9341 template<
typename _Container>
9342 constexpr bool __reservable_container
9343 = sized_range<_Container>
9344 &&
requires(_Container& __c, range_size_t<_Container> __n) {
9346 { __c.capacity() } -> same_as<
decltype(__n)>;
9347 { __c.max_size() } -> same_as<
decltype(__n)>;
9350 template<
typename _Cont,
typename _Range>
9351 constexpr bool __toable =
requires {
9352 requires (!input_range<_Cont>
9353 || convertible_to<range_reference_t<_Range>,
9354 range_value_t<_Cont>>);
9375 template<
typename _Cont, input_range _Rg,
typename... _Args>
9376 requires (!view<_Cont>)
9378 to [[nodiscard]] (_Rg&& __r, _Args&&... __args)
9380 static_assert(!is_const_v<_Cont> && !is_volatile_v<_Cont>);
9381 static_assert(is_class_v<_Cont>);
9383 if constexpr (__detail::__toable<_Cont, _Rg>)
9385 if constexpr (constructible_from<_Cont, _Rg, _Args...>)
9386 return _Cont(std::forward<_Rg>(__r),
9387 std::forward<_Args>(__args)...);
9388 else if constexpr (constructible_from<_Cont, from_range_t, _Rg, _Args...>)
9389 return _Cont(from_range, std::forward<_Rg>(__r),
9390 std::forward<_Args>(__args)...);
9391 else if constexpr (
requires {
requires common_range<_Rg>;
9392 typename __iter_category_t<iterator_t<_Rg>>;
9393 requires derived_from<__iter_category_t<iterator_t<_Rg>>,
9394 input_iterator_tag>;
9395 requires constructible_from<_Cont, iterator_t<_Rg>,
9396 sentinel_t<_Rg>, _Args...>;
9399 std::forward<_Args>(__args)...);
9402 using _RefT = range_reference_t<_Rg>;
9403 static_assert(constructible_from<_Cont, _Args...>);
9404 _Cont __c(std::forward<_Args>(__args)...);
9405 if constexpr (sized_range<_Rg>
9406 && __detail::__reservable_container<_Cont>)
9407 __c.reserve(
static_cast<range_size_t<_Cont>
>(
ranges::size(__r)));
9413 while (__it != __sent)
9415 if constexpr (
requires { __c.emplace_back(*__it); })
9416 __c.emplace_back(*__it);
9417 else if constexpr (
requires { __c.push_back(*__it); })
9418 __c.push_back(*__it);
9419 else if constexpr (
requires { __c.emplace(__c.end(), *__it); })
9420 __c.emplace(__c.end(), *__it);
9422 __c.insert(__c.end(), *__it);
9430 static_assert(input_range<range_reference_t<_Rg>>);
9433 return ranges::to<_Cont>(ref_view(__r) | views::transform(
9434 []<
typename _Elt>(_Elt&& __elem) {
9435 using _ValT = range_value_t<_Cont>;
9436 return ranges::to<_ValT>(std::forward<_Elt>(__elem));
9437 }), std::forward<_Args>(__args)...);
9444 template<
typename _Rg>
9447 using iterator_category = input_iterator_tag;
9448 using value_type = range_value_t<_Rg>;
9449 using difference_type = ptrdiff_t;
9450 using pointer = add_pointer_t<range_reference_t<_Rg>>;
9451 using reference = range_reference_t<_Rg>;
9453 pointer operator->()
const;
9454 _InputIter& operator++();
9455 _InputIter operator++(
int);
9456 bool operator==(
const _InputIter&)
const;
9459 template<
template<
typename...>
typename _Cont, input_range _Rg,
9462 =
decltype(_Cont(std::declval<_Rg>(), std::declval<_Args>()...));
9464 template<
template<
typename...>
typename _Cont, input_range _Rg,
9467 =
decltype(_Cont(from_range, std::declval<_Rg>(),
9468 std::declval<_Args>()...));
9470 template<
template<
typename...>
typename _Cont, input_range _Rg,
9475 std::declval<_Args>()...));
9480 template<
template<
typename...>
typename _Cont, input_range _Rg,
9483 to [[nodiscard]] (_Rg&& __r, _Args&&... __args)
9485 using __detail::_DeduceExpr1;
9486 using __detail::_DeduceExpr2;
9487 using __detail::_DeduceExpr3;
9488 if constexpr (
requires {
typename _DeduceExpr1<_Cont, _Rg, _Args...>; })
9489 return ranges::to<_DeduceExpr1<_Cont, _Rg, _Args...>>(
9490 std::forward<_Rg>(__r), std::forward<_Args>(__args)...);
9491 else if constexpr (
requires {
typename _DeduceExpr2<_Cont, _Rg, _Args...>; })
9492 return ranges::to<_DeduceExpr2<_Cont, _Rg, _Args...>>(
9493 std::forward<_Rg>(__r), std::forward<_Args>(__args)...);
9494 else if constexpr (
requires {
typename _DeduceExpr3<_Cont, _Rg, _Args...>; })
9495 return ranges::to<_DeduceExpr3<_Cont, _Rg, _Args...>>(
9496 std::forward<_Rg>(__r), std::forward<_Args>(__args)...);
9498 static_assert(
false);
9504 template<
typename _Cont>
9507 template<
typename _Range,
typename... _Args>
9508 requires requires { ranges::to<_Cont>(std::declval<_Range>(),
9509 std::declval<_Args>()...); }
9511 operator()(_Range&& __r, _Args&&... __args)
const
9513 return ranges::to<_Cont>(std::forward<_Range>(__r),
9514 std::forward<_Args>(__args)...);
9535 template<
typename _Cont,
typename... _Args>
9536 requires (!view<_Cont>)
9538 to [[nodiscard]] (_Args&&... __args)
9540 using __detail::_To;
9541 using views::__adaptor::_Partial;
9542 return _Partial<_To<_Cont>, decay_t<_Args>...>{0, std::forward<_Args>(__args)...};
9548 template<
template<
typename...>
typename _Cont>
9551 template<
typename _Range,
typename... _Args>
9552 requires requires { ranges::to<_Cont>(std::declval<_Range>(),
9553 std::declval<_Args>()...); }
9555 operator()(_Range&& __r, _Args&&... __args)
const
9557 return ranges::to<_Cont>(std::forward<_Range>(__r),
9558 std::forward<_Args>(__args)...);
9581 template<
template<
typename...>
typename _Cont,
typename... _Args>
9583 to [[nodiscard]] (_Args&&... __args)
9585 using __detail::_To2;
9586 using views::__adaptor::_Partial;
9587 return _Partial<_To2<_Cont>, decay_t<_Args>...>{0, std::forward<_Args>(__args)...};
9593_GLIBCXX_END_NAMESPACE_VERSION
constexpr bool operator<=(const duration< _Rep1, _Period1 > &__lhs, const duration< _Rep2, _Period2 > &__rhs)
constexpr bool operator>=(const duration< _Rep1, _Period1 > &__lhs, const duration< _Rep2, _Period2 > &__rhs)
constexpr bool operator<(const duration< _Rep1, _Period1 > &__lhs, const duration< _Rep2, _Period2 > &__rhs)
constexpr bool operator>(const duration< _Rep1, _Period1 > &__lhs, const duration< _Rep2, _Period2 > &__rhs)
constexpr complex< _Tp > operator*(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x times y.
constexpr complex< _Tp > operator-(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x minus y.
constexpr complex< _Tp > operator+(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x plus y.
basic_istream< char > istream
Base class for char input streams.
typename remove_reference< _Tp >::type remove_reference_t
Alias template for remove_reference.
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 iterator_traits< _InputIterator >::difference_type distance(_InputIterator __first, _InputIterator __last)
A generalization of pointer arithmetic.
constexpr auto cend(const _Container &__cont) noexcept(noexcept(std::end(__cont))) -> decltype(std::end(__cont))
Return an iterator pointing to one past the last element of the const container.
constexpr auto empty(const _Container &__cont) noexcept(noexcept(__cont.empty())) -> decltype(__cont.empty())
Return whether a container is empty.
constexpr auto size(const _Container &__cont) noexcept(noexcept(__cont.size())) -> decltype(__cont.size())
Return the size of a container.
constexpr void advance(_InputIterator &__i, _Distance __n)
A generalization of pointer arithmetic.
constexpr 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 auto cbegin(const _Container &__cont) noexcept(noexcept(std::begin(__cont))) -> decltype(std::begin(__cont))
Return an iterator pointing to the first element of the const container.
constexpr 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)