30 #ifndef _GLIBCXX_RANGES
31 #define _GLIBCXX_RANGES 1
33 #if __cplusplus > 201703L
35 #pragma GCC system_header
39 #if __cpp_lib_concepts
55 namespace std _GLIBCXX_VISIBILITY(default)
57 _GLIBCXX_BEGIN_NAMESPACE_VERSION
72 template<
typename _Tp> requires is_object_v<_Tp>
74 :
public view_interface<empty_view<_Tp>>
77 static constexpr _Tp*
begin() noexcept {
return nullptr; }
78 static constexpr _Tp*
end() noexcept {
return nullptr; }
79 static constexpr _Tp*
data() noexcept {
return nullptr; }
80 static constexpr
size_t size() noexcept {
return 0; }
81 static constexpr
bool empty() noexcept {
return true; }
84 template<
typename _Tp>
85 inline constexpr
bool enable_borrowed_range<empty_view<_Tp>> =
true;
89 template<
typename _Tp>
90 concept __boxable = copy_constructible<_Tp> && is_object_v<_Tp>;
92 template<__boxable _Tp>
99 noexcept(is_nothrow_default_constructible_v<_Tp>)
100 requires default_initializable<_Tp>
101 : std::optional<_Tp>{std::in_place}
104 __box(
const __box&) =
default;
105 __box(__box&&) =
default;
113 noexcept(is_nothrow_copy_constructible_v<_Tp>)
114 requires (!copyable<_Tp>)
117 this->emplace(*__that);
125 noexcept(is_nothrow_move_constructible_v<_Tp>)
126 requires (!movable<_Tp>)
140 template<__boxable _Tp> requires semiregular<_Tp>
144 [[no_unique_address]] _Tp _M_value = _Tp();
150 __box(
const _Tp& __t)
151 noexcept(is_nothrow_copy_constructible_v<_Tp>)
157 noexcept(is_nothrow_move_constructible_v<_Tp>)
161 template<
typename... _Args>
162 requires constructible_from<_Tp, _Args...>
164 __box(in_place_t, _Args&&... __args)
165 noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
166 : _M_value(std::
forward<_Args>(__args)...)
170 has_value() const noexcept
192 template<copy_constructible _Tp> requires is_object_v<_Tp>
193 class single_view :
public view_interface<single_view<_Tp>>
196 single_view() =
default;
199 single_view(
const _Tp& __t)
204 single_view(_Tp&& __t)
205 : _M_value(std::
move(__t))
210 template<
typename... _Args>
211 requires constructible_from<_Tp, _Args...>
213 single_view(in_place_t, _Args&&... __args)
214 : _M_value{in_place, std::forward<_Args>(__args)...}
222 begin() const noexcept
227 {
return data() + 1; }
231 {
return data() + 1; }
233 static constexpr
size_t
239 {
return _M_value.operator->(); }
242 data() const noexcept
243 {
return _M_value.operator->(); }
246 [[no_unique_address]] __detail::__box<_Tp> _M_value;
249 template<
typename _Tp>
250 single_view(_Tp) -> single_view<_Tp>;
254 template<
typename _Wp>
255 constexpr
auto __to_signed_like(_Wp __w) noexcept
257 if constexpr (!integral<_Wp>)
258 return iter_difference_t<_Wp>();
259 else if constexpr (sizeof(iter_difference_t<_Wp>) > sizeof(_Wp))
260 return iter_difference_t<_Wp>(__w);
261 else if constexpr (sizeof(ptrdiff_t) > sizeof(_Wp))
262 return ptrdiff_t(__w);
263 else if constexpr (sizeof(
long long) > sizeof(_Wp))
264 return (
long long)(__w);
265 #ifdef __SIZEOF_INT128__
266 else if constexpr (__SIZEOF_INT128__ >
sizeof(_Wp))
267 return __int128(__w);
270 return __max_diff_type(__w);
273 template<
typename _Wp>
274 using __iota_diff_t = decltype(__to_signed_like(std::declval<_Wp>()));
276 template<
typename _It>
277 concept __decrementable = incrementable<_It>
280 { --__i } -> same_as<_It&>;
281 { __i-- } -> same_as<_It>;
284 template<
typename _It>
285 concept __advanceable = __decrementable<_It> && totally_ordered<_It>
286 && requires( _It __i,
const _It __j,
const __iota_diff_t<_It> __n)
288 { __i += __n } -> same_as<_It&>;
289 { __i -= __n } -> same_as<_It&>;
293 { __j - __j } -> convertible_to<__iota_diff_t<_It>>;
296 template<
typename _Winc>
297 struct __iota_view_iter_cat
300 template<incrementable _Winc>
301 struct __iota_view_iter_cat<_Winc>
302 {
using iterator_category = input_iterator_tag; };
305 template<weakly_incrementable _Winc,
306 semiregular _Bound = unreachable_sentinel_t>
307 requires std::__detail::__weakly_eq_cmp_with<_Winc, _Bound>
308 && semiregular<_Winc>
309 class iota_view :
public view_interface<iota_view<_Winc, _Bound>>
314 struct _Iterator : __detail::__iota_view_iter_cat<_Winc>
320 using namespace __detail;
321 if constexpr (__advanceable<_Winc>)
322 return random_access_iterator_tag{};
323 else if constexpr (__decrementable<_Winc>)
324 return bidirectional_iterator_tag{};
325 else if constexpr (incrementable<_Winc>)
326 return forward_iterator_tag{};
328 return input_iterator_tag{};
332 using iterator_concept = decltype(_S_iter_concept());
334 using value_type = _Winc;
335 using difference_type = __detail::__iota_diff_t<_Winc>;
337 _Iterator() =
default;
340 _Iterator(_Winc __value)
341 : _M_value(__value) { }
344 operator*() const noexcept(is_nothrow_copy_constructible_v<_Winc>)
359 operator++(
int) requires incrementable<_Winc>
367 operator--() requires __detail::__decrementable<_Winc>
374 operator--(
int) requires __detail::__decrementable<_Winc>
382 operator+=(difference_type __n) requires __detail::__advanceable<_Winc>
384 using __detail::__is_integer_like;
385 using __detail::__is_signed_integer_like;
386 if constexpr (__is_integer_like<_Winc>
387 && !__is_signed_integer_like<_Winc>)
389 if (__n >= difference_type(0))
390 _M_value +=
static_cast<_Winc
>(__n);
392 _M_value -=
static_cast<_Winc
>(-__n);
400 operator-=(difference_type __n) requires __detail::__advanceable<_Winc>
402 using __detail::__is_integer_like;
403 using __detail::__is_signed_integer_like;
404 if constexpr (__is_integer_like<_Winc>
405 && !__is_signed_integer_like<_Winc>)
407 if (__n >= difference_type(0))
408 _M_value -=
static_cast<_Winc
>(__n);
410 _M_value +=
static_cast<_Winc
>(-__n);
418 operator[](difference_type __n)
const
419 requires __detail::__advanceable<_Winc>
420 {
return _Winc(_M_value + __n); }
422 friend constexpr
bool
423 operator==(
const _Iterator& __x,
const _Iterator& __y)
424 requires equality_comparable<_Winc>
425 {
return __x._M_value == __y._M_value; }
427 friend constexpr
bool
428 operator<(
const _Iterator& __x,
const _Iterator& __y)
429 requires totally_ordered<_Winc>
430 {
return __x._M_value < __y._M_value; }
432 friend constexpr
bool
433 operator>(
const _Iterator& __x,
const _Iterator& __y)
434 requires totally_ordered<_Winc>
435 {
return __y < __x; }
437 friend constexpr
bool
438 operator<=(
const _Iterator& __x,
const _Iterator& __y)
439 requires totally_ordered<_Winc>
440 {
return !(__y < __x); }
442 friend constexpr
bool
443 operator>=(
const _Iterator& __x,
const _Iterator& __y)
444 requires totally_ordered<_Winc>
445 {
return !(__x < __y); }
447 #ifdef __cpp_lib_three_way_comparison
448 friend constexpr
auto
449 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
450 requires totally_ordered<_Winc> && three_way_comparable<_Winc>
451 {
return __x._M_value <=> __y._M_value; }
454 friend constexpr _Iterator
455 operator+(_Iterator __i, difference_type __n)
456 requires __detail::__advanceable<_Winc>
457 {
return __i += __n; }
459 friend constexpr _Iterator
460 operator+(difference_type __n, _Iterator __i)
461 requires __detail::__advanceable<_Winc>
462 {
return __i += __n; }
464 friend constexpr _Iterator
465 operator-(_Iterator __i, difference_type __n)
466 requires __detail::__advanceable<_Winc>
467 {
return __i -= __n; }
469 friend constexpr difference_type
470 operator-(
const _Iterator& __x,
const _Iterator& __y)
471 requires __detail::__advanceable<_Winc>
473 using __detail::__is_integer_like;
474 using __detail::__is_signed_integer_like;
475 using _Dt = difference_type;
476 if constexpr (__is_integer_like<_Winc>)
478 if constexpr (__is_signed_integer_like<_Winc>)
479 return _Dt(_Dt(__x._M_value) - _Dt(__y._M_value));
481 return (__y._M_value > __x._M_value)
482 ? _Dt(-_Dt(__y._M_value - __x._M_value))
483 : _Dt(__x._M_value - __y._M_value);
486 return __x._M_value - __y._M_value;
490 _Winc _M_value = _Winc();
499 _M_equal(
const _Iterator& __x)
const
500 {
return __x._M_value == _M_bound; }
503 _M_distance_from(
const _Iterator& __x)
const
504 {
return _M_bound - __x._M_value; }
506 _Bound _M_bound = _Bound();
509 _Sentinel() =
default;
512 _Sentinel(_Bound __bound)
513 : _M_bound(__bound) { }
515 friend constexpr
bool
516 operator==(
const _Iterator& __x,
const _Sentinel& __y)
517 {
return __y._M_equal(__x); }
519 friend constexpr iter_difference_t<_Winc>
520 operator-(
const _Iterator& __x,
const _Sentinel& __y)
521 requires sized_sentinel_for<_Bound, _Winc>
522 {
return -__y._M_distance_from(__x); }
524 friend constexpr iter_difference_t<_Winc>
525 operator-(
const _Sentinel& __x,
const _Iterator& __y)
526 requires sized_sentinel_for<_Bound, _Winc>
527 {
return __x._M_distance_from(__y); }
530 _Winc _M_value = _Winc();
531 [[no_unique_address]] _Bound _M_bound = _Bound();
534 iota_view() =
default;
537 iota_view(_Winc __value)
542 iota_view(type_identity_t<_Winc> __value,
543 type_identity_t<_Bound> __bound)
544 : _M_value(__value), _M_bound(__bound)
546 if constexpr (totally_ordered_with<_Winc, _Bound>)
547 __glibcxx_assert(
bool(__value <= __bound) );
551 begin()
const {
return _Iterator{_M_value}; }
556 if constexpr (same_as<_Bound, unreachable_sentinel_t>)
557 return unreachable_sentinel;
559 return _Sentinel{_M_bound};
563 end() const requires same_as<_Winc, _Bound>
564 {
return _Iterator{_M_bound}; }
568 requires (same_as<_Winc, _Bound> && __detail::__advanceable<_Winc>)
569 || (integral<_Winc> && integral<_Bound>)
570 || sized_sentinel_for<_Bound, _Winc>
572 using __detail::__is_integer_like;
573 using __detail::__to_unsigned_like;
574 if constexpr (integral<_Winc> && integral<_Bound>)
577 return _Up(_M_bound) - _Up(_M_value);
579 else if constexpr (__is_integer_like<_Winc>)
580 return __to_unsigned_like(_M_bound) - __to_unsigned_like(_M_value);
582 return __to_unsigned_like(_M_bound - _M_value);
586 template<typename _Winc, typename _Bound>
587 requires (!__detail::__is_integer_like<_Winc>
588 || !__detail::__is_integer_like<_Bound>
589 || (__detail::__is_signed_integer_like<_Winc>
590 == __detail::__is_signed_integer_like<_Bound>))
591 iota_view(_Winc, _Bound) -> iota_view<_Winc, _Bound>;
593 template<weakly_incrementable _Winc, semiregular _Bound>
594 inline constexpr
bool
595 enable_borrowed_range<iota_view<_Winc, _Bound>> = true;
599 template<
typename _Tp>
600 inline constexpr empty_view<_Tp>
empty{};
604 template<
typename _Tp>
606 operator()(_Tp&& __e)
const
607 {
return single_view<decay_t<_Tp>>(std::forward<_Tp>(__e)); }
610 inline constexpr _Single single{};
614 template<
typename _Tp>
616 operator()(_Tp&& __e)
const
617 {
return iota_view(std::forward<_Tp>(__e)); }
619 template<
typename _Tp,
typename _Up>
621 operator()(_Tp&& __e, _Up&& __f)
const
622 {
return iota_view(std::forward<_Tp>(__e), std::forward<_Up>(__f)); }
625 inline constexpr _Iota
iota{};
630 template<
typename _Val,
typename _CharT,
typename _Traits>
631 concept __stream_extractable
632 = requires(basic_istream<_CharT, _Traits>& is, _Val& t) { is >> t; };
635 template<movable _Val,
typename _CharT,
typename _Traits>
636 requires default_initializable<_Val>
637 && __detail::__stream_extractable<_Val, _CharT, _Traits>
638 class basic_istream_view
639 :
public view_interface<basic_istream_view<_Val, _CharT, _Traits>>
642 basic_istream_view() =
default;
645 basic_istream_view(basic_istream<_CharT, _Traits>& __stream)
652 if (_M_stream !=
nullptr)
653 *_M_stream >> _M_object;
654 return _Iterator{
this};
657 constexpr default_sentinel_t
659 {
return default_sentinel; }
662 basic_istream<_CharT, _Traits>* _M_stream =
nullptr;
663 _Val _M_object = _Val();
668 using iterator_concept = input_iterator_tag;
669 using difference_type = ptrdiff_t;
670 using value_type = _Val;
672 _Iterator() =
default;
675 _Iterator(basic_istream_view* __parent) noexcept
676 : _M_parent(__parent)
679 _Iterator(
const _Iterator&) =
delete;
680 _Iterator(_Iterator&&) =
default;
681 _Iterator&
operator=(
const _Iterator&) =
delete;
682 _Iterator&
operator=(_Iterator&&) =
default;
687 __glibcxx_assert(_M_parent->_M_stream !=
nullptr);
688 *_M_parent->_M_stream >> _M_parent->_M_object;
699 __glibcxx_assert(_M_parent->_M_stream !=
nullptr);
700 return _M_parent->_M_object;
704 operator==(
const _Iterator& __x, default_sentinel_t)
705 {
return __x._M_at_end(); }
708 basic_istream_view* _M_parent =
nullptr;
712 {
return _M_parent ==
nullptr || !*_M_parent->_M_stream; }
718 template<
typename _Val,
typename _CharT,
typename _Traits>
719 basic_istream_view<_Val, _CharT, _Traits>
720 istream_view(basic_istream<_CharT, _Traits>& __s)
721 {
return basic_istream_view<_Val, _CharT, _Traits>{__s}; }
733 template<
bool _Present,
typename _Tp>
734 using __maybe_present_t = conditional_t<_Present, _Tp, _Empty>;
737 template<
bool _Const,
typename _Tp>
738 using __maybe_const_t = conditional_t<_Const, const _Tp, _Tp>;
742 namespace views::__adaptor
745 template<
typename _Adaptor,
typename... _Args>
746 concept __adaptor_invocable
747 = requires { std::declval<_Adaptor>()(declval<_Args>()...); };
751 template<
typename _Adaptor,
typename... _Args>
752 concept __adaptor_partial_app_viable = (_Adaptor::_S_arity > 1)
753 && (
sizeof...(_Args) == _Adaptor::_S_arity - 1)
754 && (constructible_from<decay_t<_Args>, _Args> && ...);
756 template<
typename _Adaptor,
typename... _Args>
759 template<
typename _Lhs,
typename _Rhs>
767 struct _RangeAdaptorClosure
770 template<
typename _Self,
typename _Range>
771 requires derived_from<remove_cvref_t<_Self>, _RangeAdaptorClosure>
772 && __adaptor_invocable<_Self, _Range>
773 friend constexpr
auto
775 {
return std::forward<_Self>(__self)(std::forward<_Range>(__r)); }
779 template<
typename _Lhs,
typename _Rhs>
780 requires derived_from<_Lhs, _RangeAdaptorClosure>
781 && derived_from<_Rhs, _RangeAdaptorClosure>
782 friend constexpr
auto
798 template<
typename _Derived>
803 template<
typename... _Args>
804 requires __adaptor_partial_app_viable<_Derived, _Args...>
806 operator()(_Args&&... __args)
const
808 return _Partial<_Derived, decay_t<_Args>...>{std::forward<_Args>(__args)...};
815 template<
typename _Adaptor>
816 concept __closure_has_simple_call_op = _Adaptor::_S_has_simple_call_op;
820 template<
typename _Adaptor,
typename... _Args>
821 concept __adaptor_has_simple_extra_args = _Adaptor::_S_has_simple_extra_args
822 || _Adaptor::template _S_has_simple_extra_args<_Args...>;
826 template<
typename _Adaptor,
typename... _Args>
827 struct _Partial : _RangeAdaptorClosure
829 tuple<_Args...> _M_args;
832 _Partial(_Args... __args)
833 : _M_args(std::
move(__args)...)
838 template<
typename _Range>
839 requires __adaptor_invocable<_Adaptor, _Range,
const _Args&...>
841 operator()(_Range&& __r) const &
843 auto __forwarder = [&__r] (
const auto&... __args) {
844 return _Adaptor{}(std::forward<_Range>(__r), __args...);
846 return std::apply(__forwarder, _M_args);
849 template<
typename _Range>
850 requires __adaptor_invocable<_Adaptor, _Range, _Args...>
852 operator()(_Range&& __r) &&
854 auto __forwarder = [&__r] (
auto&... __args) {
855 return _Adaptor{}(std::forward<_Range>(__r),
std::move(__args)...);
857 return std::apply(__forwarder, _M_args);
860 template<
typename _Range>
862 operator()(_Range&& __r) const && = delete;
867 template<typename _Adaptor, typename _Arg>
868 struct _Partial<_Adaptor, _Arg> : _RangeAdaptorClosure
874 : _M_arg(std::
move(__arg))
877 template<
typename _Range>
878 requires __adaptor_invocable<_Adaptor, _Range, const _Arg&>
880 operator()(_Range&& __r) const &
881 {
return _Adaptor{}(std::forward<_Range>(__r), _M_arg); }
883 template<
typename _Range>
884 requires __adaptor_invocable<_Adaptor, _Range, _Arg>
886 operator()(_Range&& __r) &&
887 {
return _Adaptor{}(std::forward<_Range>(__r),
std::move(_M_arg)); }
889 template<
typename _Range>
891 operator()(_Range&& __r) const && = delete;
898 template<typename _Adaptor, typename... _Args>
899 requires __adaptor_has_simple_extra_args<_Adaptor, _Args...>
900 && (is_trivially_copyable_v<_Args> && ...)
901 struct _Partial<_Adaptor, _Args...> : _RangeAdaptorClosure
903 tuple<_Args...> _M_args;
906 _Partial(_Args... __args)
907 : _M_args(std::
move(__args)...)
912 template<
typename _Range>
913 requires __adaptor_invocable<_Adaptor, _Range,
const _Args&...>
915 operator()(_Range&& __r)
const
917 auto __forwarder = [&__r] (
const auto&... __args) {
918 return _Adaptor{}(std::forward<_Range>(__r), __args...);
920 return std::apply(__forwarder, _M_args);
923 static constexpr
bool _S_has_simple_call_op =
true;
928 template<
typename _Adaptor,
typename _Arg>
929 requires __adaptor_has_simple_extra_args<_Adaptor, _Arg>
930 && is_trivially_copyable_v<_Arg>
931 struct _Partial<_Adaptor, _Arg> : _RangeAdaptorClosure
937 : _M_arg(std::
move(__arg))
940 template<
typename _Range>
941 requires __adaptor_invocable<_Adaptor, _Range, const _Arg&>
943 operator()(_Range&& __r)
const
944 {
return _Adaptor{}(std::forward<_Range>(__r), _M_arg); }
946 static constexpr
bool _S_has_simple_call_op =
true;
949 template<
typename _Lhs,
typename _Rhs,
typename _Range>
950 concept __pipe_invocable
951 = requires { std::declval<_Rhs>()(std::declval<_Lhs>()(std::declval<_Range>())); };
955 template<
typename _Lhs,
typename _Rhs>
956 struct _Pipe : _RangeAdaptorClosure
958 [[no_unique_address]] _Lhs _M_lhs;
959 [[no_unique_address]] _Rhs _M_rhs;
962 _Pipe(_Lhs __lhs, _Rhs __rhs)
963 : _M_lhs(std::
move(__lhs)), _M_rhs(std::
move(__rhs))
968 template<
typename _Range>
969 requires __pipe_invocable<const _Lhs&, const _Rhs&, _Range>
971 operator()(_Range&& __r) const &
972 {
return _M_rhs(_M_lhs(std::forward<_Range>(__r))); }
974 template<
typename _Range>
975 requires __pipe_invocable<_Lhs, _Rhs, _Range>
977 operator()(_Range&& __r) &&
980 template<
typename _Range>
982 operator()(_Range&& __r) const && = delete;
989 template<typename _Lhs, typename _Rhs>
990 requires __closure_has_simple_call_op<_Lhs>
991 && __closure_has_simple_call_op<_Rhs>
992 struct _Pipe<_Lhs, _Rhs> : _RangeAdaptorClosure
994 [[no_unique_address]] _Lhs _M_lhs;
995 [[no_unique_address]] _Rhs _M_rhs;
998 _Pipe(_Lhs __lhs, _Rhs __rhs)
999 : _M_lhs(std::
move(__lhs)), _M_rhs(std::
move(__rhs))
1002 template<
typename _Range>
1003 requires __pipe_invocable<const _Lhs&, const _Rhs&, _Range>
1005 operator()(_Range&& __r)
const
1006 {
return _M_rhs(_M_lhs(std::forward<_Range>(__r))); }
1008 static constexpr
bool _S_has_simple_call_op =
true;
1012 template<range _Range> requires is_object_v<_Range>
1013 class ref_view :
public view_interface<ref_view<_Range>>
1016 _Range* _M_r =
nullptr;
1018 static void _S_fun(_Range&);
1019 static void _S_fun(_Range&&) =
delete;
1023 ref_view() noexcept = default;
1025 template<__detail::__not_same_as<ref_view> _Tp>
1026 requires convertible_to<_Tp, _Range&>
1027 && requires { _S_fun(declval<_Tp>()); }
1037 constexpr iterator_t<_Range>
1041 constexpr sentinel_t<_Range>
1050 size() const requires sized_range<_Range>
1054 data() const requires contiguous_range<_Range>
1058 template<
typename _Range>
1059 ref_view(_Range&) -> ref_view<_Range>;
1061 template<
typename _Tp>
1062 inline constexpr
bool enable_borrowed_range<ref_view<_Tp>> =
true;
1068 template<
typename _Range>
1069 concept __can_ref_view = requires { ref_view{std::declval<_Range>()}; };
1071 template<
typename _Range>
1072 concept __can_subrange = requires { subrange{std::declval<_Range>()}; };
1075 struct _All : __adaptor::_RangeAdaptorClosure
1077 template<viewable_range _Range>
1078 requires view<decay_t<_Range>>
1079 || __detail::__can_ref_view<_Range>
1080 || __detail::__can_subrange<_Range>
1082 operator()(_Range&& __r)
const
1084 if constexpr (view<decay_t<_Range>>)
1085 return std::
forward<_Range>(__r);
1086 else if constexpr (__detail::__can_ref_view<_Range>)
1087 return ref_view{std::forward<_Range>(__r)};
1089 return subrange{std::forward<_Range>(__r)};
1092 static constexpr
bool _S_has_simple_call_op =
true;
1095 inline constexpr _All all;
1097 template<viewable_range _Range>
1098 using all_t = decltype(all(std::declval<_Range>()));
1105 template<
typename _Iter,
typename _Sent,
typename _Tp>
1107 find(_Iter __first, _Sent __last,
const _Tp& __value)
1109 while (__first != __last
1110 && !(
bool)(*__first == __value))
1115 template<
typename _Iter,
typename _Sent,
typename _Pred>
1117 find_if(_Iter __first, _Sent __last, _Pred __pred)
1119 while (__first != __last
1120 && !(
bool)std::__invoke(__pred, *__first))
1125 template<
typename _Iter,
typename _Sent,
typename _Pred>
1127 find_if_not(_Iter __first, _Sent __last, _Pred __pred)
1129 while (__first != __last
1130 && (
bool)std::__invoke(__pred, *__first))
1135 template<
typename _Iter1,
typename _Sent1,
typename _Iter2,
typename _Sent2>
1136 constexpr pair<_Iter1, _Iter2>
1137 mismatch(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2)
1139 while (__first1 != __last1 && __first2 != __last2
1140 && (
bool)ranges::equal_to{}(*__first1, *__first2))
1151 template<
typename _Tp>
1152 struct __non_propagating_cache
1160 template<
typename _Tp>
1161 requires is_object_v<_Tp>
1162 struct __non_propagating_cache<_Tp> :
protected _Optional_base<_Tp>
1164 __non_propagating_cache() =
default;
1167 __non_propagating_cache(
const __non_propagating_cache&) noexcept
1171 __non_propagating_cache(__non_propagating_cache&& __other) noexcept
1172 { __other._M_reset(); }
1174 constexpr __non_propagating_cache&
1175 operator=(
const __non_propagating_cache& __other) noexcept
1182 constexpr __non_propagating_cache&
1183 operator=(__non_propagating_cache&& __other) noexcept
1192 {
return this->_M_get(); }
1194 constexpr
const _Tp&
1196 {
return this->_M_get(); }
1198 template<
typename _Iter>
1200 _M_emplace_deref(
const _Iter& __i)
1207 this->_M_payload._M_engaged = true;
1208 return this->_M_get();
1212 template<range _Range>
1213 struct _CachedPosition
1216 _M_has_value()
const
1219 constexpr iterator_t<_Range>
1220 _M_get(
const _Range&)
const
1222 __glibcxx_assert(
false);
1227 _M_set(
const _Range&,
const iterator_t<_Range>&)
const
1231 template<forward_range _Range>
1232 struct _CachedPosition<_Range>
1233 :
protected __non_propagating_cache<iterator_t<_Range>>
1236 _M_has_value()
const
1237 {
return this->_M_is_engaged(); }
1239 constexpr iterator_t<_Range>
1240 _M_get(
const _Range&)
const
1242 __glibcxx_assert(_M_has_value());
1247 _M_set(
const _Range&,
const iterator_t<_Range>& __it)
1249 __glibcxx_assert(!_M_has_value());
1252 this->_M_payload._M_engaged =
true;
1256 template<random_access_range _Range>
1257 requires (
sizeof(range_difference_t<_Range>)
1258 <=
sizeof(iterator_t<_Range>))
1259 struct _CachedPosition<_Range>
1262 range_difference_t<_Range> _M_offset = -1;
1265 _CachedPosition() =
default;
1268 _CachedPosition(
const _CachedPosition&) =
default;
1271 _CachedPosition(_CachedPosition&& __other) noexcept
1274 constexpr _CachedPosition&
1275 operator=(
const _CachedPosition&) =
default;
1277 constexpr _CachedPosition&
1278 operator=(_CachedPosition&& __other) noexcept
1281 _M_offset = __other._M_offset;
1282 __other._M_offset = -1;
1287 _M_has_value()
const
1288 {
return _M_offset >= 0; }
1290 constexpr iterator_t<_Range>
1291 _M_get(_Range& __r)
const
1293 __glibcxx_assert(_M_has_value());
1298 _M_set(_Range& __r,
const iterator_t<_Range>& __it)
1300 __glibcxx_assert(!_M_has_value());
1308 template<
typename _Base>
1309 struct __filter_view_iter_cat
1312 template<forward_range _Base>
1313 struct __filter_view_iter_cat<_Base>
1319 using _Cat =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
1320 if constexpr (derived_from<_Cat, bidirectional_iterator_tag>)
1321 return bidirectional_iterator_tag{};
1322 else if constexpr (derived_from<_Cat, forward_iterator_tag>)
1323 return forward_iterator_tag{};
1328 using iterator_category = decltype(_S_iter_cat());
1332 template<input_range _Vp,
1333 indirect_unary_predicate<iterator_t<_Vp>> _Pred>
1334 requires view<_Vp> && is_object_v<_Pred>
1335 class filter_view :
public view_interface<filter_view<_Vp, _Pred>>
1340 struct _Iterator : __detail::__filter_view_iter_cat<_Vp>
1343 static constexpr
auto
1346 if constexpr (bidirectional_range<_Vp>)
1347 return bidirectional_iterator_tag{};
1348 else if constexpr (forward_range<_Vp>)
1349 return forward_iterator_tag{};
1351 return input_iterator_tag{};
1356 using _Vp_iter = iterator_t<_Vp>;
1358 _Vp_iter _M_current = _Vp_iter();
1359 filter_view* _M_parent =
nullptr;
1362 using iterator_concept = decltype(_S_iter_concept());
1364 using value_type = range_value_t<_Vp>;
1365 using difference_type = range_difference_t<_Vp>;
1367 _Iterator() =
default;
1370 _Iterator(filter_view* __parent, _Vp_iter __current)
1371 : _M_current(std::
move(__current)),
1375 constexpr
const _Vp_iter&
1376 base() const & noexcept
1377 {
return _M_current; }
1383 constexpr range_reference_t<_Vp>
1385 {
return *_M_current; }
1389 requires __detail::__has_arrow<_Vp_iter>
1390 && copyable<_Vp_iter>
1391 {
return _M_current; }
1393 constexpr _Iterator&
1396 _M_current = __detail::find_if(
std::move(++_M_current),
1398 std::ref(*_M_parent->_M_pred));
1407 operator++(
int) requires forward_range<_Vp>
1414 constexpr _Iterator&
1415 operator--() requires bidirectional_range<_Vp>
1419 while (!std::__invoke(*_M_parent->_M_pred, *_M_current));
1424 operator--(
int) requires bidirectional_range<_Vp>
1431 friend constexpr
bool
1432 operator==(
const _Iterator& __x,
const _Iterator& __y)
1433 requires equality_comparable<_Vp_iter>
1434 {
return __x._M_current == __y._M_current; }
1436 friend constexpr range_rvalue_reference_t<_Vp>
1437 iter_move(
const _Iterator& __i)
1438 noexcept(noexcept(ranges::iter_move(__i._M_current)))
1439 {
return ranges::iter_move(__i._M_current); }
1441 friend constexpr
void
1442 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
1443 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1444 requires indirectly_swappable<_Vp_iter>
1445 { ranges::iter_swap(__x._M_current, __y._M_current); }
1451 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
1454 __equal(
const _Iterator& __i)
const
1455 {
return __i._M_current == _M_end; }
1458 _Sentinel() =
default;
1461 _Sentinel(filter_view* __parent)
1462 : _M_end(ranges::
end(__parent->_M_base))
1465 constexpr sentinel_t<_Vp>
1469 friend constexpr
bool
1470 operator==(
const _Iterator& __x,
const _Sentinel& __y)
1471 {
return __y.__equal(__x); }
1474 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
1475 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
1476 _Vp _M_base = _Vp();
1479 filter_view() =
default;
1482 filter_view(_Vp
__base, _Pred __pred)
1483 : _M_pred(std::
move(__pred)), _M_base(std::
move(__base))
1487 base() const& requires copy_constructible<_Vp>
1494 constexpr
const _Pred&
1496 {
return *_M_pred; }
1501 if (_M_cached_begin._M_has_value())
1502 return {
this, _M_cached_begin._M_get(_M_base)};
1504 __glibcxx_assert(_M_pred.has_value());
1507 std::ref(*_M_pred));
1508 _M_cached_begin._M_set(_M_base, __it);
1515 if constexpr (common_range<_Vp>)
1518 return _Sentinel{
this};
1522 template<
typename _Range,
typename _Pred>
1523 filter_view(_Range&&, _Pred) -> filter_view<views::all_t<_Range>, _Pred>;
1529 template<
typename _Range,
typename _Pred>
1530 concept __can_filter_view
1531 = requires { filter_view(std::declval<_Range>(), std::declval<_Pred>()); };
1534 struct _Filter : __adaptor::_RangeAdaptor<_Filter>
1536 template<viewable_range _Range,
typename _Pred>
1537 requires __detail::__can_filter_view<_Range, _Pred>
1539 operator()(_Range&& __r, _Pred&& __p)
const
1541 return filter_view(std::forward<_Range>(__r), std::forward<_Pred>(__p));
1544 using _RangeAdaptor<_Filter>::operator();
1545 static constexpr
int _S_arity = 2;
1546 static constexpr
bool _S_has_simple_extra_args =
true;
1549 inline constexpr _Filter filter;
1552 template<input_range _Vp, copy_constructible _Fp>
1553 requires view<_Vp> && is_object_v<_Fp>
1554 && regular_invocable<_Fp&, range_reference_t<_Vp>>
1556 range_reference_t<_Vp>>>
1557 class transform_view :
public view_interface<transform_view<_Vp, _Fp>>
1560 template<
bool _Const>
1561 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
1563 template<
bool _Const>
1567 template<
bool _Const>
1568 requires forward_range<_Base<_Const>>
1569 struct __iter_cat<_Const>
1575 using _Base = transform_view::_Base<_Const>;
1576 using _Res = invoke_result_t<_Fp&, range_reference_t<_Base>>;
1577 if constexpr (is_lvalue_reference_v<_Res>)
1580 =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
1581 if constexpr (derived_from<_Cat, contiguous_iterator_tag>)
1582 return random_access_iterator_tag{};
1587 return input_iterator_tag{};
1590 using iterator_category = decltype(_S_iter_cat());
1593 template<
bool _Const>
1596 template<
bool _Const>
1597 struct _Iterator : __iter_cat<_Const>
1600 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
1601 using _Base = transform_view::_Base<_Const>;
1606 if constexpr (random_access_range<_Vp>)
1607 return random_access_iterator_tag{};
1608 else if constexpr (bidirectional_range<_Vp>)
1609 return bidirectional_iterator_tag{};
1610 else if constexpr (forward_range<_Vp>)
1611 return forward_iterator_tag{};
1613 return input_iterator_tag{};
1616 using _Base_iter = iterator_t<_Base>;
1618 _Base_iter _M_current = _Base_iter();
1619 _Parent* _M_parent =
nullptr;
1622 using iterator_concept = decltype(_S_iter_concept());
1625 = remove_cvref_t<invoke_result_t<_Fp&, range_reference_t<_Base>>>;
1626 using difference_type = range_difference_t<_Base>;
1628 _Iterator() =
default;
1631 _Iterator(_Parent* __parent, _Base_iter __current)
1632 : _M_current(std::
move(__current)),
1637 _Iterator(_Iterator<!_Const> __i)
1639 && convertible_to<iterator_t<_Vp>, _Base_iter>
1640 : _M_current(
std::move(__i._M_current)), _M_parent(__i._M_parent)
1643 constexpr
const _Base_iter&
1644 base() const & noexcept
1645 {
return _M_current; }
1647 constexpr _Base_iter
1651 constexpr decltype(
auto)
1653 noexcept(noexcept(std::__invoke(*_M_parent->_M_fun, *_M_current)))
1654 {
return std::__invoke(*_M_parent->_M_fun, *_M_current); }
1656 constexpr _Iterator&
1668 operator++(
int) requires forward_range<_Base>
1675 constexpr _Iterator&
1676 operator--() requires bidirectional_range<_Base>
1683 operator--(
int) requires bidirectional_range<_Base>
1690 constexpr _Iterator&
1691 operator+=(difference_type __n) requires random_access_range<_Base>
1697 constexpr _Iterator&
1698 operator-=(difference_type __n) requires random_access_range<_Base>
1704 constexpr decltype(
auto)
1705 operator[](difference_type __n) const
1706 requires random_access_range<_Base>
1707 {
return std::__invoke(*_M_parent->_M_fun, _M_current[__n]); }
1709 friend constexpr
bool
1710 operator==(
const _Iterator& __x,
const _Iterator& __y)
1711 requires equality_comparable<_Base_iter>
1712 {
return __x._M_current == __y._M_current; }
1714 friend constexpr
bool
1715 operator<(
const _Iterator& __x,
const _Iterator& __y)
1716 requires random_access_range<_Base>
1717 {
return __x._M_current < __y._M_current; }
1719 friend constexpr
bool
1720 operator>(
const _Iterator& __x,
const _Iterator& __y)
1721 requires random_access_range<_Base>
1722 {
return __y < __x; }
1724 friend constexpr
bool
1725 operator<=(
const _Iterator& __x,
const _Iterator& __y)
1726 requires random_access_range<_Base>
1727 {
return !(__y < __x); }
1729 friend constexpr
bool
1730 operator>=(
const _Iterator& __x,
const _Iterator& __y)
1731 requires random_access_range<_Base>
1732 {
return !(__x < __y); }
1734 #ifdef __cpp_lib_three_way_comparison
1735 friend constexpr
auto
1736 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
1737 requires random_access_range<_Base>
1738 && three_way_comparable<_Base_iter>
1739 {
return __x._M_current <=> __y._M_current; }
1742 friend constexpr _Iterator
1743 operator+(_Iterator __i, difference_type __n)
1744 requires random_access_range<_Base>
1745 {
return {__i._M_parent, __i._M_current + __n}; }
1747 friend constexpr _Iterator
1748 operator+(difference_type __n, _Iterator __i)
1749 requires random_access_range<_Base>
1750 {
return {__i._M_parent, __i._M_current + __n}; }
1752 friend constexpr _Iterator
1753 operator-(_Iterator __i, difference_type __n)
1754 requires random_access_range<_Base>
1755 {
return {__i._M_parent, __i._M_current - __n}; }
1759 friend constexpr difference_type
1760 operator-(
const _Iterator& __x,
const _Iterator& __y)
1761 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
1762 {
return __x._M_current - __y._M_current; }
1764 friend constexpr decltype(
auto)
1765 iter_move(const _Iterator& __i) noexcept(noexcept(*__i))
1767 if constexpr (is_lvalue_reference_v<decltype(*__i)>)
1768 return std::
move(*__i);
1773 friend _Iterator<!_Const>;
1774 template<
bool> friend struct _Sentinel;
1777 template<
bool _Const>
1781 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
1782 using _Base = transform_view::_Base<_Const>;
1784 template<
bool _Const2>
1786 __distance_from(
const _Iterator<_Const2>& __i)
const
1787 {
return _M_end - __i._M_current; }
1789 template<
bool _Const2>
1791 __equal(
const _Iterator<_Const2>& __i)
const
1792 {
return __i._M_current == _M_end; }
1794 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
1797 _Sentinel() =
default;
1800 _Sentinel(sentinel_t<_Base> __end)
1805 _Sentinel(_Sentinel<!_Const> __i)
1807 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
1811 constexpr sentinel_t<_Base>
1815 template<
bool _Const2>
1816 requires sentinel_for<sentinel_t<_Base>,
1817 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
1818 friend constexpr
bool
1819 operator==(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
1820 {
return __y.__equal(__x); }
1822 template<
bool _Const2,
1823 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
1824 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
1825 friend constexpr range_difference_t<_Base2>
1826 operator-(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
1827 {
return -__y.__distance_from(__x); }
1829 template<
bool _Const2,
1830 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
1831 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
1832 friend constexpr range_difference_t<_Base2>
1833 operator-(
const _Sentinel& __y,
const _Iterator<_Const2>& __x)
1834 {
return __y.__distance_from(__x); }
1836 friend _Sentinel<!_Const>;
1839 [[no_unique_address]] __detail::__box<_Fp> _M_fun;
1840 _Vp _M_base = _Vp();
1843 transform_view() =
default;
1846 transform_view(_Vp
__base, _Fp __fun)
1847 : _M_fun(std::
move(__fun)), _M_base(std::
move(__base))
1851 base() const& requires copy_constructible<_Vp>
1852 {
return _M_base ; }
1858 constexpr _Iterator<false>
1862 constexpr _Iterator<true>
1864 requires range<const _Vp>
1865 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
1868 constexpr _Sentinel<false>
1870 {
return _Sentinel<false>{
ranges::end(_M_base)}; }
1872 constexpr _Iterator<false>
1873 end() requires common_range<_Vp>
1874 {
return _Iterator<false>{
this,
ranges::end(_M_base)}; }
1876 constexpr _Sentinel<true>
1878 requires range<const _Vp>
1879 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
1882 constexpr _Iterator<true>
1884 requires common_range<const _Vp>
1885 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
1886 {
return _Iterator<true>{
this,
ranges::end(_M_base)}; }
1889 size() requires sized_range<_Vp>
1893 size() const requires sized_range<const _Vp>
1897 template<
typename _Range,
typename _Fp>
1898 transform_view(_Range&&, _Fp) -> transform_view<views::all_t<_Range>, _Fp>;
1904 template<
typename _Range,
typename _Fp>
1905 concept __can_transform_view
1906 = requires { transform_view(std::declval<_Range>(), std::declval<_Fp>()); };
1909 struct _Transform : __adaptor::_RangeAdaptor<_Transform>
1911 template<viewable_range _Range,
typename _Fp>
1912 requires __detail::__can_transform_view<_Range, _Fp>
1914 operator()(_Range&& __r, _Fp&& __f)
const
1916 return transform_view(std::forward<_Range>(__r), std::forward<_Fp>(__f));
1919 using _RangeAdaptor<_Transform>::operator();
1920 static constexpr
int _S_arity = 2;
1921 static constexpr
bool _S_has_simple_extra_args =
true;
1924 inline constexpr _Transform transform;
1928 class take_view :
public view_interface<take_view<_Vp>>
1931 template<
bool _Const>
1932 using _CI = counted_iterator<
1933 iterator_t<__detail::__maybe_const_t<_Const, _Vp>>>;
1935 template<
bool _Const>
1939 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
1940 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
1943 _Sentinel() =
default;
1946 _Sentinel(sentinel_t<_Base> __end)
1951 _Sentinel(_Sentinel<!_Const> __s)
1952 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
1956 constexpr sentinel_t<_Base>
1960 friend constexpr
bool
1961 operator==(
const _CI<_Const>& __y,
const _Sentinel& __x)
1962 {
return __y.count() == 0 || __y.base() == __x._M_end; }
1964 template<
bool _OtherConst = !_Const,
1965 typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
1966 requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
1967 friend constexpr
bool
1968 operator==(
const _CI<_OtherConst>& __y,
const _Sentinel& __x)
1969 {
return __y.count() == 0 || __y.base() == __x._M_end; }
1971 friend _Sentinel<!_Const>;
1974 range_difference_t<_Vp> _M_count = 0;
1975 _Vp _M_base = _Vp();
1978 take_view() =
default;
1981 take_view(_Vp base, range_difference_t<_Vp> __count)
1982 : _M_count(std::
move(__count)), _M_base(std::
move(base))
1986 base() const& requires copy_constructible<_Vp>
1994 begin() requires (!__detail::__simple_view<_Vp>)
1996 if constexpr (sized_range<_Vp>)
1998 if constexpr (random_access_range<_Vp>)
1999 return ranges::
begin(_M_base);
2011 begin() const requires range<const _Vp>
2013 if constexpr (sized_range<const _Vp>)
2015 if constexpr (random_access_range<const _Vp>)
2016 return ranges::
begin(_M_base);
2028 end() requires (!__detail::__simple_view<_Vp>)
2030 if constexpr (sized_range<_Vp>)
2032 if constexpr (random_access_range<_Vp>)
2035 return default_sentinel;
2042 end() const requires range<const _Vp>
2044 if constexpr (sized_range<const _Vp>)
2046 if constexpr (random_access_range<const _Vp>)
2049 return default_sentinel;
2056 size() requires sized_range<_Vp>
2059 return std::min(__n,
static_cast<decltype(__n)
>(_M_count));
2063 size() const requires sized_range<const _Vp>
2066 return std::min(__n,
static_cast<decltype(__n)
>(_M_count));
2073 template<
typename _Range>
2074 take_view(_Range&&, range_difference_t<_Range>)
2075 -> take_view<views::all_t<_Range>>;
2077 template<
typename _Tp>
2078 inline constexpr
bool enable_borrowed_range<take_view<_Tp>>
2079 = enable_borrowed_range<_Tp>;
2085 template<
typename _Range,
typename _Tp>
2086 concept __can_take_view
2087 = requires { take_view(std::declval<_Range>(), std::declval<_Tp>()); };
2090 struct _Take : __adaptor::_RangeAdaptor<_Take>
2092 template<viewable_range _Range,
typename _Tp>
2093 requires __detail::__can_take_view<_Range, _Tp>
2095 operator()(_Range&& __r, _Tp&& __n)
const
2097 return take_view(std::forward<_Range>(__r), std::forward<_Tp>(__n));
2100 using _RangeAdaptor<_Take>::operator();
2101 static constexpr
int _S_arity = 2;
2105 template<
typename _Tp>
2106 static constexpr
bool _S_has_simple_extra_args
2107 = ranges::__detail::__is_integer_like<_Tp>;
2110 inline constexpr _Take take;
2113 template<view _Vp,
typename _Pred>
2114 requires input_range<_Vp> && is_object_v<_Pred>
2115 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2116 class take_while_view :
public view_interface<take_while_view<_Vp, _Pred>>
2118 template<
bool _Const>
2122 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2124 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2125 const _Pred* _M_pred =
nullptr;
2128 _Sentinel() =
default;
2131 _Sentinel(sentinel_t<_Base> __end,
const _Pred* __pred)
2132 : _M_end(__end), _M_pred(__pred)
2136 _Sentinel(_Sentinel<!_Const> __s)
2137 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2138 : _M_end(__s._M_end), _M_pred(__s._M_pred)
2141 constexpr sentinel_t<_Base>
2142 base()
const {
return _M_end; }
2144 friend constexpr
bool
2145 operator==(
const iterator_t<_Base>& __x,
const _Sentinel& __y)
2146 {
return __y._M_end == __x || !std::__invoke(*__y._M_pred, *__x); }
2148 template<
bool _OtherConst = !_Const,
2149 typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
2150 requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2151 friend constexpr
bool
2152 operator==(
const iterator_t<_Base2>& __x,
const _Sentinel& __y)
2153 {
return __y._M_end == __x || !std::__invoke(*__y._M_pred, *__x); }
2155 friend _Sentinel<!_Const>;
2158 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
2159 _Vp _M_base = _Vp();
2162 take_while_view() =
default;
2165 take_while_view(_Vp base, _Pred __pred)
2166 : _M_pred(std::
move(__pred)), _M_base(std::
move(base))
2170 base() const& requires copy_constructible<_Vp>
2177 constexpr
const _Pred&
2179 {
return *_M_pred; }
2182 begin() requires (!__detail::__simple_view<_Vp>)
2186 begin() const requires range<const _Vp>
2187 && indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
2191 end() requires (!__detail::__simple_view<_Vp>)
2196 end() const requires range<const _Vp>
2197 && indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
2202 template<
typename _Range,
typename _Pred>
2203 take_while_view(_Range&&, _Pred)
2204 -> take_while_view<views::all_t<_Range>, _Pred>;
2210 template<
typename _Range,
typename _Pred>
2211 concept __can_take_while_view
2212 = requires { take_while_view(std::declval<_Range>(), std::declval<_Pred>()); };
2215 struct _TakeWhile : __adaptor::_RangeAdaptor<_TakeWhile>
2217 template<viewable_range _Range,
typename _Pred>
2218 requires __detail::__can_take_while_view<_Range, _Pred>
2220 operator()(_Range&& __r, _Pred&& __p)
const
2222 return take_while_view(std::forward<_Range>(__r), std::forward<_Pred>(__p));
2225 using _RangeAdaptor<_TakeWhile>::operator();
2226 static constexpr
int _S_arity = 2;
2227 static constexpr
bool _S_has_simple_extra_args =
true;
2230 inline constexpr _TakeWhile take_while;
2234 class drop_view :
public view_interface<drop_view<_Vp>>
2237 range_difference_t<_Vp> _M_count = 0;
2238 _Vp _M_base = _Vp();
2242 static constexpr
bool _S_needs_cached_begin
2243 = !(random_access_range<const _Vp> && sized_range<const _Vp>);
2244 [[no_unique_address]]
2245 __detail::__maybe_present_t<_S_needs_cached_begin,
2246 __detail::_CachedPosition<_Vp>>
2250 drop_view() =
default;
2253 drop_view(_Vp
__base, range_difference_t<_Vp> __count)
2254 : _M_count(__count), _M_base(std::
move(__base))
2255 { __glibcxx_assert(__count >= 0); }
2258 base() const& requires copy_constructible<_Vp>
2268 requires (!(__detail::__simple_view<_Vp>
2269 && random_access_range<const _Vp>
2270 && sized_range<const _Vp>))
2272 if constexpr (_S_needs_cached_begin)
2273 if (_M_cached_begin._M_has_value())
2274 return _M_cached_begin._M_get(_M_base);
2276 auto __it = ranges::next(ranges::
begin(_M_base),
2277 _M_count, ranges::
end(_M_base));
2278 if constexpr (_S_needs_cached_begin)
2279 _M_cached_begin._M_set(_M_base, __it);
2287 requires random_access_range<const _Vp> && sized_range<const _Vp>
2294 end() requires (!__detail::__simple_view<_Vp>)
2298 end() const requires range<const _Vp>
2302 size() requires sized_range<_Vp>
2305 const auto __c =
static_cast<decltype(__s)
>(_M_count);
2306 return __s < __c ? 0 : __s - __c;
2310 size() const requires sized_range<const _Vp>
2313 const auto __c =
static_cast<decltype(__s)
>(_M_count);
2314 return __s < __c ? 0 : __s - __c;
2318 template<
typename _Range>
2319 drop_view(_Range&&, range_difference_t<_Range>)
2320 -> drop_view<views::all_t<_Range>>;
2322 template<
typename _Tp>
2323 inline constexpr
bool enable_borrowed_range<drop_view<_Tp>>
2324 = enable_borrowed_range<_Tp>;
2330 template<
typename _Range,
typename _Tp>
2331 concept __can_drop_view
2332 = requires { drop_view(std::declval<_Range>(), std::declval<_Tp>()); };
2335 struct _Drop : __adaptor::_RangeAdaptor<_Drop>
2337 template<viewable_range _Range,
typename _Tp>
2338 requires __detail::__can_drop_view<_Range, _Tp>
2340 operator()(_Range&& __r, _Tp&& __n)
const
2342 return drop_view(std::forward<_Range>(__r), std::forward<_Tp>(__n));
2345 using _RangeAdaptor<_Drop>::operator();
2346 static constexpr
int _S_arity = 2;
2347 template<
typename _Tp>
2348 static constexpr
bool _S_has_simple_extra_args
2349 = _Take::_S_has_simple_extra_args<_Tp>;
2352 inline constexpr _Drop drop;
2355 template<view _Vp,
typename _Pred>
2356 requires input_range<_Vp> && is_object_v<_Pred>
2357 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2358 class drop_while_view :
public view_interface<drop_while_view<_Vp, _Pred>>
2361 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
2362 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
2363 _Vp _M_base = _Vp();
2366 drop_while_view() =
default;
2369 drop_while_view(_Vp
__base, _Pred __pred)
2370 : _M_pred(std::
move(__pred)), _M_base(std::
move(__base))
2374 base() const& requires copy_constructible<_Vp>
2381 constexpr
const _Pred&
2383 {
return *_M_pred; }
2388 if (_M_cached_begin._M_has_value())
2389 return _M_cached_begin._M_get(_M_base);
2393 std::cref(*_M_pred));
2394 _M_cached_begin._M_set(_M_base, __it);
2403 template<
typename _Range,
typename _Pred>
2404 drop_while_view(_Range&&, _Pred)
2405 -> drop_while_view<views::all_t<_Range>, _Pred>;
2407 template<
typename _Tp,
typename _Pred>
2408 inline constexpr
bool enable_borrowed_range<drop_while_view<_Tp, _Pred>>
2409 = enable_borrowed_range<_Tp>;
2415 template<
typename _Range,
typename _Pred>
2416 concept __can_drop_while_view
2417 = requires { drop_while_view(std::declval<_Range>(), std::declval<_Pred>()); };
2420 struct _DropWhile : __adaptor::_RangeAdaptor<_DropWhile>
2422 template<viewable_range _Range,
typename _Pred>
2423 requires __detail::__can_drop_while_view<_Range, _Pred>
2425 operator()(_Range&& __r, _Pred&& __p)
const
2427 return drop_while_view(std::forward<_Range>(__r),
2428 std::forward<_Pred>(__p));
2431 using _RangeAdaptor<_DropWhile>::operator();
2432 static constexpr
int _S_arity = 2;
2433 static constexpr
bool _S_has_simple_extra_args =
true;
2436 inline constexpr _DropWhile drop_while;
2439 template<input_range _Vp>
2440 requires view<_Vp> && input_range<range_reference_t<_Vp>>
2441 class join_view :
public view_interface<join_view<_Vp>>
2444 using _InnerRange = range_reference_t<_Vp>;
2446 template<
bool _Const>
2447 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2449 template<
bool _Const>
2450 using _Outer_iter = iterator_t<_Base<_Const>>;
2452 template<
bool _Const>
2453 using _Inner_iter = iterator_t<range_reference_t<_Base<_Const>>>;
2455 template<
bool _Const>
2456 static constexpr
bool _S_ref_is_glvalue
2457 = is_reference_v<range_reference_t<_Base<_Const>>>;
2459 template<
bool _Const>
2463 template<
bool _Const>
2464 requires _S_ref_is_glvalue<_Const>
2465 && forward_range<_Base<_Const>>
2466 && forward_range<range_reference_t<_Base<_Const>>>
2467 struct __iter_cat<_Const>
2470 static constexpr
auto
2473 using _Outer_iter = join_view::_Outer_iter<_Const>;
2474 using _Inner_iter = join_view::_Inner_iter<_Const>;
2475 using _OuterCat =
typename iterator_traits<_Outer_iter>::iterator_category;
2476 using _InnerCat =
typename iterator_traits<_Inner_iter>::iterator_category;
2477 if constexpr (derived_from<_OuterCat, bidirectional_iterator_tag>
2478 && derived_from<_InnerCat, bidirectional_iterator_tag>)
2479 return bidirectional_iterator_tag{};
2480 else if constexpr (derived_from<_OuterCat, forward_iterator_tag>
2481 && derived_from<_InnerCat, forward_iterator_tag>)
2482 return forward_iterator_tag{};
2484 return input_iterator_tag{};
2487 using iterator_category = decltype(_S_iter_cat());
2490 template<
bool _Const>
2493 template<
bool _Const>
2494 struct _Iterator : __iter_cat<_Const>
2497 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
2498 using _Base = join_view::_Base<_Const>;
2500 static constexpr
bool _S_ref_is_glvalue
2501 = join_view::_S_ref_is_glvalue<_Const>;
2506 auto __update_inner = [
this] (
const iterator_t<_Base>& __x) ->
auto&& {
2507 if constexpr (_S_ref_is_glvalue)
2510 return _M_parent->_M_inner._M_emplace_deref(__x);
2513 for (; _M_outer != ranges::
end(_M_parent->_M_base); ++_M_outer)
2515 auto&& __inner = __update_inner(_M_outer);
2521 if constexpr (_S_ref_is_glvalue)
2522 _M_inner = _Inner_iter();
2525 static constexpr auto
2528 if constexpr (_S_ref_is_glvalue
2529 && bidirectional_range<_Base>
2530 && bidirectional_range<range_reference_t<_Base>>)
2531 return bidirectional_iterator_tag{};
2532 else if constexpr (_S_ref_is_glvalue
2533 && forward_range<_Base>
2534 && forward_range<range_reference_t<_Base>>)
2535 return forward_iterator_tag{};
2537 return input_iterator_tag{};
2540 using _Outer_iter = join_view::_Outer_iter<_Const>;
2541 using _Inner_iter = join_view::_Inner_iter<_Const>;
2543 _Outer_iter _M_outer = _Outer_iter();
2544 _Inner_iter _M_inner = _Inner_iter();
2545 _Parent* _M_parent =
nullptr;
2548 using iterator_concept = decltype(_S_iter_concept());
2550 using value_type = range_value_t<range_reference_t<_Base>>;
2551 using difference_type
2552 = common_type_t<range_difference_t<_Base>,
2553 range_difference_t<range_reference_t<_Base>>>;
2555 _Iterator() =
default;
2558 _Iterator(_Parent* __parent, _Outer_iter __outer)
2559 : _M_outer(std::
move(__outer)),
2564 _Iterator(_Iterator<!_Const> __i)
2566 && convertible_to<iterator_t<_Vp>, _Outer_iter>
2567 && convertible_to<iterator_t<_InnerRange>, _Inner_iter>
2568 : _M_outer(
std::move(__i._M_outer)), _M_inner(__i._M_inner),
2569 _M_parent(__i._M_parent)
2572 constexpr decltype(
auto)
2574 {
return *_M_inner; }
2578 constexpr _Inner_iter
2580 requires __detail::__has_arrow<_Inner_iter>
2581 && copyable<_Inner_iter>
2582 {
return _M_inner; }
2584 constexpr _Iterator&
2587 auto&& __inner_range = [
this] () ->
auto&& {
2588 if constexpr (_S_ref_is_glvalue)
2591 return *_M_parent->_M_inner;
2593 if (++_M_inner == ranges::
end(__inner_range))
2607 requires _S_ref_is_glvalue && forward_range<_Base>
2608 && forward_range<range_reference_t<_Base>>
2615 constexpr _Iterator&
2617 requires _S_ref_is_glvalue && bidirectional_range<_Base>
2618 && bidirectional_range<range_reference_t<_Base>>
2619 && common_range<range_reference_t<_Base>>
2631 requires _S_ref_is_glvalue && bidirectional_range<_Base>
2632 && bidirectional_range<range_reference_t<_Base>>
2633 && common_range<range_reference_t<_Base>>
2640 friend constexpr
bool
2641 operator==(
const _Iterator& __x,
const _Iterator& __y)
2642 requires _S_ref_is_glvalue
2643 && equality_comparable<_Outer_iter>
2644 && equality_comparable<_Inner_iter>
2646 return (__x._M_outer == __y._M_outer
2647 && __x._M_inner == __y._M_inner);
2650 friend constexpr decltype(
auto)
2651 iter_move(const _Iterator& __i)
2652 noexcept(noexcept(ranges::iter_move(__i._M_inner)))
2653 {
return ranges::iter_move(__i._M_inner); }
2655 friend constexpr
void
2656 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
2657 noexcept(noexcept(ranges::iter_swap(__x._M_inner, __y._M_inner)))
2658 requires indirectly_swappable<_Inner_iter>
2659 {
return ranges::iter_swap(__x._M_inner, __y._M_inner); }
2661 friend _Iterator<!_Const>;
2662 template<
bool>
friend struct _Sentinel;
2665 template<
bool _Const>
2669 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
2670 using _Base = join_view::_Base<_Const>;
2672 template<
bool _Const2>
2674 __equal(
const _Iterator<_Const2>& __i)
const
2675 {
return __i._M_outer == _M_end; }
2677 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2680 _Sentinel() =
default;
2683 _Sentinel(_Parent* __parent)
2684 : _M_end(ranges::
end(__parent->_M_base))
2688 _Sentinel(_Sentinel<!_Const> __s)
2689 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2693 template<
bool _Const2>
2694 requires sentinel_for<sentinel_t<_Base>,
2695 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
2696 friend constexpr
bool
2697 operator==(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
2698 {
return __y.__equal(__x); }
2700 friend _Sentinel<!_Const>;
2703 [[no_unique_address]]
2704 __detail::__non_propagating_cache<remove_cv_t<_InnerRange>> _M_inner;
2705 _Vp _M_base = _Vp();
2708 join_view() =
default;
2712 : _M_base(std::
move(__base))
2716 base() const& requires copy_constructible<_Vp>
2726 constexpr
bool __use_const
2727 = (__detail::__simple_view<_Vp>
2728 && is_reference_v<range_reference_t<_Vp>>);
2729 return _Iterator<__use_const>{
this,
ranges::begin(_M_base)};
2734 requires input_range<const _Vp>
2735 && is_reference_v<range_reference_t<const _Vp>>
2743 if constexpr (forward_range<_Vp> && is_reference_v<_InnerRange>
2744 && forward_range<_InnerRange>
2745 && common_range<_Vp> && common_range<_InnerRange>)
2746 return _Iterator<__detail::__simple_view<_Vp>>{
this,
2749 return _Sentinel<__detail::__simple_view<_Vp>>{
this};
2754 requires input_range<const _Vp>
2755 && is_reference_v<range_reference_t<const _Vp>>
2757 if constexpr (forward_range<const _Vp>
2758 && is_reference_v<range_reference_t<const _Vp>>
2759 && forward_range<range_reference_t<const _Vp>>
2760 && common_range<const _Vp>
2761 && common_range<range_reference_t<const _Vp>>)
2762 return _Iterator<true>{
this,
ranges::end(_M_base)};
2764 return _Sentinel<true>{
this};
2768 template<
typename _Range>
2769 explicit join_view(_Range&&) -> join_view<views::all_t<_Range>>;
2775 template<
typename _Range>
2776 concept __can_join_view
2777 = requires { join_view<all_t<_Range>>{std::declval<_Range>()}; };
2780 struct _Join : __adaptor::_RangeAdaptorClosure
2782 template<viewable_range _Range>
2783 requires __detail::__can_join_view<_Range>
2785 operator()(_Range&& __r)
const
2789 return join_view<all_t<_Range>>{std::forward<_Range>(__r)};
2792 static constexpr
bool _S_has_simple_call_op =
true;
2795 inline constexpr _Join join;
2801 struct __require_constant;
2803 template<
typename _Range>
2804 concept __tiny_range = sized_range<_Range>
2809 template<
typename _Base>
2810 struct __split_view_outer_iter_cat
2813 template<forward_range _Base>
2814 struct __split_view_outer_iter_cat<_Base>
2815 {
using iterator_category = input_iterator_tag; };
2817 template<
typename _Base>
2818 struct __split_view_inner_iter_cat
2821 template<forward_range _Base>
2822 struct __split_view_inner_iter_cat<_Base>
2825 static constexpr
auto
2828 using _Cat =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
2829 if constexpr (derived_from<_Cat, forward_iterator_tag>)
2830 return forward_iterator_tag{};
2835 using iterator_category = decltype(_S_iter_cat());
2839 template<input_range _Vp, forward_range _Pattern>
2840 requires view<_Vp> && view<_Pattern>
2841 && indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
2843 && (forward_range<_Vp> || __detail::__tiny_range<_Pattern>)
2844 class split_view :
public view_interface<split_view<_Vp, _Pattern>>
2847 template<
bool _Const>
2848 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2850 template<
bool _Const>
2853 template<
bool _Const>
2855 : __detail::__split_view_outer_iter_cat<_Base<_Const>>
2858 using _Parent = __detail::__maybe_const_t<_Const, split_view>;
2859 using _Base = split_view::_Base<_Const>;
2863 {
return __current() ==
ranges::end(_M_parent->_M_base); }
2870 __current() noexcept
2872 if constexpr (forward_range<_Vp>)
2875 return _M_parent->_M_current;
2879 __current() const noexcept
2881 if constexpr (forward_range<_Vp>)
2884 return _M_parent->_M_current;
2887 _Parent* _M_parent =
nullptr;
2890 [[no_unique_address]]
2891 __detail::__maybe_present_t<forward_range<_Vp>,
2892 iterator_t<_Base>> _M_current;
2895 using iterator_concept =
conditional_t<forward_range<_Base>,
2896 forward_iterator_tag,
2897 input_iterator_tag>;
2899 using difference_type = range_difference_t<_Base>;
2901 struct value_type : view_interface<value_type>
2904 _OuterIter _M_i = _OuterIter();
2907 value_type() =
default;
2910 value_type(_OuterIter __i)
2911 : _M_i(std::
move(__i))
2914 constexpr _InnerIter<_Const>
2916 requires copyable<_OuterIter>
2917 {
return _InnerIter<_Const>{_M_i}; }
2919 constexpr _InnerIter<_Const>
2921 requires (!copyable<_OuterIter>)
2922 {
return _InnerIter<_Const>{
std::move(_M_i)}; }
2924 constexpr default_sentinel_t
2926 {
return default_sentinel; }
2929 _OuterIter() =
default;
2932 _OuterIter(_Parent* __parent) requires (!forward_range<_Base>)
2933 : _M_parent(__parent)
2937 _OuterIter(_Parent* __parent, iterator_t<_Base> __current)
2938 requires forward_range<_Base>
2939 : _M_parent(__parent),
2944 _OuterIter(_OuterIter<!_Const> __i)
2946 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
2947 : _M_parent(__i._M_parent), _M_current(
std::move(__i._M_current))
2950 constexpr value_type
2952 {
return value_type{*
this}; }
2954 constexpr _OuterIter&
2959 const auto __end =
ranges::end(_M_parent->_M_base);
2960 if (__current() == __end)
2962 const auto [__pbegin, __pend] = subrange{_M_parent->_M_pattern};
2963 if (__pbegin == __pend)
2965 else if constexpr (__detail::__tiny_range<_Pattern>)
2967 __current() = __detail::find(
std::move(__current()), __end,
2969 if (__current() != __end)
2976 = __detail::mismatch(__current(), __end, __pbegin, __pend);
2982 }
while (++__current() != __end);
2986 constexpr decltype(
auto)
2989 if constexpr (forward_range<_Base>)
2999 friend constexpr
bool
3000 operator==(
const _OuterIter& __x,
const _OuterIter& __y)
3001 requires forward_range<_Base>
3002 {
return __x._M_current == __y._M_current; }
3004 friend constexpr
bool
3005 operator==(
const _OuterIter& __x, default_sentinel_t)
3006 {
return __x.__at_end(); };
3008 friend _OuterIter<!_Const>;
3009 friend _InnerIter<_Const>;
3012 template<
bool _Const>
3014 : __detail::__split_view_inner_iter_cat<_Base<_Const>>
3017 using _Base = split_view::_Base<_Const>;
3022 auto [__pcur, __pend] = subrange{_M_i._M_parent->_M_pattern};
3023 auto __end =
ranges::end(_M_i._M_parent->_M_base);
3024 if constexpr (__detail::__tiny_range<_Pattern>)
3026 const auto& __cur = _M_i_current();
3029 if (__pcur == __pend)
3030 return _M_incremented;
3031 return *__cur == *__pcur;
3035 auto __cur = _M_i_current();
3038 if (__pcur == __pend)
3039 return _M_incremented;
3042 if (*__cur != *__pcur)
3044 if (++__pcur == __pend)
3046 }
while (++__cur != __end);
3052 _M_i_current() noexcept
3053 {
return _M_i.__current(); }
3056 _M_i_current() const noexcept
3057 {
return _M_i.__current(); }
3059 _OuterIter<_Const> _M_i = _OuterIter<_Const>();
3060 bool _M_incremented =
false;
3063 using iterator_concept
3064 =
typename _OuterIter<_Const>::iterator_concept;
3066 using value_type = range_value_t<_Base>;
3067 using difference_type = range_difference_t<_Base>;
3069 _InnerIter() =
default;
3072 _InnerIter(_OuterIter<_Const> __i)
3073 : _M_i(std::
move(__i))
3076 constexpr decltype(
auto)
3078 {
return *_M_i_current(); }
3080 constexpr _InnerIter&
3083 _M_incremented =
true;
3084 if constexpr (!forward_range<_Base>)
3085 if constexpr (_Pattern::
size() == 0)
3091 constexpr decltype(auto)
3094 if constexpr (forward_range<_Base>)
3104 friend constexpr
bool
3105 operator==(
const _InnerIter& __x,
const _InnerIter& __y)
3106 requires forward_range<_Base>
3107 {
return __x._M_i == __y._M_i; }
3109 friend constexpr
bool
3110 operator==(
const _InnerIter& __x, default_sentinel_t)
3111 {
return __x.__at_end(); }
3113 friend constexpr decltype(
auto)
3114 iter_move(const _InnerIter& __i)
3115 noexcept(noexcept(ranges::iter_move(__i._M_i_current())))
3116 {
return ranges::iter_move(__i._M_i_current()); }
3118 friend constexpr
void
3119 iter_swap(
const _InnerIter& __x,
const _InnerIter& __y)
3120 noexcept(noexcept(ranges::iter_swap(__x._M_i_current(),
3121 __y._M_i_current())))
3122 requires indirectly_swappable<iterator_t<_Base>>
3123 { ranges::iter_swap(__x._M_i_current(), __y._M_i_current()); }
3126 _Pattern _M_pattern = _Pattern();
3128 [[no_unique_address]]
3129 __detail::__maybe_present_t<!forward_range<_Vp>,
3130 iterator_t<_Vp>> _M_current;
3131 _Vp _M_base = _Vp();
3135 split_view() =
default;
3138 split_view(_Vp
__base, _Pattern __pattern)
3139 : _M_pattern(std::
move(__pattern)), _M_base(std::
move(__base))
3142 template<input_range _Range>
3143 requires constructible_from<_Vp, views::all_t<_Range>>
3144 && constructible_from<_Pattern, single_view<range_value_t<_Range>>>
3146 split_view(_Range&& __r, range_value_t<_Range> __e)
3147 : _M_pattern(views::single(std::
move(__e))),
3148 _M_base(views::all(std::
forward<_Range>(__r)))
3152 base() const& requires copy_constructible<_Vp>
3162 if constexpr (forward_range<_Vp>)
3163 return _OuterIter<__detail::__simple_view<_Vp>>{
3168 return _OuterIter<false>{
this};
3173 begin() const requires forward_range<_Vp> && forward_range<const _Vp>
3179 end() requires forward_range<_Vp> && common_range<_Vp>
3181 return _OuterIter<__detail::__simple_view<_Vp>>{
3188 if constexpr (forward_range<_Vp>
3189 && forward_range<const _Vp>
3190 && common_range<const _Vp>)
3191 return _OuterIter<true>{
this,
ranges::end(_M_base)};
3193 return default_sentinel;
3197 template<
typename _Range,
typename _Pattern>
3198 split_view(_Range&&, _Pattern&&)
3199 -> split_view<views::all_t<_Range>, views::all_t<_Pattern>>;
3201 template<input_range _Range>
3202 split_view(_Range&&, range_value_t<_Range>)
3203 -> split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
3209 template<
typename _Range,
typename _Pattern>
3210 concept __can_split_view
3211 = requires { split_view(std::declval<_Range>(), std::declval<_Pattern>()); };
3214 struct _Split : __adaptor::_RangeAdaptor<_Split>
3216 template<viewable_range _Range,
typename _Pattern>
3217 requires __detail::__can_split_view<_Range, _Pattern>
3219 operator()(_Range&& __r, _Pattern&& __f)
const
3221 return split_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
3224 using _RangeAdaptor<_Split>::operator();
3225 static constexpr
int _S_arity = 2;
3230 template<
typename _Pattern>
3231 static constexpr
bool _S_has_simple_extra_args
3232 = is_scalar_v<_Pattern> || (view<_Pattern>
3233 && copy_constructible<_Pattern>);
3236 inline constexpr _Split split;
3243 template<input_or_output_iterator _Iter>
3245 operator()(_Iter __i, iter_difference_t<_Iter> __n)
const
3247 if constexpr (random_access_iterator<_Iter>)
3248 return subrange(__i, __i + __n);
3250 return subrange(counted_iterator(std::
move(__i), __n),
3255 inline constexpr _Counted counted{};
3259 requires (!common_range<_Vp>) && copyable<iterator_t<_Vp>>
3260 class common_view :
public view_interface<common_view<_Vp>>
3263 _Vp _M_base = _Vp();
3266 common_view() =
default;
3269 common_view(_Vp __r)
3270 : _M_base(std::
move(__r))
3284 base() const& requires copy_constructible<_Vp>
3294 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3295 return ranges::
begin(_M_base);
3297 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
3298 (ranges::
begin(_M_base));
3302 begin() const requires range<const _Vp>
3304 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
3305 return ranges::
begin(_M_base);
3307 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
3308 (ranges::
begin(_M_base));
3314 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3315 return ranges::
begin(_M_base) + ranges::
size(_M_base);
3317 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
3318 (ranges::end(_M_base));
3322 end() const requires range<const _Vp>
3324 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
3325 return ranges::
begin(_M_base) + ranges::
size(_M_base);
3327 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
3328 (ranges::end(_M_base));
3332 size() requires sized_range<_Vp>
3336 size() const requires sized_range<const _Vp>
3340 template<
typename _Range>
3341 common_view(_Range&&) -> common_view<views::all_t<_Range>>;
3343 template<
typename _Tp>
3344 inline constexpr
bool enable_borrowed_range<common_view<_Tp>>
3345 = enable_borrowed_range<_Tp>;
3351 template<
typename _Range>
3352 concept __already_common = common_range<_Range>
3353 && requires { views::all(std::declval<_Range>()); };
3355 template<
typename _Range>
3356 concept __can_common_view
3357 = requires { common_view{std::declval<_Range>()}; };
3360 struct _Common : __adaptor::_RangeAdaptorClosure
3362 template<viewable_range _Range>
3363 requires __detail::__already_common<_Range>
3364 || __detail::__can_common_view<_Range>
3366 operator()(_Range&& __r)
const
3368 if constexpr (__detail::__already_common<_Range>)
3369 return views::all(std::
forward<_Range>(__r));
3371 return common_view{std::forward<_Range>(__r)};
3374 static constexpr
bool _S_has_simple_call_op =
true;
3377 inline constexpr _Common common;
3381 requires bidirectional_range<_Vp>
3382 class reverse_view :
public view_interface<reverse_view<_Vp>>
3385 static constexpr
bool _S_needs_cached_begin
3386 = !common_range<_Vp> && !random_access_range<_Vp>;
3388 [[no_unique_address]]
3389 __detail::__maybe_present_t<_S_needs_cached_begin,
3390 __detail::_CachedPosition<_Vp>>
3392 _Vp _M_base = _Vp();
3395 reverse_view() =
default;
3398 reverse_view(_Vp __r)
3399 : _M_base(std::
move(__r))
3403 base() const& requires copy_constructible<_Vp>
3410 constexpr reverse_iterator<iterator_t<_Vp>>
3413 if constexpr (_S_needs_cached_begin)
3414 if (_M_cached_begin._M_has_value())
3417 auto __it = ranges::next(ranges::
begin(_M_base), ranges::end(_M_base));
3418 if constexpr (_S_needs_cached_begin)
3419 _M_cached_begin._M_set(_M_base, __it);
3424 begin() requires common_range<_Vp>
3428 begin() const requires common_range<const _Vp>
3431 constexpr reverse_iterator<iterator_t<_Vp>>
3436 end() const requires common_range<const _Vp>
3440 size() requires sized_range<_Vp>
3444 size() const requires sized_range<const _Vp>
3448 template<
typename _Range>
3449 reverse_view(_Range&&) -> reverse_view<views::all_t<_Range>>;
3451 template<
typename _Tp>
3452 inline constexpr
bool enable_borrowed_range<reverse_view<_Tp>>
3453 = enable_borrowed_range<_Tp>;
3460 inline constexpr
bool __is_reversible_subrange =
false;
3462 template<
typename _Iter, subrange_kind _Kind>
3463 inline constexpr
bool
3464 __is_reversible_subrange<subrange<reverse_iterator<_Iter>,
3465 reverse_iterator<_Iter>,
3469 inline constexpr
bool __is_reverse_view =
false;
3471 template<
typename _Vp>
3472 inline constexpr
bool __is_reverse_view<reverse_view<_Vp>> =
true;
3474 template<
typename _Range>
3475 concept __can_reverse_view
3476 = requires { reverse_view{std::declval<_Range>()}; };
3479 struct _Reverse : __adaptor::_RangeAdaptorClosure
3481 template<viewable_range _Range>
3482 requires __detail::__is_reverse_view<remove_cvref_t<_Range>>
3483 || __detail::__is_reversible_subrange<remove_cvref_t<_Range>>
3484 || __detail::__can_reverse_view<_Range>
3486 operator()(_Range&& __r)
const
3488 using _Tp = remove_cvref_t<_Range>;
3489 if constexpr (__detail::__is_reverse_view<_Tp>)
3490 return std::
forward<_Range>(__r).base();
3491 else if constexpr (__detail::__is_reversible_subrange<_Tp>)
3494 if constexpr (sized_range<_Tp>)
3495 return subrange<_Iter, _Iter, subrange_kind::sized>
3496 {__r.end().base(), __r.begin().base(), __r.size()};
3498 return subrange<_Iter, _Iter, subrange_kind::unsized>
3499 {__r.end().base(), __r.begin().base()};
3502 return reverse_view{std::forward<_Range>(__r)};
3505 static constexpr
bool _S_has_simple_call_op =
true;
3508 inline constexpr _Reverse reverse;
3513 template<
typename _Tp,
size_t _Nm>
3514 concept __has_tuple_element = requires(_Tp __t)
3516 typename tuple_size<_Tp>::type;
3517 requires _Nm < tuple_size_v<_Tp>;
3518 typename tuple_element_t<_Nm, _Tp>;
3519 { std::get<_Nm>(__t) }
3520 -> convertible_to<
const tuple_element_t<_Nm, _Tp>&>;
3523 template<
typename _Tp,
size_t _Nm>
3524 concept __returnable_element
3525 = is_reference_v<_Tp> || move_constructible<tuple_element_t<_Nm, _Tp>>;
3528 template<input_range _Vp,
size_t _Nm>
3530 && __detail::__has_tuple_element<range_value_t<_Vp>, _Nm>
3531 && __detail::__has_tuple_element<remove_reference_t<range_reference_t<_Vp>>,
3533 && __detail::__returnable_element<range_reference_t<_Vp>, _Nm>
3534 class elements_view :
public view_interface<elements_view<_Vp, _Nm>>
3537 elements_view() =
default;
3540 elements_view(_Vp base)
3541 : _M_base(std::
move(base))
3544 constexpr
const _Vp&
3545 base() const & noexcept
3553 begin() requires (!__detail::__simple_view<_Vp>)
3557 begin() const requires range<const _Vp>
3561 end() requires (!__detail::__simple_view<_Vp> && !common_range<_Vp>)
3562 {
return _Sentinel<false>{
ranges::end(_M_base)}; }
3565 end() requires (!__detail::__simple_view<_Vp> && common_range<_Vp>)
3566 {
return _Iterator<false>{
ranges::end(_M_base)}; }
3569 end() const requires range<const _Vp>
3573 end() const requires common_range<const _Vp>
3577 size() requires sized_range<_Vp>
3581 size() const requires sized_range<const _Vp>
3585 template<
bool _Const>
3586 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
3588 template<
bool _Const>
3592 template<
bool _Const>
3593 requires forward_range<_Base<_Const>>
3594 struct __iter_cat<_Const>
3597 static auto _S_iter_cat()
3599 using _Base = elements_view::_Base<_Const>;
3600 using _Cat =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
3601 using _Res = decltype((std::get<_Nm>(*std::declval<iterator_t<_Base>>())));
3602 if constexpr (!is_lvalue_reference_v<_Res>)
3603 return input_iterator_tag{};
3604 else if constexpr (derived_from<_Cat, random_access_iterator_tag>)
3605 return random_access_iterator_tag{};
3610 using iterator_category = decltype(_S_iter_cat());
3613 template<
bool _Const>
3616 template<
bool _Const>
3617 struct _Iterator : __iter_cat<_Const>
3620 using _Base = elements_view::_Base<_Const>;
3622 iterator_t<_Base> _M_current = iterator_t<_Base>();
3624 static constexpr decltype(
auto)
3625 _S_get_element(const iterator_t<_Base>& __i)
3627 if constexpr (is_reference_v<range_reference_t<_Base>>)
3628 return std::get<_Nm>(*__i);
3631 using _Et = remove_cv_t<tuple_element_t<_Nm, range_reference_t<_Base>>>;
3632 return static_cast<_Et
>(std::get<_Nm>(*__i));
3639 if constexpr (random_access_range<_Vp>)
3640 return random_access_iterator_tag{};
3641 else if constexpr (bidirectional_range<_Vp>)
3642 return bidirectional_iterator_tag{};
3643 else if constexpr (forward_range<_Vp>)
3644 return forward_iterator_tag{};
3646 return input_iterator_tag{};
3649 friend _Iterator<!_Const>;
3652 using iterator_concept = decltype(_S_iter_concept());
3655 = remove_cvref_t<tuple_element_t<_Nm, range_value_t<_Base>>>;
3656 using difference_type = range_difference_t<_Base>;
3658 _Iterator() =
default;
3661 _Iterator(iterator_t<_Base> current)
3662 : _M_current(std::
move(current))
3666 _Iterator(_Iterator<!_Const> i)
3667 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
3671 constexpr iterator_t<_Base>
3673 requires copyable<iterator_t<_Base>>
3674 {
return _M_current; }
3676 constexpr iterator_t<_Base>
3680 constexpr decltype(
auto)
3682 {
return _S_get_element(_M_current); }
3684 constexpr _Iterator&
3696 operator++(
int) requires forward_range<_Base>
3703 constexpr _Iterator&
3704 operator--() requires bidirectional_range<_Base>
3711 operator--(
int) requires bidirectional_range<_Base>
3718 constexpr _Iterator&
3719 operator+=(difference_type __n)
3720 requires random_access_range<_Base>
3726 constexpr _Iterator&
3727 operator-=(difference_type __n)
3728 requires random_access_range<_Base>
3734 constexpr decltype(
auto)
3735 operator[](difference_type __n) const
3736 requires random_access_range<_Base>
3737 {
return _S_get_element(_M_current + __n); }
3739 friend constexpr
bool
3740 operator==(
const _Iterator& __x,
const _Iterator& __y)
3741 requires equality_comparable<iterator_t<_Base>>
3742 {
return __x._M_current == __y._M_current; }
3744 friend constexpr
bool
3745 operator<(
const _Iterator& __x,
const _Iterator& __y)
3746 requires random_access_range<_Base>
3747 {
return __x._M_current < __y._M_current; }
3749 friend constexpr
bool
3750 operator>(
const _Iterator& __x,
const _Iterator& __y)
3751 requires random_access_range<_Base>
3752 {
return __y._M_current < __x._M_current; }
3754 friend constexpr
bool
3755 operator<=(
const _Iterator& __x,
const _Iterator& __y)
3756 requires random_access_range<_Base>
3757 {
return !(__y._M_current > __x._M_current); }
3759 friend constexpr
bool
3760 operator>=(
const _Iterator& __x,
const _Iterator& __y)
3761 requires random_access_range<_Base>
3762 {
return !(__x._M_current > __y._M_current); }
3764 #ifdef __cpp_lib_three_way_comparison
3765 friend constexpr
auto
3766 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
3767 requires random_access_range<_Base>
3768 && three_way_comparable<iterator_t<_Base>>
3769 {
return __x._M_current <=> __y._M_current; }
3772 friend constexpr _Iterator
3773 operator+(
const _Iterator& __x, difference_type __y)
3774 requires random_access_range<_Base>
3775 {
return _Iterator{__x} += __y; }
3777 friend constexpr _Iterator
3778 operator+(difference_type __x,
const _Iterator& __y)
3779 requires random_access_range<_Base>
3780 {
return __y + __x; }
3782 friend constexpr _Iterator
3783 operator-(
const _Iterator& __x, difference_type __y)
3784 requires random_access_range<_Base>
3785 {
return _Iterator{__x} -= __y; }
3789 friend constexpr difference_type
3790 operator-(
const _Iterator& __x,
const _Iterator& __y)
3791 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
3792 {
return __x._M_current - __y._M_current; }
3794 template <
bool>
friend struct _Sentinel;
3797 template<
bool _Const>
3801 template<
bool _Const2>
3803 _M_equal(
const _Iterator<_Const2>& __x)
const
3804 {
return __x._M_current == _M_end; }
3806 template<
bool _Const2>
3808 _M_distance_from(
const _Iterator<_Const2>& __i)
const
3809 {
return _M_end - __i._M_current; }
3811 using _Base = elements_view::_Base<_Const>;
3812 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
3815 _Sentinel() =
default;
3818 _Sentinel(sentinel_t<_Base> __end)
3819 : _M_end(std::
move(__end))
3823 _Sentinel(_Sentinel<!_Const> __other)
3825 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
3829 constexpr sentinel_t<_Base>
3833 template<
bool _Const2>
3834 requires sentinel_for<sentinel_t<_Base>,
3835 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
3836 friend constexpr
bool
3837 operator==(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
3838 {
return __y._M_equal(__x); }
3840 template<
bool _Const2,
3841 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
3842 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
3843 friend constexpr range_difference_t<_Base2>
3844 operator-(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
3845 {
return -__y._M_distance_from(__x); }
3847 template<
bool _Const2,
3848 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
3849 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
3850 friend constexpr range_difference_t<_Base2>
3851 operator-(
const _Sentinel& __x,
const _Iterator<_Const2>& __y)
3852 {
return __x._M_distance_from(__y); }
3854 friend _Sentinel<!_Const>;
3857 _Vp _M_base = _Vp();
3860 template<
typename _Tp,
size_t _Nm>
3861 inline constexpr
bool enable_borrowed_range<elements_view<_Tp, _Nm>>
3862 = enable_borrowed_range<_Tp>;
3864 template<
typename _Range>
3865 using keys_view = elements_view<views::all_t<_Range>, 0>;
3867 template<
typename _Range>
3868 using values_view = elements_view<views::all_t<_Range>, 1>;
3874 template<
size_t _Nm,
typename _Range>
3875 concept __can_elements_view
3876 = requires { elements_view<all_t<_Range>, _Nm>{std::declval<_Range>()}; };
3879 template<
size_t _Nm>
3880 struct _Elements : __adaptor::_RangeAdaptorClosure
3882 template<viewable_range _Range>
3883 requires __detail::__can_elements_view<_Nm, _Range>
3885 operator()(_Range&& __r)
const
3887 return elements_view<all_t<_Range>, _Nm>{std::forward<_Range>(__r)};
3890 static constexpr
bool _S_has_simple_call_op =
true;
3893 template<
size_t _Nm>
3894 inline constexpr _Elements<_Nm> elements;
3895 inline constexpr
auto keys = elements<0>;
3896 inline constexpr
auto values = elements<1>;
3901 namespace views = ranges::views;
3903 _GLIBCXX_END_NAMESPACE_VERSION
3905 #endif // library concepts
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
typename make_unsigned< _Tp >::type make_unsigned_t
Alias template for make_unsigned.
constexpr const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
void reset(element_type *__p=0)
Forcibly deletes the managed object.
constexpr complex< _Tp > operator*(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x times y.
typename invoke_result< _Fn, _Args...>::type invoke_result_t
std::invoke_result_t
constexpr auto data(_Container &__cont) noexcept(noexcept(__cont.data())) -> decltype(__cont.data())
Return the data pointer of a container.
_Tp * begin(valarray< _Tp > &__va)
Return an iterator pointing to the first element of the valarray.
_Tp * end(valarray< _Tp > &__va)
Return an iterator pointing to one past the last element of the valarray.
constexpr _Tp && forward(typename std::remove_reference< _Tp >::type &__t) noexcept
Forward an lvalue.
typename conditional< _Cond, _Iftrue, _Iffalse >::type conditional_t
Alias template for conditional.
constexpr complex< _Tp > operator+(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x plus y.
constexpr _Iterator __base(_Iterator __it)
constexpr complex< _Tp > operator-(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x minus y.
constexpr reverse_iterator< _Iterator > make_reverse_iterator(_Iterator __i)
Generator function for reverse_iterator.
constexpr auto empty(const _Container &__cont) noexcept(noexcept(__cont.empty())) -> decltype(__cont.empty())
Return whether a container is empty.
element_type * operator->() const
Smart pointer dereferencing.
constexpr void iota(_ForwardIterator __first, _ForwardIterator __last, _Tp __value)
Create a range of sequentially increasing values.
bitset< _Nb > operator|(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
Class template for optional values.
constexpr auto size(const _Container &__cont) noexcept(noexcept(__cont.size())) -> decltype(__cont.size())
Return the size of a container.
auto_ptr & operator=(auto_ptr &__a)
auto_ptr assignment operator.