30#ifndef _GLIBCXX_RANGES
31#define _GLIBCXX_RANGES 1
33#if __cplusplus > 201703L
36#pragma GCC system_header
50#if __cplusplus > 202002L
57#define __glibcxx_want_algorithm_default_value_type
58#define __glibcxx_want_ranges
59#define __glibcxx_want_ranges_as_const
60#define __glibcxx_want_ranges_as_rvalue
61#define __glibcxx_want_ranges_cache_latest
62#define __glibcxx_want_ranges_cartesian_product
63#define __glibcxx_want_ranges_concat
64#define __glibcxx_want_ranges_chunk
65#define __glibcxx_want_ranges_chunk_by
66#define __glibcxx_want_ranges_enumerate
67#define __glibcxx_want_ranges_iota
68#define __glibcxx_want_ranges_join_with
69#define __glibcxx_want_ranges_repeat
70#define __glibcxx_want_ranges_slide
71#define __glibcxx_want_ranges_stride
72#define __glibcxx_want_ranges_to_container
73#define __glibcxx_want_ranges_to_input
74#define __glibcxx_want_ranges_zip
77#ifdef __glibcxx_generator
78# include <bits/elements_of.h>
87namespace std _GLIBCXX_VISIBILITY(default)
89_GLIBCXX_BEGIN_NAMESPACE_VERSION
104 template<
typename _Tp>
requires is_object_v<_Tp>
106 :
public view_interface<empty_view<_Tp>>
109 static constexpr _Tp*
begin() noexcept {
return nullptr; }
110 static constexpr _Tp*
end() noexcept {
return nullptr; }
111 static constexpr _Tp*
data() noexcept {
return nullptr; }
112 static constexpr size_t size() noexcept {
return 0; }
113 static constexpr bool empty() noexcept {
return true; }
116 template<
typename _Tp>
117 inline constexpr bool enable_borrowed_range<empty_view<_Tp>> =
true;
121#if __cpp_lib_ranges >= 202207L
123 template<
typename _Tp>
124 concept __boxable = move_constructible<_Tp> && is_object_v<_Tp>;
126 template<
typename _Tp>
127 concept __boxable = copy_constructible<_Tp> && is_object_v<_Tp>;
130 template<__boxable _Tp>
131 struct __box : std::optional<_Tp>
133 using std::optional<_Tp>::optional;
137 noexcept(is_nothrow_default_constructible_v<_Tp>)
138 requires default_initializable<_Tp>
139 :
std::optional<_Tp>{std::in_place}
142 __box(
const __box&) =
default;
143 __box(__box&&) =
default;
145 using std::optional<_Tp>::operator=;
151 operator=(
const __box& __that)
152 noexcept(is_nothrow_copy_constructible_v<_Tp>)
153 requires (!copyable<_Tp>) && copy_constructible<_Tp>
158 this->emplace(*__that);
166 operator=(__box&& __that)
167 noexcept(is_nothrow_move_constructible_v<_Tp>)
168 requires (!movable<_Tp>)
181 template<
typename _Tp>
182 concept __boxable_copyable
183 = copy_constructible<_Tp>
184 && (copyable<_Tp> || (is_nothrow_move_constructible_v<_Tp>
185 && is_nothrow_copy_constructible_v<_Tp>));
186 template<
typename _Tp>
187 concept __boxable_movable
188 = (!copy_constructible<_Tp>)
189 && (movable<_Tp> || is_nothrow_move_constructible_v<_Tp>);
195 template<__boxable _Tp>
196 requires __boxable_copyable<_Tp> || __boxable_movable<_Tp>
200 [[no_unique_address]] _Tp _M_value = _Tp();
203 __box()
requires default_initializable<_Tp> = default;
206 __box(const _Tp& __t)
207 noexcept(is_nothrow_copy_constructible_v<_Tp>)
208 requires copy_constructible<_Tp>
214 noexcept(is_nothrow_move_constructible_v<_Tp>)
218 template<
typename... _Args>
219 requires constructible_from<_Tp, _Args...>
221 __box(in_place_t, _Args&&... __args)
222 noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
226 __box(
const __box&) =
default;
227 __box(__box&&) =
default;
228 __box& operator=(
const __box&)
requires copyable<_Tp> =
default;
229 __box& operator=(__box&&)
requires movable<_Tp> = default;
234 operator=(const __box& __that) noexcept
235 requires (!copyable<_Tp>) && copy_constructible<_Tp>
237 static_assert(is_nothrow_copy_constructible_v<_Tp>);
248 operator=(__box&& __that)
noexcept
249 requires (!movable<_Tp>)
251 static_assert(is_nothrow_move_constructible_v<_Tp>);
261 has_value() const noexcept
276 constexpr const _Tp&&
281 operator->() noexcept
285 operator->() const noexcept
291#if __cpp_lib_ranges >= 202207L
292 template<move_constructible _Tp>
294 template<copy_constructible _Tp>
296 requires is_object_v<_Tp>
297 class single_view :
public view_interface<single_view<_Tp>>
300 single_view()
requires default_initializable<_Tp> = default;
303 single_view(const _Tp& __t)
304 noexcept(is_nothrow_copy_constructible_v<_Tp>)
305 requires copy_constructible<_Tp>
310 single_view(_Tp&& __t)
311 noexcept(is_nothrow_move_constructible_v<_Tp>)
317 template<
typename... _Args>
318 requires constructible_from<_Tp, _Args...>
320 single_view(in_place_t, _Args&&... __args)
321 noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
322 : _M_value{in_place,
std::
forward<_Args>(__args)...}
330 begin() const noexcept
335 {
return data() + 1; }
339 {
return data() + 1; }
343 static constexpr bool
347 static constexpr size_t
353 {
return _M_value.operator->(); }
356 data() const noexcept
357 {
return _M_value.operator->(); }
360 [[no_unique_address]] __detail::__box<_Tp> _M_value;
363 template<
typename _Tp>
364 single_view(_Tp) -> single_view<_Tp>;
368 template<
typename _Wp>
369 constexpr auto __to_signed_like(_Wp __w)
noexcept
371 if constexpr (!integral<_Wp>)
372 return iter_difference_t<_Wp>();
373 else if constexpr (
sizeof(iter_difference_t<_Wp>) >
sizeof(_Wp))
374 return iter_difference_t<_Wp>(__w);
375 else if constexpr (
sizeof(ptrdiff_t) >
sizeof(_Wp))
376 return ptrdiff_t(__w);
377 else if constexpr (
sizeof(
long long) >
sizeof(_Wp))
378 return (
long long)(__w);
379#ifdef __SIZEOF_INT128__
380 else if constexpr (__SIZEOF_INT128__ >
sizeof(_Wp))
381 return __int128(__w);
384 return __max_diff_type(__w);
387 template<
typename _Wp>
388 using __iota_diff_t =
decltype(__to_signed_like(std::declval<_Wp>()));
390 template<
typename _It>
391 concept __decrementable = incrementable<_It>
394 { --__i } -> same_as<_It&>;
395 { __i-- } -> same_as<_It>;
398 template<
typename _It>
399 concept __advanceable = __decrementable<_It> && totally_ordered<_It>
400 &&
requires( _It __i,
const _It __j,
const __iota_diff_t<_It> __n)
402 { __i += __n } -> same_as<_It&>;
403 { __i -= __n } -> same_as<_It&>;
407 { __j - __j } -> convertible_to<__iota_diff_t<_It>>;
410 template<
typename _Winc>
411 struct __iota_view_iter_cat
414 template<incrementable _Winc>
415 struct __iota_view_iter_cat<_Winc>
416 {
using iterator_category = input_iterator_tag; };
419 template<weakly_incrementable _Winc,
420 semiregular _Bound = unreachable_sentinel_t>
421 requires std::__detail::__weakly_eq_cmp_with<_Winc, _Bound>
423 class iota_view :
public view_interface<iota_view<_Winc, _Bound>>
428 struct _Iterator : __detail::__iota_view_iter_cat<_Winc>
434 using namespace __detail;
435 if constexpr (__advanceable<_Winc>)
436 return random_access_iterator_tag{};
437 else if constexpr (__decrementable<_Winc>)
438 return bidirectional_iterator_tag{};
439 else if constexpr (incrementable<_Winc>)
440 return forward_iterator_tag{};
442 return input_iterator_tag{};
446 using iterator_concept =
decltype(_S_iter_concept());
448 using value_type = _Winc;
449 using difference_type = __detail::__iota_diff_t<_Winc>;
451 _Iterator()
requires default_initializable<_Winc> = default;
454 _Iterator(_Winc __value)
455 : _M_value(__value) { }
458 operator*() const noexcept(is_nothrow_copy_constructible_v<_Winc>)
473 operator++(
int)
requires incrementable<_Winc>
481 operator--()
requires __detail::__decrementable<_Winc>
488 operator--(
int)
requires __detail::__decrementable<_Winc>
496 operator+=(difference_type __n)
requires __detail::__advanceable<_Winc>
498 using __detail::__is_integer_like;
499 using __detail::__is_signed_integer_like;
500 if constexpr (__is_integer_like<_Winc>
501 && !__is_signed_integer_like<_Winc>)
503 if (__n >= difference_type(0))
504 _M_value +=
static_cast<_Winc
>(__n);
506 _M_value -=
static_cast<_Winc
>(-__n);
514 operator-=(difference_type __n)
requires __detail::__advanceable<_Winc>
516 using __detail::__is_integer_like;
517 using __detail::__is_signed_integer_like;
518 if constexpr (__is_integer_like<_Winc>
519 && !__is_signed_integer_like<_Winc>)
521 if (__n >= difference_type(0))
522 _M_value -=
static_cast<_Winc
>(__n);
524 _M_value +=
static_cast<_Winc
>(-__n);
532 operator[](difference_type __n)
const
533 requires __detail::__advanceable<_Winc>
534 {
return _Winc(_M_value + __n); }
536 friend constexpr bool
537 operator==(
const _Iterator& __x,
const _Iterator& __y)
538 requires equality_comparable<_Winc>
539 {
return __x._M_value == __y._M_value; }
541 friend constexpr bool
542 operator<(
const _Iterator& __x,
const _Iterator& __y)
543 requires totally_ordered<_Winc>
544 {
return __x._M_value < __y._M_value; }
546 friend constexpr bool
547 operator>(
const _Iterator& __x,
const _Iterator& __y)
548 requires totally_ordered<_Winc>
549 {
return __y < __x; }
551 friend constexpr bool
552 operator<=(
const _Iterator& __x,
const _Iterator& __y)
553 requires totally_ordered<_Winc>
554 {
return !(__y < __x); }
556 friend constexpr bool
557 operator>=(
const _Iterator& __x,
const _Iterator& __y)
558 requires totally_ordered<_Winc>
559 {
return !(__x < __y); }
561#ifdef __cpp_lib_three_way_comparison
562 friend constexpr auto
563 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
564 requires totally_ordered<_Winc> && three_way_comparable<_Winc>
565 {
return __x._M_value <=> __y._M_value; }
568 friend constexpr _Iterator
569 operator+(_Iterator __i, difference_type __n)
570 requires __detail::__advanceable<_Winc>
576 friend constexpr _Iterator
577 operator+(difference_type __n, _Iterator __i)
578 requires __detail::__advanceable<_Winc>
579 {
return __i += __n; }
581 friend constexpr _Iterator
582 operator-(_Iterator __i, difference_type __n)
583 requires __detail::__advanceable<_Winc>
589 friend constexpr difference_type
590 operator-(
const _Iterator& __x,
const _Iterator& __y)
591 requires __detail::__advanceable<_Winc>
593 using __detail::__is_integer_like;
594 using __detail::__is_signed_integer_like;
595 using _Dt = difference_type;
596 if constexpr (__is_integer_like<_Winc>)
598 if constexpr (__is_signed_integer_like<_Winc>)
599 return _Dt(_Dt(__x._M_value) - _Dt(__y._M_value));
601 return (__y._M_value > __x._M_value)
602 ? _Dt(-_Dt(__y._M_value - __x._M_value))
603 : _Dt(__x._M_value - __y._M_value);
606 return __x._M_value - __y._M_value;
610 _Winc _M_value = _Winc();
620 _M_equal(
const _Iterator& __x)
const
621 {
return __x._M_value == _M_bound; }
624 _M_distance_from(
const _Iterator& __x)
const
625 {
return _M_bound - __x._M_value; }
627 _Bound _M_bound = _Bound();
630 _Sentinel() =
default;
633 _Sentinel(_Bound __bound)
634 : _M_bound(__bound) { }
636 friend constexpr bool
637 operator==(
const _Iterator& __x,
const _Sentinel& __y)
638 {
return __y._M_equal(__x); }
640 friend constexpr iter_difference_t<_Winc>
641 operator-(
const _Iterator& __x,
const _Sentinel& __y)
642 requires sized_sentinel_for<_Bound, _Winc>
643 {
return -__y._M_distance_from(__x); }
645 friend constexpr iter_difference_t<_Winc>
646 operator-(
const _Sentinel& __x,
const _Iterator& __y)
647 requires sized_sentinel_for<_Bound, _Winc>
648 {
return __x._M_distance_from(__y); }
653 _Winc _M_value = _Winc();
654 [[no_unique_address]] _Bound _M_bound = _Bound();
657 iota_view()
requires default_initializable<_Winc> = default;
660 iota_view(_Winc __value)
665 iota_view(type_identity_t<_Winc> __value,
666 type_identity_t<_Bound> __bound)
667 : _M_value(__value), _M_bound(__bound)
669 if constexpr (totally_ordered_with<_Winc, _Bound>)
670 __glibcxx_assert(
bool(__value <= __bound) );
674 iota_view(_Iterator __first, _Iterator __last)
675 requires same_as<_Winc, _Bound>
676 : iota_view(__first._M_value, __last._M_value)
680 iota_view(_Iterator __first, unreachable_sentinel_t __last)
681 requires same_as<_Bound, unreachable_sentinel_t>
682 : iota_view(__first._M_value, __last)
686 iota_view(_Iterator __first, _Sentinel __last)
687 requires (!same_as<_Winc, _Bound>) && (!same_as<_Bound, unreachable_sentinel_t>)
688 : iota_view(__first._M_value, __last._M_bound)
692 begin()
const {
return _Iterator{_M_value}; }
697 if constexpr (same_as<_Bound, unreachable_sentinel_t>)
698 return unreachable_sentinel;
700 return _Sentinel{_M_bound};
704 end() const requires same_as<_Winc, _Bound>
705 {
return _Iterator{_M_bound}; }
711 {
return _M_value == _M_bound; }
715 requires (same_as<_Winc, _Bound> && __detail::__advanceable<_Winc>)
716 || (integral<_Winc> && integral<_Bound>)
717 || sized_sentinel_for<_Bound, _Winc>
719 using __detail::__is_integer_like;
720 using __detail::__to_unsigned_like;
721 if constexpr (integral<_Winc> && integral<_Bound>)
724 return _Up(_M_bound) - _Up(_M_value);
726 else if constexpr (__is_integer_like<_Winc>)
727 return __to_unsigned_like(_M_bound) - __to_unsigned_like(_M_value);
729 return __to_unsigned_like(_M_bound - _M_value);
733 template<
typename _Winc,
typename _Bound>
734 requires (!__detail::__is_integer_like<_Winc>
735 || !__detail::__is_integer_like<_Bound>
736 || (__detail::__is_signed_integer_like<_Winc>
737 == __detail::__is_signed_integer_like<_Bound>))
738 iota_view(_Winc, _Bound) -> iota_view<_Winc, _Bound>;
740 template<
typename _Winc,
typename _Bound>
741 inline constexpr bool
742 enable_borrowed_range<iota_view<_Winc, _Bound>> =
true;
746 template<
typename _Tp>
747 inline constexpr empty_view<_Tp>
empty{};
751 template<
typename _Tp>
752 concept __can_single_view
753 =
requires { single_view<decay_t<_Tp>>(std::declval<_Tp>()); };
758 template<__detail::__can_single_view _Tp>
760 operator() [[nodiscard]] (_Tp&& __e)
const
761 noexcept(
noexcept(single_view<decay_t<_Tp>>(std::forward<_Tp>(__e))))
762 {
return single_view<decay_t<_Tp>>(std::forward<_Tp>(__e)); }
765 inline constexpr _Single single{};
769 template<
typename... _Args>
770 concept __can_iota_view =
requires { iota_view(std::declval<_Args>()...); };
775 template<__detail::__can_iota_view _Tp>
777 operator() [[nodiscard]] (_Tp&& __e)
const
778 {
return iota_view(std::forward<_Tp>(__e)); }
780 template<
typename _Tp,
typename _Up>
781 requires __detail::__can_iota_view<_Tp, _Up>
783 operator() [[nodiscard]] (_Tp&& __e, _Up&& __f)
const
784 {
return iota_view(std::forward<_Tp>(__e), std::forward<_Up>(__f)); }
787 inline constexpr _Iota
iota{};
793 template<
typename _Val,
typename _CharT,
typename _Traits>
794 concept __stream_extractable
795 =
requires(basic_istream<_CharT, _Traits>& is, _Val& t) { is >> t; };
798 template<movable _Val,
typename _CharT,
799 typename _Traits = char_traits<_CharT>>
800 requires default_initializable<_Val>
801 && __detail::__stream_extractable<_Val, _CharT, _Traits>
802 class basic_istream_view
803 :
public view_interface<basic_istream_view<_Val, _CharT, _Traits>>
807 basic_istream_view(basic_istream<_CharT, _Traits>& __stream)
814 *_M_stream >> _M_object;
815 return _Iterator{
this};
818 constexpr default_sentinel_t
823 basic_istream<_CharT, _Traits>* _M_stream;
824 _Val _M_object = _Val();
829 using iterator_concept = input_iterator_tag;
830 using difference_type = ptrdiff_t;
831 using value_type = _Val;
834 _Iterator(basic_istream_view* __parent) noexcept
835 : _M_parent(__parent)
838 _Iterator(
const _Iterator&) =
delete;
839 _Iterator(_Iterator&&) =
default;
840 _Iterator& operator=(
const _Iterator&) =
delete;
841 _Iterator& operator=(_Iterator&&) =
default;
846 *_M_parent->_M_stream >> _M_parent->_M_object;
856 {
return _M_parent->_M_object; }
859 operator==(
const _Iterator& __x, default_sentinel_t)
860 {
return __x._M_at_end(); }
863 basic_istream_view* _M_parent;
867 {
return !*_M_parent->_M_stream; }
873 template<
typename _Val>
874 using istream_view = basic_istream_view<_Val, char>;
876 template<
typename _Val>
877 using wistream_view = basic_istream_view<_Val, wchar_t>;
883 template<
typename _Tp,
typename _Up>
884 concept __can_istream_view =
requires (_Up __e) {
885 basic_istream_view<_Tp, typename _Up::char_type, typename _Up::traits_type>(__e);
889 template<
typename _Tp>
892 template<
typename _CharT,
typename _Traits>
894 operator() [[nodiscard]] (basic_istream<_CharT, _Traits>& __e)
const
895 requires __detail::__can_istream_view<_Tp, remove_reference_t<
decltype(__e)>>
896 {
return basic_istream_view<_Tp, _CharT, _Traits>(__e); }
899 template<
typename _Tp>
900 inline constexpr _Istream<_Tp>
istream;
908 template<
typename _Tp,
int _Disc>
917 template<
bool _Present,
typename _Tp,
int _Disc = 0>
918 using __maybe_present_t = __conditional_t<_Present, _Tp, _Absent<_Tp, _Disc>>;
921 template<
bool _Const,
typename _Tp>
922 using __maybe_const_t = __conditional_t<_Const, const _Tp, _Tp>;
927using __detail::__maybe_const_t;
929namespace views::__adaptor
932 template<
typename _Adaptor,
typename... _Args>
933 concept __adaptor_invocable
934 =
requires { std::declval<_Adaptor>()(declval<_Args>()...); };
938 template<
typename _Adaptor,
typename... _Args>
939 concept __adaptor_partial_app_viable = (_Adaptor::_S_arity > 1)
940 && (
sizeof...(_Args) == _Adaptor::_S_arity - 1)
941 && (constructible_from<decay_t<_Args>, _Args> && ...);
943 template<
typename _Adaptor,
typename... _Args>
946 template<
typename _Lhs,
typename _Rhs>
954 template<
typename _Derived>
955 struct _RangeAdaptorClosure;
957 template<
typename _Tp,
typename _Up>
958 requires (!same_as<_Tp, _RangeAdaptorClosure<_Up>>)
959 void __is_range_adaptor_closure_fn
960 (
const _Tp&,
const _RangeAdaptorClosure<_Up>&);
962 template<
typename _Tp>
963 concept __is_range_adaptor_closure
964 =
requires (_Tp __t) { __adaptor::__is_range_adaptor_closure_fn(__t, __t); };
966#pragma GCC diagnostic push
967#pragma GCC diagnostic ignored "-Wdangling-reference"
969 template<
typename _Self,
typename _Range>
970 requires __is_range_adaptor_closure<_Self>
971 && __adaptor_invocable<_Self, _Range>
974 {
return std::forward<_Self>(__self)(std::forward<_Range>(__r)); }
978 template<
typename _Lhs,
typename _Rhs>
979 requires __is_range_adaptor_closure<_Lhs>
980 && __is_range_adaptor_closure<_Rhs>
984 return _Pipe<decay_t<_Lhs>, decay_t<_Rhs>>{std::forward<_Lhs>(__lhs),
985 std::forward<_Rhs>(__rhs)};
987#pragma GCC diagnostic pop
989 template<
typename _Derived>
990 struct _RangeAdaptorClosure
996 template<
typename _Self,
typename _Range>
997 requires __is_range_adaptor_closure<_Self>
998 && __adaptor_invocable<_Self, _Range>
999 friend constexpr auto
1000 operator|(_Range&& __r, _Self&& __self);
1002 template<
typename _Lhs,
typename _Rhs>
1003 requires __is_range_adaptor_closure<_Lhs>
1004 && __is_range_adaptor_closure<_Rhs>
1005 friend constexpr auto
1020 template<
typename _Derived>
1021 struct _RangeAdaptor
1025 template<
typename... _Args>
1026 requires __adaptor_partial_app_viable<_Derived, _Args...>
1028 operator()(_Args&&... __args)
const
1030 return _Partial<_Derived, decay_t<_Args>...>{0, std::forward<_Args>(__args)...};
1037 template<
typename _Adaptor>
1038 concept __closure_has_simple_call_op = _Adaptor::_S_has_simple_call_op;
1042 template<
typename _Adaptor,
typename... _Args>
1043 concept __adaptor_has_simple_extra_args = _Adaptor::_S_has_simple_extra_args
1044 || _Adaptor::template _S_has_simple_extra_args<_Args...>;
1048 template<
typename _Adaptor,
typename... _Args>
1049 struct _Partial : _RangeAdaptorClosure<_Partial<_Adaptor, _Args...>>
1051 tuple<_Args...> _M_args;
1055 template<
typename... _Ts>
1057 _Partial(
int, _Ts&&... __args)
1063#if __cpp_explicit_this_parameter
1064 template<
typename _Self,
typename _Range>
1065 requires __adaptor_invocable<_Adaptor, _Range, __like_t<_Self, _Args>...>
1067 operator()(
this _Self&& __self, _Range&& __r)
1069 auto __forwarder = [&__r] (
auto&&... __args) {
1070 return _Adaptor{}(std::forward<_Range>(__r),
1071 std::forward<decltype(__args)>(__args)...);
1073 return std::apply(__forwarder, __like_t<_Self, _Partial>(__self)._M_args);
1076 template<
typename _Range>
1077 requires __adaptor_invocable<_Adaptor, _Range,
const _Args&...>
1079 operator()(_Range&& __r)
const &
1081 auto __forwarder = [&__r] (
const auto&... __args) {
1082 return _Adaptor{}(std::forward<_Range>(__r), __args...);
1084 return std::apply(__forwarder, _M_args);
1087 template<
typename _Range>
1088 requires __adaptor_invocable<_Adaptor, _Range, _Args...>
1090 operator()(_Range&& __r) &&
1092 auto __forwarder = [&__r] (
auto&... __args) {
1093 return _Adaptor{}(std::forward<_Range>(__r),
std::move(__args)...);
1095 return std::apply(__forwarder, _M_args);
1098 template<
typename _Range>
1100 operator()(_Range&& __r)
const && =
delete;
1106 template<
typename _Adaptor,
typename _Arg>
1107 struct _Partial<_Adaptor, _Arg> : _RangeAdaptorClosure<_Partial<_Adaptor, _Arg>>
1111 template<
typename _Tp>
1113 _Partial(
int, _Tp&& __arg)
1117#if __cpp_explicit_this_parameter
1118 template<
typename _Self,
typename _Range>
1119 requires __adaptor_invocable<_Adaptor, _Range, __like_t<_Self, _Arg>>
1121 operator()(
this _Self&& __self, _Range&& __r)
1123 return _Adaptor{}(std::forward<_Range>(__r),
1124 __like_t<_Self, _Partial>(__self)._M_arg);
1127 template<
typename _Range>
1128 requires __adaptor_invocable<_Adaptor, _Range, const _Arg&>
1130 operator()(_Range&& __r)
const &
1131 {
return _Adaptor{}(std::forward<_Range>(__r), _M_arg); }
1133 template<
typename _Range>
1134 requires __adaptor_invocable<_Adaptor, _Range, _Arg>
1136 operator()(_Range&& __r) &&
1137 {
return _Adaptor{}(std::forward<_Range>(__r),
std::move(_M_arg)); }
1139 template<
typename _Range>
1141 operator()(_Range&& __r)
const && =
delete;
1149 template<
typename _Adaptor,
typename... _Args>
1150 requires __adaptor_has_simple_extra_args<_Adaptor, _Args...>
1151 && (is_trivially_copy_constructible_v<_Args> && ...)
1152 struct _Partial<_Adaptor, _Args...> : _RangeAdaptorClosure<_Partial<_Adaptor, _Args...>>
1154 tuple<_Args...> _M_args;
1156 template<
typename... _Ts>
1158 _Partial(
int, _Ts&&... __args)
1164 template<
typename _Range>
1165 requires __adaptor_invocable<_Adaptor, _Range,
const _Args&...>
1167 operator()(_Range&& __r)
const
1169 auto __forwarder = [&__r] (
const auto&... __args) {
1170 return _Adaptor{}(std::forward<_Range>(__r), __args...);
1172 return std::apply(__forwarder, _M_args);
1175 static constexpr bool _S_has_simple_call_op =
true;
1180 template<
typename _Adaptor,
typename _Arg>
1181 requires __adaptor_has_simple_extra_args<_Adaptor, _Arg>
1182 && is_trivially_copy_constructible_v<_Arg>
1183 struct _Partial<_Adaptor, _Arg> : _RangeAdaptorClosure<_Partial<_Adaptor, _Arg>>
1187 template<
typename _Tp>
1189 _Partial(
int, _Tp&& __arg)
1193 template<
typename _Range>
1194 requires __adaptor_invocable<_Adaptor, _Range, const _Arg&>
1196 operator()(_Range&& __r)
const
1197 {
return _Adaptor{}(std::forward<_Range>(__r), _M_arg); }
1199 static constexpr bool _S_has_simple_call_op =
true;
1202 template<
typename _Lhs,
typename _Rhs,
typename _Range>
1203 concept __pipe_invocable
1204 =
requires { std::declval<_Rhs>()(std::declval<_Lhs>()(std::declval<_Range>())); };
1208 template<
typename _Lhs,
typename _Rhs>
1209 struct _Pipe : _RangeAdaptorClosure<_Pipe<_Lhs, _Rhs>>
1211 [[no_unique_address]] _Lhs _M_lhs;
1212 [[no_unique_address]] _Rhs _M_rhs;
1214 template<
typename _Tp,
typename _Up>
1216 _Pipe(_Tp&& __lhs, _Up&& __rhs)
1222#if __cpp_explicit_this_parameter
1223 template<
typename _Self,
typename _Range>
1224 requires __pipe_invocable<__like_t<_Self, _Lhs>, __like_t<_Self, _Rhs>, _Range>
1226 operator()(
this _Self&& __self, _Range&& __r)
1228 return (__like_t<_Self, _Pipe>(__self)._M_rhs
1229 (__like_t<_Self, _Pipe>(__self)._M_lhs
1230 (std::forward<_Range>(__r))));
1233 template<
typename _Range>
1234 requires __pipe_invocable<const _Lhs&, const _Rhs&, _Range>
1236 operator()(_Range&& __r)
const &
1237 {
return _M_rhs(_M_lhs(std::forward<_Range>(__r))); }
1239 template<
typename _Range>
1240 requires __pipe_invocable<_Lhs, _Rhs, _Range>
1242 operator()(_Range&& __r) &&
1245 template<
typename _Range>
1247 operator()(_Range&& __r)
const && =
delete;
1255 template<
typename _Lhs,
typename _Rhs>
1256 requires __closure_has_simple_call_op<_Lhs>
1257 && __closure_has_simple_call_op<_Rhs>
1258 struct _Pipe<_Lhs, _Rhs> : _RangeAdaptorClosure<_Pipe<_Lhs, _Rhs>>
1260 [[no_unique_address]] _Lhs _M_lhs;
1261 [[no_unique_address]] _Rhs _M_rhs;
1263 template<
typename _Tp,
typename _Up>
1265 _Pipe(_Tp&& __lhs, _Up&& __rhs)
1269 template<
typename _Range>
1270 requires __pipe_invocable<const _Lhs&, const _Rhs&, _Range>
1272 operator()(_Range&& __r)
const
1273 {
return _M_rhs(_M_lhs(std::forward<_Range>(__r))); }
1275 static constexpr bool _S_has_simple_call_op =
true;
1279#if __cpp_lib_ranges >= 202202L
1281 template<
typename _Derived>
1282 requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
1283 class range_adaptor_closure
1284 :
public views::__adaptor::_RangeAdaptorClosure<_Derived>
1288 template<range _Range>
requires is_object_v<_Range>
1289 class ref_view :
public view_interface<ref_view<_Range>>
1294 static void _S_fun(_Range&);
1295 static void _S_fun(_Range&&) =
delete;
1298 template<__detail::__different_from<ref_view> _Tp>
1299 requires convertible_to<_Tp, _Range&>
1300 &&
requires { _S_fun(declval<_Tp>()); }
1303 noexcept(
noexcept(
static_cast<_Range&
>(std::declval<_Tp>())))
1311 constexpr iterator_t<_Range>
1313 {
return ranges::begin(*_M_r); }
1315 constexpr sentinel_t<_Range>
1317 {
return ranges::end(*_M_r); }
1320 empty() const requires requires { ranges::empty(*_M_r); }
1321 {
return ranges::empty(*_M_r); }
1324 size() const requires sized_range<_Range>
1325 {
return ranges::size(*_M_r); }
1328 data() const requires contiguous_range<_Range>
1329 {
return ranges::data(*_M_r); }
1332 template<
typename _Range>
1333 ref_view(_Range&) -> ref_view<_Range>;
1335 template<
typename _Tp>
1336 inline constexpr bool enable_borrowed_range<ref_view<_Tp>> =
true;
1338 template<range _Range>
1339 requires movable<_Range>
1340 && (!__detail::__is_initializer_list<remove_cv_t<_Range>>)
1341 class owning_view : public view_interface<owning_view<_Range>>
1344 _Range _M_r = _Range();
1347 owning_view()
requires default_initializable<_Range> = default;
1350 owning_view(_Range&& __t)
1351 noexcept(is_nothrow_move_constructible_v<_Range>)
1355 owning_view(owning_view&&) =
default;
1356 owning_view& operator=(owning_view&&) =
default;
1362 constexpr const _Range&
1363 base() const& noexcept
1370 constexpr const _Range&&
1371 base() const&& noexcept
1374 constexpr iterator_t<_Range>
1376 {
return ranges::begin(_M_r); }
1378 constexpr sentinel_t<_Range>
1380 {
return ranges::end(_M_r); }
1383 begin() const requires range<const _Range>
1384 {
return ranges::begin(_M_r); }
1387 end() const requires range<const _Range>
1388 {
return ranges::end(_M_r); }
1391 empty()
requires requires { ranges::empty(_M_r); }
1392 {
return ranges::empty(_M_r); }
1395 empty() const requires requires { ranges::empty(_M_r); }
1396 {
return ranges::empty(_M_r); }
1399 size()
requires sized_range<_Range>
1400 {
return ranges::size(_M_r); }
1403 size() const requires sized_range<const _Range>
1404 {
return ranges::size(_M_r); }
1407 data()
requires contiguous_range<_Range>
1408 {
return ranges::data(_M_r); }
1411 data() const requires contiguous_range<const _Range>
1412 {
return ranges::data(_M_r); }
1415 template<
typename _Tp>
1416 inline constexpr bool enable_borrowed_range<owning_view<_Tp>>
1417 = enable_borrowed_range<_Tp>;
1423 template<
typename _Range>
1424 concept __can_ref_view =
requires { ref_view{std::declval<_Range>()}; };
1426 template<
typename _Range>
1427 concept __can_owning_view =
requires { owning_view{std::declval<_Range>()}; };
1430 struct _All : __adaptor::_RangeAdaptorClosure<_All>
1432 template<
typename _Range>
1433 static constexpr bool
1436 if constexpr (view<decay_t<_Range>>)
1437 return is_nothrow_constructible_v<decay_t<_Range>, _Range>;
1438 else if constexpr (__detail::__can_ref_view<_Range>)
1441 return noexcept(owning_view{std::declval<_Range>()});
1444 template<viewable_range _Range>
1445 requires view<decay_t<_Range>>
1446 || __detail::__can_ref_view<_Range>
1447 || __detail::__can_owning_view<_Range>
1449 operator() [[nodiscard]] (_Range&& __r)
const
1450 noexcept(_S_noexcept<_Range>())
1452 if constexpr (view<decay_t<_Range>>)
1453 return std::forward<_Range>(__r);
1454 else if constexpr (__detail::__can_ref_view<_Range>)
1455 return ref_view{std::forward<_Range>(__r)};
1457 return owning_view{std::forward<_Range>(__r)};
1460 static constexpr bool _S_has_simple_call_op =
true;
1463 inline constexpr _All all;
1465 template<viewable_range _Range>
1466 using all_t =
decltype(all(std::declval<_Range>()));
1471 template<
typename _Tp>
1472 struct __non_propagating_cache
1480 template<
typename _Tp>
1481 requires is_object_v<_Tp>
1482 struct __non_propagating_cache<_Tp>
1483 :
protected _Optional_base<_Tp>
1485 __non_propagating_cache() =
default;
1488 __non_propagating_cache(
const __non_propagating_cache&)
noexcept
1492 __non_propagating_cache(__non_propagating_cache&& __other)
noexcept
1493 { __other._M_reset(); }
1495 constexpr __non_propagating_cache&
1496 operator=(
const __non_propagating_cache& __other)
noexcept
1503 constexpr __non_propagating_cache&
1504 operator=(__non_propagating_cache&& __other)
noexcept
1511 constexpr __non_propagating_cache&
1512 operator=(_Tp __val)
1515 this->_M_payload._M_construct(
std::move(__val));
1520 operator bool() const noexcept
1521 {
return this->_M_is_engaged(); }
1525 {
return this->_M_get(); }
1527 constexpr const _Tp&
1529 {
return this->_M_get(); }
1531 template<
typename _Iter>
1533 _M_emplace_deref(
const _Iter& __i)
1536 auto __f = [] (
auto& __x) {
return *__x; };
1537 this->_M_payload._M_apply(_Optional_func{__f}, __i);
1538 return this->_M_get();
1541 using _Optional_base<_Tp>::_M_reset;
1544 template<range _Range>
1545 struct _CachedPosition
1548 _M_has_value()
const
1551 constexpr iterator_t<_Range>
1552 _M_get(
const _Range&)
const
1554 __glibcxx_assert(
false);
1555 __builtin_unreachable();
1559 _M_set(
const _Range&,
const iterator_t<_Range>&)
const
1563 template<forward_range _Range>
1564 struct _CachedPosition<_Range>
1565 :
protected __non_propagating_cache<iterator_t<_Range>>
1568 _M_has_value()
const
1569 {
return this->_M_is_engaged(); }
1571 constexpr iterator_t<_Range>
1572 _M_get(
const _Range&)
const
1574 __glibcxx_assert(_M_has_value());
1579 _M_set(
const _Range&,
const iterator_t<_Range>& __it)
1581 __glibcxx_assert(!_M_has_value());
1584 this->_M_payload._M_engaged =
true;
1588 template<random_access_range _Range>
1589 requires (
sizeof(range_difference_t<_Range>)
1590 <=
sizeof(iterator_t<_Range>))
1591 struct _CachedPosition<_Range>
1594 range_difference_t<_Range> _M_offset = -1;
1597 _CachedPosition() =
default;
1600 _CachedPosition(
const _CachedPosition&) =
default;
1603 _CachedPosition(_CachedPosition&& __other)
noexcept
1606 constexpr _CachedPosition&
1607 operator=(
const _CachedPosition&) =
default;
1609 constexpr _CachedPosition&
1610 operator=(_CachedPosition&& __other)
noexcept
1613 _M_offset = __other._M_offset;
1614 __other._M_offset = -1;
1619 _M_has_value()
const
1620 {
return _M_offset >= 0; }
1622 constexpr iterator_t<_Range>
1623 _M_get(_Range& __r)
const
1625 __glibcxx_assert(_M_has_value());
1626 return ranges::begin(__r) + _M_offset;
1630 _M_set(_Range& __r,
const iterator_t<_Range>& __it)
1632 __glibcxx_assert(!_M_has_value());
1633 _M_offset = __it - ranges::begin(__r);
1640 template<
typename _Base>
1641 struct __filter_view_iter_cat
1644 template<forward_range _Base>
1645 struct __filter_view_iter_cat<_Base>
1651 using _Cat =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
1652 if constexpr (derived_from<_Cat, bidirectional_iterator_tag>)
1653 return bidirectional_iterator_tag{};
1654 else if constexpr (derived_from<_Cat, forward_iterator_tag>)
1655 return forward_iterator_tag{};
1660 using iterator_category =
decltype(_S_iter_cat());
1664 template<input_range _Vp,
1665 indirect_unary_predicate<iterator_t<_Vp>> _Pred>
1666 requires view<_Vp> && is_object_v<_Pred>
1667 class filter_view :
public view_interface<filter_view<_Vp, _Pred>>
1672 struct _Iterator : __detail::__filter_view_iter_cat<_Vp>
1675 static constexpr auto
1678 if constexpr (bidirectional_range<_Vp>)
1679 return bidirectional_iterator_tag{};
1680 else if constexpr (forward_range<_Vp>)
1681 return forward_iterator_tag{};
1683 return input_iterator_tag{};
1688 using _Vp_iter = iterator_t<_Vp>;
1690 _Vp_iter _M_current = _Vp_iter();
1691 filter_view* _M_parent =
nullptr;
1694 using iterator_concept =
decltype(_S_iter_concept());
1696 using value_type = range_value_t<_Vp>;
1697 using difference_type = range_difference_t<_Vp>;
1699 _Iterator()
requires default_initializable<_Vp_iter> = default;
1702 _Iterator(filter_view* __parent, _Vp_iter __current)
1703 : _M_current(
std::move(__current)),
1707 constexpr const _Vp_iter&
1708 base() const & noexcept
1709 {
return _M_current; }
1715 constexpr range_reference_t<_Vp>
1717 {
return *_M_current; }
1721 requires __detail::__has_arrow<_Vp_iter>
1722 && copyable<_Vp_iter>
1723 {
return _M_current; }
1725 constexpr _Iterator&
1728 _M_current = ranges::find_if(
std::move(++_M_current),
1729 ranges::end(_M_parent->_M_base),
1730 std::ref(*_M_parent->_M_pred));
1739 operator++(
int)
requires forward_range<_Vp>
1746 constexpr _Iterator&
1747 operator--()
requires bidirectional_range<_Vp>
1756 operator--(
int)
requires bidirectional_range<_Vp>
1763 friend constexpr bool
1764 operator==(
const _Iterator& __x,
const _Iterator& __y)
1765 requires equality_comparable<_Vp_iter>
1766 {
return __x._M_current == __y._M_current; }
1768 friend constexpr range_rvalue_reference_t<_Vp>
1769 iter_move(
const _Iterator& __i)
1770 noexcept(
noexcept(ranges::iter_move(__i._M_current)))
1771 {
return ranges::iter_move(__i._M_current); }
1773 friend constexpr void
1774 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
1775 noexcept(
noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1776 requires indirectly_swappable<_Vp_iter>
1777 { ranges::iter_swap(__x._M_current, __y._M_current); }
1783 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
1786 __equal(
const _Iterator& __i)
const
1787 {
return __i._M_current == _M_end; }
1790 _Sentinel() =
default;
1793 _Sentinel(filter_view* __parent)
1794 : _M_end(ranges::
end(__parent->_M_base))
1797 constexpr sentinel_t<_Vp>
1801 friend constexpr bool
1802 operator==(
const _Iterator& __x,
const _Sentinel& __y)
1803 {
return __y.__equal(__x); }
1806 _Vp _M_base = _Vp();
1807 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
1808 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
1811 filter_view()
requires (default_initializable<_Vp>
1812 && default_initializable<_Pred>)
1816 filter_view(_Vp __base, _Pred __pred)
1821 base() const& requires copy_constructible<_Vp>
1828 constexpr const _Pred&
1830 {
return *_M_pred; }
1835 if (_M_cached_begin._M_has_value())
1836 return {
this, _M_cached_begin._M_get(_M_base)};
1838 __glibcxx_assert(_M_pred.has_value());
1839 auto __it = ranges::find_if(ranges::begin(_M_base),
1840 ranges::end(_M_base),
1841 std::ref(*_M_pred));
1842 _M_cached_begin._M_set(_M_base, __it);
1849 if constexpr (common_range<_Vp>)
1850 return _Iterator{
this, ranges::end(_M_base)};
1852 return _Sentinel{
this};
1856 template<
typename _Range,
typename _Pred>
1857 filter_view(_Range&&, _Pred) -> filter_view<views::all_t<_Range>, _Pred>;
1863 template<
typename _Range,
typename _Pred>
1864 concept __can_filter_view
1865 =
requires { filter_view(std::declval<_Range>(), std::declval<_Pred>()); };
1868 struct _Filter : __adaptor::_RangeAdaptor<_Filter>
1870 template<viewable_range _Range,
typename _Pred>
1871 requires __detail::__can_filter_view<_Range, _Pred>
1873 operator() [[nodiscard]] (_Range&& __r, _Pred&& __p)
const
1875 return filter_view(std::forward<_Range>(__r), std::forward<_Pred>(__p));
1878 using _RangeAdaptor<_Filter>::operator();
1879 static constexpr int _S_arity = 2;
1880 static constexpr bool _S_has_simple_extra_args =
true;
1883 inline constexpr _Filter filter;
1886#if __cpp_lib_ranges >= 202207L
1887 template<input_range _Vp, move_constructible _Fp>
1889 template<input_range _Vp, copy_constructible _Fp>
1891 requires view<_Vp> && is_object_v<_Fp>
1892 && regular_invocable<_Fp&, range_reference_t<_Vp>>
1893 && std::__detail::__can_reference<invoke_result_t<_Fp&,
1894 range_reference_t<_Vp>>>
1895 class transform_view :
public view_interface<transform_view<_Vp, _Fp>>
1898 template<
bool _Const>
1899 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
1901 template<
bool _Const>
1905 template<
bool _Const>
1906 requires forward_range<_Base<_Const>>
1907 struct __iter_cat<_Const>
1916 using _Base = transform_view::_Base<_Const>;
1917 using _Res = invoke_result_t<__maybe_const_t<_Const, _Fp>&,
1918 range_reference_t<_Base>>;
1921 if constexpr (is_reference_v<_Res>)
1924 =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
1925 if constexpr (derived_from<_Cat, contiguous_iterator_tag>)
1926 return random_access_iterator_tag{};
1931 return input_iterator_tag{};
1934 using iterator_category =
decltype(_S_iter_cat());
1937 template<
bool _Const>
1940 template<
bool _Const>
1941 struct _Iterator : __iter_cat<_Const>
1944 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
1945 using _Base = transform_view::_Base<_Const>;
1950 if constexpr (random_access_range<_Base>)
1951 return random_access_iterator_tag{};
1952 else if constexpr (bidirectional_range<_Base>)
1953 return bidirectional_iterator_tag{};
1954 else if constexpr (forward_range<_Base>)
1955 return forward_iterator_tag{};
1957 return input_iterator_tag{};
1960 using _Base_iter = iterator_t<_Base>;
1962 _Base_iter _M_current = _Base_iter();
1963 _Parent* _M_parent =
nullptr;
1966 using iterator_concept =
decltype(_S_iter_concept());
1969 = remove_cvref_t<invoke_result_t<__maybe_const_t<_Const, _Fp>&,
1970 range_reference_t<_Base>>>;
1971 using difference_type = range_difference_t<_Base>;
1973 _Iterator()
requires default_initializable<_Base_iter> = default;
1976 _Iterator(_Parent* __parent, _Base_iter __current)
1977 : _M_current(
std::move(__current)),
1982 _Iterator(_Iterator<!_Const> __i)
1984 && convertible_to<iterator_t<_Vp>, _Base_iter>
1985 : _M_current(
std::move(__i._M_current)), _M_parent(__i._M_parent)
1988 constexpr const _Base_iter&
1989 base() const & noexcept
1990 {
return _M_current; }
1992 constexpr _Base_iter
1996 constexpr decltype(
auto)
1998 noexcept(
noexcept(
std::__invoke(*_M_parent->_M_fun, *_M_current)))
2001 constexpr _Iterator&
2013 operator++(
int)
requires forward_range<_Base>
2020 constexpr _Iterator&
2021 operator--()
requires bidirectional_range<_Base>
2028 operator--(
int)
requires bidirectional_range<_Base>
2035 constexpr _Iterator&
2036 operator+=(difference_type __n)
requires random_access_range<_Base>
2042 constexpr _Iterator&
2043 operator-=(difference_type __n)
requires random_access_range<_Base>
2049 constexpr decltype(
auto)
2050 operator[](difference_type __n)
const
2051 requires random_access_range<_Base>
2052 {
return std::__invoke(*_M_parent->_M_fun, _M_current[__n]); }
2054 friend constexpr bool
2055 operator==(
const _Iterator& __x,
const _Iterator& __y)
2056 requires equality_comparable<_Base_iter>
2057 {
return __x._M_current == __y._M_current; }
2059 friend constexpr bool
2060 operator<(
const _Iterator& __x,
const _Iterator& __y)
2061 requires random_access_range<_Base>
2062 {
return __x._M_current < __y._M_current; }
2064 friend constexpr bool
2065 operator>(
const _Iterator& __x,
const _Iterator& __y)
2066 requires random_access_range<_Base>
2067 {
return __y < __x; }
2069 friend constexpr bool
2070 operator<=(
const _Iterator& __x,
const _Iterator& __y)
2071 requires random_access_range<_Base>
2072 {
return !(__y < __x); }
2074 friend constexpr bool
2075 operator>=(
const _Iterator& __x,
const _Iterator& __y)
2076 requires random_access_range<_Base>
2077 {
return !(__x < __y); }
2079#ifdef __cpp_lib_three_way_comparison
2080 friend constexpr auto
2081 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
2082 requires random_access_range<_Base>
2083 && three_way_comparable<_Base_iter>
2084 {
return __x._M_current <=> __y._M_current; }
2087 friend constexpr _Iterator
2088 operator+(_Iterator __i, difference_type __n)
2089 requires random_access_range<_Base>
2090 {
return {__i._M_parent, __i._M_current + __n}; }
2092 friend constexpr _Iterator
2093 operator+(difference_type __n, _Iterator __i)
2094 requires random_access_range<_Base>
2095 {
return {__i._M_parent, __i._M_current + __n}; }
2097 friend constexpr _Iterator
2098 operator-(_Iterator __i, difference_type __n)
2099 requires random_access_range<_Base>
2100 {
return {__i._M_parent, __i._M_current - __n}; }
2104 friend constexpr difference_type
2105 operator-(
const _Iterator& __x,
const _Iterator& __y)
2106 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
2107 {
return __x._M_current - __y._M_current; }
2109 friend constexpr decltype(
auto)
2110 iter_move(
const _Iterator& __i)
noexcept(
noexcept(*__i))
2112 if constexpr (is_lvalue_reference_v<
decltype(*__i)>)
2118 friend _Iterator<!_Const>;
2119 template<
bool>
friend struct _Sentinel;
2122 template<
bool _Const>
2126 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
2127 using _Base = transform_view::_Base<_Const>;
2129 template<
bool _Const2>
2131 __distance_from(
const _Iterator<_Const2>& __i)
const
2132 {
return _M_end - __i._M_current; }
2134 template<
bool _Const2>
2136 __equal(
const _Iterator<_Const2>& __i)
const
2137 {
return __i._M_current == _M_end; }
2139 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2142 _Sentinel() =
default;
2145 _Sentinel(sentinel_t<_Base> __end)
2150 _Sentinel(_Sentinel<!_Const> __i)
2152 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2156 constexpr sentinel_t<_Base>
2160 template<
bool _Const2>
2161 requires sentinel_for<sentinel_t<_Base>,
2162 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
2163 friend constexpr bool
2164 operator==(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
2165 {
return __y.__equal(__x); }
2167 template<
bool _Const2,
2168 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
2169 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2170 friend constexpr range_difference_t<_Base2>
2171 operator-(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
2172 {
return -__y.__distance_from(__x); }
2174 template<
bool _Const2,
2175 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
2176 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2177 friend constexpr range_difference_t<_Base2>
2178 operator-(
const _Sentinel& __y,
const _Iterator<_Const2>& __x)
2179 {
return __y.__distance_from(__x); }
2181 friend _Sentinel<!_Const>;
2184 _Vp _M_base = _Vp();
2185 [[no_unique_address]] __detail::__box<_Fp> _M_fun;
2188 transform_view()
requires (default_initializable<_Vp>
2189 && default_initializable<_Fp>)
2193 transform_view(_Vp __base, _Fp __fun)
2198 base() const& requires copy_constructible<_Vp>
2199 {
return _M_base ; }
2205 constexpr _Iterator<false>
2207 {
return _Iterator<false>{
this, ranges::begin(_M_base)}; }
2209 constexpr _Iterator<true>
2211 requires range<const _Vp>
2212 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
2213 {
return _Iterator<true>{
this, ranges::begin(_M_base)}; }
2215 constexpr _Sentinel<false>
2217 {
return _Sentinel<false>{ranges::end(_M_base)}; }
2219 constexpr _Iterator<false>
2220 end()
requires common_range<_Vp>
2221 {
return _Iterator<false>{
this, ranges::end(_M_base)}; }
2223 constexpr _Sentinel<true>
2225 requires range<const _Vp>
2226 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
2227 {
return _Sentinel<true>{ranges::end(_M_base)}; }
2229 constexpr _Iterator<true>
2231 requires common_range<const _Vp>
2232 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
2233 {
return _Iterator<true>{
this, ranges::end(_M_base)}; }
2236 size()
requires sized_range<_Vp>
2237 {
return ranges::size(_M_base); }
2240 size() const requires sized_range<const _Vp>
2241 {
return ranges::size(_M_base); }
2244 template<
typename _Range,
typename _Fp>
2245 transform_view(_Range&&, _Fp) -> transform_view<views::all_t<_Range>, _Fp>;
2251 template<
typename _Range,
typename _Fp>
2252 concept __can_transform_view
2253 =
requires { transform_view(std::declval<_Range>(), std::declval<_Fp>()); };
2256 struct _Transform : __adaptor::_RangeAdaptor<_Transform>
2258 template<viewable_range _Range,
typename _Fp>
2259 requires __detail::__can_transform_view<_Range, _Fp>
2261 operator() [[nodiscard]] (_Range&& __r, _Fp&& __f)
const
2263 return transform_view(std::forward<_Range>(__r), std::forward<_Fp>(__f));
2266 using _RangeAdaptor<_Transform>::operator();
2267 static constexpr int _S_arity = 2;
2268 static constexpr bool _S_has_simple_extra_args =
true;
2271 inline constexpr _Transform transform;
2275 class take_view :
public view_interface<take_view<_Vp>>
2278 template<
bool _Const>
2279 using _CI = counted_iterator<
2280 iterator_t<__detail::__maybe_const_t<_Const, _Vp>>>;
2282 template<
bool _Const>
2286 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2287 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2290 _Sentinel() =
default;
2293 _Sentinel(sentinel_t<_Base> __end)
2298 _Sentinel(_Sentinel<!_Const> __s)
2299 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2303 constexpr sentinel_t<_Base>
2307 friend constexpr bool
2308 operator==(
const _CI<_Const>& __y,
const _Sentinel& __x)
2309 {
return __y.count() == 0 || __y.base() == __x._M_end; }
2311 template<
bool _OtherConst = !_Const,
2312 typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
2313 requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2314 friend constexpr bool
2315 operator==(
const _CI<_OtherConst>& __y,
const _Sentinel& __x)
2316 {
return __y.count() == 0 || __y.base() == __x._M_end; }
2318 friend _Sentinel<!_Const>;
2321 _Vp _M_base = _Vp();
2322 range_difference_t<_Vp> _M_count = 0;
2325 take_view()
requires default_initializable<_Vp> = default;
2328 take_view(_Vp __base, range_difference_t<_Vp> __count)
2329 : _M_base(
std::move(__base)), _M_count(
std::move(__count))
2333 base() const& requires copy_constructible<_Vp>
2341 begin()
requires (!__detail::__simple_view<_Vp>)
2343 if constexpr (sized_range<_Vp>)
2345 if constexpr (random_access_range<_Vp>)
2346 return ranges::begin(_M_base);
2350 return counted_iterator(ranges::begin(_M_base), __sz);
2354 return counted_iterator(ranges::begin(_M_base), _M_count);
2358 begin() const requires range<const _Vp>
2360 if constexpr (sized_range<const _Vp>)
2362 if constexpr (random_access_range<const _Vp>)
2363 return ranges::begin(_M_base);
2367 return counted_iterator(ranges::begin(_M_base), __sz);
2371 return counted_iterator(ranges::begin(_M_base), _M_count);
2375 end()
requires (!__detail::__simple_view<_Vp>)
2377 if constexpr (sized_range<_Vp>)
2379 if constexpr (random_access_range<_Vp>)
2380 return ranges::begin(_M_base) +
size();
2385 return _Sentinel<false>{ranges::end(_M_base)};
2389 end() const requires range<const _Vp>
2391 if constexpr (sized_range<const _Vp>)
2393 if constexpr (random_access_range<const _Vp>)
2394 return ranges::begin(_M_base) +
size();
2399 return _Sentinel<true>{ranges::end(_M_base)};
2403 size()
requires sized_range<_Vp>
2405 auto __n = ranges::size(_M_base);
2406 return std::min(__n,
static_cast<decltype(__n)
>(_M_count));
2410 size() const requires sized_range<const _Vp>
2412 auto __n = ranges::size(_M_base);
2413 return std::min(__n,
static_cast<decltype(__n)
>(_M_count));
2420 template<
typename _Range>
2421 take_view(_Range&&, range_difference_t<_Range>)
2422 -> take_view<views::all_t<_Range>>;
2424 template<
typename _Tp>
2425 inline constexpr bool enable_borrowed_range<take_view<_Tp>>
2426 = enable_borrowed_range<_Tp>;
2432 template<
typename _Range>
2433 inline constexpr bool __is_empty_view =
false;
2435 template<
typename _Tp>
2436 inline constexpr bool __is_empty_view<empty_view<_Tp>> =
true;
2438 template<
typename _Range>
2439 inline constexpr bool __is_basic_string_view =
false;
2441 template<
typename _CharT,
typename _Traits>
2442 inline constexpr bool __is_basic_string_view<basic_string_view<_CharT, _Traits>>
2445 using ranges::__detail::__is_subrange;
2447 template<
typename _Range>
2448 inline constexpr bool __is_iota_view =
false;
2450 template<
typename _Winc,
typename _Bound>
2451 inline constexpr bool __is_iota_view<iota_view<_Winc, _Bound>> =
true;
2453 template<
typename _Range>
2454 inline constexpr bool __is_repeat_view =
false;
2456 template<
typename _Range>
2458 __take_of_repeat_view(_Range&&, range_difference_t<_Range>);
2460 template<
typename _Range,
typename _Dp>
2461 concept __can_take_view
2462 =
requires { take_view(std::declval<_Range>(), std::declval<_Dp>()); };
2465 struct _Take : __adaptor::_RangeAdaptor<_Take>
2467 template<viewable_range _Range,
typename _Dp = range_difference_t<_Range>>
2468 requires __detail::__can_take_view<_Range, _Dp>
2470 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n)
const
2472 using _Tp = remove_cvref_t<_Range>;
2473 if constexpr (__detail::__is_empty_view<_Tp>)
2475 else if constexpr (random_access_range<_Tp>
2477 && (std::__detail::__is_span<_Tp>
2478 || __detail::__is_basic_string_view<_Tp>
2479 || __detail::__is_subrange<_Tp>
2480 || __detail::__is_iota_view<_Tp>))
2482 __n = std::min<_Dp>(ranges::distance(__r), __n);
2483 auto __begin = ranges::begin(__r);
2484 auto __end = __begin + __n;
2485 if constexpr (std::__detail::__is_span<_Tp>)
2486 return span<typename _Tp::element_type>(__begin, __end);
2487 else if constexpr (__detail::__is_basic_string_view<_Tp>)
2488 return _Tp(__begin, __end);
2489 else if constexpr (__detail::__is_subrange<_Tp>)
2490 return subrange<iterator_t<_Tp>>(__begin, __end);
2492 return iota_view(*__begin, *__end);
2494 else if constexpr (__detail::__is_repeat_view<_Tp>)
2495 return __detail::__take_of_repeat_view(std::forward<_Range>(__r), __n);
2497 return take_view(std::forward<_Range>(__r), __n);
2500 using _RangeAdaptor<_Take>::operator();
2501 static constexpr int _S_arity = 2;
2505 template<
typename _Tp>
2506 static constexpr bool _S_has_simple_extra_args
2507 = ranges::__detail::__is_integer_like<_Tp>;
2510 inline constexpr _Take take;
2513 template<view _Vp,
typename _Pred>
2514 requires input_range<_Vp> && is_object_v<_Pred>
2515 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2516 class take_while_view :
public view_interface<take_while_view<_Vp, _Pred>>
2518 template<
bool _Const>
2522 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2524 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2525 const _Pred* _M_pred =
nullptr;
2528 _Sentinel() =
default;
2531 _Sentinel(sentinel_t<_Base> __end,
const _Pred* __pred)
2532 : _M_end(__end), _M_pred(__pred)
2536 _Sentinel(_Sentinel<!_Const> __s)
2537 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2538 : _M_end(__s._M_end), _M_pred(__s._M_pred)
2541 constexpr sentinel_t<_Base>
2542 base()
const {
return _M_end; }
2544 friend constexpr bool
2545 operator==(
const iterator_t<_Base>& __x,
const _Sentinel& __y)
2546 {
return __y._M_end == __x || !
std::__invoke(*__y._M_pred, *__x); }
2548 template<
bool _OtherConst = !_Const,
2549 typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
2550 requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2551 friend constexpr bool
2552 operator==(
const iterator_t<_Base2>& __x,
const _Sentinel& __y)
2553 {
return __y._M_end == __x || !
std::__invoke(*__y._M_pred, *__x); }
2555 friend _Sentinel<!_Const>;
2558 _Vp _M_base = _Vp();
2559 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
2562 take_while_view()
requires (default_initializable<_Vp>
2563 && default_initializable<_Pred>)
2567 take_while_view(_Vp __base, _Pred __pred)
2572 base() const& requires copy_constructible<_Vp>
2579 constexpr const _Pred&
2581 {
return *_M_pred; }
2584 begin()
requires (!__detail::__simple_view<_Vp>)
2585 {
return ranges::begin(_M_base); }
2588 begin() const requires range<const _Vp>
2589 && indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
2590 {
return ranges::begin(_M_base); }
2593 end()
requires (!__detail::__simple_view<_Vp>)
2594 {
return _Sentinel<false>(ranges::end(_M_base),
2598 end() const requires range<const _Vp>
2599 && indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
2600 {
return _Sentinel<true>(ranges::end(_M_base),
2604 template<
typename _Range,
typename _Pred>
2605 take_while_view(_Range&&, _Pred)
2606 -> take_while_view<views::all_t<_Range>, _Pred>;
2612 template<
typename _Range,
typename _Pred>
2613 concept __can_take_while_view
2614 =
requires { take_while_view(std::declval<_Range>(), std::declval<_Pred>()); };
2617 struct _TakeWhile : __adaptor::_RangeAdaptor<_TakeWhile>
2619 template<viewable_range _Range,
typename _Pred>
2620 requires __detail::__can_take_while_view<_Range, _Pred>
2622 operator() [[nodiscard]] (_Range&& __r, _Pred&& __p)
const
2624 return take_while_view(std::forward<_Range>(__r), std::forward<_Pred>(__p));
2627 using _RangeAdaptor<_TakeWhile>::operator();
2628 static constexpr int _S_arity = 2;
2629 static constexpr bool _S_has_simple_extra_args =
true;
2632 inline constexpr _TakeWhile take_while;
2636 class drop_view :
public view_interface<drop_view<_Vp>>
2639 _Vp _M_base = _Vp();
2640 range_difference_t<_Vp> _M_count = 0;
2644 static constexpr bool _S_needs_cached_begin
2645 = !(random_access_range<const _Vp> && sized_range<const _Vp>);
2646 [[no_unique_address]]
2647 __detail::__maybe_present_t<_S_needs_cached_begin,
2648 __detail::_CachedPosition<_Vp>>
2652 drop_view()
requires default_initializable<_Vp> = default;
2655 drop_view(_Vp __base, range_difference_t<_Vp> __count)
2656 : _M_base(
std::move(__base)), _M_count(__count)
2657 { __glibcxx_assert(__count >= 0); }
2660 base() const& requires copy_constructible<_Vp>
2670 requires (!(__detail::__simple_view<_Vp>
2671 && random_access_range<const _Vp>
2672 && sized_range<const _Vp>))
2674 if constexpr (_S_needs_cached_begin)
2675 if (_M_cached_begin._M_has_value())
2676 return _M_cached_begin._M_get(_M_base);
2678 auto __it = ranges::next(ranges::begin(_M_base),
2679 _M_count, ranges::end(_M_base));
2680 if constexpr (_S_needs_cached_begin)
2681 _M_cached_begin._M_set(_M_base, __it);
2689 requires random_access_range<const _Vp> && sized_range<const _Vp>
2691 return ranges::begin(_M_base) + ranges::min(ranges::distance(_M_base),
2696 end()
requires (!__detail::__simple_view<_Vp>)
2697 {
return ranges::end(_M_base); }
2700 end() const requires range<const _Vp>
2701 {
return ranges::end(_M_base); }
2704 size()
requires sized_range<_Vp>
2706 const auto __s = ranges::size(_M_base);
2707 const auto __c =
static_cast<decltype(__s)
>(_M_count);
2708 return __s < __c ? 0 : __s - __c;
2712 size() const requires sized_range<const _Vp>
2714 const auto __s = ranges::size(_M_base);
2715 const auto __c =
static_cast<decltype(__s)
>(_M_count);
2716 return __s < __c ? 0 : __s - __c;
2720 template<
typename _Range>
2721 drop_view(_Range&&, range_difference_t<_Range>)
2722 -> drop_view<views::all_t<_Range>>;
2724 template<
typename _Tp>
2725 inline constexpr bool enable_borrowed_range<drop_view<_Tp>>
2726 = enable_borrowed_range<_Tp>;
2732 template<
typename _Range>
2734 __drop_of_repeat_view(_Range&&, range_difference_t<_Range>);
2736 template<
typename _Range,
typename _Dp>
2737 concept __can_drop_view
2738 =
requires { drop_view(std::declval<_Range>(), std::declval<_Dp>()); };
2741 struct _Drop : __adaptor::_RangeAdaptor<_Drop>
2743 template<viewable_range _Range,
typename _Dp = range_difference_t<_Range>>
2744 requires __detail::__can_drop_view<_Range, _Dp>
2746 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n)
const
2748 using _Tp = remove_cvref_t<_Range>;
2749 if constexpr (__detail::__is_empty_view<_Tp>)
2751 else if constexpr (random_access_range<_Tp>
2753 && (std::__detail::__is_span<_Tp>
2754 || __detail::__is_basic_string_view<_Tp>
2755 || __detail::__is_iota_view<_Tp>
2756 || __detail::__is_subrange<_Tp>))
2758 __n = std::min<_Dp>(ranges::distance(__r), __n);
2759 auto __begin = ranges::begin(__r) + __n;
2760 auto __end = ranges::end(__r);
2761 if constexpr (std::__detail::__is_span<_Tp>)
2762 return span<typename _Tp::element_type>(__begin, __end);
2763 else if constexpr (__detail::__is_subrange<_Tp>)
2765 if constexpr (_Tp::_S_store_size)
2767 using ranges::__detail::__to_unsigned_like;
2768 auto __m = ranges::distance(__r) - __n;
2769 return _Tp(__begin, __end, __to_unsigned_like(__m));
2772 return _Tp(__begin, __end);
2775 return _Tp(__begin, __end);
2777 else if constexpr (__detail::__is_repeat_view<_Tp>)
2778 return __detail::__drop_of_repeat_view(std::forward<_Range>(__r), __n);
2780 return drop_view(std::forward<_Range>(__r), __n);
2783 using _RangeAdaptor<_Drop>::operator();
2784 static constexpr int _S_arity = 2;
2785 template<
typename _Tp>
2786 static constexpr bool _S_has_simple_extra_args
2787 = _Take::_S_has_simple_extra_args<_Tp>;
2790 inline constexpr _Drop drop;
2793 template<view _Vp,
typename _Pred>
2794 requires input_range<_Vp> && is_object_v<_Pred>
2795 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2796 class drop_while_view :
public view_interface<drop_while_view<_Vp, _Pred>>
2799 _Vp _M_base = _Vp();
2800 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
2801 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
2804 drop_while_view()
requires (default_initializable<_Vp>
2805 && default_initializable<_Pred>)
2809 drop_while_view(_Vp __base, _Pred __pred)
2814 base() const& requires copy_constructible<_Vp>
2821 constexpr const _Pred&
2823 {
return *_M_pred; }
2828 if (_M_cached_begin._M_has_value())
2829 return _M_cached_begin._M_get(_M_base);
2831 __glibcxx_assert(_M_pred.has_value());
2832 auto __it = ranges::find_if_not(ranges::begin(_M_base),
2833 ranges::end(_M_base),
2834 std::cref(*_M_pred));
2835 _M_cached_begin._M_set(_M_base, __it);
2841 {
return ranges::end(_M_base); }
2844 template<
typename _Range,
typename _Pred>
2845 drop_while_view(_Range&&, _Pred)
2846 -> drop_while_view<views::all_t<_Range>, _Pred>;
2848 template<
typename _Tp,
typename _Pred>
2849 inline constexpr bool enable_borrowed_range<drop_while_view<_Tp, _Pred>>
2850 = enable_borrowed_range<_Tp>;
2856 template<
typename _Range,
typename _Pred>
2857 concept __can_drop_while_view
2858 =
requires { drop_while_view(std::declval<_Range>(), std::declval<_Pred>()); };
2861 struct _DropWhile : __adaptor::_RangeAdaptor<_DropWhile>
2863 template<viewable_range _Range,
typename _Pred>
2864 requires __detail::__can_drop_while_view<_Range, _Pred>
2866 operator() [[nodiscard]] (_Range&& __r, _Pred&& __p)
const
2868 return drop_while_view(std::forward<_Range>(__r),
2869 std::forward<_Pred>(__p));
2872 using _RangeAdaptor<_DropWhile>::operator();
2873 static constexpr int _S_arity = 2;
2874 static constexpr bool _S_has_simple_extra_args =
true;
2877 inline constexpr _DropWhile drop_while;
2882 template<
typename _Tp>
2884 __as_lvalue(_Tp&& __t)
2885 {
return static_cast<_Tp&
>(__t); }
2888 template<input_range _Vp>
2889 requires view<_Vp> && input_range<range_reference_t<_Vp>>
2890 class join_view :
public view_interface<join_view<_Vp>>
2893 using _InnerRange = range_reference_t<_Vp>;
2895 template<
bool _Const>
2896 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2898 template<
bool _Const>
2899 using _Outer_iter = iterator_t<_Base<_Const>>;
2901 template<
bool _Const>
2902 using _Inner_iter = iterator_t<range_reference_t<_Base<_Const>>>;
2904 template<
bool _Const>
2905 static constexpr bool _S_ref_is_glvalue
2906 = is_reference_v<range_reference_t<_Base<_Const>>>;
2908 template<
bool _Const>
2912 template<
bool _Const>
2913 requires _S_ref_is_glvalue<_Const>
2914 && forward_range<_Base<_Const>>
2915 && forward_range<range_reference_t<_Base<_Const>>>
2916 struct __iter_cat<_Const>
2919 static constexpr auto
2922 using _Outer_iter = join_view::_Outer_iter<_Const>;
2923 using _Inner_iter = join_view::_Inner_iter<_Const>;
2924 using _OuterCat =
typename iterator_traits<_Outer_iter>::iterator_category;
2925 using _InnerCat =
typename iterator_traits<_Inner_iter>::iterator_category;
2926 if constexpr (derived_from<_OuterCat, bidirectional_iterator_tag>
2927 && derived_from<_InnerCat, bidirectional_iterator_tag>
2928 && common_range<range_reference_t<_Base<_Const>>>)
2929 return bidirectional_iterator_tag{};
2930 else if constexpr (derived_from<_OuterCat, forward_iterator_tag>
2931 && derived_from<_InnerCat, forward_iterator_tag>)
2932 return forward_iterator_tag{};
2934 return input_iterator_tag{};
2937 using iterator_category =
decltype(_S_iter_cat());
2940 template<
bool _Const>
2943 template<
bool _Const>
2944 struct _Iterator : __iter_cat<_Const>
2947 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
2948 using _Base = join_view::_Base<_Const>;
2952 static constexpr bool _S_ref_is_glvalue
2953 = join_view::_S_ref_is_glvalue<_Const>;
2958 auto __update_inner = [
this] (
const iterator_t<_Base>& __x) ->
auto&& {
2959 if constexpr (_S_ref_is_glvalue)
2962 return _M_parent->_M_inner._M_emplace_deref(__x);
2965 _Outer_iter& __outer = _M_get_outer();
2966 for (; __outer != ranges::end(_M_parent->_M_base); ++__outer)
2968 auto&& __inner = __update_inner(__outer);
2969 _M_inner = ranges::begin(__inner);
2970 if (_M_inner != ranges::end(__inner))
2974 if constexpr (_S_ref_is_glvalue)
2978 static constexpr auto
2981 if constexpr (_S_ref_is_glvalue
2982 && bidirectional_range<_Base>
2983 && bidirectional_range<range_reference_t<_Base>>
2984 && common_range<range_reference_t<_Base>>)
2985 return bidirectional_iterator_tag{};
2986 else if constexpr (_S_ref_is_glvalue
2987 && forward_range<_Base>
2988 && forward_range<range_reference_t<_Base>>)
2989 return forward_iterator_tag{};
2991 return input_iterator_tag{};
2994 using _Outer_iter = join_view::_Outer_iter<_Const>;
2995 using _Inner_iter = join_view::_Inner_iter<_Const>;
2997 constexpr _Outer_iter&
3000 if constexpr (forward_range<_Base>)
3003 return *_M_parent->_M_outer;
3006 constexpr const _Outer_iter&
3007 _M_get_outer()
const
3009 if constexpr (forward_range<_Base>)
3012 return *_M_parent->_M_outer;
3016 _Iterator(_Parent* __parent, _Outer_iter __outer)
requires forward_range<_Base>
3017 : _M_outer(
std::move(__outer)), _M_parent(__parent)
3021 _Iterator(_Parent* __parent)
requires (!forward_range<_Base>)
3022 : _M_parent(__parent)
3025 [[no_unique_address]]
3026 __detail::__maybe_present_t<forward_range<_Base>, _Outer_iter> _M_outer;
3027 optional<_Inner_iter> _M_inner;
3028 _Parent* _M_parent =
nullptr;
3031 using iterator_concept =
decltype(_S_iter_concept());
3033 using value_type = range_value_t<range_reference_t<_Base>>;
3034 using difference_type
3035 = common_type_t<range_difference_t<_Base>,
3036 range_difference_t<range_reference_t<_Base>>>;
3038 _Iterator() =
default;
3041 _Iterator(_Iterator<!_Const> __i)
3043 && convertible_to<iterator_t<_Vp>, _Outer_iter>
3044 && convertible_to<iterator_t<_InnerRange>, _Inner_iter>
3046 _M_parent(__i._M_parent)
3049 constexpr decltype(
auto)
3051 {
return **_M_inner; }
3055 constexpr _Inner_iter
3057 requires __detail::__has_arrow<_Inner_iter>
3058 && copyable<_Inner_iter>
3059 {
return *_M_inner; }
3061 constexpr _Iterator&
3064 auto&& __inner_range = [
this] () ->
auto&& {
3065 if constexpr (_S_ref_is_glvalue)
3066 return *_M_get_outer();
3068 return *_M_parent->_M_inner;
3070 if (++*_M_inner == ranges::end(__inner_range))
3084 requires _S_ref_is_glvalue && forward_range<_Base>
3085 && forward_range<range_reference_t<_Base>>
3092 constexpr _Iterator&
3094 requires _S_ref_is_glvalue && bidirectional_range<_Base>
3095 && bidirectional_range<range_reference_t<_Base>>
3096 && common_range<range_reference_t<_Base>>
3098 if (_M_outer == ranges::end(_M_parent->_M_base))
3099 _M_inner = ranges::end(__detail::__as_lvalue(*--_M_outer));
3100 while (*_M_inner == ranges::begin(__detail::__as_lvalue(*_M_outer)))
3101 *_M_inner = ranges::end(__detail::__as_lvalue(*--_M_outer));
3108 requires _S_ref_is_glvalue && bidirectional_range<_Base>
3109 && bidirectional_range<range_reference_t<_Base>>
3110 && common_range<range_reference_t<_Base>>
3117 friend constexpr bool
3118 operator==(
const _Iterator& __x,
const _Iterator& __y)
3119 requires _S_ref_is_glvalue
3120 && forward_range<_Base>
3121 && equality_comparable<_Inner_iter>
3123 return (__x._M_outer == __y._M_outer
3124 && __x._M_inner == __y._M_inner);
3127 friend constexpr decltype(
auto)
3128 iter_move(
const _Iterator& __i)
3129 noexcept(
noexcept(ranges::iter_move(*__i._M_inner)))
3130 {
return ranges::iter_move(*__i._M_inner); }
3132 friend constexpr void
3133 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
3134 noexcept(
noexcept(ranges::iter_swap(*__x._M_inner, *__y._M_inner)))
3135 requires indirectly_swappable<_Inner_iter>
3136 {
return ranges::iter_swap(*__x._M_inner, *__y._M_inner); }
3138 friend _Iterator<!_Const>;
3139 template<
bool>
friend struct _Sentinel;
3142 template<
bool _Const>
3146 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
3147 using _Base = join_view::_Base<_Const>;
3149 template<
bool _Const2>
3151 __equal(
const _Iterator<_Const2>& __i)
const
3152 {
return __i._M_get_outer() == _M_end; }
3154 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
3157 _Sentinel() =
default;
3160 _Sentinel(_Parent* __parent)
3161 : _M_end(ranges::
end(__parent->_M_base))
3165 _Sentinel(_Sentinel<!_Const> __s)
3166 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
3170 template<
bool _Const2>
3171 requires sentinel_for<sentinel_t<_Base>,
3172 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
3173 friend constexpr bool
3174 operator==(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
3175 {
return __y.__equal(__x); }
3177 friend _Sentinel<!_Const>;
3180 _Vp _M_base = _Vp();
3181 [[no_unique_address]]
3182 __detail::__maybe_present_t<!forward_range<_Vp>,
3183 __detail::__non_propagating_cache<iterator_t<_Vp>>> _M_outer;
3184 [[no_unique_address]]
3185 __detail::__non_propagating_cache<remove_cv_t<_InnerRange>> _M_inner;
3188 join_view()
requires default_initializable<_Vp> = default;
3191 join_view(_Vp __base)
3192 : _M_base(
std::move(__base))
3196 base() const& requires copy_constructible<_Vp>
3206 if constexpr (forward_range<_Vp>)
3208 constexpr bool __use_const
3209 = (__detail::__simple_view<_Vp>
3210 && is_reference_v<range_reference_t<_Vp>>);
3211 return _Iterator<__use_const>{
this, ranges::begin(_M_base)};
3215 _M_outer = ranges::begin(_M_base);
3216 return _Iterator<false>{
this};
3222 requires forward_range<const _Vp>
3223 && is_reference_v<range_reference_t<const _Vp>>
3224 && input_range<range_reference_t<const _Vp>>
3226 return _Iterator<true>{
this, ranges::begin(_M_base)};
3232 if constexpr (forward_range<_Vp> && is_reference_v<_InnerRange>
3233 && forward_range<_InnerRange>
3234 && common_range<_Vp> && common_range<_InnerRange>)
3235 return _Iterator<__detail::__simple_view<_Vp>>{
this,
3236 ranges::end(_M_base)};
3238 return _Sentinel<__detail::__simple_view<_Vp>>{
this};
3243 requires forward_range<const _Vp>
3244 && is_reference_v<range_reference_t<const _Vp>>
3245 && input_range<range_reference_t<const _Vp>>
3247 if constexpr (is_reference_v<range_reference_t<const _Vp>>
3248 && forward_range<range_reference_t<const _Vp>>
3249 && common_range<const _Vp>
3250 && common_range<range_reference_t<const _Vp>>)
3251 return _Iterator<true>{
this, ranges::end(_M_base)};
3253 return _Sentinel<true>{
this};
3257 template<
typename _Range>
3258 explicit join_view(_Range&&) -> join_view<views::all_t<_Range>>;
3264 template<
typename _Range>
3265 concept __can_join_view
3266 =
requires { join_view<all_t<_Range>>{std::declval<_Range>()}; };
3269 struct _Join : __adaptor::_RangeAdaptorClosure<_Join>
3271 template<viewable_range _Range>
3272 requires __detail::__can_join_view<_Range>
3274 operator() [[nodiscard]] (_Range&& __r)
const
3278 return join_view<all_t<_Range>>{std::forward<_Range>(__r)};
3281 static constexpr bool _S_has_simple_call_op =
true;
3284 inline constexpr _Join join;
3290 struct __require_constant;
3292 template<
typename _Range>
3293 concept __tiny_range = sized_range<_Range>
3295 {
typename __require_constant<remove_reference_t<_Range>::size()>; }
3296 && (remove_reference_t<_Range>::size() <= 1);
3298 template<
typename _Base>
3299 struct __lazy_split_view_outer_iter_cat
3302 template<forward_range _Base>
3303 struct __lazy_split_view_outer_iter_cat<_Base>
3304 {
using iterator_category = input_iterator_tag; };
3306 template<
typename _Base>
3307 struct __lazy_split_view_inner_iter_cat
3310 template<forward_range _Base>
3311 struct __lazy_split_view_inner_iter_cat<_Base>
3314 static constexpr auto
3317 using _Cat =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
3318 if constexpr (derived_from<_Cat, forward_iterator_tag>)
3319 return forward_iterator_tag{};
3324 using iterator_category =
decltype(_S_iter_cat());
3328 template<input_range _Vp, forward_range _Pattern>
3329 requires view<_Vp> && view<_Pattern>
3330 && indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
3332 && (forward_range<_Vp> || __detail::__tiny_range<_Pattern>)
3333 class lazy_split_view : public view_interface<lazy_split_view<_Vp, _Pattern>>
3336 template<
bool _Const>
3337 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
3339 template<
bool _Const>
3342 template<
bool _Const>
3344 : __detail::__lazy_split_view_outer_iter_cat<_Base<_Const>>
3347 using _Parent = __detail::__maybe_const_t<_Const, lazy_split_view>;
3348 using _Base = lazy_split_view::_Base<_Const>;
3352 {
return __current() == ranges::end(_M_parent->_M_base) && !_M_trailing_empty; }
3359 __current() noexcept
3361 if constexpr (forward_range<_Vp>)
3364 return *_M_parent->_M_current;
3368 __current() const noexcept
3370 if constexpr (forward_range<_Vp>)
3373 return *_M_parent->_M_current;
3376 _Parent* _M_parent =
nullptr;
3378 [[no_unique_address]]
3379 __detail::__maybe_present_t<forward_range<_Vp>,
3380 iterator_t<_Base>> _M_current;
3381 bool _M_trailing_empty =
false;
3384 using iterator_concept = __conditional_t<forward_range<_Base>,
3385 forward_iterator_tag,
3386 input_iterator_tag>;
3388 using difference_type = range_difference_t<_Base>;
3390 struct value_type : view_interface<value_type>
3393 _OuterIter _M_i = _OuterIter();
3399 value_type(_OuterIter __i)
3406 constexpr _InnerIter<_Const>
3408 {
return _InnerIter<_Const>{_M_i}; }
3410 constexpr default_sentinel_t
3411 end() const noexcept
3415 _OuterIter() =
default;
3418 _OuterIter(_Parent* __parent)
requires (!forward_range<_Base>)
3419 : _M_parent(__parent)
3423 _OuterIter(_Parent* __parent, iterator_t<_Base> __current)
3424 requires forward_range<_Base>
3425 : _M_parent(__parent),
3430 _OuterIter(_OuterIter<!_Const> __i)
3432 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
3433 : _M_parent(__i._M_parent), _M_current(
std::move(__i._M_current)),
3434 _M_trailing_empty(__i._M_trailing_empty)
3437 constexpr value_type
3439 {
return value_type{*
this}; }
3441 constexpr _OuterIter&
3446 const auto __end = ranges::end(_M_parent->_M_base);
3447 if (__current() == __end)
3449 _M_trailing_empty =
false;
3452 const auto [__pbegin, __pend] = subrange{_M_parent->_M_pattern};
3453 if (__pbegin == __pend)
3455 else if constexpr (__detail::__tiny_range<_Pattern>)
3457 __current() = ranges::find(
std::move(__current()), __end,
3459 if (__current() != __end)
3462 if (__current() == __end)
3463 _M_trailing_empty =
true;
3470 = ranges::mismatch(__current(), __end, __pbegin, __pend);
3474 if (__current() == __end)
3475 _M_trailing_empty =
true;
3478 }
while (++__current() != __end);
3482 constexpr decltype(
auto)
3485 if constexpr (forward_range<_Base>)
3495 friend constexpr bool
3496 operator==(
const _OuterIter& __x,
const _OuterIter& __y)
3497 requires forward_range<_Base>
3499 return __x._M_current == __y._M_current
3500 && __x._M_trailing_empty == __y._M_trailing_empty;
3503 friend constexpr bool
3504 operator==(
const _OuterIter& __x, default_sentinel_t)
3505 {
return __x.__at_end(); };
3507 friend _OuterIter<!_Const>;
3508 friend _InnerIter<_Const>;
3511 template<
bool _Const>
3513 : __detail::__lazy_split_view_inner_iter_cat<_Base<_Const>>
3516 using _Base = lazy_split_view::_Base<_Const>;
3521 auto [__pcur, __pend] = subrange{_M_i._M_parent->_M_pattern};
3522 auto __end = ranges::end(_M_i._M_parent->_M_base);
3523 if constexpr (__detail::__tiny_range<_Pattern>)
3525 const auto& __cur = _M_i_current();
3528 if (__pcur == __pend)
3529 return _M_incremented;
3530 return *__cur == *__pcur;
3534 auto __cur = _M_i_current();
3537 if (__pcur == __pend)
3538 return _M_incremented;
3541 if (*__cur != *__pcur)
3543 if (++__pcur == __pend)
3545 }
while (++__cur != __end);
3551 _M_i_current() noexcept
3552 {
return _M_i.__current(); }
3555 _M_i_current() const noexcept
3556 {
return _M_i.__current(); }
3558 _OuterIter<_Const> _M_i = _OuterIter<_Const>();
3559 bool _M_incremented =
false;
3562 using iterator_concept
3563 =
typename _OuterIter<_Const>::iterator_concept;
3565 using value_type = range_value_t<_Base>;
3566 using difference_type = range_difference_t<_Base>;
3568 _InnerIter() =
default;
3571 _InnerIter(_OuterIter<_Const> __i)
3575 constexpr const iterator_t<_Base>&
3576 base() const& noexcept
3577 {
return _M_i_current(); }
3579 constexpr iterator_t<_Base>
3580 base() &&
requires forward_range<_Vp>
3583 constexpr decltype(
auto)
3585 {
return *_M_i_current(); }
3587 constexpr _InnerIter&
3590 _M_incremented =
true;
3591 if constexpr (!forward_range<_Base>)
3592 if constexpr (_Pattern::size() == 0)
3598 constexpr decltype(
auto)
3601 if constexpr (forward_range<_Base>)
3611 friend constexpr bool
3612 operator==(
const _InnerIter& __x,
const _InnerIter& __y)
3613 requires forward_range<_Base>
3614 {
return __x._M_i == __y._M_i; }
3616 friend constexpr bool
3617 operator==(
const _InnerIter& __x, default_sentinel_t)
3618 {
return __x.__at_end(); }
3620 friend constexpr decltype(
auto)
3621 iter_move(
const _InnerIter& __i)
3622 noexcept(
noexcept(ranges::iter_move(__i._M_i_current())))
3623 {
return ranges::iter_move(__i._M_i_current()); }
3625 friend constexpr void
3626 iter_swap(
const _InnerIter& __x,
const _InnerIter& __y)
3627 noexcept(
noexcept(ranges::iter_swap(__x._M_i_current(),
3628 __y._M_i_current())))
3629 requires indirectly_swappable<iterator_t<_Base>>
3630 { ranges::iter_swap(__x._M_i_current(), __y._M_i_current()); }
3633 _Vp _M_base = _Vp();
3634 _Pattern _M_pattern = _Pattern();
3635 [[no_unique_address]]
3636 __detail::__maybe_present_t<!forward_range<_Vp>,
3637 __detail::__non_propagating_cache<iterator_t<_Vp>>> _M_current;
3641 lazy_split_view()
requires (default_initializable<_Vp>
3642 && default_initializable<_Pattern>)
3646 lazy_split_view(_Vp __base, _Pattern __pattern)
3650 template<input_range _Range>
3651 requires constructible_from<_Vp, views::all_t<_Range>>
3652 && constructible_from<_Pattern, single_view<range_value_t<_Range>>>
3654 lazy_split_view(_Range&& __r, range_value_t<_Range> __e)
3655 : _M_base(views::all(
std::
forward<_Range>(__r))),
3656 _M_pattern(views::single(
std::
move(__e)))
3660 base() const& requires copy_constructible<_Vp>
3670 if constexpr (forward_range<_Vp>)
3672 constexpr bool __simple
3673 = __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
3674 return _OuterIter<__simple>{
this, ranges::begin(_M_base)};
3678 _M_current = ranges::begin(_M_base);
3679 return _OuterIter<false>{
this};
3684 begin() const requires forward_range<_Vp> && forward_range<const _Vp>
3686 return _OuterIter<true>{
this, ranges::begin(_M_base)};
3690 end()
requires forward_range<_Vp> && common_range<_Vp>
3692 constexpr bool __simple
3693 = __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
3694 return _OuterIter<__simple>{
this, ranges::end(_M_base)};
3700 if constexpr (forward_range<_Vp>
3701 && forward_range<const _Vp>
3702 && common_range<const _Vp>)
3703 return _OuterIter<true>{
this, ranges::end(_M_base)};
3709 template<
typename _Range,
typename _Pattern>
3710 lazy_split_view(_Range&&, _Pattern&&)
3711 -> lazy_split_view<views::all_t<_Range>, views::all_t<_Pattern>>;
3713 template<input_range _Range>
3714 lazy_split_view(_Range&&, range_value_t<_Range>)
3715 -> lazy_split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
3721 template<
typename _Range,
typename _Pattern>
3722 concept __can_lazy_split_view
3723 =
requires { lazy_split_view(std::declval<_Range>(), std::declval<_Pattern>()); };
3726 struct _LazySplit : __adaptor::_RangeAdaptor<_LazySplit>
3728 template<viewable_range _Range,
typename _Pattern>
3729 requires __detail::__can_lazy_split_view<_Range, _Pattern>
3731 operator() [[nodiscard]] (_Range&& __r, _Pattern&& __f)
const
3733 return lazy_split_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
3736 using _RangeAdaptor<_LazySplit>::operator();
3737 static constexpr int _S_arity = 2;
3742 template<
typename _Pattern>
3743 static constexpr bool _S_has_simple_extra_args
3744 = is_scalar_v<_Pattern> || (view<_Pattern>
3745 && copy_constructible<_Pattern>);
3748 inline constexpr _LazySplit lazy_split;
3751 template<forward_range _Vp, forward_range _Pattern>
3752 requires view<_Vp> && view<_Pattern>
3753 && indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
3755 class split_view :
public view_interface<split_view<_Vp, _Pattern>>
3758 _Vp _M_base = _Vp();
3759 _Pattern _M_pattern = _Pattern();
3760 __detail::__non_propagating_cache<subrange<iterator_t<_Vp>>> _M_cached_begin;
3766 split_view()
requires (default_initializable<_Vp>
3767 && default_initializable<_Pattern>)
3771 split_view(_Vp __base, _Pattern __pattern)
3775 template<forward_range _Range>
3776 requires constructible_from<_Vp, views::all_t<_Range>>
3777 && constructible_from<_Pattern, single_view<range_value_t<_Range>>>
3779 split_view(_Range&& __r, range_value_t<_Range> __e)
3780 : _M_base(views::all(
std::
forward<_Range>(__r))),
3781 _M_pattern(views::single(
std::
move(__e)))
3785 base() const& requires copy_constructible<_Vp>
3795 if (!_M_cached_begin)
3796 _M_cached_begin = _M_find_next(ranges::begin(_M_base));
3797 return {
this, ranges::begin(_M_base), *_M_cached_begin};
3803 if constexpr (common_range<_Vp>)
3804 return _Iterator{
this, ranges::end(_M_base), {}};
3806 return _Sentinel{
this};
3809 constexpr subrange<iterator_t<_Vp>>
3810 _M_find_next(iterator_t<_Vp> __it)
3812 auto [__b, __e] = ranges::search(subrange(__it, ranges::end(_M_base)), _M_pattern);
3813 if (__b != ranges::end(_M_base) && ranges::empty(_M_pattern))
3825 split_view* _M_parent =
nullptr;
3826 iterator_t<_Vp> _M_cur = iterator_t<_Vp>();
3827 subrange<iterator_t<_Vp>> _M_next = subrange<iterator_t<_Vp>>();
3828 bool _M_trailing_empty =
false;
3830 friend struct _Sentinel;
3833 using iterator_concept = forward_iterator_tag;
3834 using iterator_category = input_iterator_tag;
3835 using value_type = subrange<iterator_t<_Vp>>;
3836 using difference_type = range_difference_t<_Vp>;
3838 _Iterator() =
default;
3841 _Iterator(split_view* __parent,
3842 iterator_t<_Vp> __current,
3843 subrange<iterator_t<_Vp>> __next)
3844 : _M_parent(__parent),
3849 constexpr iterator_t<_Vp>
3853 constexpr value_type
3855 {
return {_M_cur, _M_next.begin()}; }
3857 constexpr _Iterator&
3860 _M_cur = _M_next.begin();
3861 if (_M_cur != ranges::end(_M_parent->_M_base))
3863 _M_cur = _M_next.end();
3864 if (_M_cur == ranges::end(_M_parent->_M_base))
3866 _M_trailing_empty =
true;
3867 _M_next = {_M_cur, _M_cur};
3870 _M_next = _M_parent->_M_find_next(_M_cur);
3873 _M_trailing_empty =
false;
3885 friend constexpr bool
3886 operator==(
const _Iterator& __x,
const _Iterator& __y)
3888 return __x._M_cur == __y._M_cur
3889 && __x._M_trailing_empty == __y._M_trailing_empty;
3896 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
3899 _M_equal(
const _Iterator& __x)
const
3900 {
return __x._M_cur == _M_end && !__x._M_trailing_empty; }
3903 _Sentinel() =
default;
3906 _Sentinel(split_view* __parent)
3907 : _M_end(ranges::
end(__parent->_M_base))
3910 friend constexpr bool
3911 operator==(
const _Iterator& __x,
const _Sentinel& __y)
3912 {
return __y._M_equal(__x); }
3916 template<
typename _Range,
typename _Pattern>
3917 split_view(_Range&&, _Pattern&&)
3918 -> split_view<views::all_t<_Range>, views::all_t<_Pattern>>;
3920 template<forward_range _Range>
3921 split_view(_Range&&, range_value_t<_Range>)
3922 -> split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
3928 template<
typename _Range,
typename _Pattern>
3929 concept __can_split_view
3930 =
requires { split_view(std::declval<_Range>(), std::declval<_Pattern>()); };
3933 struct _Split : __adaptor::_RangeAdaptor<_Split>
3935 template<viewable_range _Range,
typename _Pattern>
3936 requires __detail::__can_split_view<_Range, _Pattern>
3938 operator() [[nodiscard]] (_Range&& __r, _Pattern&& __f)
const
3940 return split_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
3943 using _RangeAdaptor<_Split>::operator();
3944 static constexpr int _S_arity = 2;
3945 template<
typename _Pattern>
3946 static constexpr bool _S_has_simple_extra_args
3947 = _LazySplit::_S_has_simple_extra_args<_Pattern>;
3950 inline constexpr _Split split;
3957 template<input_or_output_iterator _Iter>
3959 operator() [[nodiscard]] (_Iter __i, iter_difference_t<_Iter> __n)
const
3961 if constexpr (contiguous_iterator<_Iter>)
3963 else if constexpr (random_access_iterator<_Iter>)
3964 return subrange(__i, __i + __n);
3966 return subrange(counted_iterator(
std::move(__i), __n),
3971 inline constexpr _Counted counted{};
3975 requires (!common_range<_Vp>) && copyable<iterator_t<_Vp>>
3976 class common_view : public view_interface<common_view<_Vp>>
3979 _Vp _M_base = _Vp();
3982 common_view()
requires default_initializable<_Vp> = default;
3985 common_view(_Vp __r)
3986 : _M_base(
std::move(__r))
3990 base() const& requires copy_constructible<_Vp>
4000 begin()
requires (!__detail::__simple_view<_Vp>)
4002 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
4003 return ranges::begin(_M_base);
4005 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
4006 (ranges::begin(_M_base));
4010 begin() const requires range<const _Vp>
4012 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
4013 return ranges::begin(_M_base);
4015 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
4016 (ranges::begin(_M_base));
4020 end()
requires (!__detail::__simple_view<_Vp>)
4022 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
4023 return ranges::begin(_M_base) + ranges::size(_M_base);
4025 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
4026 (ranges::end(_M_base));
4030 end() const requires range<const _Vp>
4032 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
4033 return ranges::begin(_M_base) + ranges::size(_M_base);
4035 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
4036 (ranges::end(_M_base));
4040 size()
requires sized_range<_Vp>
4041 {
return ranges::size(_M_base); }
4044 size() const requires sized_range<const _Vp>
4045 {
return ranges::size(_M_base); }
4048 template<
typename _Range>
4049 common_view(_Range&&) -> common_view<views::all_t<_Range>>;
4051 template<
typename _Tp>
4052 inline constexpr bool enable_borrowed_range<common_view<_Tp>>
4053 = enable_borrowed_range<_Tp>;
4059 template<
typename _Range>
4060 concept __already_common = common_range<_Range>
4061 &&
requires { views::all(std::declval<_Range>()); };
4063 template<
typename _Range>
4064 concept __can_common_view
4065 =
requires { common_view{std::declval<_Range>()}; };
4068 struct _Common : __adaptor::_RangeAdaptorClosure<_Common>
4070 template<viewable_range _Range>
4071 requires __detail::__already_common<_Range>
4072 || __detail::__can_common_view<_Range>
4074 operator() [[nodiscard]] (_Range&& __r)
const
4076 if constexpr (__detail::__already_common<_Range>)
4077 return views::all(std::forward<_Range>(__r));
4079 return common_view{std::forward<_Range>(__r)};
4082 static constexpr bool _S_has_simple_call_op =
true;
4085 inline constexpr _Common common;
4089 requires bidirectional_range<_Vp>
4090 class reverse_view :
public view_interface<reverse_view<_Vp>>
4093 static constexpr bool _S_needs_cached_begin
4094 = !common_range<_Vp> && !(random_access_range<_Vp>
4095 && sized_sentinel_for<sentinel_t<_Vp>,
4098 _Vp _M_base = _Vp();
4099 [[no_unique_address]]
4100 __detail::__maybe_present_t<_S_needs_cached_begin,
4101 __detail::_CachedPosition<_Vp>>
4105 reverse_view()
requires default_initializable<_Vp> = default;
4108 reverse_view(_Vp __r)
4109 : _M_base(
std::move(__r))
4113 base() const& requires copy_constructible<_Vp>
4120 constexpr reverse_iterator<iterator_t<_Vp>>
4123 if constexpr (_S_needs_cached_begin)
4124 if (_M_cached_begin._M_has_value())
4127 auto __it = ranges::next(ranges::begin(_M_base), ranges::end(_M_base));
4128 if constexpr (_S_needs_cached_begin)
4129 _M_cached_begin._M_set(_M_base, __it);
4134 begin()
requires common_range<_Vp>
4138 begin() const requires common_range<const _Vp>
4141 constexpr reverse_iterator<iterator_t<_Vp>>
4146 end() const requires common_range<const _Vp>
4150 size()
requires sized_range<_Vp>
4151 {
return ranges::size(_M_base); }
4154 size() const requires sized_range<const _Vp>
4155 {
return ranges::size(_M_base); }
4158 template<
typename _Range>
4159 reverse_view(_Range&&) -> reverse_view<views::all_t<_Range>>;
4161 template<
typename _Tp>
4162 inline constexpr bool enable_borrowed_range<reverse_view<_Tp>>
4163 = enable_borrowed_range<_Tp>;
4170 inline constexpr bool __is_reversible_subrange =
false;
4172 template<
typename _Iter, subrange_kind _Kind>
4173 inline constexpr bool
4174 __is_reversible_subrange<subrange<reverse_iterator<_Iter>,
4175 reverse_iterator<_Iter>,
4179 inline constexpr bool __is_reverse_view =
false;
4181 template<
typename _Vp>
4182 inline constexpr bool __is_reverse_view<reverse_view<_Vp>> =
true;
4184 template<
typename _Range>
4185 concept __can_reverse_view
4186 =
requires { reverse_view{std::declval<_Range>()}; };
4189 struct _Reverse : __adaptor::_RangeAdaptorClosure<_Reverse>
4191 template<viewable_range _Range>
4192 requires __detail::__is_reverse_view<remove_cvref_t<_Range>>
4193 || __detail::__is_reversible_subrange<remove_cvref_t<_Range>>
4194 || __detail::__can_reverse_view<_Range>
4196 operator() [[nodiscard]] (_Range&& __r)
const
4198 using _Tp = remove_cvref_t<_Range>;
4199 if constexpr (__detail::__is_reverse_view<_Tp>)
4200 return std::forward<_Range>(__r).base();
4201 else if constexpr (__detail::__is_reversible_subrange<_Tp>)
4203 using _Iter =
decltype(ranges::begin(__r).base());
4204 if constexpr (sized_range<_Tp>)
4205 return subrange<_Iter, _Iter, subrange_kind::sized>
4206 {__r.end().base(), __r.begin().base(), __r.size()};
4208 return subrange<_Iter, _Iter, subrange_kind::unsized>
4209 {__r.end().base(), __r.begin().base()};
4212 return reverse_view{std::forward<_Range>(__r)};
4215 static constexpr bool _S_has_simple_call_op =
true;
4218 inline constexpr _Reverse reverse;
4223#if __cpp_lib_tuple_like
4224 template<
typename _Tp,
size_t _Nm>
4225 concept __has_tuple_element = __tuple_like<_Tp> && _Nm < tuple_size_v<_Tp>;
4227 template<
typename _Tp,
size_t _Nm>
4228 concept __has_tuple_element =
requires(_Tp __t)
4230 typename tuple_size<_Tp>::type;
4231 requires _Nm < tuple_size_v<_Tp>;
4232 typename tuple_element_t<_Nm, _Tp>;
4233 { std::get<_Nm>(__t) }
4234 -> convertible_to<const tuple_element_t<_Nm, _Tp>&>;
4238 template<
typename _Tp,
size_t _Nm>
4239 concept __returnable_element
4240 = is_reference_v<_Tp> || move_constructible<tuple_element_t<_Nm, _Tp>>;
4243 template<input_range _Vp,
size_t _Nm>
4245 && __detail::__has_tuple_element<range_value_t<_Vp>, _Nm>
4246 && __detail::__has_tuple_element<remove_reference_t<range_reference_t<_Vp>>,
4248 && __detail::__returnable_element<range_reference_t<_Vp>, _Nm>
4249 class elements_view :
public view_interface<elements_view<_Vp, _Nm>>
4252 elements_view()
requires default_initializable<_Vp> = default;
4255 elements_view(_Vp __base)
4256 : _M_base(
std::move(__base))
4260 base() const& requires copy_constructible<_Vp>
4268 begin()
requires (!__detail::__simple_view<_Vp>)
4269 {
return _Iterator<false>(ranges::begin(_M_base)); }
4272 begin() const requires range<const _Vp>
4273 {
return _Iterator<true>(ranges::begin(_M_base)); }
4276 end()
requires (!__detail::__simple_view<_Vp> && !common_range<_Vp>)
4277 {
return _Sentinel<false>{ranges::end(_M_base)}; }
4280 end()
requires (!__detail::__simple_view<_Vp> && common_range<_Vp>)
4281 {
return _Iterator<false>{ranges::end(_M_base)}; }
4284 end() const requires range<const _Vp>
4285 {
return _Sentinel<true>{ranges::end(_M_base)}; }
4288 end() const requires common_range<const _Vp>
4289 {
return _Iterator<true>{ranges::end(_M_base)}; }
4292 size()
requires sized_range<_Vp>
4293 {
return ranges::size(_M_base); }
4296 size() const requires sized_range<const _Vp>
4297 {
return ranges::size(_M_base); }
4300 template<
bool _Const>
4301 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
4303 template<
bool _Const>
4307 template<
bool _Const>
4308 requires forward_range<_Base<_Const>>
4309 struct __iter_cat<_Const>
4312 static auto _S_iter_cat()
4314 using _Base = elements_view::_Base<_Const>;
4315 using _Cat =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
4316 using _Res =
decltype((std::get<_Nm>(*
std::declval<iterator_t<_Base>>())));
4317 if constexpr (!is_lvalue_reference_v<_Res>)
4318 return input_iterator_tag{};
4319 else if constexpr (derived_from<_Cat, random_access_iterator_tag>)
4320 return random_access_iterator_tag{};
4325 using iterator_category =
decltype(_S_iter_cat());
4328 template<
bool _Const>
4331 template<
bool _Const>
4332 struct _Iterator : __iter_cat<_Const>
4335 using _Base = elements_view::_Base<_Const>;
4337 iterator_t<_Base> _M_current = iterator_t<_Base>();
4339 static constexpr decltype(
auto)
4340 _S_get_element(
const iterator_t<_Base>& __i)
4342 if constexpr (is_reference_v<range_reference_t<_Base>>)
4343 return std::get<_Nm>(*__i);
4346 using _Et = remove_cv_t<tuple_element_t<_Nm, range_reference_t<_Base>>>;
4347 return static_cast<_Et
>(std::get<_Nm>(*__i));
4354 if constexpr (random_access_range<_Base>)
4355 return random_access_iterator_tag{};
4356 else if constexpr (bidirectional_range<_Base>)
4357 return bidirectional_iterator_tag{};
4358 else if constexpr (forward_range<_Base>)
4359 return forward_iterator_tag{};
4361 return input_iterator_tag{};
4364 friend _Iterator<!_Const>;
4367 using iterator_concept =
decltype(_S_iter_concept());
4370 = remove_cvref_t<tuple_element_t<_Nm, range_value_t<_Base>>>;
4371 using difference_type = range_difference_t<_Base>;
4373 _Iterator()
requires default_initializable<iterator_t<_Base>> = default;
4376 _Iterator(iterator_t<_Base> __current)
4377 : _M_current(
std::move(__current))
4381 _Iterator(_Iterator<!_Const> __i)
4382 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
4386 constexpr const iterator_t<_Base>&
4387 base() const& noexcept
4388 {
return _M_current; }
4390 constexpr iterator_t<_Base>
4394 constexpr decltype(
auto)
4396 {
return _S_get_element(_M_current); }
4398 constexpr _Iterator&
4410 operator++(
int)
requires forward_range<_Base>
4417 constexpr _Iterator&
4418 operator--()
requires bidirectional_range<_Base>
4425 operator--(
int)
requires bidirectional_range<_Base>
4432 constexpr _Iterator&
4433 operator+=(difference_type __n)
4434 requires random_access_range<_Base>
4440 constexpr _Iterator&
4441 operator-=(difference_type __n)
4442 requires random_access_range<_Base>
4448 constexpr decltype(
auto)
4449 operator[](difference_type __n)
const
4450 requires random_access_range<_Base>
4451 {
return _S_get_element(_M_current + __n); }
4453 friend constexpr bool
4454 operator==(
const _Iterator& __x,
const _Iterator& __y)
4455 requires equality_comparable<iterator_t<_Base>>
4456 {
return __x._M_current == __y._M_current; }
4458 friend constexpr bool
4459 operator<(
const _Iterator& __x,
const _Iterator& __y)
4460 requires random_access_range<_Base>
4461 {
return __x._M_current < __y._M_current; }
4463 friend constexpr bool
4464 operator>(
const _Iterator& __x,
const _Iterator& __y)
4465 requires random_access_range<_Base>
4466 {
return __y._M_current < __x._M_current; }
4468 friend constexpr bool
4469 operator<=(
const _Iterator& __x,
const _Iterator& __y)
4470 requires random_access_range<_Base>
4471 {
return !(__y._M_current > __x._M_current); }
4473 friend constexpr bool
4474 operator>=(
const _Iterator& __x,
const _Iterator& __y)
4475 requires random_access_range<_Base>
4476 {
return !(__x._M_current > __y._M_current); }
4478#ifdef __cpp_lib_three_way_comparison
4479 friend constexpr auto
4480 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
4481 requires random_access_range<_Base>
4482 && three_way_comparable<iterator_t<_Base>>
4483 {
return __x._M_current <=> __y._M_current; }
4486 friend constexpr _Iterator
4487 operator+(
const _Iterator& __x, difference_type __y)
4488 requires random_access_range<_Base>
4489 {
return _Iterator{__x} += __y; }
4491 friend constexpr _Iterator
4492 operator+(difference_type __x,
const _Iterator& __y)
4493 requires random_access_range<_Base>
4494 {
return __y + __x; }
4496 friend constexpr _Iterator
4497 operator-(
const _Iterator& __x, difference_type __y)
4498 requires random_access_range<_Base>
4499 {
return _Iterator{__x} -= __y; }
4503 friend constexpr difference_type
4504 operator-(
const _Iterator& __x,
const _Iterator& __y)
4505 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
4506 {
return __x._M_current - __y._M_current; }
4508 template <
bool>
friend struct _Sentinel;
4511 template<
bool _Const>
4515 template<
bool _Const2>
4517 _M_equal(
const _Iterator<_Const2>& __x)
const
4518 {
return __x._M_current == _M_end; }
4520 template<
bool _Const2>
4522 _M_distance_from(
const _Iterator<_Const2>& __i)
const
4523 {
return _M_end - __i._M_current; }
4525 using _Base = elements_view::_Base<_Const>;
4526 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
4529 _Sentinel() =
default;
4532 _Sentinel(sentinel_t<_Base> __end)
4537 _Sentinel(_Sentinel<!_Const> __other)
4539 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
4543 constexpr sentinel_t<_Base>
4547 template<
bool _Const2>
4548 requires sentinel_for<sentinel_t<_Base>,
4549 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
4550 friend constexpr bool
4551 operator==(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
4552 {
return __y._M_equal(__x); }
4554 template<
bool _Const2,
4555 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
4556 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
4557 friend constexpr range_difference_t<_Base2>
4558 operator-(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
4559 {
return -__y._M_distance_from(__x); }
4561 template<
bool _Const2,
4562 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
4563 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
4564 friend constexpr range_difference_t<_Base2>
4565 operator-(
const _Sentinel& __x,
const _Iterator<_Const2>& __y)
4566 {
return __x._M_distance_from(__y); }
4568 friend _Sentinel<!_Const>;
4571 _Vp _M_base = _Vp();
4574 template<
typename _Tp,
size_t _Nm>
4575 inline constexpr bool enable_borrowed_range<elements_view<_Tp, _Nm>>
4576 = enable_borrowed_range<_Tp>;
4580 template<
typename _Range>
4581 using keys_view = elements_view<_Range, 0>;
4583 template<
typename _Range>
4584 using values_view = elements_view<_Range, 1>;
4590 template<
size_t _Nm,
typename _Range>
4591 concept __can_elements_view
4592 =
requires { elements_view<all_t<_Range>, _Nm>{std::declval<_Range>()}; };
4595 template<
size_t _Nm>
4596 struct _Elements : __adaptor::_RangeAdaptorClosure<_Elements<_Nm>>
4598 template<viewable_range _Range>
4599 requires __detail::__can_elements_view<_Nm, _Range>
4601 operator() [[nodiscard]] (_Range&& __r)
const
4603 return elements_view<all_t<_Range>, _Nm>{std::forward<_Range>(__r)};
4606 static constexpr bool _S_has_simple_call_op =
true;
4609 template<
size_t _Nm>
4610 inline constexpr _Elements<_Nm> elements;
4611 inline constexpr auto keys = elements<0>;
4612 inline constexpr auto values = elements<1>;
4615#ifdef __cpp_lib_ranges_zip
4618 template<
typename... _Rs>
4619 concept __zip_is_common = (
sizeof...(_Rs) == 1 && (common_range<_Rs> && ...))
4620 || (!(bidirectional_range<_Rs> && ...) && (common_range<_Rs> && ...))
4621 || ((random_access_range<_Rs> && ...) && (sized_range<_Rs> && ...));
4623 template<
typename _Fp,
typename _Tuple>
4625 __tuple_transform(_Fp&& __f, _Tuple&& __tuple)
4627 return std::apply([&]<
typename... _Ts>(_Ts&&... __elts) {
4628 return tuple<invoke_result_t<_Fp&, _Ts>...>
4630 }, std::forward<_Tuple>(__tuple));
4633 template<
typename _Fp,
typename _Tuple>
4635 __tuple_for_each(_Fp&& __f, _Tuple&& __tuple)
4637 std::apply([&]<
typename... _Ts>(_Ts&&... __elts) {
4639 }, std::forward<_Tuple>(__tuple));
4643 template<input_range... _Vs>
4644 requires (view<_Vs> && ...) && (
sizeof...(_Vs) > 0)
4645 class zip_view :
public view_interface<zip_view<_Vs...>>
4647 tuple<_Vs...> _M_views;
4649 template<
bool>
class _Iterator;
4650 template<
bool>
class _Sentinel;
4653 zip_view() =
default;
4656 zip_view(_Vs... __views)
4657 : _M_views(
std::
move(__views)...)
4661 begin()
requires (!(__detail::__simple_view<_Vs> && ...))
4662 {
return _Iterator<false>(__detail::__tuple_transform(ranges::begin, _M_views)); }
4665 begin() const requires (range<const _Vs> && ...)
4666 {
return _Iterator<true>(__detail::__tuple_transform(ranges::begin, _M_views)); }
4669 end()
requires (!(__detail::__simple_view<_Vs> && ...))
4671 if constexpr (!__detail::__zip_is_common<_Vs...>)
4672 return _Sentinel<false>(__detail::__tuple_transform(ranges::end, _M_views));
4673 else if constexpr ((random_access_range<_Vs> && ...))
4674 return begin() + iter_difference_t<_Iterator<false>>(
size());
4676 return _Iterator<false>(__detail::__tuple_transform(ranges::end, _M_views));
4680 end() const requires (range<const _Vs> && ...)
4682 if constexpr (!__detail::__zip_is_common<
const _Vs...>)
4683 return _Sentinel<true>(__detail::__tuple_transform(ranges::end, _M_views));
4684 else if constexpr ((random_access_range<const _Vs> && ...))
4685 return begin() + iter_difference_t<_Iterator<true>>(
size());
4687 return _Iterator<true>(__detail::__tuple_transform(ranges::end, _M_views));
4691 size()
requires (sized_range<_Vs> && ...)
4693 return std::apply([](
auto... sizes) {
4694 using _CT = __detail::__make_unsigned_like_t<
common_type_t<
decltype(sizes)...>>;
4695 return ranges::min({_CT(sizes)...});
4696 }, __detail::__tuple_transform(ranges::size, _M_views));
4700 size() const requires (sized_range<const _Vs> && ...)
4702 return std::apply([](
auto... sizes) {
4703 using _CT = __detail::__make_unsigned_like_t<
common_type_t<
decltype(sizes)...>>;
4704 return ranges::min({_CT(sizes)...});
4705 }, __detail::__tuple_transform(ranges::size, _M_views));
4709 template<
typename... _Rs>
4710 zip_view(_Rs&&...) -> zip_view<views::all_t<_Rs>...>;
4712 template<
typename... _Views>
4713 inline constexpr bool enable_borrowed_range<zip_view<_Views...>>
4714 = (enable_borrowed_range<_Views> && ...);
4718 template<
bool _Const,
typename... _Vs>
4719 concept __all_random_access
4720 = (random_access_range<__maybe_const_t<_Const, _Vs>> && ...);
4722 template<
bool _Const,
typename... _Vs>
4723 concept __all_bidirectional
4724 = (bidirectional_range<__maybe_const_t<_Const, _Vs>> && ...);
4726 template<
bool _Const,
typename... _Vs>
4727 concept __all_forward
4728 = (forward_range<__maybe_const_t<_Const, _Vs>> && ...);
4730 template<
bool _Const,
typename... _Views>
4731 struct __zip_view_iter_cat
4734 template<
bool _Const,
typename... _Views>
4735 requires __all_forward<_Const, _Views...>
4736 struct __zip_view_iter_cat<_Const, _Views...>
4737 {
using iterator_category = input_iterator_tag; };
4740 template<input_range... _Vs>
4741 requires (view<_Vs> && ...) && (
sizeof...(_Vs) > 0)
4742 template<
bool _Const>
4743 class zip_view<_Vs...>::_Iterator
4744 :
public __detail::__zip_view_iter_cat<_Const, _Vs...>
4746#ifdef _GLIBCXX_CLANG
4749 tuple<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>...> _M_current;
4752 _Iterator(
decltype(_M_current) __current)
4753 : _M_current(
std::
move(__current))
4759 if constexpr (__detail::__all_random_access<_Const, _Vs...>)
4760 return random_access_iterator_tag{};
4761 else if constexpr (__detail::__all_bidirectional<_Const, _Vs...>)
4762 return bidirectional_iterator_tag{};
4763 else if constexpr (__detail::__all_forward<_Const, _Vs...>)
4764 return forward_iterator_tag{};
4766 return input_iterator_tag{};
4769#ifndef _GLIBCXX_CLANG
4770 template<move_constructible _Fp, input_range... _Ws>
4771 requires (view<_Ws> && ...) && (
sizeof...(_Ws) > 0) && is_object_v<_Fp>
4772 && regular_invocable<_Fp&, range_reference_t<_Ws>...>
4773 && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Ws>...>>
4774 friend class zip_transform_view;
4779 using iterator_concept =
decltype(_S_iter_concept());
4781 = tuple<range_value_t<__detail::__maybe_const_t<_Const, _Vs>>...>;
4782 using difference_type
4783 = common_type_t<range_difference_t<__detail::__maybe_const_t<_Const, _Vs>>...>;
4785 _Iterator() =
default;
4788 _Iterator(_Iterator<!_Const> __i)
4790 && (convertible_to<iterator_t<_Vs>,
4791 iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4792 : _M_current(
std::
move(__i._M_current))
4798 auto __f = [](
auto& __i) ->
decltype(
auto) {
4801 return __detail::__tuple_transform(__f, _M_current);
4804 constexpr _Iterator&
4807 __detail::__tuple_for_each([](
auto& __i) { ++__i; }, _M_current);
4817 requires __detail::__all_forward<_Const, _Vs...>
4824 constexpr _Iterator&
4826 requires __detail::__all_bidirectional<_Const, _Vs...>
4828 __detail::__tuple_for_each([](
auto& __i) { --__i; }, _M_current);
4834 requires __detail::__all_bidirectional<_Const, _Vs...>
4841 constexpr _Iterator&
4842 operator+=(difference_type __x)
4843 requires __detail::__all_random_access<_Const, _Vs...>
4845 auto __f = [&]<
typename _It>(_It& __i) {
4846 __i += iter_difference_t<_It>(__x);
4848 __detail::__tuple_for_each(__f, _M_current);
4852 constexpr _Iterator&
4853 operator-=(difference_type __x)
4854 requires __detail::__all_random_access<_Const, _Vs...>
4856 auto __f = [&]<
typename _It>(_It& __i) {
4857 __i -= iter_difference_t<_It>(__x);
4859 __detail::__tuple_for_each(__f, _M_current);
4864 operator[](difference_type __n)
const
4865 requires __detail::__all_random_access<_Const, _Vs...>
4867 auto __f = [&]<
typename _It>(_It& __i) ->
decltype(
auto) {
4868 return __i[iter_difference_t<_It>(__n)];
4870 return __detail::__tuple_transform(__f, _M_current);
4873 friend constexpr bool
4874 operator==(
const _Iterator& __x,
const _Iterator& __y)
4875 requires (equality_comparable<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4877 if constexpr (__detail::__all_bidirectional<_Const, _Vs...>)
4878 return __x._M_current == __y._M_current;
4881 return ((std::get<_Is>(__x._M_current) == std::get<_Is>(__y._M_current)) || ...);
4885 friend constexpr auto
4886 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
4887 requires __detail::__all_random_access<_Const, _Vs...>
4888 {
return __x._M_current <=> __y._M_current; }
4890 friend constexpr _Iterator
4891 operator+(
const _Iterator& __i, difference_type __n)
4892 requires __detail::__all_random_access<_Const, _Vs...>
4899 friend constexpr _Iterator
4900 operator+(difference_type __n,
const _Iterator& __i)
4901 requires __detail::__all_random_access<_Const, _Vs...>
4908 friend constexpr _Iterator
4909 operator-(
const _Iterator& __i, difference_type __n)
4910 requires __detail::__all_random_access<_Const, _Vs...>
4917 friend constexpr difference_type
4918 operator-(
const _Iterator& __x,
const _Iterator& __y)
4919 requires (sized_sentinel_for<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>,
4920 iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4923 return ranges::min({difference_type(std::get<_Is>(__x._M_current)
4924 - std::get<_Is>(__y._M_current))...},
4926 [](difference_type __i) {
4927 return __detail::__to_unsigned_like(__i < 0 ? -__i : __i);
4932 friend constexpr auto
4933 iter_move(
const _Iterator& __i)
4934 {
return __detail::__tuple_transform(ranges::iter_move, __i._M_current); }
4936 friend constexpr void
4937 iter_swap(
const _Iterator& __l,
const _Iterator& __r)
4938 requires (indirectly_swappable<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4941 (ranges::iter_swap(std::get<_Is>(__l._M_current), std::get<_Is>(__r._M_current)), ...);
4945 friend class zip_view;
4948 template<input_range... _Vs>
4949 requires (view<_Vs> && ...) && (
sizeof...(_Vs) > 0)
4950 template<
bool _Const>
4951 class zip_view<_Vs...>::_Sentinel
4953 tuple<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>...> _M_end;
4956 _Sentinel(
decltype(_M_end) __end)
4960 friend class zip_view;
4963 _Sentinel() =
default;
4966 _Sentinel(_Sentinel<!_Const> __i)
4968 && (convertible_to<sentinel_t<_Vs>,
4969 sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4970 : _M_end(
std::
move(__i._M_end))
4973 template<
bool _OtherConst>
4974 requires (sentinel_for<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>,
4975 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vs>>> && ...)
4976 friend constexpr bool
4977 operator==(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
4980 return ((std::get<_Is>(__x._M_current) == std::get<_Is>(__y._M_end)) || ...);
4984 template<
bool _OtherConst>
4985 requires (sized_sentinel_for<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>,
4986 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vs>>> && ...)
4987 friend constexpr auto
4988 operator-(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
4991 = common_type_t<range_difference_t<__detail::__maybe_const_t<_OtherConst, _Vs>>...>;
4993 return ranges::min({_Ret(std::get<_Is>(__x._M_current) - std::get<_Is>(__y._M_end))...},
4996 return __detail::__to_unsigned_like(__i < 0 ? -__i : __i);
5001 template<
bool _OtherConst>
5002 requires (sized_sentinel_for<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>,
5003 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vs>>> && ...)
5004 friend constexpr auto
5005 operator-(
const _Sentinel& __y,
const _Iterator<_OtherConst>& __x)
5006 {
return -(__x - __y); }
5013 template<
typename... _Ts>
5014 concept __can_zip_view
5015 =
requires { zip_view<all_t<_Ts>...>(std::declval<_Ts>()...); };
5020 template<
typename... _Ts>
5021 requires (
sizeof...(_Ts) == 0 || __detail::__can_zip_view<_Ts...>)
5023 operator() [[nodiscard]] (_Ts&&... __ts)
const
5025 if constexpr (
sizeof...(_Ts) == 0)
5026 return views::empty<tuple<>>;
5028 return zip_view<all_t<_Ts>...>(std::forward<_Ts>(__ts)...);
5032 inline constexpr _Zip zip;
5037 template<
typename _Range,
bool _Const>
5038 using __range_iter_cat
5039 =
typename iterator_traits<iterator_t<__maybe_const_t<_Const, _Range>>>::iterator_category;
5042 template<move_constructible _Fp, input_range... _Vs>
5043 requires (view<_Vs> && ...) && (
sizeof...(_Vs) > 0) && is_object_v<_Fp>
5044 && regular_invocable<_Fp&, range_reference_t<_Vs>...>
5045 && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Vs>...>>
5046 class zip_transform_view :
public view_interface<zip_transform_view<_Fp, _Vs...>>
5048 [[no_unique_address]] __detail::__box<_Fp> _M_fun;
5049 zip_view<_Vs...> _M_zip;
5051 using _InnerView = zip_view<_Vs...>;
5053 template<
bool _Const>
5054 using __ziperator = iterator_t<__detail::__maybe_const_t<_Const, _InnerView>>;
5056 template<
bool _Const>
5057 using __zentinel = sentinel_t<__detail::__maybe_const_t<_Const, _InnerView>>;
5059 template<
bool _Const>
5060 using _Base = __detail::__maybe_const_t<_Const, _InnerView>;
5062 template<
bool _Const>
5066 template<
bool _Const>
5067 requires forward_range<_Base<_Const>>
5068 struct __iter_cat<_Const>
5074 using __detail::__maybe_const_t;
5075 using __detail::__range_iter_cat;
5076 using _Res = invoke_result_t<__maybe_const_t<_Const, _Fp>&,
5077 range_reference_t<__maybe_const_t<_Const, _Vs>>...>;
5080 if constexpr (!is_reference_v<_Res>)
5081 return input_iterator_tag{};
5082 else if constexpr ((derived_from<__range_iter_cat<_Vs, _Const>,
5083 random_access_iterator_tag> && ...))
5084 return random_access_iterator_tag{};
5085 else if constexpr ((derived_from<__range_iter_cat<_Vs, _Const>,
5086 bidirectional_iterator_tag> && ...))
5087 return bidirectional_iterator_tag{};
5088 else if constexpr ((derived_from<__range_iter_cat<_Vs, _Const>,
5089 forward_iterator_tag> && ...))
5090 return forward_iterator_tag{};
5092 return input_iterator_tag{};
5095 using iterator_category =
decltype(_S_iter_cat());
5098 template<
bool>
class _Iterator;
5099 template<
bool>
class _Sentinel;
5102 zip_transform_view() =
default;
5105 zip_transform_view(_Fp __fun, _Vs... __views)
5111 {
return _Iterator<false>(*
this, _M_zip.begin()); }
5115 requires range<const _InnerView>
5116 && regular_invocable<const _Fp&, range_reference_t<const _Vs>...>
5117 {
return _Iterator<true>(*
this, _M_zip.begin()); }
5122 if constexpr (common_range<_InnerView>)
5123 return _Iterator<false>(*
this, _M_zip.end());
5125 return _Sentinel<false>(_M_zip.end());
5130 requires range<const _InnerView>
5131 && regular_invocable<const _Fp&, range_reference_t<const _Vs>...>
5133 if constexpr (common_range<const _InnerView>)
5134 return _Iterator<true>(*
this, _M_zip.end());
5136 return _Sentinel<true>(_M_zip.end());
5140 size()
requires sized_range<_InnerView>
5141 {
return _M_zip.size(); }
5144 size() const requires sized_range<const _InnerView>
5145 {
return _M_zip.size(); }
5148 template<
class _Fp,
class... Rs>
5149 zip_transform_view(_Fp, Rs&&...) -> zip_transform_view<_Fp, views::all_t<Rs>...>;
5151 template<move_constructible _Fp, input_range... _Vs>
5152 requires (view<_Vs> && ...) && (
sizeof...(_Vs) > 0) && is_object_v<_Fp>
5153 && regular_invocable<_Fp&, range_reference_t<_Vs>...>
5154 && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Vs>...>>
5155 template<
bool _Const>
5156 class zip_transform_view<_Fp, _Vs...>::_Iterator :
public __iter_cat<_Const>
5158 using _Parent = __detail::__maybe_const_t<_Const, zip_transform_view>;
5160 _Parent* _M_parent =
nullptr;
5161 __ziperator<_Const> _M_inner;
5164 _Iterator(_Parent& __parent, __ziperator<_Const> __inner)
5168 friend class zip_transform_view;
5172 using iterator_concept =
typename __ziperator<_Const>::iterator_concept;
5174 = remove_cvref_t<invoke_result_t<__detail::__maybe_const_t<_Const, _Fp>&,
5175 range_reference_t<__detail::__maybe_const_t<_Const, _Vs>>...>>;
5176 using difference_type = range_difference_t<_Base<_Const>>;
5178 _Iterator() =
default;
5181 _Iterator(_Iterator<!_Const> __i)
5182 requires _Const && convertible_to<__ziperator<false>, __ziperator<_Const>>
5183 : _M_parent(__i._M_parent), _M_inner(
std::move(__i._M_inner))
5186 constexpr decltype(
auto)
5189 return std::apply([&](
const auto&... __iters) ->
decltype(
auto) {
5191 }, _M_inner._M_current);
5194 constexpr _Iterator&
5206 operator++(
int)
requires forward_range<_Base<_Const>>
5213 constexpr _Iterator&
5214 operator--()
requires bidirectional_range<_Base<_Const>>
5221 operator--(
int)
requires bidirectional_range<_Base<_Const>>
5228 constexpr _Iterator&
5229 operator+=(difference_type __x)
requires random_access_range<_Base<_Const>>
5235 constexpr _Iterator&
5236 operator-=(difference_type __x)
requires random_access_range<_Base<_Const>>
5242 constexpr decltype(
auto)
5243 operator[](difference_type __n)
const requires random_access_range<_Base<_Const>>
5245 return std::apply([&]<
typename... _Is>(
const _Is&... __iters) ->
decltype(
auto) {
5246 return std::__invoke(*_M_parent->_M_fun, __iters[iter_difference_t<_Is>(__n)]...);
5247 }, _M_inner._M_current);
5250 friend constexpr bool
5251 operator==(
const _Iterator& __x,
const _Iterator& __y)
5252 requires equality_comparable<__ziperator<_Const>>
5253 {
return __x._M_inner == __y._M_inner; }
5255 friend constexpr auto
5256 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
5257 requires random_access_range<_Base<_Const>>
5258 {
return __x._M_inner <=> __y._M_inner; }
5260 friend constexpr _Iterator
5261 operator+(
const _Iterator& __i, difference_type __n)
5262 requires random_access_range<_Base<_Const>>
5263 {
return _Iterator(*__i._M_parent, __i._M_inner + __n); }
5265 friend constexpr _Iterator
5266 operator+(difference_type __n,
const _Iterator& __i)
5267 requires random_access_range<_Base<_Const>>
5268 {
return _Iterator(*__i._M_parent, __i._M_inner + __n); }
5270 friend constexpr _Iterator
5271 operator-(
const _Iterator& __i, difference_type __n)
5272 requires random_access_range<_Base<_Const>>
5273 {
return _Iterator(*__i._M_parent, __i._M_inner - __n); }
5275 friend constexpr difference_type
5276 operator-(
const _Iterator& __x,
const _Iterator& __y)
5277 requires sized_sentinel_for<__ziperator<_Const>, __ziperator<_Const>>
5278 {
return __x._M_inner - __y._M_inner; }
5281 template<move_constructible _Fp, input_range... _Vs>
5282 requires (view<_Vs> && ...) && (
sizeof...(_Vs) > 0) && is_object_v<_Fp>
5283 && regular_invocable<_Fp&, range_reference_t<_Vs>...>
5284 && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Vs>...>>
5285 template<
bool _Const>
5286 class zip_transform_view<_Fp, _Vs...>::_Sentinel
5288 __zentinel<_Const> _M_inner;
5291 _Sentinel(__zentinel<_Const> __inner)
5295 friend class zip_transform_view;
5298 _Sentinel() =
default;
5301 _Sentinel(_Sentinel<!_Const> __i)
5302 requires _Const && convertible_to<__zentinel<false>, __zentinel<_Const>>
5306 template<
bool _OtherConst>
5307 requires sentinel_for<__zentinel<_Const>, __ziperator<_OtherConst>>
5308 friend constexpr bool
5309 operator==(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
5310 {
return __x._M_inner == __y._M_inner; }
5312 template<
bool _OtherConst>
5313 requires sized_sentinel_for<__zentinel<_Const>, __ziperator<_OtherConst>>
5314 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
5315 operator-(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
5316 {
return __x._M_inner - __y._M_inner; }
5318 template<
bool _OtherConst>
5319 requires sized_sentinel_for<__zentinel<_Const>, __ziperator<_OtherConst>>
5320 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
5321 operator-(
const _Sentinel& __x,
const _Iterator<_OtherConst>& __y)
5322 {
return __x._M_inner - __y._M_inner; }
5329 template<
typename _Fp,
typename... _Ts>
5330 concept __can_zip_transform_view
5331 =
requires { zip_transform_view(std::declval<_Fp>(), std::declval<_Ts>()...); };
5334 struct _ZipTransform
5336 template<
typename _Fp,
typename... _Ts>
5337 requires (
sizeof...(_Ts) == 0) || __detail::__can_zip_transform_view<_Fp, _Ts...>
5339 operator() [[nodiscard]] (_Fp&& __f, _Ts&&... __ts)
const
5341 if constexpr (
sizeof...(_Ts) == 0)
5342 return views::empty<decay_t<invoke_result_t<decay_t<_Fp>&>>>;
5344 return zip_transform_view(std::forward<_Fp>(__f), std::forward<_Ts>(__ts)...);
5348 inline constexpr _ZipTransform zip_transform;
5351 template<forward_range _Vp,
size_t _Nm>
5352 requires view<_Vp> && (_Nm > 0)
5353 class adjacent_view : public view_interface<adjacent_view<_Vp, _Nm>>
5355 _Vp _M_base = _Vp();
5357 template<
bool>
class _Iterator;
5358 template<
bool>
class _Sentinel;
5360 struct __as_sentinel
5364 adjacent_view()
requires default_initializable<_Vp> = default;
5367 adjacent_view(_Vp __base)
5368 : _M_base(
std::move(__base))
5374 base() const & requires copy_constructible<_Vp>
5382 begin()
requires (!__detail::__simple_view<_Vp>)
5383 {
return _Iterator<false>(ranges::begin(_M_base), ranges::end(_M_base)); }
5386 begin() const requires range<const _Vp>
5387 {
return _Iterator<true>(ranges::begin(_M_base), ranges::end(_M_base)); }
5390 end()
requires (!__detail::__simple_view<_Vp>)
5392 if constexpr (common_range<_Vp>)
5393 return _Iterator<false>(__as_sentinel{}, ranges::begin(_M_base), ranges::end(_M_base));
5395 return _Sentinel<false>(ranges::end(_M_base));
5399 end() const requires range<const _Vp>
5401 if constexpr (common_range<const _Vp>)
5402 return _Iterator<true>(__as_sentinel{}, ranges::begin(_M_base), ranges::end(_M_base));
5404 return _Sentinel<true>(ranges::end(_M_base));
5408 size()
requires sized_range<_Vp>
5410 using _ST =
decltype(ranges::size(_M_base));
5411 using _CT = common_type_t<_ST, size_t>;
5412 auto __sz =
static_cast<_CT
>(ranges::size(_M_base));
5413 __sz -= std::min<_CT>(__sz, _Nm - 1);
5414 return static_cast<_ST
>(__sz);
5418 size() const requires sized_range<const _Vp>
5420 using _ST =
decltype(ranges::size(_M_base));
5421 using _CT = common_type_t<_ST, size_t>;
5422 auto __sz =
static_cast<_CT
>(ranges::size(_M_base));
5423 __sz -= std::min<_CT>(__sz, _Nm - 1);
5424 return static_cast<_ST
>(__sz);
5428 template<
typename _Vp,
size_t _Nm>
5429 inline constexpr bool enable_borrowed_range<adjacent_view<_Vp, _Nm>>
5430 = enable_borrowed_range<_Vp>;
5435 template<
typename _Tp,
size_t _Nm>
5440 template<
typename _Fp,
size_t _Nm>
5443 template<
typename... _Ts>
5444 static invoke_result_t<_Fp, _Ts...>
5445 __tuple_apply(
const tuple<_Ts...>&);
5447 template<
typename _Tp>
5448 decltype(__tuple_apply(
std::declval<__repeated_tuple<_Tp, _Nm>>()))
5453 template<forward_range _Vp,
size_t _Nm>
5454 requires view<_Vp> && (_Nm > 0)
5455 template<bool _Const>
5456 class adjacent_view<_Vp, _Nm>::_Iterator
5458#ifdef _GLIBCXX_CLANG
5461 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
5462 array<iterator_t<_Base>, _Nm> _M_current = array<iterator_t<_Base>, _Nm>();
5465 _Iterator(iterator_t<_Base> __first, sentinel_t<_Base> __last)
5467 for (
auto& __i : _M_current)
5470 ranges::advance(__first, 1, __last);
5475 _Iterator(__as_sentinel, iterator_t<_Base> __first, iterator_t<_Base> __last)
5477 if constexpr (!bidirectional_range<_Base>)
5478 for (
auto& __it : _M_current)
5481 for (
size_t __i = 0; __i < _Nm; ++__i)
5483 _M_current[_Nm - 1 - __i] = __last;
5484 ranges::advance(__last, -1, __first);
5491 if constexpr (random_access_range<_Base>)
5492 return random_access_iterator_tag{};
5493 else if constexpr (bidirectional_range<_Base>)
5494 return bidirectional_iterator_tag{};
5496 return forward_iterator_tag{};
5499 friend class adjacent_view;
5501#ifndef _GLIBCXX_CLANG
5502 template<forward_range _Wp, move_constructible _Fp,
size_t _Mm>
5503 requires view<_Wp> && (_Mm > 0) && is_object_v<_Fp>
5504 && regular_invocable<__detail::__unarize<_Fp&, _Mm>, range_reference_t<_Wp>>
5505 && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Mm>,
5506 range_reference_t<_Wp>>>
5507 friend class adjacent_transform_view;
5511 using iterator_category = input_iterator_tag;
5512 using iterator_concept =
decltype(_S_iter_concept());
5514 pair<range_value_t<_Base>, range_value_t<_Base>>,
5515 __detail::__repeated_tuple<range_value_t<_Base>, _Nm>>;
5516 using difference_type = range_difference_t<_Base>;
5518 _Iterator() =
default;
5521 _Iterator(_Iterator<!_Const> __i)
5522 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
5524 for (
size_t __j = 0; __j < _Nm; ++__j)
5525 _M_current[__j] =
std::move(__i._M_current[__j]);
5531 auto __f = [](
auto& __i) ->
decltype(
auto) {
return *__i; };
5532 return __detail::__tuple_transform(__f, _M_current);
5535 constexpr _Iterator&
5538 for (
auto& __i : _M_current)
5551 constexpr _Iterator&
5552 operator--()
requires bidirectional_range<_Base>
5554 for (
auto& __i : _M_current)
5560 operator--(
int)
requires bidirectional_range<_Base>
5567 constexpr _Iterator&
5568 operator+=(difference_type __x)
5569 requires random_access_range<_Base>
5571 for (
auto& __i : _M_current)
5576 constexpr _Iterator&
5577 operator-=(difference_type __x)
5578 requires random_access_range<_Base>
5580 for (
auto& __i : _M_current)
5586 operator[](difference_type __n)
const
5587 requires random_access_range<_Base>
5589 auto __f = [&](
auto& __i) ->
decltype(
auto) {
return __i[__n]; };
5590 return __detail::__tuple_transform(__f, _M_current);
5593 friend constexpr bool
5594 operator==(
const _Iterator& __x,
const _Iterator& __y)
5595 {
return __x._M_current.back() == __y._M_current.back(); }
5597 friend constexpr bool
5598 operator<(
const _Iterator& __x,
const _Iterator& __y)
5599 requires random_access_range<_Base>
5600 {
return __x._M_current.back() < __y._M_current.back(); }
5602 friend constexpr bool
5603 operator>(
const _Iterator& __x,
const _Iterator& __y)
5604 requires random_access_range<_Base>
5605 {
return __y < __x; }
5607 friend constexpr bool
5608 operator<=(
const _Iterator& __x,
const _Iterator& __y)
5609 requires random_access_range<_Base>
5610 {
return !(__y < __x); }
5612 friend constexpr bool
5613 operator>=(
const _Iterator& __x,
const _Iterator& __y)
5614 requires random_access_range<_Base>
5615 {
return !(__x < __y); }
5617 friend constexpr auto
5618 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
5619 requires random_access_range<_Base>
5620 && three_way_comparable<iterator_t<_Base>>
5621 {
return __x._M_current.back() <=> __y._M_current.back(); }
5623 friend constexpr _Iterator
5624 operator+(
const _Iterator& __i, difference_type __n)
5625 requires random_access_range<_Base>
5632 friend constexpr _Iterator
5633 operator+(difference_type __n,
const _Iterator& __i)
5634 requires random_access_range<_Base>
5641 friend constexpr _Iterator
5642 operator-(
const _Iterator& __i, difference_type __n)
5643 requires random_access_range<_Base>
5650 friend constexpr difference_type
5651 operator-(
const _Iterator& __x,
const _Iterator& __y)
5652 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
5653 {
return __x._M_current.back() - __y._M_current.back(); }
5655 friend constexpr auto
5656 iter_move(
const _Iterator& __i)
5657 {
return __detail::__tuple_transform(ranges::iter_move, __i._M_current); }
5659 friend constexpr void
5660 iter_swap(
const _Iterator& __l,
const _Iterator& __r)
5661 requires indirectly_swappable<iterator_t<_Base>>
5663 for (
size_t __i = 0; __i < _Nm; __i++)
5664 ranges::iter_swap(__l._M_current[__i], __r._M_current[__i]);
5668 template<forward_range _Vp,
size_t _Nm>
5669 requires view<_Vp> && (_Nm > 0)
5670 template<bool _Const>
5671 class adjacent_view<_Vp, _Nm>::_Sentinel
5673 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
5675 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
5678 _Sentinel(sentinel_t<_Base> __end)
5682 friend class adjacent_view;
5685 _Sentinel() =
default;
5688 _Sentinel(_Sentinel<!_Const> __i)
5689 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
5693 template<
bool _OtherConst>
5694 requires sentinel_for<sentinel_t<_Base>,
5695 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
5696 friend constexpr bool
5697 operator==(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
5698 {
return __x._M_current.back() == __y._M_end; }
5700 template<
bool _OtherConst>
5701 requires sized_sentinel_for<sentinel_t<_Base>,
5702 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
5703 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _Vp>>
5704 operator-(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
5705 {
return __x._M_current.back() - __y._M_end; }
5707 template<
bool _OtherConst>
5708 requires sized_sentinel_for<sentinel_t<_Base>,
5709 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
5710 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _Vp>>
5711 operator-(
const _Sentinel& __y,
const _Iterator<_OtherConst>& __x)
5712 {
return __y._M_end - __x._M_current.back(); }
5719 template<
size_t _Nm,
typename _Range>
5720 concept __can_adjacent_view
5721 =
requires { adjacent_view<all_t<_Range>, _Nm>(std::declval<_Range>()); };
5724 template<
size_t _Nm>
5725 struct _Adjacent : __adaptor::_RangeAdaptorClosure<_Adjacent<_Nm>>
5727 template<viewable_range _Range>
5728 requires (_Nm == 0) || __detail::__can_adjacent_view<_Nm, _Range>
5730 operator() [[nodiscard]] (_Range&& __r)
const
5732 if constexpr (_Nm == 0)
5733 return views::empty<tuple<>>;
5735 return adjacent_view<all_t<_Range>, _Nm>(std::forward<_Range>(__r));
5739 template<
size_t _Nm>
5740 inline constexpr _Adjacent<_Nm> adjacent;
5742 inline constexpr auto pairwise = adjacent<2>;
5745 template<forward_range _Vp, move_constructible _Fp,
size_t _Nm>
5746 requires view<_Vp> && (_Nm > 0) && is_object_v<_Fp>
5747 && regular_invocable<__detail::__unarize<_Fp&, _Nm>, range_reference_t<_Vp>>
5748 && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Nm>,
5749 range_reference_t<_Vp>>>
5750 class adjacent_transform_view : public view_interface<adjacent_transform_view<_Vp, _Fp, _Nm>>
5752 [[no_unique_address]] __detail::__box<_Fp> _M_fun;
5753 adjacent_view<_Vp, _Nm> _M_inner;
5755 using _InnerView = adjacent_view<_Vp, _Nm>;
5757 template<
bool _Const>
5758 using _InnerIter = iterator_t<__detail::__maybe_const_t<_Const, _InnerView>>;
5760 template<
bool _Const>
5761 using _InnerSent = sentinel_t<__detail::__maybe_const_t<_Const, _InnerView>>;
5763 template<
bool>
class _Iterator;
5764 template<
bool>
class _Sentinel;
5767 adjacent_transform_view() =
default;
5770 adjacent_transform_view(_Vp __base, _Fp __fun)
5778 base() const & requires copy_constructible<_Vp>
5779 {
return _M_inner.base(); }
5787 {
return _Iterator<false>(*
this, _M_inner.begin()); }
5791 requires range<const _InnerView>
5792 && regular_invocable<__detail::__unarize<const _Fp&, _Nm>,
5793 range_reference_t<const _Vp>>
5794 {
return _Iterator<true>(*
this, _M_inner.begin()); }
5799 if constexpr (common_range<_InnerView>)
5800 return _Iterator<false>(*
this, _M_inner.end());
5802 return _Sentinel<false>(_M_inner.end());
5807 requires range<const _InnerView>
5808 && regular_invocable<__detail::__unarize<const _Fp&, _Nm>,
5809 range_reference_t<const _Vp>>
5811 if constexpr (common_range<const _InnerView>)
5812 return _Iterator<true>(*
this, _M_inner.end());
5814 return _Sentinel<true>(_M_inner.end());
5818 size()
requires sized_range<_InnerView>
5819 {
return _M_inner.size(); }
5822 size() const requires sized_range<const _InnerView>
5823 {
return _M_inner.size(); }
5826 template<forward_range _Vp, move_constructible _Fp,
size_t _Nm>
5827 requires view<_Vp> && (_Nm > 0) && is_object_v<_Fp>
5828 && regular_invocable<__detail::__unarize<_Fp&, _Nm>, range_reference_t<_Vp>>
5829 && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Nm>,
5830 range_reference_t<_Vp>>>
5831 template<bool _Const>
5832 class adjacent_transform_view<_Vp, _Fp, _Nm>::_Iterator
5834 using _Parent = __detail::__maybe_const_t<_Const, adjacent_transform_view>;
5835 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
5837 _Parent* _M_parent =
nullptr;
5838 _InnerIter<_Const> _M_inner;
5841 _Iterator(_Parent& __parent, _InnerIter<_Const> __inner)
5848 using __detail::__maybe_const_t;
5849 using __detail::__unarize;
5850 using _Res = invoke_result_t<__unarize<__maybe_const_t<_Const, _Fp>&, _Nm>,
5851 range_reference_t<_Base>>;
5852 using _Cat =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
5855 if constexpr (!is_reference_v<_Res>)
5856 return input_iterator_tag{};
5857 else if constexpr (derived_from<_Cat, random_access_iterator_tag>)
5858 return random_access_iterator_tag{};
5859 else if constexpr (derived_from<_Cat, bidirectional_iterator_tag>)
5860 return bidirectional_iterator_tag{};
5861 else if constexpr (derived_from<_Cat, forward_iterator_tag>)
5862 return forward_iterator_tag{};
5864 return input_iterator_tag{};
5867 friend class adjacent_transform_view;
5870 using iterator_category =
decltype(_S_iter_cat());
5871 using iterator_concept =
typename _InnerIter<_Const>::iterator_concept;
5873 = remove_cvref_t<invoke_result_t
5874 <__detail::__unarize<__detail::__maybe_const_t<_Const, _Fp>&, _Nm>,
5875 range_reference_t<_Base>>>;
5876 using difference_type = range_difference_t<_Base>;
5878 _Iterator() =
default;
5881 _Iterator(_Iterator<!_Const> __i)
5882 requires _Const && convertible_to<_InnerIter<false>, _InnerIter<_Const>>
5883 : _M_parent(__i._M_parent), _M_inner(
std::move(__i._M_inner))
5886 constexpr decltype(
auto)
5889 return std::apply([&](
const auto&... __iters) ->
decltype(
auto) {
5891 }, _M_inner._M_current);
5894 constexpr _Iterator&
5909 constexpr _Iterator&
5910 operator--()
requires bidirectional_range<_Base>
5917 operator--(
int)
requires bidirectional_range<_Base>
5924 constexpr _Iterator&
5925 operator+=(difference_type __x)
requires random_access_range<_Base>
5931 constexpr _Iterator&
5932 operator-=(difference_type __x)
requires random_access_range<_Base>
5938 constexpr decltype(
auto)
5939 operator[](difference_type __n)
const requires random_access_range<_Base>
5941 return std::apply([&](
const auto&... __iters) ->
decltype(
auto) {
5943 }, _M_inner._M_current);
5946 friend constexpr bool
5947 operator==(
const _Iterator& __x,
const _Iterator& __y)
5948 {
return __x._M_inner == __y._M_inner; }
5950 friend constexpr bool
5951 operator<(
const _Iterator& __x,
const _Iterator& __y)
5952 requires random_access_range<_Base>
5953 {
return __x._M_inner < __y._M_inner; }
5955 friend constexpr bool
5956 operator>(
const _Iterator& __x,
const _Iterator& __y)
5957 requires random_access_range<_Base>
5958 {
return __x._M_inner > __y._M_inner; }
5960 friend constexpr bool
5961 operator<=(
const _Iterator& __x,
const _Iterator& __y)
5962 requires random_access_range<_Base>
5963 {
return __x._M_inner <= __y._M_inner; }
5965 friend constexpr bool
5966 operator>=(
const _Iterator& __x,
const _Iterator& __y)
5967 requires random_access_range<_Base>
5968 {
return __x._M_inner >= __y._M_inner; }
5970 friend constexpr auto
5971 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
5972 requires random_access_range<_Base> &&
5973 three_way_comparable<_InnerIter<_Const>>
5974 {
return __x._M_inner <=> __y._M_inner; }
5976 friend constexpr _Iterator
5977 operator+(
const _Iterator& __i, difference_type __n)
5978 requires random_access_range<_Base>
5979 {
return _Iterator(*__i._M_parent, __i._M_inner + __n); }
5981 friend constexpr _Iterator
5982 operator+(difference_type __n,
const _Iterator& __i)
5983 requires random_access_range<_Base>
5984 {
return _Iterator(*__i._M_parent, __i._M_inner + __n); }
5986 friend constexpr _Iterator
5987 operator-(
const _Iterator& __i, difference_type __n)
5988 requires random_access_range<_Base>
5989 {
return _Iterator(*__i._M_parent, __i._M_inner - __n); }
5991 friend constexpr difference_type
5992 operator-(
const _Iterator& __x,
const _Iterator& __y)
5993 requires sized_sentinel_for<_InnerIter<_Const>, _InnerIter<_Const>>
5994 {
return __x._M_inner - __y._M_inner; }
5997 template<forward_range _Vp, move_constructible _Fp,
size_t _Nm>
5998 requires view<_Vp> && (_Nm > 0) && is_object_v<_Fp>
5999 && regular_invocable<__detail::__unarize<_Fp&, _Nm>, range_reference_t<_Vp>>
6000 && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Nm>,
6001 range_reference_t<_Vp>>>
6002 template<bool _Const>
6003 class adjacent_transform_view<_Vp, _Fp, _Nm>::_Sentinel
6005 _InnerSent<_Const> _M_inner;
6008 _Sentinel(_InnerSent<_Const> __inner)
6012 friend class adjacent_transform_view;
6015 _Sentinel() =
default;
6018 _Sentinel(_Sentinel<!_Const> __i)
6019 requires _Const && convertible_to<_InnerSent<false>, _InnerSent<_Const>>
6023 template<
bool _OtherConst>
6024 requires sentinel_for<_InnerSent<_Const>, _InnerIter<_OtherConst>>
6025 friend constexpr bool
6026 operator==(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
6027 {
return __x._M_inner == __y._M_inner; }
6029 template<
bool _OtherConst>
6030 requires sized_sentinel_for<_InnerSent<_Const>, _InnerIter<_OtherConst>>
6031 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
6032 operator-(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
6033 {
return __x._M_inner - __y._M_inner; }
6035 template<
bool _OtherConst>
6036 requires sized_sentinel_for<_InnerSent<_Const>, _InnerIter<_OtherConst>>
6037 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
6038 operator-(
const _Sentinel& __x,
const _Iterator<_OtherConst>& __y)
6039 {
return __x._M_inner - __y._M_inner; }
6046 template<
size_t _Nm,
typename _Range,
typename _Fp>
6047 concept __can_adjacent_transform_view
6048 =
requires { adjacent_transform_view<all_t<_Range>, decay_t<_Fp>, _Nm>
6049 (std::declval<_Range>(), std::declval<_Fp>()); };
6052 template<
size_t _Nm>
6053 struct _AdjacentTransform : __adaptor::_RangeAdaptor<_AdjacentTransform<_Nm>>
6055 template<viewable_range _Range,
typename _Fp>
6056 requires (_Nm == 0) || __detail::__can_adjacent_transform_view<_Nm, _Range, _Fp>
6058 operator() [[nodiscard]] (_Range&& __r, _Fp&& __f)
const
6060 if constexpr (_Nm == 0)
6061 return zip_transform(std::forward<_Fp>(__f));
6063 return adjacent_transform_view<all_t<_Range>, decay_t<_Fp>, _Nm>
6064 (std::forward<_Range>(__r), std::forward<_Fp>(__f));
6067 using __adaptor::_RangeAdaptor<_AdjacentTransform>::operator();
6068 static constexpr int _S_arity = 2;
6069 static constexpr bool _S_has_simple_extra_args =
true;
6072 template<
size_t _Nm>
6073 inline constexpr _AdjacentTransform<_Nm> adjacent_transform;
6075 inline constexpr auto pairwise_transform = adjacent_transform<2>;
6079#ifdef __cpp_lib_ranges_chunk
6082 template<
typename _Tp>
6083 constexpr _Tp __div_ceil(_Tp __num, _Tp __denom)
6085 _Tp __r = __num / __denom;
6086 if (__num % __denom)
6093 requires input_range<_Vp>
6094 class chunk_view :
public view_interface<chunk_view<_Vp>>
6097 range_difference_t<_Vp> _M_n;
6098 range_difference_t<_Vp> _M_remainder = 0;
6099 __detail::__non_propagating_cache<iterator_t<_Vp>> _M_current;
6106 chunk_view(_Vp __base, range_difference_t<_Vp> __n)
6108 { __glibcxx_assert(__n >= 0); }
6111 base() const & requires copy_constructible<_Vp>
6118 constexpr _OuterIter
6121 _M_current = ranges::begin(_M_base);
6122 _M_remainder = _M_n;
6123 return _OuterIter(*
this);
6126 constexpr default_sentinel_t
6127 end() const noexcept
6131 size()
requires sized_range<_Vp>
6133 return __detail::__to_unsigned_like(__detail::__div_ceil
6134 (ranges::distance(_M_base), _M_n));
6138 size() const requires sized_range<const _Vp>
6140 return __detail::__to_unsigned_like(__detail::__div_ceil
6141 (ranges::distance(_M_base), _M_n));
6145 template<
typename _Range>
6146 chunk_view(_Range&&, range_difference_t<_Range>) -> chunk_view<views::all_t<_Range>>;
6149 requires input_range<_Vp>
6150 class chunk_view<_Vp>::_OuterIter
6152 chunk_view* _M_parent;
6155 _OuterIter(chunk_view& __parent) noexcept
6162 using iterator_concept = input_iterator_tag;
6163 using difference_type = range_difference_t<_Vp>;
6167 _OuterIter(_OuterIter&&) =
default;
6168 _OuterIter& operator=(_OuterIter&&) =
default;
6170 constexpr value_type
6173 __glibcxx_assert(*
this != default_sentinel);
6174 return value_type(*_M_parent);
6177 constexpr _OuterIter&
6180 __glibcxx_assert(*
this != default_sentinel);
6181 ranges::advance(*_M_parent->_M_current, _M_parent->_M_remainder,
6182 ranges::end(_M_parent->_M_base));
6183 _M_parent->_M_remainder = _M_parent->_M_n;
6191 friend constexpr bool
6192 operator==(
const _OuterIter& __x, default_sentinel_t)
6194 return *__x._M_parent->_M_current == ranges::end(__x._M_parent->_M_base)
6195 && __x._M_parent->_M_remainder != 0;
6198 friend constexpr difference_type
6199 operator-(default_sentinel_t,
const _OuterIter& __x)
6200 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6202 const auto __dist = ranges::end(__x._M_parent->_M_base) - *__x._M_parent->_M_current;
6204 if (__dist < __x._M_parent->_M_remainder)
6205 return __dist == 0 ? 0 : 1;
6207 return 1 + __detail::__div_ceil(__dist - __x._M_parent->_M_remainder,
6208 __x._M_parent->_M_n);
6211 friend constexpr difference_type
6212 operator-(
const _OuterIter& __x, default_sentinel_t __y)
6213 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6214 {
return -(__y - __x); }
6218 requires input_range<_Vp>
6219 struct chunk_view<_Vp>::_OuterIter::value_type : view_interface<value_type>
6222 chunk_view* _M_parent;
6225 value_type(chunk_view& __parent) noexcept
6232 constexpr _InnerIter
6233 begin() const noexcept
6234 {
return _InnerIter(*_M_parent); }
6236 constexpr default_sentinel_t
6237 end() const noexcept
6242 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6244 return __detail::__to_unsigned_like
6245 (ranges::min(_M_parent->_M_remainder,
6246 ranges::end(_M_parent->_M_base) - *_M_parent->_M_current));
6251 requires input_range<_Vp>
6252 class chunk_view<_Vp>::_InnerIter
6254 chunk_view* _M_parent;
6257 _InnerIter(chunk_view& __parent) noexcept
6261 friend _OuterIter::value_type;
6264 using iterator_concept = input_iterator_tag;
6265 using difference_type = range_difference_t<_Vp>;
6266 using value_type = range_value_t<_Vp>;
6268 _InnerIter(_InnerIter&&) =
default;
6269 _InnerIter& operator=(_InnerIter&&) =
default;
6271 constexpr const iterator_t<_Vp>&
6273 {
return *_M_parent->_M_current; }
6275 constexpr range_reference_t<_Vp>
6278 __glibcxx_assert(*
this != default_sentinel);
6279 return **_M_parent->_M_current;
6282 constexpr _InnerIter&
6285 __glibcxx_assert(*
this != default_sentinel);
6286 ++*_M_parent->_M_current;
6287 if (*_M_parent->_M_current == ranges::end(_M_parent->_M_base))
6288 _M_parent->_M_remainder = 0;
6290 --_M_parent->_M_remainder;
6298 friend constexpr bool
6299 operator==(
const _InnerIter& __x, default_sentinel_t)
noexcept
6300 {
return __x._M_parent->_M_remainder == 0; }
6302 friend constexpr difference_type
6303 operator-(default_sentinel_t,
const _InnerIter& __x)
6304 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6306 return ranges::min(__x._M_parent->_M_remainder,
6307 ranges::end(__x._M_parent->_M_base) - *__x._M_parent->_M_current);
6310 friend constexpr difference_type
6311 operator-(
const _InnerIter& __x, default_sentinel_t __y)
6312 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6313 {
return -(__y - __x); }
6317 friend constexpr range_rvalue_reference_t<_Vp>
6318 iter_move(
const _InnerIter& __i)
6319 noexcept(
noexcept(ranges::iter_move(*__i._M_parent->_M_current)))
6320 {
return ranges::iter_move(*__i._M_parent->_M_current); }
6322 friend constexpr void
6323 iter_swap(
const _InnerIter& __x,
const _InnerIter& __y)
6324 noexcept(
noexcept(ranges::iter_swap(*__x._M_parent->_M_current,
6325 *__x._M_parent->_M_current)))
6326 requires indirectly_swappable<iterator_t<_Vp>>
6327 {
return ranges::iter_swap(*__x._M_parent->_M_current, *__y._M_parent->_M_current); }
6331 requires forward_range<_Vp>
6332 class chunk_view<_Vp> :
public view_interface<chunk_view<_Vp>>
6335 range_difference_t<_Vp> _M_n;
6336 template<
bool>
class _Iterator;
6340 chunk_view(_Vp __base, range_difference_t<_Vp> __n)
6342 { __glibcxx_assert(__n > 0); }
6345 base() const & requires copy_constructible<_Vp>
6353 begin()
requires (!__detail::__simple_view<_Vp>)
6354 {
return _Iterator<false>(
this, ranges::begin(_M_base)); }
6357 begin() const requires forward_range<const _Vp>
6358 {
return _Iterator<true>(
this, ranges::begin(_M_base)); }
6361 end()
requires (!__detail::__simple_view<_Vp>)
6363 if constexpr (common_range<_Vp> && sized_range<_Vp>)
6365 auto __missing = (_M_n - ranges::distance(_M_base) % _M_n) % _M_n;
6366 return _Iterator<false>(
this, ranges::end(_M_base), __missing);
6368 else if constexpr (common_range<_Vp> && !bidirectional_range<_Vp>)
6369 return _Iterator<false>(
this, ranges::end(_M_base));
6375 end() const requires forward_range<const _Vp>
6377 if constexpr (common_range<const _Vp> && sized_range<const _Vp>)
6379 auto __missing = (_M_n - ranges::distance(_M_base) % _M_n) % _M_n;
6380 return _Iterator<true>(
this, ranges::end(_M_base), __missing);
6382 else if constexpr (common_range<const _Vp> && !bidirectional_range<const _Vp>)
6383 return _Iterator<true>(
this, ranges::end(_M_base));
6389 size()
requires sized_range<_Vp>
6391 return __detail::__to_unsigned_like(__detail::__div_ceil
6392 (ranges::distance(_M_base), _M_n));
6396 size() const requires sized_range<const _Vp>
6398 return __detail::__to_unsigned_like(__detail::__div_ceil
6399 (ranges::distance(_M_base), _M_n));
6403 template<
typename _Vp>
6404 inline constexpr bool enable_borrowed_range<chunk_view<_Vp>>
6405 = forward_range<_Vp> && enable_borrowed_range<_Vp>;
6408 requires forward_range<_Vp>
6409 template<
bool _Const>
6410 class chunk_view<_Vp>::_Iterator
6412 using _Parent = __detail::__maybe_const_t<_Const, chunk_view>;
6413 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
6415 iterator_t<_Base> _M_current = iterator_t<_Base>();
6416 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
6417 range_difference_t<_Base> _M_n = 0;
6418 range_difference_t<_Base> _M_missing = 0;
6421 _Iterator(_Parent* __parent, iterator_t<_Base> __current,
6422 range_difference_t<_Base> __missing = 0)
6423 : _M_current(__current), _M_end(ranges::
end(__parent->_M_base)),
6424 _M_n(__parent->_M_n), _M_missing(__missing)
6430 if constexpr (random_access_range<_Base>)
6431 return random_access_iterator_tag{};
6432 else if constexpr (bidirectional_range<_Base>)
6433 return bidirectional_iterator_tag{};
6435 return forward_iterator_tag{};
6441 using iterator_category = input_iterator_tag;
6442 using iterator_concept =
decltype(_S_iter_cat());
6443 using value_type =
decltype(views::take(subrange(_M_current, _M_end), _M_n));
6444 using difference_type = range_difference_t<_Base>;
6446 _Iterator() =
default;
6448 constexpr _Iterator(_Iterator<!_Const> __i)
6450 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
6451 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
6453 _M_n(__i._M_n), _M_missing(__i._M_missing)
6456 constexpr iterator_t<_Base>
6458 {
return _M_current; }
6460 constexpr value_type
6463 __glibcxx_assert(_M_current != _M_end);
6464 return views::take(subrange(_M_current, _M_end), _M_n);
6467 constexpr _Iterator&
6470 __glibcxx_assert(_M_current != _M_end);
6471 _M_missing = ranges::advance(_M_current, _M_n, _M_end);
6483 constexpr _Iterator&
6484 operator--()
requires bidirectional_range<_Base>
6486 ranges::advance(_M_current, _M_missing - _M_n);
6492 operator--(
int)
requires bidirectional_range<_Base>
6499 constexpr _Iterator&
6500 operator+=(difference_type __x)
6501 requires random_access_range<_Base>
6505 __glibcxx_assert(ranges::distance(_M_current, _M_end) > _M_n * (__x - 1));
6506 _M_missing = ranges::advance(_M_current, _M_n * __x, _M_end);
6510 ranges::advance(_M_current, _M_n * __x + _M_missing);
6516 constexpr _Iterator&
6517 operator-=(difference_type __x)
6518 requires random_access_range<_Base>
6519 {
return *
this += -__x; }
6521 constexpr value_type
6522 operator[](difference_type __n)
const
6523 requires random_access_range<_Base>
6524 {
return *(*
this + __n); }
6526 friend constexpr bool
6527 operator==(
const _Iterator& __x,
const _Iterator& __y)
6528 {
return __x._M_current == __y._M_current; }
6530 friend constexpr bool
6531 operator==(
const _Iterator& __x, default_sentinel_t)
6532 {
return __x._M_current == __x._M_end; }
6534 friend constexpr bool
6535 operator<(
const _Iterator& __x,
const _Iterator& __y)
6536 requires random_access_range<_Base>
6537 {
return __x._M_current > __y._M_current; }
6539 friend constexpr bool
6540 operator>(
const _Iterator& __x,
const _Iterator& __y)
6541 requires random_access_range<_Base>
6542 {
return __y < __x; }
6544 friend constexpr bool
6545 operator<=(
const _Iterator& __x,
const _Iterator& __y)
6546 requires random_access_range<_Base>
6547 {
return !(__y < __x); }
6549 friend constexpr bool
6550 operator>=(
const _Iterator& __x,
const _Iterator& __y)
6551 requires random_access_range<_Base>
6552 {
return !(__x < __y); }
6554 friend constexpr auto
6555 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
6556 requires random_access_range<_Base>
6557 && three_way_comparable<iterator_t<_Base>>
6558 {
return __x._M_current <=> __y._M_current; }
6560 friend constexpr _Iterator
6561 operator+(
const _Iterator& __i, difference_type __n)
6562 requires random_access_range<_Base>
6569 friend constexpr _Iterator
6570 operator+(difference_type __n,
const _Iterator& __i)
6571 requires random_access_range<_Base>
6578 friend constexpr _Iterator
6579 operator-(
const _Iterator& __i, difference_type __n)
6580 requires random_access_range<_Base>
6587 friend constexpr difference_type
6588 operator-(
const _Iterator& __x,
const _Iterator& __y)
6589 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
6591 return (__x._M_current - __y._M_current
6592 + __x._M_missing - __y._M_missing) / __x._M_n;
6595 friend constexpr difference_type
6596 operator-(default_sentinel_t __y,
const _Iterator& __x)
6597 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
6598 {
return __detail::__div_ceil(__x._M_end - __x._M_current, __x._M_n); }
6600 friend constexpr difference_type
6601 operator-(
const _Iterator& __x, default_sentinel_t __y)
6602 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
6603 {
return -(__y - __x); }
6610 template<
typename _Range,
typename _Dp>
6611 concept __can_chunk_view
6612 =
requires { chunk_view(std::declval<_Range>(), std::declval<_Dp>()); };
6615 struct _Chunk : __adaptor::_RangeAdaptor<_Chunk>
6617 template<viewable_range _Range,
typename _Dp = range_difference_t<_Range>>
6618 requires __detail::__can_chunk_view<_Range, _Dp>
6620 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n)
const
6621 {
return chunk_view(std::forward<_Range>(__r), __n); }
6623 using __adaptor::_RangeAdaptor<_Chunk>::operator();
6624 static constexpr int _S_arity = 2;
6625 static constexpr bool _S_has_simple_extra_args =
true;
6628 inline constexpr _Chunk chunk;
6632#ifdef __cpp_lib_ranges_slide
6635 template<
typename _Vp>
6636 concept __slide_caches_nothing = random_access_range<_Vp> && sized_range<_Vp>;
6638 template<
typename _Vp>
6639 concept __slide_caches_last
6640 = !__slide_caches_nothing<_Vp> && bidirectional_range<_Vp> && common_range<_Vp>;
6642 template<
typename _Vp>
6643 concept __slide_caches_first
6644 = !__slide_caches_nothing<_Vp> && !__slide_caches_last<_Vp>;
6647 template<forward_range _Vp>
6649 class slide_view :
public view_interface<slide_view<_Vp>>
6652 range_difference_t<_Vp> _M_n;
6653 [[no_unique_address]]
6654 __detail::__maybe_present_t<__detail::__slide_caches_first<_Vp>,
6655 __detail::_CachedPosition<_Vp>, 0> _M_cached_begin;
6656 [[no_unique_address]]
6657 __detail::__maybe_present_t<__detail::__slide_caches_last<_Vp>,
6658 __detail::_CachedPosition<_Vp>, 1> _M_cached_end;
6660 template<
bool>
class _Iterator;
6665 slide_view(_Vp __base, range_difference_t<_Vp> __n)
6667 { __glibcxx_assert(__n > 0); }
6672 base() const & requires copy_constructible<_Vp>
6680 begin()
requires (!(__detail::__simple_view<_Vp>
6681 && __detail::__slide_caches_nothing<const _Vp>))
6683 if constexpr (__detail::__slide_caches_first<_Vp>)
6685 iterator_t<_Vp> __it;
6686 if (_M_cached_begin._M_has_value())
6687 __it = _M_cached_begin._M_get(_M_base);
6690 __it = ranges::next(ranges::begin(_M_base), _M_n - 1, ranges::end(_M_base));
6691 _M_cached_begin._M_set(_M_base, __it);
6693 return _Iterator<false>(ranges::begin(_M_base),
std::move(__it), _M_n);
6696 return _Iterator<false>(ranges::begin(_M_base), _M_n);
6700 begin() const requires __detail::__slide_caches_nothing<const _Vp>
6701 {
return _Iterator<true>(ranges::begin(_M_base), _M_n); }
6704 end()
requires (!(__detail::__simple_view<_Vp>
6705 && __detail::__slide_caches_nothing<const _Vp>))
6707 if constexpr (__detail::__slide_caches_nothing<_Vp>)
6708 return _Iterator<false>(ranges::begin(_M_base) + range_difference_t<_Vp>(
size()),
6710 else if constexpr (__detail::__slide_caches_last<_Vp>)
6712 iterator_t<_Vp> __it;
6713 if (_M_cached_end._M_has_value())
6714 __it = _M_cached_end._M_get(_M_base);
6717 __it = ranges::prev(ranges::end(_M_base), _M_n - 1, ranges::begin(_M_base));
6718 _M_cached_end._M_set(_M_base, __it);
6720 return _Iterator<false>(
std::move(__it), _M_n);
6722 else if constexpr (common_range<_Vp>)
6723 return _Iterator<false>(ranges::end(_M_base), ranges::end(_M_base), _M_n);
6725 return _Sentinel(ranges::end(_M_base));
6729 end() const requires __detail::__slide_caches_nothing<const _Vp>
6730 {
return begin() + range_difference_t<const _Vp>(
size()); }
6733 size()
requires sized_range<_Vp>
6735 auto __sz = ranges::distance(_M_base) - _M_n + 1;
6738 return __detail::__to_unsigned_like(__sz);
6742 size() const requires sized_range<const _Vp>
6744 auto __sz = ranges::distance(_M_base) - _M_n + 1;
6747 return __detail::__to_unsigned_like(__sz);
6751 template<
typename _Range>
6752 slide_view(_Range&&, range_difference_t<_Range>) -> slide_view<views::all_t<_Range>>;
6754 template<
typename _Vp>
6755 inline constexpr bool enable_borrowed_range<slide_view<_Vp>>
6756 = enable_borrowed_range<_Vp>;
6758 template<forward_range _Vp>
6760 template<
bool _Const>
6761 class slide_view<_Vp>::_Iterator
6763 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
6764 static constexpr bool _S_last_elt_present
6765 = __detail::__slide_caches_first<_Base>;
6767 iterator_t<_Base> _M_current = iterator_t<_Base>();
6768 [[no_unique_address]]
6769 __detail::__maybe_present_t<_S_last_elt_present, iterator_t<_Base>>
6770 _M_last_elt =
decltype(_M_last_elt)();
6771 range_difference_t<_Base> _M_n = 0;
6774 _Iterator(iterator_t<_Base> __current, range_difference_t<_Base> __n)
6775 requires (!_S_last_elt_present)
6776 : _M_current(__current), _M_n(__n)
6780 _Iterator(iterator_t<_Base> __current, iterator_t<_Base> __last_elt,
6781 range_difference_t<_Base> __n)
6782 requires _S_last_elt_present
6783 : _M_current(__current), _M_last_elt(__last_elt), _M_n(__n)
6789 if constexpr (random_access_range<_Base>)
6790 return random_access_iterator_tag{};
6791 else if constexpr (bidirectional_range<_Base>)
6792 return bidirectional_iterator_tag{};
6794 return forward_iterator_tag{};
6798 friend slide_view::_Sentinel;
6801 using iterator_category = input_iterator_tag;
6802 using iterator_concept =
decltype(_S_iter_concept());
6803 using value_type =
decltype(views::counted(_M_current, _M_n));
6804 using difference_type = range_difference_t<_Base>;
6806 _Iterator() =
default;
6809 _Iterator(_Iterator<!_Const> __i)
6810 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
6811 : _M_current(
std::move(__i._M_current)), _M_n(__i._M_n)
6816 {
return views::counted(_M_current, _M_n); }
6818 constexpr _Iterator&
6822 if constexpr (_S_last_elt_present)
6835 constexpr _Iterator&
6836 operator--()
requires bidirectional_range<_Base>
6839 if constexpr (_S_last_elt_present)
6845 operator--(
int)
requires bidirectional_range<_Base>
6852 constexpr _Iterator&
6853 operator+=(difference_type __x)
6854 requires random_access_range<_Base>
6857 if constexpr (_S_last_elt_present)
6862 constexpr _Iterator&
6863 operator-=(difference_type __x)
6864 requires random_access_range<_Base>
6867 if constexpr (_S_last_elt_present)
6873 operator[](difference_type __n)
const
6874 requires random_access_range<_Base>
6875 {
return views::counted(_M_current + __n, _M_n); }
6877 friend constexpr bool
6878 operator==(
const _Iterator& __x,
const _Iterator& __y)
6880 if constexpr (_S_last_elt_present)
6881 return __x._M_last_elt == __y._M_last_elt;
6883 return __x._M_current == __y._M_current;
6886 friend constexpr bool
6887 operator<(
const _Iterator& __x,
const _Iterator& __y)
6888 requires random_access_range<_Base>
6889 {
return __x._M_current < __y._M_current; }
6891 friend constexpr bool
6892 operator>(
const _Iterator& __x,
const _Iterator& __y)
6893 requires random_access_range<_Base>
6894 {
return __y < __x; }
6896 friend constexpr bool
6897 operator<=(
const _Iterator& __x,
const _Iterator& __y)
6898 requires random_access_range<_Base>
6899 {
return !(__y < __x); }
6901 friend constexpr bool
6902 operator>=(
const _Iterator& __x,
const _Iterator& __y)
6903 requires random_access_range<_Base>
6904 {
return !(__x < __y); }
6906 friend constexpr auto
6907 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
6908 requires random_access_range<_Base>
6909 && three_way_comparable<iterator_t<_Base>>
6910 {
return __x._M_current <=> __y._M_current; }
6912 friend constexpr _Iterator
6913 operator+(
const _Iterator& __i, difference_type __n)
6914 requires random_access_range<_Base>
6921 friend constexpr _Iterator
6922 operator+(difference_type __n,
const _Iterator& __i)
6923 requires random_access_range<_Base>
6930 friend constexpr _Iterator
6931 operator-(
const _Iterator& __i, difference_type __n)
6932 requires random_access_range<_Base>
6939 friend constexpr difference_type
6940 operator-(
const _Iterator& __x,
const _Iterator& __y)
6941 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
6943 if constexpr (_S_last_elt_present)
6944 return __x._M_last_elt - __y._M_last_elt;
6946 return __x._M_current - __y._M_current;
6950 template<forward_range _Vp>
6952 class slide_view<_Vp>::_Sentinel
6954 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
6957 _Sentinel(sentinel_t<_Vp> __end)
6964 _Sentinel() =
default;
6966 friend constexpr bool
6967 operator==(
const _Iterator<false>& __x,
const _Sentinel& __y)
6968 {
return __x._M_last_elt == __y._M_end; }
6970 friend constexpr range_difference_t<_Vp>
6971 operator-(
const _Iterator<false>& __x,
const _Sentinel& __y)
6972 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6973 {
return __x._M_last_elt - __y._M_end; }
6975 friend constexpr range_difference_t<_Vp>
6976 operator-(
const _Sentinel& __y,
const _Iterator<false>& __x)
6977 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6978 {
return __y._M_end -__x._M_last_elt; }
6985 template<
typename _Range,
typename _Dp>
6986 concept __can_slide_view
6987 =
requires { slide_view(std::declval<_Range>(), std::declval<_Dp>()); };
6990 struct _Slide : __adaptor::_RangeAdaptor<_Slide>
6992 template<viewable_range _Range,
typename _Dp = range_difference_t<_Range>>
6993 requires __detail::__can_slide_view<_Range, _Dp>
6995 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n)
const
6996 {
return slide_view(std::forward<_Range>(__r), __n); }
6998 using __adaptor::_RangeAdaptor<_Slide>::operator();
6999 static constexpr int _S_arity = 2;
7000 static constexpr bool _S_has_simple_extra_args =
true;
7003 inline constexpr _Slide slide;
7007#ifdef __cpp_lib_ranges_chunk_by
7008 template<forward_range _Vp,
7009 indirect_binary_predicate<iterator_t<_Vp>, iterator_t<_Vp>> _Pred>
7010 requires view<_Vp> && is_object_v<_Pred>
7011 class chunk_by_view :
public view_interface<chunk_by_view<_Vp, _Pred>>
7013 _Vp _M_base = _Vp();
7014 __detail::__box<_Pred> _M_pred;
7015 __detail::_CachedPosition<_Vp> _M_cached_begin;
7017 constexpr iterator_t<_Vp>
7018 _M_find_next(iterator_t<_Vp> __current)
7020 __glibcxx_assert(_M_pred.has_value());
7021 auto __pred = [
this]<
typename _Tp,
typename _Up>(_Tp&& __x, _Up&& __y) {
7022 return !bool((*_M_pred)(std::forward<_Tp>(__x), std::forward<_Up>(__y)));
7024 auto __it = ranges::adjacent_find(__current, ranges::end(_M_base), __pred);
7025 return ranges::next(__it, 1, ranges::end(_M_base));
7028 constexpr iterator_t<_Vp>
7029 _M_find_prev(iterator_t<_Vp> __current)
requires bidirectional_range<_Vp>
7031 __glibcxx_assert(_M_pred.has_value());
7032 auto __pred = [
this]<
typename _Tp,
typename _Up>(_Tp&& __x, _Up&& __y) {
7033 return !bool((*_M_pred)(std::forward<_Up>(__y), std::forward<_Tp>(__x)));
7037 __glibcxx_assert(__rbegin != __rend);
7038 auto __it = ranges::adjacent_find(__rbegin, __rend, __pred).base();
7039 return ranges::prev(__it, 1, ranges::begin(_M_base));
7045 chunk_by_view()
requires (default_initializable<_Vp>
7046 && default_initializable<_Pred>)
7050 chunk_by_view(_Vp __base, _Pred __pred)
7055 base() const & requires copy_constructible<_Vp>
7062 constexpr const _Pred&
7064 {
return *_M_pred; }
7069 __glibcxx_assert(_M_pred.has_value());
7070 iterator_t<_Vp> __it;
7071 if (_M_cached_begin._M_has_value())
7072 __it = _M_cached_begin._M_get(_M_base);
7075 __it = _M_find_next(ranges::begin(_M_base));
7076 _M_cached_begin._M_set(_M_base, __it);
7078 return _Iterator(*
this, ranges::begin(_M_base), __it);
7084 if constexpr (common_range<_Vp>)
7085 return _Iterator(*
this, ranges::end(_M_base), ranges::end(_M_base));
7091 template<
typename _Range,
typename _Pred>
7092 chunk_by_view(_Range&&, _Pred) -> chunk_by_view<views::all_t<_Range>, _Pred>;
7094 template<forward_range _Vp,
7095 indirect_binary_predicate<iterator_t<_Vp>, iterator_t<_Vp>> _Pred>
7096 requires view<_Vp> && is_object_v<_Pred>
7097 class chunk_by_view<_Vp, _Pred>::_Iterator
7099 chunk_by_view* _M_parent =
nullptr;
7100 iterator_t<_Vp> _M_current = iterator_t<_Vp>();
7101 iterator_t<_Vp> _M_next = iterator_t<_Vp>();
7104 _Iterator(chunk_by_view& __parent, iterator_t<_Vp> __current, iterator_t<_Vp> __next)
7105 : _M_parent(
std::
__addressof(__parent)), _M_current(__current), _M_next(__next)
7111 if constexpr (bidirectional_range<_Vp>)
7112 return bidirectional_iterator_tag{};
7114 return forward_iterator_tag{};
7117 friend chunk_by_view;
7120 using value_type = subrange<iterator_t<_Vp>>;
7121 using difference_type = range_difference_t<_Vp>;
7122 using iterator_category = input_iterator_tag;
7123 using iterator_concept =
decltype(_S_iter_concept());
7125 _Iterator() =
default;
7127 constexpr value_type
7130 __glibcxx_assert(_M_current != _M_next);
7131 return ranges::subrange(_M_current, _M_next);
7134 constexpr _Iterator&
7137 __glibcxx_assert(_M_current != _M_next);
7138 _M_current = _M_next;
7139 _M_next = _M_parent->_M_find_next(_M_current);
7151 constexpr _Iterator&
7152 operator--()
requires bidirectional_range<_Vp>
7154 _M_next = _M_current;
7155 _M_current = _M_parent->_M_find_prev(_M_next);
7160 operator--(
int)
requires bidirectional_range<_Vp>
7167 friend constexpr bool
7168 operator==(
const _Iterator& __x,
const _Iterator& __y)
7169 {
return __x._M_current == __y._M_current; }
7171 friend constexpr bool
7172 operator==(
const _Iterator& __x, default_sentinel_t)
7173 {
return __x._M_current == __x._M_next; }
7180 template<
typename _Range,
typename _Pred>
7181 concept __can_chunk_by_view
7182 =
requires { chunk_by_view(std::declval<_Range>(), std::declval<_Pred>()); };
7185 struct _ChunkBy : __adaptor::_RangeAdaptor<_ChunkBy>
7187 template<viewable_range _Range,
typename _Pred>
7188 requires __detail::__can_chunk_by_view<_Range, _Pred>
7190 operator() [[nodiscard]] (_Range&& __r, _Pred&& __pred)
const
7191 {
return chunk_by_view(std::forward<_Range>(__r), std::forward<_Pred>(__pred)); }
7193 using __adaptor::_RangeAdaptor<_ChunkBy>::operator();
7194 static constexpr int _S_arity = 2;
7195 static constexpr bool _S_has_simple_extra_args =
true;
7198 inline constexpr _ChunkBy chunk_by;
7202#ifdef __cpp_lib_ranges_join_with
7205 template<
typename _Range,
typename _Pattern>
7206 concept __compatible_joinable_ranges
7207 = common_with<range_value_t<_Range>, range_value_t<_Pattern>>
7208 && common_reference_with<range_reference_t<_Range>,
7209 range_reference_t<_Pattern>>
7210 && common_reference_with<range_rvalue_reference_t<_Range>,
7211 range_rvalue_reference_t<_Pattern>>;
7213 template<
typename _Range>
7214 concept __bidirectional_common = bidirectional_range<_Range> && common_range<_Range>;
7217 template<input_range _Vp, forward_range _Pattern>
7218 requires view<_Vp> && view<_Pattern>
7219 && input_range<range_reference_t<_Vp>>
7220 && __detail::__compatible_joinable_ranges<range_reference_t<_Vp>, _Pattern>
7221 class join_with_view :
public view_interface<join_with_view<_Vp, _Pattern>>
7223 using _InnerRange = range_reference_t<_Vp>;
7225 _Vp _M_base = _Vp();
7226 [[no_unique_address]]
7227 __detail::__maybe_present_t<!forward_range<_Vp>,
7228 __detail::__non_propagating_cache<iterator_t<_Vp>>> _M_outer_it;
7229 __detail::__non_propagating_cache<remove_cv_t<_InnerRange>> _M_inner;
7230 _Pattern _M_pattern = _Pattern();
7232 template<
bool _Const>
using _Base = __detail::__maybe_const_t<_Const, _Vp>;
7233 template<
bool _Const>
using _InnerBase = range_reference_t<_Base<_Const>>;
7234 template<
bool _Const>
using _PatternBase = __detail::__maybe_const_t<_Const, _Pattern>;
7236 template<
bool _Const>
using _OuterIter = iterator_t<_Base<_Const>>;
7237 template<
bool _Const>
using _InnerIter = iterator_t<_InnerBase<_Const>>;
7238 template<
bool _Const>
using _PatternIter = iterator_t<_PatternBase<_Const>>;
7240 template<
bool _Const>
7241 static constexpr bool _S_ref_is_glvalue = is_reference_v<_InnerBase<_Const>>;
7243 template<
bool _Const>
7247 template<
bool _Const>
7248 requires _S_ref_is_glvalue<_Const>
7249 && forward_range<_Base<_Const>>
7250 && forward_range<_InnerBase<_Const>>
7251 struct __iter_cat<_Const>
7257 using _OuterIter = join_with_view::_OuterIter<_Const>;
7258 using _InnerIter = join_with_view::_InnerIter<_Const>;
7259 using _PatternIter = join_with_view::_PatternIter<_Const>;
7260 using _OuterCat =
typename iterator_traits<_OuterIter>::iterator_category;
7261 using _InnerCat =
typename iterator_traits<_InnerIter>::iterator_category;
7262 using _PatternCat =
typename iterator_traits<_PatternIter>::iterator_category;
7265 if constexpr (!is_reference_v<common_reference_t<iter_reference_t<_InnerIter>,
7266 iter_reference_t<_PatternIter>>>)
7267 return input_iterator_tag{};
7268 else if constexpr (derived_from<_OuterCat, bidirectional_iterator_tag>
7269 && derived_from<_InnerCat, bidirectional_iterator_tag>
7270 && derived_from<_PatternCat, bidirectional_iterator_tag>
7271 && common_range<_InnerBase<_Const>>
7272 && common_range<_PatternBase<_Const>>)
7273 return bidirectional_iterator_tag{};
7274 else if constexpr (derived_from<_OuterCat, forward_iterator_tag>
7275 && derived_from<_InnerCat, forward_iterator_tag>
7276 && derived_from<_PatternCat, forward_iterator_tag>)
7277 return forward_iterator_tag{};
7279 return input_iterator_tag{};
7282 using iterator_category =
decltype(_S_iter_cat());
7285 template<
bool>
struct _Iterator;
7286 template<
bool>
struct _Sentinel;
7289 join_with_view()
requires (default_initializable<_Vp>
7290 && default_initializable<_Pattern>)
7294 join_with_view(_Vp __base, _Pattern __pattern)
7298 template<input_range _Range>
7299 requires constructible_from<_Vp, views::all_t<_Range>>
7300 && constructible_from<_Pattern, single_view<range_value_t<_InnerRange>>>
7302 join_with_view(_Range&& __r, range_value_t<_InnerRange> __e)
7303 : _M_base(views::all(
std::
forward<_Range>(__r))),
7304 _M_pattern(views::single(
std::
move(__e)))
7308 base() const& requires copy_constructible<_Vp>
7318 if constexpr (forward_range<_Vp>)
7320 constexpr bool __use_const = is_reference_v<_InnerRange>
7321 && __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
7322 return _Iterator<__use_const>{*
this, ranges::begin(_M_base)};
7326 _M_outer_it = ranges::begin(_M_base);
7327 return _Iterator<false>{*
this};
7333 requires forward_range<const _Vp>
7334 && forward_range<const _Pattern>
7335 && is_reference_v<range_reference_t<const _Vp>>
7336 && input_range<range_reference_t<const _Vp>>
7337 {
return _Iterator<true>{*
this, ranges::begin(_M_base)}; }
7342 constexpr bool __use_const
7343 = __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
7344 if constexpr (is_reference_v<_InnerRange>
7345 && forward_range<_Vp> && common_range<_Vp>
7346 && forward_range<_InnerRange> && common_range<_InnerRange>)
7347 return _Iterator<__use_const>{*
this, ranges::end(_M_base)};
7349 return _Sentinel<__use_const>{*
this};
7354 requires forward_range<const _Vp>
7355 && forward_range<const _Pattern>
7356 && is_reference_v<range_reference_t<const _Vp>>
7357 && input_range<range_reference_t<const _Vp>>
7359 using _InnerConstRange = range_reference_t<const _Vp>;
7360 if constexpr (forward_range<_InnerConstRange>
7361 && common_range<const _Vp>
7362 && common_range<_InnerConstRange>)
7363 return _Iterator<true>{*
this, ranges::end(_M_base)};
7365 return _Sentinel<true>{*
this};
7369 template<
typename _Range,
typename _Pattern>
7370 join_with_view(_Range&&, _Pattern&&)
7371 -> join_with_view<views::all_t<_Range>, views::all_t<_Pattern>>;
7373 template<input_range _Range>
7374 join_with_view(_Range&&, range_value_t<range_reference_t<_Range>>)
7375 -> join_with_view<views::all_t<_Range>,
7376 single_view<range_value_t<range_reference_t<_Range>>>>;
7378 template<input_range _Vp, forward_range _Pattern>
7379 requires view<_Vp> && view<_Pattern>
7380 && input_range<range_reference_t<_Vp>>
7381 && __detail::__compatible_joinable_ranges<range_reference_t<_Vp>, _Pattern>
7382 template<
bool _Const>
7383 class join_with_view<_Vp, _Pattern>::_Iterator :
public __iter_cat<_Const>
7385 using _Parent = __detail::__maybe_const_t<_Const, join_with_view>;
7386 using _Base = join_with_view::_Base<_Const>;
7387 using _InnerBase = join_with_view::_InnerBase<_Const>;
7388 using _PatternBase = join_with_view::_PatternBase<_Const>;
7390 using _OuterIter = join_with_view::_OuterIter<_Const>;
7391 using _InnerIter = join_with_view::_InnerIter<_Const>;
7392 using _PatternIter = join_with_view::_PatternIter<_Const>;
7394 static constexpr bool _S_ref_is_glvalue = join_with_view::_S_ref_is_glvalue<_Const>;
7396 _Parent* _M_parent =
nullptr;
7397 [[no_unique_address]]
7398 __detail::__maybe_present_t<forward_range<_Base>, _OuterIter> _M_outer_it;
7399 variant<_PatternIter, _InnerIter> _M_inner_it;
7401 constexpr _OuterIter&
7404 if constexpr (forward_range<_Base>)
7407 return *_M_parent->_M_outer_it;
7410 constexpr const _OuterIter&
7411 _M_get_outer()
const
7413 if constexpr (forward_range<_Base>)
7416 return *_M_parent->_M_outer_it;
7420 _Iterator(_Parent& __parent, _OuterIter __outer)
7421 requires forward_range<_Base>
7424 if (_M_get_outer() != ranges::end(_M_parent->_M_base))
7426 auto&& __inner = _M_update_inner();
7427 _M_inner_it.template emplace<1>(ranges::begin(__inner));
7433 _Iterator(_Parent& __parent)
7434 requires (!forward_range<_Base>)
7437 if (_M_get_outer() != ranges::end(_M_parent->_M_base))
7439 auto&& __inner = _M_update_inner();
7440 _M_inner_it.template emplace<1>(ranges::begin(__inner));
7448 _OuterIter& __outer = _M_get_outer();
7449 if constexpr (_S_ref_is_glvalue)
7450 return __detail::__as_lvalue(*__outer);
7452 return _M_parent->_M_inner._M_emplace_deref(__outer);
7458 if constexpr (_S_ref_is_glvalue)
7459 return __detail::__as_lvalue(*_M_get_outer());
7461 return *_M_parent->_M_inner;
7469 if (_M_inner_it.index() == 0)
7471 if (std::get<0>(_M_inner_it) != ranges::end(_M_parent->_M_pattern))
7474 auto&& __inner = _M_update_inner();
7475 _M_inner_it.template emplace<1>(ranges::begin(__inner));
7479 auto&& __inner = _M_get_inner();
7480 if (std::get<1>(_M_inner_it) != ranges::end(__inner))
7483 if (++_M_get_outer() == ranges::end(_M_parent->_M_base))
7485 if constexpr (_S_ref_is_glvalue)
7486 _M_inner_it.template emplace<0>();
7490 _M_inner_it.template emplace<0>(ranges::begin(_M_parent->_M_pattern));
7498 if constexpr (_S_ref_is_glvalue
7499 && bidirectional_range<_Base>
7500 && __detail::__bidirectional_common<_InnerBase>
7501 && __detail::__bidirectional_common<_PatternBase>)
7502 return bidirectional_iterator_tag{};
7503 else if constexpr (_S_ref_is_glvalue
7504 && forward_range<_Base>
7505 && forward_range<_InnerBase>)
7506 return forward_iterator_tag{};
7508 return input_iterator_tag{};
7511 friend join_with_view;
7514 using iterator_concept =
decltype(_S_iter_concept());
7516 using value_type = common_type_t<iter_value_t<_InnerIter>,
7517 iter_value_t<_PatternIter>>;
7518 using difference_type = common_type_t<iter_difference_t<_OuterIter>,
7519 iter_difference_t<_InnerIter>,
7520 iter_difference_t<_PatternIter>>;
7522 _Iterator() =
default;
7525 _Iterator(_Iterator<!_Const> __i)
7527 && convertible_to<iterator_t<_Vp>, _OuterIter>
7528 && convertible_to<iterator_t<_InnerRange>, _InnerIter>
7529 && convertible_to<iterator_t<_Pattern>, _PatternIter>
7530 : _M_parent(__i._M_parent),
7533 if (__i._M_inner_it.index() == 0)
7534 _M_inner_it.template emplace<0>(std::get<0>(
std::move(__i._M_inner_it)));
7536 _M_inner_it.template emplace<1>(std::get<1>(
std::move(__i._M_inner_it)));
7539 constexpr common_reference_t<iter_reference_t<_InnerIter>,
7540 iter_reference_t<_PatternIter>>
7543 if (_M_inner_it.index() == 0)
7544 return *std::get<0>(_M_inner_it);
7546 return *std::get<1>(_M_inner_it);
7549 constexpr _Iterator&
7552 if (_M_inner_it.index() == 0)
7553 ++std::get<0>(_M_inner_it);
7555 ++std::get<1>(_M_inner_it);
7566 requires _S_ref_is_glvalue
7567 && forward_iterator<_OuterIter> && forward_iterator<_InnerIter>
7569 _Iterator __tmp = *
this;
7574 constexpr _Iterator&
7576 requires _S_ref_is_glvalue
7577 && bidirectional_range<_Base>
7578 && __detail::__bidirectional_common<_InnerBase>
7579 && __detail::__bidirectional_common<_PatternBase>
7581 if (_M_outer_it == ranges::end(_M_parent->_M_base))
7583 auto&& __inner = *--_M_outer_it;
7584 _M_inner_it.template emplace<1>(ranges::end(__inner));
7589 if (_M_inner_it.index() == 0)
7591 auto& __it = std::get<0>(_M_inner_it);
7592 if (__it == ranges::begin(_M_parent->_M_pattern))
7594 auto&& __inner = *--_M_outer_it;
7595 _M_inner_it.template emplace<1>(ranges::end(__inner));
7602 auto& __it = std::get<1>(_M_inner_it);
7603 auto&& __inner = *_M_outer_it;
7604 if (__it == ranges::begin(__inner))
7605 _M_inner_it.template emplace<0>(ranges::end(_M_parent->_M_pattern));
7611 if (_M_inner_it.index() == 0)
7612 --std::get<0>(_M_inner_it);
7614 --std::get<1>(_M_inner_it);
7620 requires _S_ref_is_glvalue && bidirectional_range<_Base>
7621 && __detail::__bidirectional_common<_InnerBase>
7622 && __detail::__bidirectional_common<_PatternBase>
7624 _Iterator __tmp = *
this;
7629 friend constexpr bool
7630 operator==(
const _Iterator& __x,
const _Iterator& __y)
7631 requires _S_ref_is_glvalue
7632 && forward_range<_Base> && equality_comparable<_InnerIter>
7633 {
return __x._M_outer_it == __y._M_outer_it && __x._M_inner_it ==__y._M_inner_it; }
7635 friend constexpr common_reference_t<iter_rvalue_reference_t<_InnerIter>,
7636 iter_rvalue_reference_t<_PatternIter>>
7637 iter_move(
const _Iterator& __x)
7639 if (__x._M_inner_it.index() == 0)
7640 return ranges::iter_move(std::get<0>(__x._M_inner_it));
7642 return ranges::iter_move(std::get<1>(__x._M_inner_it));
7645 friend constexpr void
7646 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
7647 requires indirectly_swappable<_InnerIter, _PatternIter>
7649 if (__x._M_inner_it.index() == 0)
7651 if (__y._M_inner_it.index() == 0)
7652 ranges::iter_swap(std::get<0>(__x._M_inner_it), std::get<0>(__y._M_inner_it));
7654 ranges::iter_swap(std::get<0>(__x._M_inner_it), std::get<1>(__y._M_inner_it));
7658 if (__y._M_inner_it.index() == 0)
7659 ranges::iter_swap(std::get<1>(__x._M_inner_it), std::get<0>(__y._M_inner_it));
7661 ranges::iter_swap(std::get<1>(__x._M_inner_it), std::get<1>(__y._M_inner_it));
7666 template<input_range _Vp, forward_range _Pattern>
7667 requires view<_Vp> && view<_Pattern>
7668 && input_range<range_reference_t<_Vp>>
7669 && __detail::__compatible_joinable_ranges<range_reference_t<_Vp>, _Pattern>
7670 template<
bool _Const>
7671 class join_with_view<_Vp, _Pattern>::_Sentinel
7673 using _Parent = __detail::__maybe_const_t<_Const, join_with_view>;
7674 using _Base = join_with_view::_Base<_Const>;
7676 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
7679 _Sentinel(_Parent& __parent)
7680 : _M_end(ranges::
end(__parent._M_base))
7683 friend join_with_view;
7686 _Sentinel() =
default;
7689 _Sentinel(_Sentinel<!_Const> __s)
7690 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
7694 template<
bool _OtherConst>
7695 requires sentinel_for<sentinel_t<_Base>,
7696 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
7697 friend constexpr bool
7698 operator==(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
7699 {
return __x._M_get_outer() == __y._M_end; }
7706 template<
typename _Range,
typename _Pattern>
7707 concept __can_join_with_view
7708 =
requires { join_with_view(std::declval<_Range>(), std::declval<_Pattern>()); };
7711 struct _JoinWith : __adaptor::_RangeAdaptor<_JoinWith>
7713 template<viewable_range _Range,
typename _Pattern>
7714 requires __detail::__can_join_with_view<_Range, _Pattern>
7716 operator() [[nodiscard]] (_Range&& __r, _Pattern&& __f)
const
7718 return join_with_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
7721 using _RangeAdaptor<_JoinWith>::operator();
7722 static constexpr int _S_arity = 2;
7723 template<
typename _Pattern>
7724 static constexpr bool _S_has_simple_extra_args
7725 = _LazySplit::_S_has_simple_extra_args<_Pattern>;
7728 inline constexpr _JoinWith join_with;
7732#ifdef __cpp_lib_ranges_repeat
7733 template<move_constructible _Tp, semiregular _Bound = unreachable_sentinel_t>
7734 requires is_object_v<_Tp> && same_as<_Tp, remove_cv_t<_Tp>>
7735 && (__detail::__is_integer_like<_Bound> || same_as<_Bound, unreachable_sentinel_t>)
7736 class repeat_view : public view_interface<repeat_view<_Tp, _Bound>>
7738 __detail::__box<_Tp> _M_value;
7739 [[no_unique_address]] _Bound _M_bound = _Bound();
7743 template<
typename _Range>
7744 friend constexpr auto
7745 views::__detail::__take_of_repeat_view(_Range&&, range_difference_t<_Range>);
7747 template<
typename _Range>
7748 friend constexpr auto
7749 views::__detail::__drop_of_repeat_view(_Range&&, range_difference_t<_Range>);
7752 repeat_view()
requires default_initializable<_Tp> = default;
7755 repeat_view(const _Tp& __value, _Bound __bound = _Bound())
7756 requires copy_constructible<_Tp>
7757 : _M_value(__value), _M_bound(__bound)
7759 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7760 __glibcxx_assert(__bound >= 0);
7764 repeat_view(_Tp&& __value, _Bound __bound = _Bound())
7765 : _M_value(
std::
move(__value)), _M_bound(__bound)
7768 template<
typename... _Args,
typename... _BoundArgs>
7769 requires constructible_from<_Tp, _Args...>
7770 && constructible_from<_Bound, _BoundArgs...>
7772 repeat_view(piecewise_construct_t,
7773 tuple<_Args...> __args,
7774 tuple<_BoundArgs...> __bound_args = tuple<>{})
7775 : _M_value(
std::make_from_tuple<_Tp>(
std::
move(__args))),
7776 _M_bound(
std::make_from_tuple<_Bound>(
std::
move(__bound_args)))
7784 end() const requires (!same_as<_Bound, unreachable_sentinel_t>)
7787 constexpr unreachable_sentinel_t
7788 end() const noexcept
7789 {
return unreachable_sentinel; }
7792 size() const requires (!same_as<_Bound, unreachable_sentinel_t>)
7793 {
return __detail::__to_unsigned_like(_M_bound); }
7798 template<
typename _Tp,
typename _Bound = unreachable_sentinel_t>
7799 repeat_view(_Tp, _Bound = _Bound()) -> repeat_view<_Tp, _Bound>;
7801 template<move_constructible _Tp, semiregular _Bound>
7802 requires is_object_v<_Tp> && same_as<_Tp, remove_cv_t<_Tp>>
7803 && (__detail::__is_integer_like<_Bound> || same_as<_Bound, unreachable_sentinel_t>)
7804 class repeat_view<_Tp, _Bound>::_Iterator
7807 = __conditional_t<same_as<_Bound, unreachable_sentinel_t>, ptrdiff_t, _Bound>;
7809 const _Tp* _M_value =
nullptr;
7810 __index_type _M_current = __index_type();
7813 _Iterator(
const _Tp* __value, __index_type __bound = __index_type())
7814 : _M_value(__value), _M_current(__bound)
7816 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7817 __glibcxx_assert(__bound >= 0);
7823 using iterator_concept = random_access_iterator_tag;
7824 using iterator_category = random_access_iterator_tag;
7825 using value_type = _Tp;
7826 using difference_type = __conditional_t<__detail::__is_signed_integer_like<__index_type>,
7828 __detail::__iota_diff_t<__index_type>>;
7830 _Iterator() =
default;
7832 constexpr const _Tp&
7834 {
return *_M_value; }
7836 constexpr _Iterator&
7851 constexpr _Iterator&
7854 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7855 __glibcxx_assert(_M_current > 0);
7868 constexpr _Iterator&
7869 operator+=(difference_type __n)
7871 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7872 __glibcxx_assert(_M_current + __n >= 0);
7877 constexpr _Iterator&
7878 operator-=(difference_type __n)
7880 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7881 __glibcxx_assert(_M_current - __n >= 0);
7886 constexpr const _Tp&
7887 operator[](difference_type __n)
const noexcept
7888 {
return *(*
this + __n); }
7890 friend constexpr bool
7891 operator==(
const _Iterator& __x,
const _Iterator& __y)
7892 {
return __x._M_current == __y._M_current; }
7894 friend constexpr auto
7895 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
7896 {
return __x._M_current <=> __y._M_current; }
7898 friend constexpr _Iterator
7899 operator+(_Iterator __i, difference_type __n)
7905 friend constexpr _Iterator
7906 operator+(difference_type __n, _Iterator __i)
7907 {
return __i + __n; }
7909 friend constexpr _Iterator
7910 operator-(_Iterator __i, difference_type __n)
7916 friend constexpr difference_type
7917 operator-(
const _Iterator& __x,
const _Iterator& __y)
7919 return (
static_cast<difference_type
>(__x._M_current)
7920 -
static_cast<difference_type
>(__y._M_current));
7928 template<
typename _Tp,
typename _Bound>
7929 inline constexpr bool __is_repeat_view<repeat_view<_Tp, _Bound>> =
true;
7931 template<
typename _Tp>
7932 concept __can_repeat_view
7933 =
requires { repeat_view(std::declval<_Tp>()); };
7935 template<
typename _Tp,
typename _Bound>
7936 concept __can_bounded_repeat_view
7937 =
requires { repeat_view(std::declval<_Tp>(), std::declval<_Bound>()); };
7942 template<
typename _Tp>
7943 requires __detail::__can_repeat_view<_Tp>
7945 operator() [[nodiscard]] (_Tp&& __value)
const
7949 return repeat_view<decay_t<_Tp>>(std::forward<_Tp>(__value));
7952 template<
typename _Tp,
typename _Bound>
7953 requires __detail::__can_bounded_repeat_view<_Tp, _Bound>
7955 operator() [[nodiscard]] (_Tp&& __value, _Bound __bound)
const
7956 {
return repeat_view(std::forward<_Tp>(__value), __bound); }
7959 inline constexpr _Repeat repeat;
7963 template<
typename _Range>
7965 __take_of_repeat_view(_Range&& __r, range_difference_t<_Range> __n)
7967 using _Tp = remove_cvref_t<_Range>;
7968 static_assert(__is_repeat_view<_Tp>);
7969 if constexpr (sized_range<_Tp>)
7970 return views::repeat(*std::forward<_Range>(__r)._M_value,
7971 std::min(ranges::distance(__r), __n));
7973 return views::repeat(*std::forward<_Range>(__r)._M_value, __n);
7976 template<
typename _Range>
7978 __drop_of_repeat_view(_Range&& __r, range_difference_t<_Range> __n)
7980 using _Tp = remove_cvref_t<_Range>;
7981 static_assert(__is_repeat_view<_Tp>);
7982 if constexpr (sized_range<_Tp>)
7984 auto __sz = ranges::distance(__r);
7985 return views::repeat(*std::forward<_Range>(__r)._M_value,
7995#ifdef __cpp_lib_ranges_stride
7996 template<input_range _Vp>
7998 class stride_view :
public view_interface<stride_view<_Vp>>
8001 range_difference_t<_Vp> _M_stride;
8003 template<
bool _Const>
using _Base = __detail::__maybe_const_t<_Const, _Vp>;
8005 template<
bool _Const>
8009 template<
bool _Const>
8010 requires forward_range<_Base<_Const>>
8011 struct __iter_cat<_Const>
8017 using _Cat =
typename iterator_traits<iterator_t<_Base<_Const>>>::iterator_category;
8018 if constexpr (derived_from<_Cat, random_access_iterator_tag>)
8019 return random_access_iterator_tag{};
8024 using iterator_category =
decltype(_S_iter_cat());
8027 template<
bool>
class _Iterator;
8031 stride_view(_Vp __base, range_difference_t<_Vp> __stride)
8033 { __glibcxx_assert(__stride > 0); }
8036 base() const& requires copy_constructible<_Vp>
8043 constexpr range_difference_t<_Vp>
8044 stride() const noexcept
8045 {
return _M_stride; }
8048 begin()
requires (!__detail::__simple_view<_Vp>)
8049 {
return _Iterator<false>(
this, ranges::begin(_M_base)); }
8052 begin() const requires range<const _Vp>
8053 {
return _Iterator<true>(
this, ranges::begin(_M_base)); }
8056 end()
requires (!__detail::__simple_view<_Vp>)
8058 if constexpr (common_range<_Vp> && sized_range<_Vp> && forward_range<_Vp>)
8060 auto __missing = (_M_stride - ranges::distance(_M_base) % _M_stride) % _M_stride;
8061 return _Iterator<false>(
this, ranges::end(_M_base), __missing);
8063 else if constexpr (common_range<_Vp> && !bidirectional_range<_Vp>)
8064 return _Iterator<false>(
this, ranges::end(_M_base));
8070 end() const requires range<const _Vp>
8072 if constexpr (common_range<const _Vp> && sized_range<const _Vp>
8073 && forward_range<const _Vp>)
8075 auto __missing = (_M_stride - ranges::distance(_M_base) % _M_stride) % _M_stride;
8076 return _Iterator<true>(
this, ranges::end(_M_base), __missing);
8078 else if constexpr (common_range<const _Vp> && !bidirectional_range<const _Vp>)
8079 return _Iterator<true>(
this, ranges::end(_M_base));
8085 size()
requires sized_range<_Vp>
8087 return __detail::__to_unsigned_like
8088 (__detail::__div_ceil(ranges::distance(_M_base), _M_stride));
8092 size() const requires sized_range<const _Vp>
8094 return __detail::__to_unsigned_like
8095 (__detail::__div_ceil(ranges::distance(_M_base), _M_stride));
8099 template<
typename _Range>
8100 stride_view(_Range&&, range_difference_t<_Range>) -> stride_view<views::all_t<_Range>>;
8102 template<
typename _Vp>
8103 inline constexpr bool enable_borrowed_range<stride_view<_Vp>>
8104 = enable_borrowed_range<_Vp>;
8106 template<input_range _Vp>
8108 template<
bool _Const>
8109 class stride_view<_Vp>::_Iterator :
public __iter_cat<_Const>
8111 using _Parent = __detail::__maybe_const_t<_Const, stride_view>;
8112 using _Base = stride_view::_Base<_Const>;
8114 iterator_t<_Base> _M_current = iterator_t<_Base>();
8115 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
8116 range_difference_t<_Base> _M_stride = 0;
8117 range_difference_t<_Base> _M_missing = 0;
8120 _Iterator(_Parent* __parent, iterator_t<_Base> __current,
8121 range_difference_t<_Base> __missing = 0)
8122 : _M_current(
std::
move(__current)), _M_end(ranges::
end(__parent->_M_base)),
8123 _M_stride(__parent->_M_stride), _M_missing(__missing)
8129 if constexpr (random_access_range<_Base>)
8130 return random_access_iterator_tag{};
8131 else if constexpr (bidirectional_range<_Base>)
8132 return bidirectional_iterator_tag{};
8133 else if constexpr (forward_range<_Base>)
8134 return forward_iterator_tag{};
8136 return input_iterator_tag{};
8142 using difference_type = range_difference_t<_Base>;
8143 using value_type = range_value_t<_Base>;
8144 using iterator_concept =
decltype(_S_iter_concept());
8147 _Iterator()
requires default_initializable<iterator_t<_Base>> = default;
8150 _Iterator(_Iterator<!_Const> __other)
8152 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
8153 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
8154 : _M_current(
std::move(__other._M_current)), _M_end(
std::move(__other._M_end)),
8155 _M_stride(__other._M_stride), _M_missing(__other._M_missing)
8158 constexpr iterator_t<_Base>
8162 constexpr const iterator_t<_Base>&
8163 base() const & noexcept
8164 {
return _M_current; }
8166 constexpr decltype(
auto)
8168 {
return *_M_current; }
8170 constexpr _Iterator&
8173 __glibcxx_assert(_M_current != _M_end);
8174 _M_missing = ranges::advance(_M_current, _M_stride, _M_end);
8183 operator++(
int)
requires forward_range<_Base>
8190 constexpr _Iterator&
8191 operator--()
requires bidirectional_range<_Base>
8193 ranges::advance(_M_current, _M_missing - _M_stride);
8199 operator--(
int)
requires bidirectional_range<_Base>
8206 constexpr _Iterator&
8207 operator+=(difference_type __n)
requires random_access_range<_Base>
8211 __glibcxx_assert(ranges::distance(_M_current, _M_end) > _M_stride * (__n - 1));
8212 _M_missing = ranges::advance(_M_current, _M_stride * __n, _M_end);
8216 ranges::advance(_M_current, _M_stride * __n + _M_missing);
8222 constexpr _Iterator&
8223 operator-=(difference_type __n)
requires random_access_range<_Base>
8224 {
return *
this += -__n; }
8226 constexpr decltype(
auto)
operator[](difference_type __n)
const
8227 requires random_access_range<_Base>
8228 {
return *(*
this + __n); }
8230 friend constexpr bool
8231 operator==(
const _Iterator& __x, default_sentinel_t)
8232 {
return __x._M_current == __x._M_end; }
8234 friend constexpr bool
8235 operator==(
const _Iterator& __x,
const _Iterator& __y)
8236 requires equality_comparable<iterator_t<_Base>>
8237 {
return __x._M_current == __y._M_current; }
8239 friend constexpr bool
8240 operator<(
const _Iterator& __x,
const _Iterator& __y)
8241 requires random_access_range<_Base>
8242 {
return __x._M_current < __y._M_current; }
8244 friend constexpr bool
8245 operator>(
const _Iterator& __x,
const _Iterator& __y)
8246 requires random_access_range<_Base>
8247 {
return __y._M_current < __x._M_current; }
8249 friend constexpr bool
8250 operator<=(
const _Iterator& __x,
const _Iterator& __y)
8251 requires random_access_range<_Base>
8252 {
return !(__y._M_current < __x._M_current); }
8254 friend constexpr bool
8255 operator>=(
const _Iterator& __x,
const _Iterator& __y)
8256 requires random_access_range<_Base>
8257 {
return !(__x._M_current < __y._M_current); }
8259 friend constexpr auto
8260 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
8261 requires random_access_range<_Base> && three_way_comparable<iterator_t<_Base>>
8262 {
return __x._M_current <=> __y._M_current; }
8264 friend constexpr _Iterator
8265 operator+(
const _Iterator& __i, difference_type __n)
8266 requires random_access_range<_Base>
8273 friend constexpr _Iterator
8274 operator+(difference_type __n,
const _Iterator& __i)
8275 requires random_access_range<_Base>
8276 {
return __i + __n; }
8278 friend constexpr _Iterator
8279 operator-(
const _Iterator& __i, difference_type __n)
8280 requires random_access_range<_Base>
8287 friend constexpr difference_type
8288 operator-(
const _Iterator& __x,
const _Iterator& __y)
8289 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
8291 auto __n = __x._M_current - __y._M_current;
8292 if constexpr (forward_range<_Base>)
8293 return (__n + __x._M_missing - __y._M_missing) / __x._M_stride;
8295 return -__detail::__div_ceil(-__n, __x._M_stride);
8297 return __detail::__div_ceil(__n, __x._M_stride);
8300 friend constexpr difference_type
8301 operator-(default_sentinel_t __y,
const _Iterator& __x)
8302 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
8303 {
return __detail::__div_ceil(__x._M_end - __x._M_current, __x._M_stride); }
8305 friend constexpr difference_type
8306 operator-(
const _Iterator& __x, default_sentinel_t __y)
8307 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
8308 {
return -(__y - __x); }
8310 friend constexpr range_rvalue_reference_t<_Base>
8311 iter_move(
const _Iterator& __i)
8312 noexcept(
noexcept(ranges::iter_move(__i._M_current)))
8313 {
return ranges::iter_move(__i._M_current); }
8315 friend constexpr void
8316 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
8317 noexcept(
noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
8318 requires indirectly_swappable<iterator_t<_Base>>
8319 { ranges::iter_swap(__x._M_current, __y._M_current); }
8326 template<
typename _Range,
typename _Dp>
8327 concept __can_stride_view
8328 =
requires { stride_view(std::declval<_Range>(), std::declval<_Dp>()); };
8331 struct _Stride : __adaptor::_RangeAdaptor<_Stride>
8333 template<viewable_range _Range,
typename _Dp = range_difference_t<_Range>>
8334 requires __detail::__can_stride_view<_Range, _Dp>
8336 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n)
const
8337 {
return stride_view(std::forward<_Range>(__r), __n); }
8339 using __adaptor::_RangeAdaptor<_Stride>::operator();
8340 static constexpr int _S_arity = 2;
8341 static constexpr bool _S_has_simple_extra_args =
true;
8344 inline constexpr _Stride stride;
8348#ifdef __cpp_lib_ranges_cartesian_product
8351 template<
bool _Const,
typename _First,
typename... _Vs>
8352 concept __cartesian_product_is_random_access
8353 = (random_access_range<__maybe_const_t<_Const, _First>>
8355 && (random_access_range<__maybe_const_t<_Const, _Vs>>
8356 && sized_range<__maybe_const_t<_Const, _Vs>>));
8358 template<
typename _Range>
8359 concept __cartesian_product_common_arg
8360 = common_range<_Range> || (sized_range<_Range> && random_access_range<_Range>);
8362 template<
bool _Const,
typename _First,
typename... _Vs>
8363 concept __cartesian_product_is_bidirectional
8364 = (bidirectional_range<__maybe_const_t<_Const, _First>>
8366 && (bidirectional_range<__maybe_const_t<_Const, _Vs>>
8367 && __cartesian_product_common_arg<__maybe_const_t<_Const, _Vs>>));
8369 template<
typename _First,
typename... _Vs>
8370 concept __cartesian_product_is_common = __cartesian_product_common_arg<_First>;
8372 template<
typename... _Vs>
8373 concept __cartesian_product_is_sized = (sized_range<_Vs> && ...);
8375 template<
bool _Const,
template<
typename>
class FirstSent,
typename _First,
typename... _Vs>
8376 concept __cartesian_is_sized_sentinel
8377 = (sized_sentinel_for<FirstSent<__maybe_const_t<_Const, _First>>,
8378 iterator_t<__maybe_const_t<_Const, _First>>>
8380 && (sized_range<__maybe_const_t<_Const, _Vs>>
8381 && sized_sentinel_for<iterator_t<__maybe_const_t<_Const, _Vs>>,
8382 iterator_t<__maybe_const_t<_Const, _Vs>>>));
8384 template<__cartesian_product_common_arg _Range>
8386 __cartesian_common_arg_end(_Range& __r)
8388 if constexpr (common_range<_Range>)
8389 return ranges::end(__r);
8391 return ranges::begin(__r) + ranges::distance(__r);
8395 template<input_range _First, forward_range... _Vs>
8396 requires (view<_First> && ... && view<_Vs>)
8397 class cartesian_product_view : public view_interface<cartesian_product_view<_First, _Vs...>>
8399 tuple<_First, _Vs...> _M_bases;
8401 template<
bool>
class _Iterator;
8404 _S_difference_type()
8410 range_difference_t<_First>,
8411 range_difference_t<_Vs>...>{};
8415 cartesian_product_view() =
default;
8418 cartesian_product_view(_First __first, _Vs... __rest)
8422 constexpr _Iterator<false>
8423 begin()
requires (!__detail::__simple_view<_First> || ... || !__detail::__simple_view<_Vs>)
8424 {
return _Iterator<false>(*
this, __detail::__tuple_transform(ranges::begin, _M_bases)); }
8426 constexpr _Iterator<true>
8427 begin() const requires (range<const _First> && ... && range<const _Vs>)
8428 {
return _Iterator<true>(*
this, __detail::__tuple_transform(ranges::begin, _M_bases)); }
8430 constexpr _Iterator<false>
8431 end()
requires ((!__detail::__simple_view<_First> || ... || !__detail::__simple_view<_Vs>)
8432 && __detail::__cartesian_product_is_common<_First, _Vs...>)
8435 using _Ret = tuple<iterator_t<_First>, iterator_t<_Vs>...>;
8436 bool __empty_tail = (ranges::empty(std::get<1 + _Is>(_M_bases)) || ...);
8437 auto& __first = std::get<0>(_M_bases);
8438 return _Ret{(__empty_tail
8439 ? ranges::begin(__first)
8440 : __detail::__cartesian_common_arg_end(__first)),
8441 ranges::
begin(
std::get<1 + _Is>(_M_bases))...};
8444 return _Iterator<false>{*
this,
std::move(__its)};
8447 constexpr _Iterator<true>
8448 end() const requires __detail::__cartesian_product_is_common<const _First, const _Vs...>
8451 using _Ret = tuple<iterator_t<const _First>, iterator_t<const _Vs>...>;
8452 bool __empty_tail = (ranges::empty(std::get<1 + _Is>(_M_bases)) || ...);
8453 auto& __first = std::get<0>(_M_bases);
8454 return _Ret{(__empty_tail
8455 ? ranges::begin(__first)
8456 : __detail::__cartesian_common_arg_end(__first)),
8457 ranges::
begin(
std::get<1 + _Is>(_M_bases))...};
8460 return _Iterator<true>{*
this,
std::move(__its)};
8463 constexpr default_sentinel_t
8464 end() const noexcept
8468 size()
requires __detail::__cartesian_product_is_sized<_First, _Vs...>
8470 using _ST = __detail::__make_unsigned_like_t<
decltype(_S_difference_type())>;
8472 auto __size =
static_cast<_ST
>(1);
8473#ifdef _GLIBCXX_ASSERTIONS
8474 if constexpr (integral<_ST>)
8477 = (__builtin_mul_overflow(__size,
8478 static_cast<_ST
>(ranges::size(std::get<_Is>(_M_bases))),
8481 __glibcxx_assert(!__overflow);
8485 __size = (
static_cast<_ST
>(ranges::size(std::get<_Is>(_M_bases))) * ...);
8491 size() const requires __detail::__cartesian_product_is_sized<const _First, const _Vs...>
8493 using _ST = __detail::__make_unsigned_like_t<
decltype(_S_difference_type())>;
8495 auto __size =
static_cast<_ST
>(1);
8496#ifdef _GLIBCXX_ASSERTIONS
8497 if constexpr (integral<_ST>)
8500 = (__builtin_mul_overflow(__size,
8501 static_cast<_ST
>(ranges::size(std::get<_Is>(_M_bases))),
8504 __glibcxx_assert(!__overflow);
8508 __size = (
static_cast<_ST
>(ranges::size(std::get<_Is>(_M_bases))) * ...);
8514 template<
typename... _Vs>
8515 cartesian_product_view(_Vs&&...) -> cartesian_product_view<views::all_t<_Vs>...>;
8517 template<input_range _First, forward_range... _Vs>
8518 requires (view<_First> && ... && view<_Vs>)
8519 template<bool _Const>
8520 class cartesian_product_view<_First, _Vs...>::_Iterator
8522 using _Parent = __maybe_const_t<_Const, cartesian_product_view>;
8523 _Parent* _M_parent =
nullptr;
8524 tuple<iterator_t<__maybe_const_t<_Const, _First>>,
8525 iterator_t<__maybe_const_t<_Const, _Vs>>...> _M_current;
8528 _Iterator(_Parent& __parent,
decltype(_M_current) __current)
8530 _M_current(
std::
move(__current))
8536 if constexpr (__detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>)
8537 return random_access_iterator_tag{};
8538 else if constexpr (__detail::__cartesian_product_is_bidirectional<_Const, _First, _Vs...>)
8539 return bidirectional_iterator_tag{};
8540 else if constexpr (forward_range<__maybe_const_t<_Const, _First>>)
8541 return forward_iterator_tag{};
8543 return input_iterator_tag{};
8546 friend cartesian_product_view;
8549 using iterator_category = input_iterator_tag;
8550 using iterator_concept =
decltype(_S_iter_concept());
8552 = tuple<range_value_t<__maybe_const_t<_Const, _First>>,
8553 range_value_t<__maybe_const_t<_Const, _Vs>>...>;
8555 = tuple<range_reference_t<__maybe_const_t<_Const, _First>>,
8556 range_reference_t<__maybe_const_t<_Const, _Vs>>...>;
8557 using difference_type =
decltype(cartesian_product_view::_S_difference_type());
8559 _Iterator() =
default;
8562 _Iterator(_Iterator<!_Const> __i)
8564 && (convertible_to<iterator_t<_First>, iterator_t<const _First>>
8565 && ... && convertible_to<iterator_t<_Vs>, iterator_t<const _Vs>>)
8567 _M_current(
std::
move(__i._M_current))
8573 auto __f = [](
auto& __i) ->
decltype(
auto) {
8576 return __detail::__tuple_transform(__f, _M_current);
8579 constexpr _Iterator&
8591 operator++(
int)
requires forward_range<__maybe_const_t<_Const, _First>>
8598 constexpr _Iterator&
8600 requires __detail::__cartesian_product_is_bidirectional<_Const, _First, _Vs...>
8608 requires __detail::__cartesian_product_is_bidirectional<_Const, _First, _Vs...>
8615 constexpr _Iterator&
8616 operator+=(difference_type __x)
8617 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8623 constexpr _Iterator&
8624 operator-=(difference_type __x)
8625 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8626 {
return *
this += -__x; }
8629 operator[](difference_type __n)
const
8630 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8631 {
return *((*this) + __n); }
8633 friend constexpr bool
8634 operator==(
const _Iterator& __x,
const _Iterator& __y)
8635 requires equality_comparable<iterator_t<__maybe_const_t<_Const, _First>>>
8636 {
return __x._M_current == __y._M_current; }
8638 friend constexpr bool
8639 operator==(
const _Iterator& __x, default_sentinel_t)
8642 return ((std::get<_Is>(__x._M_current)
8643 == ranges::end(std::get<_Is>(__x._M_parent->_M_bases)))
8648 friend constexpr auto
8649 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
8650 requires __detail::__all_random_access<_Const, _First, _Vs...>
8651 {
return __x._M_current <=> __y._M_current; }
8653 friend constexpr _Iterator
8654 operator+(_Iterator __x, difference_type __y)
8655 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8656 {
return __x += __y; }
8658 friend constexpr _Iterator
8659 operator+(difference_type __x, _Iterator __y)
8660 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8661 {
return __y += __x; }
8663 friend constexpr _Iterator
8664 operator-(_Iterator __x, difference_type __y)
8665 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8666 {
return __x -= __y; }
8668 friend constexpr difference_type
8669 operator-(
const _Iterator& __x,
const _Iterator& __y)
8670 requires __detail::__cartesian_is_sized_sentinel<_Const, iterator_t, _First, _Vs...>
8671 {
return __x._M_distance_from(__y._M_current); }
8673 friend constexpr difference_type
8674 operator-(
const _Iterator& __i, default_sentinel_t)
8675 requires __detail::__cartesian_is_sized_sentinel<_Const, sentinel_t, _First, _Vs...>
8678 return tuple{ranges::end(std::get<0>(__i._M_parent->_M_bases)),
8679 ranges::begin(std::get<1 + _Is>(__i._M_parent->_M_bases))...};
8681 return __i._M_distance_from(__end_tuple);
8684 friend constexpr difference_type
8685 operator-(default_sentinel_t,
const _Iterator& __i)
8686 requires __detail::__cartesian_is_sized_sentinel<_Const, sentinel_t, _First, _Vs...>
8689 friend constexpr auto
8690 iter_move(
const _Iterator& __i)
8691 {
return __detail::__tuple_transform(ranges::iter_move, __i._M_current); }
8693 friend constexpr void
8694 iter_swap(
const _Iterator& __l,
const _Iterator& __r)
8695 requires (indirectly_swappable<iterator_t<__maybe_const_t<_Const, _First>>>
8697 && indirectly_swappable<iterator_t<__maybe_const_t<_Const, _Vs>>>)
8700 (ranges::iter_swap(std::get<_Is>(__l._M_current), std::get<_Is>(__r._M_current)), ...);
8705 template<
size_t _Nm =
sizeof...(_Vs)>
8709 auto& __it = std::get<_Nm>(_M_current);
8711 if constexpr (_Nm > 0)
8712 if (__it == ranges::end(std::get<_Nm>(_M_parent->_M_bases)))
8714 __it = ranges::begin(std::get<_Nm>(_M_parent->_M_bases));
8719 template<
size_t _Nm =
sizeof...(_Vs)>
8723 auto& __it = std::get<_Nm>(_M_current);
8724 if constexpr (_Nm > 0)
8725 if (__it == ranges::begin(std::get<_Nm>(_M_parent->_M_bases)))
8727 __it = __detail::__cartesian_common_arg_end(std::get<_Nm>(_M_parent->_M_bases));
8733 template<
size_t _Nm =
sizeof...(_Vs)>
8735 _M_advance(difference_type __x)
8736 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8745 auto& __r = std::get<_Nm>(_M_parent->_M_bases);
8746 auto& __it = std::get<_Nm>(_M_current);
8747 if constexpr (_Nm == 0)
8749#ifdef _GLIBCXX_ASSERTIONS
8750 if constexpr (sized_range<__maybe_const_t<_Const, _First>>)
8752 auto __size = ranges::ssize(__r);
8753 auto __begin = ranges::begin(__r);
8754 auto __offset = __it - __begin;
8755 __glibcxx_assert(__offset + __x >= 0 && __offset + __x <= __size);
8762 auto __size = ranges::ssize(__r);
8763 auto __begin = ranges::begin(__r);
8764 auto __offset = __it - __begin;
8766 __x = __offset / __size;
8770 __offset = __size + __offset;
8773 __it = __begin + __offset;
8774 _M_advance<_Nm - 1>(__x);
8779 template<
typename _Tuple>
8780 constexpr difference_type
8781 _M_distance_from(
const _Tuple& __t)
const
8784 auto __sum =
static_cast<difference_type
>(0);
8785#ifdef _GLIBCXX_ASSERTIONS
8786 if constexpr (integral<difference_type>)
8789 = (__builtin_add_overflow(__sum, _M_scaled_distance<_Is>(__t), &__sum)
8791 __glibcxx_assert(!__overflow);
8795 __sum = (_M_scaled_distance<_Is>(__t) + ...);
8800 template<
size_t _Nm,
typename _Tuple>
8801 constexpr difference_type
8802 _M_scaled_distance(
const _Tuple& __t)
const
8804 auto __dist =
static_cast<difference_type
>(std::get<_Nm>(_M_current)
8805 - std::get<_Nm>(__t));
8806#ifdef _GLIBCXX_ASSERTIONS
8807 if constexpr (integral<difference_type>)
8809 bool __overflow = __builtin_mul_overflow(__dist, _M_scaled_size<_Nm+1>(), &__dist);
8810 __glibcxx_assert(!__overflow);
8814 __dist *= _M_scaled_size<_Nm+1>();
8818 template<
size_t _Nm>
8819 constexpr difference_type
8820 _M_scaled_size()
const
8822 if constexpr (_Nm <=
sizeof...(_Vs))
8824 auto __size =
static_cast<difference_type
>(ranges::size
8825 (std::get<_Nm>(_M_parent->_M_bases)));
8826#ifdef _GLIBCXX_ASSERTIONS
8827 if constexpr (integral<difference_type>)
8829 bool __overflow = __builtin_mul_overflow(__size, _M_scaled_size<_Nm+1>(), &__size);
8830 __glibcxx_assert(!__overflow);
8834 __size *= _M_scaled_size<_Nm+1>();
8838 return static_cast<difference_type
>(1);
8846 template<
typename... _Ts>
8847 concept __can_cartesian_product_view
8848 =
requires { cartesian_product_view<all_t<_Ts>...>(std::declval<_Ts>()...); };
8851 struct _CartesianProduct
8853 template<
typename... _Ts>
8854 requires (
sizeof...(_Ts) == 0 || __detail::__can_cartesian_product_view<_Ts...>)
8856 operator() [[nodiscard]] (_Ts&&... __ts)
const
8858 if constexpr (
sizeof...(_Ts) == 0)
8859 return views::single(tuple{});
8861 return cartesian_product_view<all_t<_Ts>...>(std::forward<_Ts>(__ts)...);
8865 inline constexpr _CartesianProduct cartesian_product;
8869#ifdef __cpp_lib_ranges_as_rvalue
8870 template<input_range _Vp>
8872 class as_rvalue_view :
public view_interface<as_rvalue_view<_Vp>>
8874 _Vp _M_base = _Vp();
8877 as_rvalue_view()
requires default_initializable<_Vp> = default;
8880 as_rvalue_view(_Vp __base)
8881 : _M_base(
std::move(__base))
8885 base() const& requires copy_constructible<_Vp>
8893 begin()
requires (!__detail::__simple_view<_Vp>)
8894 {
return move_iterator(ranges::begin(_M_base)); }
8897 begin() const requires range<const _Vp>
8898 {
return move_iterator(ranges::begin(_M_base)); }
8901 end()
requires (!__detail::__simple_view<_Vp>)
8903 if constexpr (common_range<_Vp>)
8904 return move_iterator(ranges::end(_M_base));
8906 return move_sentinel(ranges::end(_M_base));
8910 end() const requires range<const _Vp>
8912 if constexpr (common_range<const _Vp>)
8913 return move_iterator(ranges::end(_M_base));
8915 return move_sentinel(ranges::end(_M_base));
8919 size()
requires sized_range<_Vp>
8920 {
return ranges::size(_M_base); }
8923 size() const requires sized_range<const _Vp>
8924 {
return ranges::size(_M_base); }
8927 template<
typename _Range>
8928 as_rvalue_view(_Range&&) -> as_rvalue_view<views::all_t<_Range>>;
8930 template<
typename _Tp>
8931 inline constexpr bool enable_borrowed_range<as_rvalue_view<_Tp>>
8932 = enable_borrowed_range<_Tp>;
8938 template<
typename _Tp>
8939 concept __can_as_rvalue_view =
requires { as_rvalue_view(std::declval<_Tp>()); };
8942 struct _AsRvalue : __adaptor::_RangeAdaptorClosure<_AsRvalue>
8944 template<viewable_range _Range>
8945 requires __detail::__can_as_rvalue_view<_Range>
8947 operator() [[nodiscard]] (_Range&& __r)
const
8949 if constexpr (same_as<range_rvalue_reference_t<_Range>,
8950 range_reference_t<_Range>>)
8951 return views::all(std::forward<_Range>(__r));
8953 return as_rvalue_view(std::forward<_Range>(__r));
8957 inline constexpr _AsRvalue as_rvalue;
8961#ifdef __cpp_lib_ranges_enumerate
8964 template<
typename _Range>
8965 concept __range_with_movable_reference = input_range<_Range>
8966 && move_constructible<range_reference_t<_Range>>
8967 && move_constructible<range_rvalue_reference_t<_Range>>;
8971 requires __detail::__range_with_movable_reference<_Vp>
8972 class enumerate_view :
public view_interface<enumerate_view<_Vp>>
8974 _Vp _M_base = _Vp();
8976 template<
bool _Const>
class _Iterator;
8977 template<
bool _Const>
class _Sentinel;
8980 enumerate_view()
requires default_initializable<_Vp> = default;
8983 enumerate_view(_Vp __base)
8984 : _M_base(
std::move(__base))
8988 begin()
requires (!__detail::__simple_view<_Vp>)
8989 {
return _Iterator<false>(ranges::begin(_M_base), 0); }
8992 begin() const requires __detail::__range_with_movable_reference<const _Vp>
8993 {
return _Iterator<true>(ranges::begin(_M_base), 0); }
8996 end()
requires (!__detail::__simple_view<_Vp>)
8998 if constexpr (common_range<_Vp> && sized_range<_Vp>)
8999 return _Iterator<false>(ranges::end(_M_base), ranges::distance(_M_base));
9001 return _Sentinel<false>(ranges::end(_M_base));
9005 end() const requires __detail::__range_with_movable_reference<const _Vp>
9007 if constexpr (common_range<const _Vp> && sized_range<const _Vp>)
9008 return _Iterator<true>(ranges::end(_M_base), ranges::distance(_M_base));
9010 return _Sentinel<true>(ranges::end(_M_base));
9014 size()
requires sized_range<_Vp>
9015 {
return ranges::size(_M_base); }
9018 size() const requires sized_range<const _Vp>
9019 {
return ranges::size(_M_base); }
9022 base() const & requires copy_constructible<_Vp>
9030 template<
typename _Range>
9031 enumerate_view(_Range&&) -> enumerate_view<views::all_t<_Range>>;
9033 template<
typename _Tp>
9034 inline constexpr bool enable_borrowed_range<enumerate_view<_Tp>>
9035 = enable_borrowed_range<_Tp>;
9038 requires __detail::__range_with_movable_reference<_Vp>
9039 template<
bool _Const>
9040 class enumerate_view<_Vp>::_Iterator
9042 using _Base = __maybe_const_t<_Const, _Vp>;
9047 if constexpr (random_access_range<_Base>)
9048 return random_access_iterator_tag{};
9049 else if constexpr (bidirectional_range<_Base>)
9050 return bidirectional_iterator_tag{};
9051 else if constexpr (forward_range<_Base>)
9052 return forward_iterator_tag{};
9054 return input_iterator_tag{};
9057 friend enumerate_view;
9060 using iterator_category = input_iterator_tag;
9061 using iterator_concept =
decltype(_S_iter_concept());
9062 using difference_type = range_difference_t<_Base>;
9063 using value_type = tuple<difference_type, range_value_t<_Base>>;
9066 using __reference_type = tuple<difference_type, range_reference_t<_Base>>;
9068 iterator_t<_Base> _M_current = iterator_t<_Base>();
9069 difference_type _M_pos = 0;
9072 _Iterator(iterator_t<_Base> __current, difference_type __pos)
9073 : _M_current(
std::
move(__current)), _M_pos(__pos)
9077 _Iterator()
requires default_initializable<iterator_t<_Base>> = default;
9080 _Iterator(_Iterator<!_Const> __i)
9081 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
9082 : _M_current(
std::move(__i._M_current)), _M_pos(__i._M_pos)
9085 constexpr const iterator_t<_Base> &
9086 base() const & noexcept
9087 {
return _M_current; }
9089 constexpr iterator_t<_Base>
9093 constexpr difference_type
9094 index() const noexcept
9099 {
return __reference_type(_M_pos, *_M_current); }
9101 constexpr _Iterator&
9114 operator++(
int)
requires forward_range<_Base>
9121 constexpr _Iterator&
9122 operator--()
requires bidirectional_range<_Base>
9130 operator--(
int)
requires bidirectional_range<_Base>
9137 constexpr _Iterator&
9138 operator+=(difference_type __n)
requires random_access_range<_Base>
9145 constexpr _Iterator&
9146 operator-=(difference_type __n)
requires random_access_range<_Base>
9154 operator[](difference_type __n)
const requires random_access_range<_Base>
9155 {
return __reference_type(_M_pos + __n, _M_current[__n]); }
9157 friend constexpr bool
9158 operator==(
const _Iterator& __x,
const _Iterator& __y)
noexcept
9159 {
return __x._M_pos == __y._M_pos; }
9161 friend constexpr strong_ordering
9162 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
noexcept
9163 {
return __x._M_pos <=> __y._M_pos; }
9165 friend constexpr _Iterator
9166 operator+(
const _Iterator& __x, difference_type __y)
9167 requires random_access_range<_Base>
9168 {
return (
auto(__x) += __y); }
9170 friend constexpr _Iterator
9171 operator+(difference_type __x,
const _Iterator& __y)
9172 requires random_access_range<_Base>
9173 {
return auto(__y) += __x; }
9175 friend constexpr _Iterator
9176 operator-(
const _Iterator& __x, difference_type __y)
9177 requires random_access_range<_Base>
9178 {
return auto(__x) -= __y; }
9180 friend constexpr difference_type
9181 operator-(
const _Iterator& __x,
const _Iterator& __y)
noexcept
9182 {
return __x._M_pos - __y._M_pos; }
9184 friend constexpr auto
9185 iter_move(
const _Iterator& __i)
9186 noexcept(
noexcept(ranges::iter_move(__i._M_current))
9187 && is_nothrow_move_constructible_v<range_rvalue_reference_t<_Base>>)
9189 return tuple<difference_type, range_rvalue_reference_t<_Base>>
9190 (__i._M_pos, ranges::iter_move(__i._M_current));
9195 requires __detail::__range_with_movable_reference<_Vp>
9196 template<
bool _Const>
9197 class enumerate_view<_Vp>::_Sentinel
9199 using _Base = __maybe_const_t<_Const, _Vp>;
9201 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
9204 _Sentinel(sentinel_t<_Base> __end)
9208 friend enumerate_view;
9211 _Sentinel() =
default;
9214 _Sentinel(_Sentinel<!_Const> __other)
9215 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
9219 constexpr sentinel_t<_Base>
9223 template<
bool _OtherConst>
9224 requires sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const_t<_OtherConst, _Vp>>>
9225 friend constexpr bool
9226 operator==(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
9227 {
return __x._M_current == __y._M_end; }
9229 template<
bool _OtherConst>
9230 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const_t<_OtherConst, _Vp>>>
9231 friend constexpr range_difference_t<__maybe_const_t<_OtherConst, _Vp>>
9232 operator-(
const _Iterator<_OtherConst>& __x,
const _Sentinel& __y)
9233 {
return __x._M_current - __y._M_end; }
9235 template<
bool _OtherConst>
9236 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const_t<_OtherConst, _Vp>>>
9237 friend constexpr range_difference_t<__maybe_const_t<_OtherConst, _Vp>>
9238 operator-(
const _Sentinel& __x,
const _Iterator<_OtherConst>& __y)
9239 {
return __x._M_end - __y._M_current; }
9246 template<
typename _Tp>
9247 concept __can_enumerate_view
9248 =
requires { enumerate_view<all_t<_Tp>>(std::declval<_Tp>()); };
9251 struct _Enumerate : __adaptor::_RangeAdaptorClosure<_Enumerate>
9253 template<viewable_range _Range>
9254 requires __detail::__can_enumerate_view<_Range>
9256 operator() [[nodiscard]] (_Range&& __r)
const
9257 {
return enumerate_view<all_t<_Range>>(std::forward<_Range>(__r)); }
9260 inline constexpr _Enumerate enumerate;
9264#ifdef __cpp_lib_ranges_as_const
9266 requires input_range<_Vp>
9267 class as_const_view :
public view_interface<as_const_view<_Vp>>
9269 _Vp _M_base = _Vp();
9272 as_const_view()
requires default_initializable<_Vp> = default;
9275 as_const_view(_Vp __base)
9276 noexcept(is_nothrow_move_constructible_v<_Vp>)
9277 : _M_base(
std::move(__base))
9282 noexcept(is_nothrow_copy_constructible_v<_Vp>)
9283 requires copy_constructible<_Vp>
9288 noexcept(is_nothrow_move_constructible_v<_Vp>)
9292 begin()
requires (!__detail::__simple_view<_Vp>)
9293 {
return ranges::cbegin(_M_base); }
9296 begin() const requires range<const _Vp>
9297 {
return ranges::cbegin(_M_base); }
9300 end()
requires (!__detail::__simple_view<_Vp>)
9301 {
return ranges::cend(_M_base); }
9304 end() const requires range<const _Vp>
9305 {
return ranges::cend(_M_base); }
9308 size()
requires sized_range<_Vp>
9309 {
return ranges::size(_M_base); }
9312 size() const requires sized_range<const _Vp>
9313 {
return ranges::size(_M_base); }
9316 template<
typename _Range>
9317 as_const_view(_Range&&) -> as_const_view<views::all_t<_Range>>;
9319 template<
typename _Tp>
9320 inline constexpr bool enable_borrowed_range<as_const_view<_Tp>>
9321 = enable_borrowed_range<_Tp>;
9327 template<
typename _Tp>
9328 inline constexpr bool __is_constable_ref_view =
false;
9330 template<
typename _Range>
9331 inline constexpr bool __is_constable_ref_view<ref_view<_Range>>
9332 = constant_range<const _Range>;
9334 template<
typename _Range>
9335 concept __can_as_const_view =
requires { as_const_view(std::declval<_Range>()); };
9338 struct _AsConst : __adaptor::_RangeAdaptorClosure<_AsConst>
9340 template<viewable_range _Range>
9342 operator()(_Range&& __r)
const
9343 noexcept(
noexcept(as_const_view(std::declval<_Range>())))
9344 requires __detail::__can_as_const_view<_Range>
9346 using _Tp = remove_cvref_t<_Range>;
9347 using element_type = remove_reference_t<range_reference_t<_Range>>;
9348 if constexpr (constant_range<views::all_t<_Range>>)
9349 return views::all(std::forward<_Range>(__r));
9350 else if constexpr (__detail::__is_empty_view<_Tp>)
9351 return views::empty<const element_type>;
9352 else if constexpr (std::__detail::__is_span<_Tp>)
9353 return span<const element_type, _Tp::extent>(std::forward<_Range>(__r));
9354 else if constexpr (__detail::__is_constable_ref_view<_Tp>)
9355 return ref_view(std::as_const(std::forward<_Range>(__r).base()));
9356 else if constexpr (is_lvalue_reference_v<_Range>
9357 && constant_range<const _Tp>
9359 return ref_view(
static_cast<const _Tp&
>(__r));
9361 return as_const_view(std::forward<_Range>(__r));
9365 inline constexpr _AsConst as_const;
9370 namespace views = ranges::views;
9372#if __cpp_lib_ranges_to_container
9378 template<
typename _Container>
9379 constexpr bool __reservable_container
9380 = sized_range<_Container>
9381 &&
requires(_Container& __c, range_size_t<_Container> __n) {
9383 { __c.capacity() } -> same_as<
decltype(__n)>;
9384 { __c.max_size() } -> same_as<
decltype(__n)>;
9387 template<
typename _Cont,
typename _Range>
9388 constexpr bool __toable =
requires {
9389 requires (!input_range<_Cont>
9390 || convertible_to<range_reference_t<_Range>,
9391 range_value_t<_Cont>>);
9412 template<
typename _Cont, input_range _Rg,
typename... _Args>
9413 requires (!view<_Cont>)
9415 to [[nodiscard]] (_Rg&& __r, _Args&&... __args)
9417 static_assert(!is_const_v<_Cont> && !is_volatile_v<_Cont>);
9418 static_assert(is_class_v<_Cont>);
9420 if constexpr (__detail::__toable<_Cont, _Rg>)
9422 if constexpr (constructible_from<_Cont, _Rg, _Args...>)
9423 return _Cont(std::forward<_Rg>(__r),
9424 std::forward<_Args>(__args)...);
9425 else if constexpr (constructible_from<_Cont, from_range_t, _Rg, _Args...>)
9426 return _Cont(from_range, std::forward<_Rg>(__r),
9427 std::forward<_Args>(__args)...);
9428 else if constexpr (
requires {
requires common_range<_Rg>;
9429 typename __iter_category_t<iterator_t<_Rg>>;
9430 requires derived_from<__iter_category_t<iterator_t<_Rg>>,
9431 input_iterator_tag>;
9432 requires constructible_from<_Cont, iterator_t<_Rg>,
9433 sentinel_t<_Rg>, _Args...>;
9435 return _Cont(ranges::begin(__r), ranges::end(__r),
9436 std::forward<_Args>(__args)...);
9439 static_assert(constructible_from<_Cont, _Args...>);
9440 _Cont __c(std::forward<_Args>(__args)...);
9441 if constexpr (sized_range<_Rg>
9442 && __detail::__reservable_container<_Cont>)
9443 __c.reserve(
static_cast<range_size_t<_Cont>
>(ranges::size(__r)));
9447 auto __it = ranges::begin(__r);
9448 const auto __sent = ranges::end(__r);
9449 while (__it != __sent)
9451 if constexpr (
requires { __c.emplace_back(*__it); })
9452 __c.emplace_back(*__it);
9453 else if constexpr (
requires { __c.push_back(*__it); })
9454 __c.push_back(*__it);
9455 else if constexpr (
requires { __c.emplace(__c.end(), *__it); })
9456 __c.emplace(__c.end(), *__it);
9458 __c.insert(__c.end(), *__it);
9466 static_assert(input_range<range_reference_t<_Rg>>);
9469 return ranges::to<_Cont>(ref_view(__r) | views::transform(
9470 []<
typename _Elt>(_Elt&& __elem) {
9471 using _ValT = range_value_t<_Cont>;
9472 return ranges::to<_ValT>(std::forward<_Elt>(__elem));
9473 }), std::forward<_Args>(__args)...);
9480 template<
typename _Rg>
9483 using iterator_category = input_iterator_tag;
9484 using value_type = range_value_t<_Rg>;
9485 using difference_type = ptrdiff_t;
9486 using pointer = add_pointer_t<range_reference_t<_Rg>>;
9487 using reference = range_reference_t<_Rg>;
9489 pointer operator->()
const;
9490 _InputIter& operator++();
9491 _InputIter operator++(
int);
9492 bool operator==(
const _InputIter&)
const;
9495 template<
template<
typename...>
typename _Cont, input_range _Rg,
9498 =
decltype(_Cont(std::declval<_Rg>(), std::declval<_Args>()...));
9500 template<
template<
typename...>
typename _Cont, input_range _Rg,
9503 =
decltype(_Cont(from_range, std::declval<_Rg>(),
9504 std::declval<_Args>()...));
9506 template<
template<
typename...>
typename _Cont, input_range _Rg,
9511 std::declval<_Args>()...));
9516 template<
template<
typename...>
typename _Cont, input_range _Rg,
9519 to [[nodiscard]] (_Rg&& __r, _Args&&... __args)
9521 using __detail::_DeduceExpr1;
9522 using __detail::_DeduceExpr2;
9523 using __detail::_DeduceExpr3;
9524 if constexpr (
requires {
typename _DeduceExpr1<_Cont, _Rg, _Args...>; })
9525 return ranges::to<_DeduceExpr1<_Cont, _Rg, _Args...>>(
9526 std::forward<_Rg>(__r), std::forward<_Args>(__args)...);
9527 else if constexpr (
requires {
typename _DeduceExpr2<_Cont, _Rg, _Args...>; })
9528 return ranges::to<_DeduceExpr2<_Cont, _Rg, _Args...>>(
9529 std::forward<_Rg>(__r), std::forward<_Args>(__args)...);
9530 else if constexpr (
requires {
typename _DeduceExpr3<_Cont, _Rg, _Args...>; })
9531 return ranges::to<_DeduceExpr3<_Cont, _Rg, _Args...>>(
9532 std::forward<_Rg>(__r), std::forward<_Args>(__args)...);
9534 static_assert(
false);
9540 template<
typename _Cont>
9543 template<
typename _Range,
typename... _Args>
9544 requires requires { ranges::to<_Cont>(std::declval<_Range>(),
9545 std::declval<_Args>()...); }
9547 operator()(_Range&& __r, _Args&&... __args)
const
9549 return ranges::to<_Cont>(std::forward<_Range>(__r),
9550 std::forward<_Args>(__args)...);
9571 template<
typename _Cont,
typename... _Args>
9572 requires (!view<_Cont>)
9574 to [[nodiscard]] (_Args&&... __args)
9576 static_assert(!is_const_v<_Cont> && !is_volatile_v<_Cont>);
9577 static_assert(is_class_v<_Cont>);
9579 using __detail::_To;
9580 using views::__adaptor::_Partial;
9581 return _Partial<_To<_Cont>, decay_t<_Args>...>{0, std::forward<_Args>(__args)...};
9587 template<
template<
typename...>
typename _Cont>
9590 template<
typename _Range,
typename... _Args>
9591 requires requires { ranges::to<_Cont>(std::declval<_Range>(),
9592 std::declval<_Args>()...); }
9594 operator()(_Range&& __r, _Args&&... __args)
const
9596 return ranges::to<_Cont>(std::forward<_Range>(__r),
9597 std::forward<_Args>(__args)...);
9620 template<
template<
typename...>
typename _Cont,
typename... _Args>
9622 to [[nodiscard]] (_Args&&... __args)
9624 using __detail::_To2;
9625 using views::__adaptor::_Partial;
9626 return _Partial<_To2<_Cont>, decay_t<_Args>...>{0, std::forward<_Args>(__args)...};
9632#if __cpp_lib_ranges_concat
9637 template<
typename... _Rs>
9638 using __concat_reference_t = common_reference_t<range_reference_t<_Rs>...>;
9640 template<
typename... _Rs>
9641 using __concat_value_t = common_type_t<range_value_t<_Rs>...>;
9643 template<
typename... _Rs>
9644 using __concat_rvalue_reference_t
9645 = common_reference_t<range_rvalue_reference_t<_Rs>...>;
9647 template<
typename _Ref,
typename _RRef,
typename _It>
9648 concept __concat_indirectly_readable_impl =
requires(
const _It __it) {
9649 { *__it } -> convertible_to<_Ref>;
9650 { ranges::iter_move(__it) } -> convertible_to<_RRef>;
9653 template<
typename... _Rs>
9654 concept __concat_indirectly_readable
9655 = common_reference_with<__concat_reference_t<_Rs...>&&, __concat_value_t<_Rs...>&>
9656 && common_reference_with<__concat_reference_t<_Rs...>&&,
9657 __concat_rvalue_reference_t<_Rs...>&&>
9658 && common_reference_with<__concat_rvalue_reference_t<_Rs...>&&,
9659 __concat_value_t<_Rs...>
const&>
9660 && (__concat_indirectly_readable_impl<__concat_reference_t<_Rs...>,
9661 __concat_rvalue_reference_t<_Rs...>,
9665 template<
typename... _Rs>
9666 concept __concatable =
requires {
9667 typename __concat_reference_t<_Rs...>;
9668 typename __concat_value_t<_Rs...>;
9669 typename __concat_rvalue_reference_t<_Rs...>;
9670 } && __concat_indirectly_readable<_Rs...>;
9672 template<
bool _Const,
typename _Range,
typename... _Rs>
9673 struct __all_but_last_common
9675 static inline constexpr bool value
9676 =
requires {
requires (common_range<__maybe_const_t<_Const, _Range>>
9677 && __all_but_last_common<_Const, _Rs...>::value); };
9680 template<
bool _Const,
typename _Range>
9681 struct __all_but_last_common<_Const, _Range>
9682 {
static inline constexpr bool value =
true; };
9684 template<
bool _Const,
typename... _Rs>
9685 concept __concat_is_random_access = __all_random_access<_Const, _Rs...>
9686 && __all_but_last_common<_Const, _Rs...>::value;
9688 template<
bool _Const,
typename... _Rs>
9689 concept __concat_is_bidirectional = __all_bidirectional<_Const, _Rs...>
9690 && __all_but_last_common<_Const, _Rs...>::value;
9692 template<
typename _Range,
typename... _Rs>
9693 struct __all_but_first_sized
9694 {
static inline constexpr bool value = (sized_range<_Rs> && ...); };
9697 template<input_range... _Vs>
9698 requires (view<_Vs> && ...) && (
sizeof...(_Vs) > 0) && __detail::__concatable<_Vs...>
9699 class concat_view :
public view_interface<concat_view<_Vs...>>
9701 tuple<_Vs...> _M_views;
9703 template<
bool _Const>
class _Iterator;
9706 constexpr concat_view() =
default;
9709 concat_view(_Vs... __views)
9710 : _M_views(
std::
move(__views)...)
9713 constexpr _Iterator<false>
9714 begin()
requires (!(__detail::__simple_view<_Vs> && ...))
9716 _Iterator<false> __it(
this, in_place_index<0>, ranges::begin(std::get<0>(_M_views)));
9717 __it.template _M_satisfy<0>();
9721 constexpr _Iterator<true>
9722 begin() const requires (range<const _Vs> && ...) && __detail::__concatable<const _Vs...>
9724 _Iterator<true> __it(
this, in_place_index<0>, ranges::begin(std::get<0>(_M_views)));
9725 __it.template _M_satisfy<0>();
9730 end()
requires (!(__detail::__simple_view<_Vs> && ...))
9732 constexpr auto __n =
sizeof...(_Vs);
9733 if constexpr ((semiregular<iterator_t<_Vs>> && ...)
9734 && common_range<_Vs...[__n - 1]>)
9735 return _Iterator<false>(
this, in_place_index<__n - 1>,
9736 ranges::end(std::get<__n - 1>(_M_views)));
9742 end() const requires (range<const _Vs> && ...) && __detail::__concatable<const _Vs...>
9744 constexpr auto __n =
sizeof...(_Vs);
9745 if constexpr ((semiregular<iterator_t<const _Vs>> && ...)
9746 && common_range<
const _Vs...[__n - 1]>)
9747 return _Iterator<true>(
this, in_place_index<__n - 1>,
9748 ranges::end(std::get<__n - 1>(_M_views)));
9754 size()
requires (sized_range<_Vs>&&...)
9756 return std::apply([](
auto... __sizes) {
9757 using _CT = __detail::__make_unsigned_like_t<
common_type_t<
decltype(__sizes)...>>;
9758 return (_CT(__sizes) + ...);
9759 }, __detail::__tuple_transform(ranges::size, _M_views));
9763 size() const requires (sized_range<const _Vs>&&...)
9765 return std::apply([](
auto... __sizes) {
9766 using _CT = __detail::__make_unsigned_like_t<
common_type_t<
decltype(__sizes)...>>;
9767 return (_CT(__sizes) + ...);
9768 }, __detail::__tuple_transform(ranges::size, _M_views));
9772 template<
typename... _Rs>
9773 concat_view(_Rs&&...) -> concat_view<views::all_t<_Rs>...>;
9777 template<
bool _Const,
typename... _Vs>
9778 struct __concat_view_iter_cat
9781 template<
bool _Const,
typename... _Vs>
9782 requires __detail::__all_forward<_Const, _Vs...>
9783 struct __concat_view_iter_cat<_Const, _Vs...>
9788 if constexpr (!is_reference_v<__concat_reference_t<__maybe_const_t<_Const, _Vs>...>>)
9789 return input_iterator_tag{};
9791 return []<
typename... _Cats>(_Cats... __cats) {
9792 if constexpr ((derived_from<_Cats, random_access_iterator_tag> && ...)
9793 && __concat_is_random_access<_Const, _Vs...>)
9794 return random_access_iterator_tag{};
9795 else if constexpr ((derived_from<_Cats, bidirectional_iterator_tag> && ...)
9796 && __concat_is_bidirectional<_Const, _Vs...>)
9797 return bidirectional_iterator_tag{};
9798 else if constexpr ((derived_from<_Cats, forward_iterator_tag> && ...))
9799 return forward_iterator_tag{};
9801 return input_iterator_tag{};
9802 }(
typename iterator_traits<iterator_t<__maybe_const_t<_Const, _Vs>>>
9803 ::iterator_category{}...);
9808 template<input_range... _Vs>
9809 requires (view<_Vs> && ...) && (
sizeof...(_Vs) > 0) && __detail::__concatable<_Vs...>
9810 template<
bool _Const>
9811 class concat_view<_Vs...>::_Iterator
9812 :
public __detail::__concat_view_iter_cat<_Const, _Vs...>
9817 if constexpr (__detail::__concat_is_random_access<_Const, _Vs...>)
9818 return random_access_iterator_tag{};
9819 else if constexpr (__detail::__concat_is_bidirectional<_Const, _Vs...>)
9820 return bidirectional_iterator_tag{};
9821 else if constexpr (__detail::__all_forward<_Const, _Vs...>)
9822 return forward_iterator_tag{};
9824 return input_iterator_tag{};
9828 friend _Iterator<!_Const>;
9832 using iterator_concept =
decltype(_S_iter_concept());
9833 using value_type = __detail::__concat_value_t<__maybe_const_t<_Const, _Vs>...>;
9834 using difference_type = common_type_t<range_difference_t<__maybe_const_t<_Const, _Vs>>...>;
9837 using __base_iter = variant<iterator_t<__maybe_const_t<_Const, _Vs>>...>;
9839 __maybe_const_t<_Const, concat_view>* _M_parent =
nullptr;
9842 template<
size_t _Nm>
9846 if constexpr (_Nm < (
sizeof...(_Vs) - 1))
9848 if (std::get<_Nm>(_M_it) == ranges::end(std::get<_Nm>(_M_parent->_M_views)))
9850 _M_it.template emplace<_Nm + 1>(ranges::begin
9851 (std::get<_Nm + 1>(_M_parent->_M_views)));
9852 _M_satisfy<_Nm + 1>();
9857 template<
size_t _Nm>
9861 if constexpr (_Nm == 0)
9862 --std::get<0>(_M_it);
9865 if (std::get<_Nm>(_M_it) == ranges::begin(std::get<_Nm>(_M_parent->_M_views)))
9867 _M_it.template emplace<_Nm - 1>(ranges::end
9868 (std::get<_Nm - 1>(_M_parent->_M_views)));
9872 --std::get<_Nm>(_M_it);
9876 template<
size_t _Nm>
9878 _M_advance_fwd(difference_type __offset, difference_type __steps)
9880 using _Dt = iter_difference_t<variant_alternative_t<_Nm, __base_iter>>;
9881 if constexpr (_Nm ==
sizeof...(_Vs) - 1)
9882 std::get<_Nm>(_M_it) +=
static_cast<_Dt
>(__steps);
9885 auto __n_size = ranges::distance(std::get<_Nm>(_M_parent->_M_views));
9886 if (__offset + __steps < __n_size)
9887 std::get<_Nm>(_M_it) +=
static_cast<_Dt
>(__steps);
9890 _M_it.template emplace<_Nm + 1>(ranges::begin
9891 (std::get<_Nm + 1>(_M_parent->_M_views)));
9892 _M_advance_fwd<_Nm + 1>(0, __offset + __steps - __n_size);
9897 template<
size_t _Nm>
9899 _M_advance_bwd(difference_type __offset, difference_type __steps)
9901 using _Dt = iter_difference_t<variant_alternative_t<_Nm, __base_iter>>;
9902 if constexpr (_Nm == 0)
9903 std::get<_Nm>(_M_it) -=
static_cast<_Dt
>(__steps);
9905 if (__offset >= __steps)
9906 std::get<_Nm>(_M_it) -=
static_cast<_Dt
>(__steps);
9909 auto __prev_size = ranges::distance(std::get<_Nm - 1>(_M_parent->_M_views));
9910 _M_it.template emplace<_Nm - 1>(ranges::end
9911 (std::get<_Nm - 1>(_M_parent->_M_views)));
9912 _M_advance_bwd<_Nm - 1>(__prev_size, __steps - __offset);
9920 template<
typename _Fp>
9921 static constexpr auto
9922 _S_invoke_with_runtime_index(_Fp&& __f,
size_t __index)
9924 return [&__f, __index]<
size_t _Idx>(
this auto&& __self) {
9925 if (_Idx == __index)
9926 return __f.template operator()<_Idx>();
9927 if constexpr (_Idx + 1 <
sizeof...(_Vs))
9928 return __self.template operator()<_Idx + 1>();
9929 __builtin_unreachable();
9930 }.template operator()<0>();
9933 template<
typename _Fp>
9935 _M_invoke_with_runtime_index(_Fp&& __f)
9936 {
return _S_invoke_with_runtime_index(std::forward<_Fp>(__f), _M_it.index()); }
9938 template<
typename... _Args>
9940 _Iterator(__maybe_const_t<_Const, concat_view>* __parent, _Args&&... __args)
9941 requires constructible_from<__base_iter, _Args&&...>
9942 : _M_parent(__parent), _M_it(std::forward<_Args>(__args)...)
9946 _Iterator() =
default;
9949 _Iterator(_Iterator<!_Const> __it)
9950 requires _Const && (convertible_to<iterator_t<_Vs>, iterator_t<const _Vs>> && ...)
9951 : _M_parent(__it._M_parent),
9952 _M_it(_S_invoke_with_runtime_index([this, &__it]<size_t _Idx>() {
9953 return __base_iter(in_place_index<_Idx>,
9955 }, __it._M_it.index()))
9958 constexpr decltype(
auto)
9961 __glibcxx_assert(!_M_it.valueless_by_exception());
9962 using reference = __detail::__concat_reference_t<__maybe_const_t<_Const, _Vs>...>;
9963 return std::visit([](
auto&& __it) -> reference {
return *__it; }, _M_it);
9966 constexpr _Iterator&
9969 _M_invoke_with_runtime_index([
this]<
size_t _Idx>() {
9970 ++std::get<_Idx>(_M_it);
9982 requires __detail::__all_forward<_Const, _Vs...>
9989 constexpr _Iterator&
9991 requires __detail::__concat_is_bidirectional<_Const, _Vs...>
9993 __glibcxx_assert(!_M_it.valueless_by_exception());
9994 _M_invoke_with_runtime_index([
this]<
size_t _Idx>() {
10000 constexpr _Iterator
10002 requires __detail::__concat_is_bidirectional<_Const, _Vs...>
10004 auto __tmp = *
this;
10009 constexpr _Iterator&
10010 operator+=(difference_type __n)
10011 requires __detail::__concat_is_random_access<_Const, _Vs...>
10013 __glibcxx_assert(!_M_it.valueless_by_exception());
10014 _M_invoke_with_runtime_index([
this, __n]<
size_t _Idx>() {
10015 auto __begin = ranges::begin(std::get<_Idx>(_M_parent->_M_views));
10017 _M_advance_fwd<_Idx>(std::get<_Idx>(_M_it) - __begin, __n);
10019 _M_advance_bwd<_Idx>(std::get<_Idx>(_M_it) - __begin, -__n);
10024 constexpr _Iterator&
10025 operator-=(difference_type __n)
10026 requires __detail::__concat_is_random_access<_Const, _Vs...>
10032 constexpr decltype(
auto)
10033 operator[](difference_type __n)
const
10034 requires __detail::__concat_is_random_access<_Const, _Vs...>
10035 {
return *((*this) + __n); }
10037 friend constexpr bool
10038 operator==(
const _Iterator& __x,
const _Iterator& __y)
10039 requires (equality_comparable<iterator_t<__maybe_const_t<_Const, _Vs>>> && ...)
10041 __glibcxx_assert(!__x._M_it.valueless_by_exception());
10042 __glibcxx_assert(!__y._M_it.valueless_by_exception());
10043 return __x._M_it == __y._M_it;
10046 friend constexpr bool
10047 operator==(
const _Iterator& __it, default_sentinel_t)
10049 __glibcxx_assert(!__it._M_it.valueless_by_exception());
10050 constexpr auto __last_idx =
sizeof...(_Vs) - 1;
10051 return (__it._M_it.index() == __last_idx
10052 && (std::get<__last_idx>(__it._M_it)
10053 == ranges::end(std::get<__last_idx>(__it._M_parent->_M_views))));
10056 friend constexpr bool
10057 operator<(
const _Iterator& __x,
const _Iterator& __y)
10058 requires __detail::__all_random_access<_Const, _Vs...>
10059 {
return __x._M_it < __y._M_it; }
10061 friend constexpr bool
10062 operator>(
const _Iterator& __x,
const _Iterator& __y)
10063 requires __detail::__all_random_access<_Const, _Vs...>
10064 {
return __x._M_it > __y._M_it; }
10066 friend constexpr bool
10067 operator<=(
const _Iterator& __x,
const _Iterator& __y)
10068 requires __detail::__all_random_access<_Const, _Vs...>
10069 {
return __x._M_it <= __y._M_it; }
10071 friend constexpr bool
10072 operator>=(
const _Iterator& __x,
const _Iterator& __y)
10073 requires __detail::__all_random_access<_Const, _Vs...>
10074 {
return __x._M_it >= __y._M_it; }
10076 friend constexpr auto
10077 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
10078 requires __detail::__all_random_access<_Const, _Vs...>
10079 && (three_way_comparable<iterator_t<__maybe_const_t<_Const, _Vs>>> && ...)
10080 {
return __x._M_it <=> __y._M_it; }
10082 friend constexpr _Iterator
10083 operator+(
const _Iterator& __it, difference_type __n)
10084 requires __detail::__concat_is_random_access<_Const, _Vs...>
10085 {
return auto(__it) += __n; }
10087 friend constexpr _Iterator
10088 operator+(difference_type __n,
const _Iterator& __it)
10089 requires __detail::__concat_is_random_access<_Const, _Vs...>
10090 {
return __it + __n; }
10092 friend constexpr _Iterator
10093 operator-(
const _Iterator& __it, difference_type __n)
10094 requires __detail::__concat_is_random_access<_Const, _Vs...>
10095 {
return auto(__it) -= __n; }
10097 friend constexpr difference_type
10098 operator-(
const _Iterator& __x,
const _Iterator& __y)
10099 requires __detail::__concat_is_random_access<_Const, _Vs...>
10101 return _S_invoke_with_runtime_index([&]<
size_t _Ix>() -> difference_type {
10102 return _S_invoke_with_runtime_index([&]<
size_t _Iy>() -> difference_type {
10103 if constexpr (_Ix > _Iy)
10105 auto __dy = ranges::distance(std::get<_Iy>(__y._M_it),
10106 ranges::end(std::get<_Iy>(__y._M_parent
10108 auto __dx = ranges::distance(ranges::begin(std::get<_Ix>(__x._M_parent
10110 std::get<_Ix>(__x._M_it));
10111 difference_type __s = 0;
10112 [&]<
size_t _Idx = _Iy + 1>(
this auto&& __self) {
10113 if constexpr (_Idx < _Ix)
10115 __s += ranges::size(std::get<_Idx>(__x._M_parent->_M_views));
10116 __self.template operator()<_Idx + 1>();
10119 return __dy + __s + __dx;
10121 else if constexpr (_Ix < _Iy)
10122 return -(__y - __x);
10124 return std::get<_Ix>(__x._M_it) - std::get<_Iy>(__y._M_it);
10125 }, __y._M_it.index());
10126 }, __x._M_it.index());
10129 friend constexpr difference_type
10130 operator-(
const _Iterator& __x, default_sentinel_t)
10131 requires (sized_sentinel_for<sentinel_t<__maybe_const_t<_Const, _Vs>>,
10132 iterator_t<__maybe_const_t<_Const, _Vs>>> && ...)
10133 && __detail::__all_but_first_sized<__maybe_const_t<_Const, _Vs>...>::value
10135 return _S_invoke_with_runtime_index([&]<
size_t _Ix>() -> difference_type {
10136 auto __dx = ranges::distance(std::get<_Ix>(__x._M_it),
10137 ranges::end(std::get<_Ix>(__x._M_parent->_M_views)));
10138 difference_type __s = 0;
10139 [&]<
size_t _Idx = _Ix + 1>(
this auto&& __self) {
10140 if constexpr (_Idx <
sizeof...(_Vs))
10142 __s += ranges::size(std::get<_Idx>(__x._M_parent->_M_views));
10143 __self.template operator()<_Idx + 1>();
10146 return -(__dx + __s);
10147 }, __x._M_it.index());
10150 friend constexpr difference_type
10151 operator-(default_sentinel_t,
const _Iterator& __x)
10152 requires (sized_sentinel_for<sentinel_t<__maybe_const_t<_Const, _Vs>>,
10153 iterator_t<__maybe_const_t<_Const, _Vs>>> && ...)
10154 && __detail::__all_but_first_sized<__maybe_const_t<_Const, _Vs>...>::value
10157 friend constexpr decltype(
auto)
10158 iter_move(
const _Iterator& __it)
10160 using _Res = __detail::__concat_rvalue_reference_t<__maybe_const_t<_Const, _Vs>...>;
10161 return std::visit([](
const auto& __i) -> _Res {
10162 return ranges::iter_move(__i);
10166 friend constexpr void
10167 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
10168 requires swappable_with<iter_reference_t<_Iterator>, iter_reference_t<_Iterator>>
10169 && (... && indirectly_swappable<iterator_t<__maybe_const_t<_Const, _Vs>>>)
10171 std::visit([&]<
typename _Tp,
typename _Up>(
const _Tp& __it1,
const _Up& __it2) {
10172 if constexpr (is_same_v<_Tp, _Up>)
10173 ranges::iter_swap(__it1, __it2);
10175 ranges::swap(*__it1, *__it2);
10176 }, __x._M_it, __y._M_it);
10184 template<
typename... _Ts>
10185 concept __can_concat_view =
requires { concat_view(std::declval<_Ts>()...); };
10190 template<
typename... _Ts>
10191 requires __detail::__can_concat_view<_Ts...>
10193 operator() [[nodiscard]] (_Ts&&... __ts)
const
10194 {
return concat_view(std::forward<_Ts>(__ts)...); }
10196 template<input_range _Range>
10198 operator() [[nodiscard]] (_Range&& __t)
const
10199 {
return views::all(std::forward<_Range>(__t)); }
10202 inline constexpr _Concat concat;
10208#if __cpp_lib_ranges_cache_latest
10211 template<input_range _Vp>
10213 class cache_latest_view :
public view_interface<cache_latest_view<_Vp>>
10215 _Vp _M_base = _Vp();
10217 using __cache_t = __conditional_t<is_reference_v<range_reference_t<_Vp>>,
10218 add_pointer_t<range_reference_t<_Vp>>,
10219 range_reference_t<_Vp>>;
10220 __detail::__non_propagating_cache<__cache_t> _M_cache;
10226 cache_latest_view()
requires default_initializable<_Vp> = default;
10229 cache_latest_view(_Vp __base)
10230 : _M_base(
std::move(__base))
10234 base() const & requires copy_constructible<_Vp>
10235 {
return _M_base; }
10243 {
return _Iterator(*
this); }
10247 {
return _Sentinel(*
this); }
10250 size()
requires sized_range<_Vp>
10251 {
return ranges::size(_M_base); }
10254 size() const requires sized_range<const _Vp>
10255 {
return ranges::size(_M_base); }
10258 template<
typename _Range>
10259 cache_latest_view(_Range&&) -> cache_latest_view<views::all_t<_Range>>;
10261 template<input_range _Vp>
10263 class cache_latest_view<_Vp>::_Iterator
10265 cache_latest_view* _M_parent;
10266 iterator_t<_Vp> _M_current;
10269 _Iterator(cache_latest_view& __parent)
10271 _M_current(ranges::
begin(__parent._M_base))
10274 friend class cache_latest_view;
10277 using difference_type = range_difference_t<_Vp>;
10278 using value_type = range_value_t<_Vp>;
10279 using iterator_concept = input_iterator_tag;
10281 _Iterator(_Iterator&&) =
default;
10284 operator=(_Iterator&&) =
default;
10286 constexpr iterator_t<_Vp>
10290 constexpr const iterator_t<_Vp>&
10291 base() const & noexcept
10292 {
return _M_current; }
10294 constexpr range_reference_t<_Vp>&
10297 if constexpr (is_reference_v<range_reference_t<_Vp>>)
10299 if (!_M_parent->_M_cache)
10300 _M_parent->_M_cache =
std::__addressof(__detail::__as_lvalue(*_M_current));
10301 return **_M_parent->_M_cache;
10305 if (!_M_parent->_M_cache)
10306 _M_parent->_M_cache._M_emplace_deref(_M_current);
10307 return *_M_parent->_M_cache;
10311 constexpr _Iterator&
10314 _M_parent->_M_cache._M_reset();
10323 friend constexpr range_rvalue_reference_t<_Vp>
10324 iter_move(
const _Iterator& __i)
10325 noexcept(
noexcept(ranges::iter_move(__i._M_current)))
10326 {
return ranges::iter_move(__i._M_current); }
10328 friend constexpr void
10329 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
10330 noexcept(
noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
10331 requires indirectly_swappable<iterator_t<_Vp>>
10332 { ranges::iter_swap(__x._M_current, __y._M_current); }
10335 template<input_range _Vp>
10337 class cache_latest_view<_Vp>::_Sentinel
10339 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
10342 _Sentinel(cache_latest_view& __parent)
10343 : _M_end(ranges::
end(__parent._M_base))
10346 friend class cache_latest_view;
10349 _Sentinel() =
default;
10351 constexpr sentinel_t<_Vp>
10355 friend constexpr bool
10356 operator==(
const _Iterator& __x,
const _Sentinel& __y)
10357 {
return __x._M_current == __y._M_end; }
10359 friend constexpr range_difference_t<_Vp>
10360 operator-(
const _Iterator& __x,
const _Sentinel& __y)
10361 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
10362 {
return __x._M_current - __y._M_end; }
10364 friend constexpr range_difference_t<_Vp>
10365 operator-(
const _Sentinel& __x,
const _Iterator& __y)
10366 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
10367 {
return __x._M_end - __y._M_current; }
10374 template<
typename _Tp>
10375 concept __can_cache_latest =
requires { cache_latest_view(std::declval<_Tp>()); };
10378 struct _CacheLatest : __adaptor::_RangeAdaptorClosure<_CacheLatest>
10380 template<viewable_range _Range>
10381 requires __detail::__can_cache_latest<_Range>
10383 operator() [[nodiscard]] (_Range&& __r)
const
10384 {
return cache_latest_view(std::forward<_Range>(__r)); }
10386 static constexpr bool _S_has_simple_call_op =
true;
10389 inline constexpr _CacheLatest cache_latest;
10394#if __cpp_lib_ranges_to_input
10397 template<input_range _Vp>
10399 class to_input_view :
public view_interface<to_input_view<_Vp>>
10401 _Vp _M_base = _Vp();
10403 template<
bool _Const>
10407 to_input_view()
requires default_initializable<_Vp> = default;
10410 to_input_view(_Vp __base)
10411 : _M_base(
std::move(__base))
10415 base() const & requires copy_constructible<_Vp>
10416 {
return _M_base; }
10423 begin()
requires (!__detail::__simple_view<_Vp>)
10424 {
return _Iterator<false>(ranges::begin(_M_base)); }
10427 begin() const requires range<const _Vp>
10428 {
return _Iterator<true>(ranges::begin(_M_base)); }
10431 end()
requires (!__detail::__simple_view<_Vp>)
10432 {
return ranges::end(_M_base); }
10435 end() const requires range<const _Vp>
10436 {
return ranges::end(_M_base); }
10439 size()
requires sized_range<_Vp>
10440 {
return ranges::size(_M_base); }
10443 size() const requires sized_range<const _Vp>
10444 {
return ranges::size(_M_base); }
10447 template<
typename _Range>
10448 to_input_view(_Range&&) -> to_input_view<views::all_t<_Range>>;
10450 template<input_range _Vp>
10452 template<
bool _Const>
10453 class to_input_view<_Vp>::_Iterator
10455 using _Base = __maybe_const_t<_Const, _Vp>;
10457 iterator_t<_Base> _M_current = iterator_t<_Base>();
10460 _Iterator(iterator_t<_Base> __current)
10461 : _M_current(
std::
move(__current))
10464 friend to_input_view;
10465 friend _Iterator<!_Const>;
10468 using difference_type = range_difference_t<_Base>;
10469 using value_type = range_value_t<_Base>;
10470 using iterator_concept = input_iterator_tag;
10472 _Iterator()
requires default_initializable<iterator_t<_Base>> = default;
10474 _Iterator(_Iterator&&) = default;
10475 _Iterator& operator=(_Iterator&&) = default;
10478 _Iterator(_Iterator<!_Const> __i)
10479 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
10480 : _M_current(
std::move(__i._M_current))
10483 constexpr iterator_t<_Base>
10487 constexpr const iterator_t<_Base>&
10488 base() const & noexcept
10489 {
return _M_current; }
10491 constexpr decltype(
auto)
10493 {
return *_M_current; }
10495 constexpr _Iterator&
10506 friend constexpr bool
10507 operator==(
const _Iterator& __x,
const sentinel_t<_Base>& __y)
10508 {
return __x._M_current == __y; }
10510 friend constexpr difference_type
10511 operator-(
const sentinel_t<_Base>& __y,
const _Iterator& __x)
10512 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
10513 {
return __y - __x._M_current; }
10515 friend constexpr difference_type
10516 operator-(
const _Iterator& __x,
const sentinel_t<_Base>& __y)
10517 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
10518 {
return __x._M_current - __y; }
10520 friend constexpr range_rvalue_reference_t<_Base>
10521 iter_move(
const _Iterator& __i)
10522 noexcept(
noexcept(ranges::iter_move(__i._M_current)))
10523 {
return ranges::iter_move(__i._M_current); }
10525 friend constexpr void
10526 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
10527 noexcept(
noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
10528 requires indirectly_swappable<iterator_t<_Base>>
10529 { ranges::iter_swap(__x._M_current, __y._M_current); }
10536 template<
typename _Tp>
10537 concept __can_to_input =
requires { to_input_view(std::declval<_Tp>()); };
10540 struct _ToInput : __adaptor::_RangeAdaptorClosure<_ToInput>
10542 template<viewable_range _Range>
10543 requires __detail::__can_to_input<_Range>
10545 operator() [[nodiscard]] (_Range&& __r)
const
10547 if constexpr (input_range<_Range>
10548 && !common_range<_Range>
10549 && !forward_range<_Range>)
10550 return views::all(std::forward<_Range>(__r));
10552 return to_input_view(std::forward<_Range>(__r));
10555 static constexpr bool _S_has_simple_call_op =
true;
10558 inline constexpr _ToInput to_input;
10563_GLIBCXX_END_NAMESPACE_VERSION
constexpr bool operator<=(const duration< _Rep1, _Period1 > &__lhs, const duration< _Rep2, _Period2 > &__rhs)
constexpr bool operator>=(const duration< _Rep1, _Period1 > &__lhs, const duration< _Rep2, _Period2 > &__rhs)
constexpr bool operator<(const duration< _Rep1, _Period1 > &__lhs, const duration< _Rep2, _Period2 > &__rhs)
constexpr bool operator>(const duration< _Rep1, _Period1 > &__lhs, const duration< _Rep2, _Period2 > &__rhs)
constexpr complex< _Tp > operator*(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x times y.
constexpr complex< _Tp > operator-(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x minus y.
constexpr complex< _Tp > operator+(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x plus y.
basic_istream< char > istream
Base class for char input streams.
constexpr _Tp * to_address(_Tp *__ptr) noexcept
Obtain address referenced by a pointer to an object.
typename make_unsigned< _Tp >::type make_unsigned_t
Alias template for make_unsigned.
typename common_type< _Tp... >::type common_type_t
Alias template for common_type.
typename conditional< _Cond, _Iftrue, _Iffalse >::type conditional_t
Alias template for conditional.
constexpr auto tuple_cat(_Tpls &&... __tpls) -> typename __tuple_cat_result< _Tpls... >::__type
Create a tuple containing all elements from multiple tuple-like objects.
auto declval() noexcept -> decltype(__declval< _Tp >(0))
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
constexpr __invoke_result< _Callable, _Args... >::type __invoke(_Callable &&__fn, _Args &&... __args) noexcept(__is_nothrow_invocable< _Callable, _Args... >::value)
Invoke a callable object.
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
constexpr _Tp && forward(typename std::remove_reference< _Tp >::type &__t) noexcept
Forward an lvalue.
_Tp * end(valarray< _Tp > &__va) noexcept
Return an iterator pointing to one past the last element of the valarray.
_Tp * begin(valarray< _Tp > &__va) noexcept
Return an iterator pointing to the first element of the valarray.
constexpr const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
constexpr reverse_iterator< _Iterator > make_reverse_iterator(_Iterator __i)
Generator function for reverse_iterator.
constexpr void iota(_ForwardIterator __first, _ForwardIterator __last, _Tp __value)
Create a range of sequentially increasing values.
ISO C++ entities toplevel namespace is std.
make_integer_sequence< size_t, _Num > make_index_sequence
Alias template make_index_sequence.
constexpr auto empty(const _Container &__cont) noexcept(noexcept(__cont.empty())) -> decltype(__cont.empty())
Return whether a container is empty.
constexpr auto size(const _Container &__cont) noexcept(noexcept(__cont.size())) -> decltype(__cont.size())
Return the size of a container.
constexpr default_sentinel_t default_sentinel
A default sentinel value.
constexpr auto data(_Container &__cont) noexcept(noexcept(__cont.data())) -> decltype(__cont.data())
Return the data pointer of a container.
constexpr bitset< _Nb > operator|(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
integer_sequence< size_t, _Idx... > index_sequence
Alias template index_sequence.
constexpr _Iterator __base(_Iterator __it)