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
183 {
return &_M_value; }
187 {
return &_M_value; }
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)
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;
251 template<
typename _Wp>
252 constexpr
auto __to_signed_like(_Wp __w) noexcept
254 if constexpr (!integral<_Wp>)
255 return iter_difference_t<_Wp>();
256 else if constexpr (
sizeof(iter_difference_t<_Wp>) >
sizeof(_Wp))
257 return iter_difference_t<_Wp>(__w);
258 else if constexpr (
sizeof(ptrdiff_t) >
sizeof(_Wp))
259 return ptrdiff_t(__w);
260 else if constexpr (
sizeof(
long long) >
sizeof(_Wp))
261 return (
long long)(__w);
262 #ifdef __SIZEOF_INT128__ 263 else if constexpr (__SIZEOF_INT128__ >
sizeof(_Wp))
264 return __int128(__w);
267 return __max_diff_type(__w);
270 template<
typename _Wp>
271 using __iota_diff_t = decltype(__to_signed_like(std::declval<_Wp>()));
273 template<
typename _It>
274 concept __decrementable = incrementable<_It>
277 { --__i } -> same_as<_It&>;
278 { __i-- } -> same_as<_It>;
281 template<
typename _It>
282 concept __advanceable = __decrementable<_It> && totally_ordered<_It>
283 && requires( _It __i,
const _It __j,
const __iota_diff_t<_It> __n)
285 { __i += __n } -> same_as<_It&>;
286 { __i -= __n } -> same_as<_It&>;
290 { __j - __j } -> convertible_to<__iota_diff_t<_It>>;
293 template<
typename _Winc>
294 struct __iota_view_iter_cat
297 template<incrementable _Winc>
298 struct __iota_view_iter_cat<_Winc>
299 {
using iterator_category = input_iterator_tag; };
302 template<weakly_incrementable _Winc,
303 semiregular _Bound = unreachable_sentinel_t>
304 requires std::__detail::__weakly_eq_cmp_with<_Winc, _Bound>
305 && semiregular<_Winc>
306 class iota_view :
public view_interface<iota_view<_Winc, _Bound>>
311 struct _Iterator : __detail::__iota_view_iter_cat<_Winc>
317 using namespace __detail;
318 if constexpr (__advanceable<_Winc>)
319 return random_access_iterator_tag{};
320 else if constexpr (__decrementable<_Winc>)
321 return bidirectional_iterator_tag{};
322 else if constexpr (incrementable<_Winc>)
323 return forward_iterator_tag{};
325 return input_iterator_tag{};
329 using iterator_concept = decltype(_S_iter_concept());
331 using value_type = _Winc;
332 using difference_type = __detail::__iota_diff_t<_Winc>;
334 _Iterator() =
default;
337 _Iterator(_Winc __value)
338 : _M_value(__value) { }
341 operator*() const noexcept(is_nothrow_copy_constructible_v<_Winc>)
356 operator++(
int) requires incrementable<_Winc>
364 operator--() requires __detail::__decrementable<_Winc>
371 operator--(
int) requires __detail::__decrementable<_Winc>
379 operator+=(difference_type __n) requires __detail::__advanceable<_Winc>
381 using __detail::__is_integer_like;
382 using __detail::__is_signed_integer_like;
383 if constexpr (__is_integer_like<_Winc>
384 && !__is_signed_integer_like<_Winc>)
386 if (__n >= difference_type(0))
387 _M_value +=
static_cast<_Winc
>(__n);
389 _M_value -=
static_cast<_Winc
>(-__n);
397 operator-=(difference_type __n) requires __detail::__advanceable<_Winc>
399 using __detail::__is_integer_like;
400 using __detail::__is_signed_integer_like;
401 if constexpr (__is_integer_like<_Winc>
402 && !__is_signed_integer_like<_Winc>)
404 if (__n >= difference_type(0))
405 _M_value -=
static_cast<_Winc
>(__n);
407 _M_value +=
static_cast<_Winc
>(-__n);
415 operator[](difference_type __n)
const 416 requires __detail::__advanceable<_Winc>
417 {
return _Winc(_M_value + __n); }
419 friend constexpr
bool 420 operator==(
const _Iterator& __x,
const _Iterator& __y)
421 requires equality_comparable<_Winc>
422 {
return __x._M_value == __y._M_value; }
424 friend constexpr
bool 425 operator<(
const _Iterator& __x,
const _Iterator& __y)
426 requires totally_ordered<_Winc>
427 {
return __x._M_value < __y._M_value; }
429 friend constexpr
bool 430 operator>(
const _Iterator& __x,
const _Iterator& __y)
431 requires totally_ordered<_Winc>
432 {
return __y < __x; }
434 friend constexpr
bool 435 operator<=(
const _Iterator& __x,
const _Iterator& __y)
436 requires totally_ordered<_Winc>
437 {
return !(__y < __x); }
439 friend constexpr
bool 440 operator>=(
const _Iterator& __x,
const _Iterator& __y)
441 requires totally_ordered<_Winc>
442 {
return !(__x < __y); }
444 #ifdef __cpp_lib_three_way_comparison 445 friend constexpr
auto 446 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
447 requires totally_ordered<_Winc> && three_way_comparable<_Winc>
448 {
return __x._M_value <=> __y._M_value; }
451 friend constexpr _Iterator
452 operator+(_Iterator __i, difference_type __n)
453 requires __detail::__advanceable<_Winc>
454 {
return __i += __n; }
456 friend constexpr _Iterator
457 operator+(difference_type __n, _Iterator __i)
458 requires __detail::__advanceable<_Winc>
459 {
return __i += __n; }
461 friend constexpr _Iterator
462 operator-(_Iterator __i, difference_type __n)
463 requires __detail::__advanceable<_Winc>
464 {
return __i -= __n; }
466 friend constexpr difference_type
467 operator-(
const _Iterator& __x,
const _Iterator& __y)
468 requires __detail::__advanceable<_Winc>
470 using __detail::__is_integer_like;
471 using __detail::__is_signed_integer_like;
472 using _Dt = difference_type;
473 if constexpr (__is_integer_like<_Winc>)
475 if constexpr (__is_signed_integer_like<_Winc>)
476 return _Dt(_Dt(__x._M_value) - _Dt(__y._M_value));
478 return (__y._M_value > __x._M_value)
479 ? _Dt(-_Dt(__y._M_value - __x._M_value))
480 : _Dt(__x._M_value - __y._M_value);
483 return __x._M_value - __y._M_value;
487 _Winc _M_value = _Winc();
496 _M_equal(
const _Iterator& __x)
const 497 {
return __x._M_value == _M_bound; }
499 _Bound _M_bound = _Bound();
502 _Sentinel() =
default;
505 _Sentinel(_Bound __bound)
506 : _M_bound(__bound) { }
508 friend constexpr
bool 509 operator==(
const _Iterator& __x,
const _Sentinel& __y)
510 {
return __y._M_equal(__x); }
512 friend constexpr iter_difference_t<_Winc>
513 operator-(
const _Iterator& __x,
const _Sentinel& __y)
514 requires sized_sentinel_for<_Bound, _Winc>
515 {
return __x._M_value - __y._M_bound; }
517 friend constexpr iter_difference_t<_Winc>
518 operator-(
const _Sentinel& __x,
const _Iterator& __y)
519 requires sized_sentinel_for<_Bound, _Winc>
520 {
return -(__y - __x); }
523 _Winc _M_value = _Winc();
524 [[no_unique_address]] _Bound _M_bound = _Bound();
527 iota_view() =
default;
530 iota_view(_Winc __value)
535 iota_view(type_identity_t<_Winc> __value,
536 type_identity_t<_Bound> __bound)
537 : _M_value(__value), _M_bound(__bound)
539 if constexpr (totally_ordered_with<_Winc, _Bound>)
540 __glibcxx_assert(
bool(__value <= __bound) );
544 begin()
const {
return _Iterator{_M_value}; }
549 if constexpr (same_as<_Bound, unreachable_sentinel_t>)
550 return unreachable_sentinel;
552 return _Sentinel{_M_bound};
556 end() const requires same_as<_Winc, _Bound>
557 {
return _Iterator{_M_bound}; }
561 requires (same_as<_Winc, _Bound> && __detail::__advanceable<_Winc>)
562 || (integral<_Winc> && integral<_Bound>)
563 || sized_sentinel_for<_Bound, _Winc>
565 using __detail::__is_integer_like;
566 using __detail::__to_unsigned_like;
567 if constexpr (integral<_Winc> && integral<_Bound>)
570 return _Up(_M_bound) - _Up(_M_value);
572 else if constexpr (__is_integer_like<_Winc>)
573 return __to_unsigned_like(_M_bound) - __to_unsigned_like(_M_value);
575 return __to_unsigned_like(_M_bound - _M_value);
579 template<
typename _Winc,
typename _Bound>
580 requires (!__detail::__is_integer_like<_Winc>
581 || !__detail::__is_integer_like<_Bound>
582 || (__detail::__is_signed_integer_like<_Winc>
583 == __detail::__is_signed_integer_like<_Bound>))
584 iota_view(_Winc, _Bound) -> iota_view<_Winc, _Bound>;
586 template<weakly_incrementable _Winc, semiregular _Bound>
587 inline constexpr
bool 588 enable_borrowed_range<iota_view<_Winc, _Bound>> =
true;
592 template<
typename _Tp>
593 inline constexpr empty_view<_Tp>
empty{};
597 template<
typename _Tp>
599 operator()(_Tp&& __e)
const 600 {
return single_view{std::forward<_Tp>(__e)}; }
603 inline constexpr _Single single{};
607 template<
typename _Tp>
609 operator()(_Tp&& __e)
const 610 {
return iota_view{std::forward<_Tp>(__e)}; }
612 template<
typename _Tp,
typename _Up>
614 operator()(_Tp&& __e, _Up&& __f)
const 615 {
return iota_view{std::forward<_Tp>(__e), std::forward<_Up>(__f)}; }
618 inline constexpr _Iota
iota{};
623 template<
typename _Val,
typename _CharT,
typename _Traits>
624 concept __stream_extractable
625 = requires(basic_istream<_CharT, _Traits>& is, _Val& t) { is >> t; };
628 template<movable _Val,
typename _CharT,
typename _Traits>
629 requires default_initializable<_Val>
630 && __detail::__stream_extractable<_Val, _CharT, _Traits>
631 class basic_istream_view
632 :
public view_interface<basic_istream_view<_Val, _CharT, _Traits>>
635 basic_istream_view() =
default;
638 basic_istream_view(basic_istream<_CharT, _Traits>& __stream)
645 if (_M_stream !=
nullptr)
646 *_M_stream >> _M_object;
647 return _Iterator{
this};
650 constexpr default_sentinel_t
652 {
return default_sentinel; }
655 basic_istream<_CharT, _Traits>* _M_stream =
nullptr;
656 _Val _M_object = _Val();
661 using iterator_concept = input_iterator_tag;
662 using difference_type = ptrdiff_t;
663 using value_type = _Val;
665 _Iterator() =
default;
668 _Iterator(basic_istream_view* __parent) noexcept
669 : _M_parent(__parent)
672 _Iterator(
const _Iterator&) =
delete;
673 _Iterator(_Iterator&&) =
default;
674 _Iterator&
operator=(
const _Iterator&) =
delete;
675 _Iterator&
operator=(_Iterator&&) =
default;
680 __glibcxx_assert(_M_parent->_M_stream !=
nullptr);
681 *_M_parent->_M_stream >> _M_parent->_M_object;
692 __glibcxx_assert(_M_parent->_M_stream !=
nullptr);
693 return _M_parent->_M_object;
697 operator==(
const _Iterator& __x, default_sentinel_t)
698 {
return __x._M_at_end(); }
701 basic_istream_view* _M_parent =
nullptr;
705 {
return _M_parent ==
nullptr || !*_M_parent->_M_stream; }
711 template<
typename _Val,
typename _CharT,
typename _Traits>
712 basic_istream_view<_Val, _CharT, _Traits>
713 istream_view(basic_istream<_CharT, _Traits>& __s)
714 {
return basic_istream_view<_Val, _CharT, _Traits>{__s}; }
726 template<
bool _Present,
typename _Tp>
727 using __maybe_present_t = conditional_t<_Present, _Tp, _Empty>;
730 template<
bool _Const,
typename _Tp>
731 using __maybe_const_t = conditional_t<_Const, const _Tp, _Tp>;
735 namespace views::__adaptor
738 template<
typename _Adaptor,
typename... _Args>
739 concept __adaptor_invocable
740 = requires { std::declval<_Adaptor>()(declval<_Args>()...); };
744 template<
typename _Adaptor,
typename... _Args>
745 concept __adaptor_partial_app_viable = (_Adaptor::_S_arity > 1)
746 && (
sizeof...(_Args) == _Adaptor::_S_arity - 1)
747 && (constructible_from<decay_t<_Args>, _Args> && ...);
749 template<
typename _Adaptor,
typename... _Args>
752 template<
typename _Lhs,
typename _Rhs>
756 struct _RangeAdaptorClosure
759 template<
typename _Self,
typename _Range>
760 requires derived_from<remove_cvref_t<_Self>, _RangeAdaptorClosure>
761 && __adaptor_invocable<_Self, _Range>
762 friend constexpr
auto 764 {
return std::forward<_Self>(__self)(std::forward<_Range>(__r)); }
768 template<
typename _Lhs,
typename _Rhs>
769 requires derived_from<_Lhs, _RangeAdaptorClosure>
770 && derived_from<_Rhs, _RangeAdaptorClosure>
771 friend constexpr
auto 781 template<
typename _Derived>
786 template<
typename... _Args>
787 requires __adaptor_partial_app_viable<_Derived, _Args...>
789 operator()(_Args&&... __args)
const 791 return _Partial<_Derived, decay_t<_Args>...>{std::forward<_Args>(__args)...};
797 template<
typename _Adaptor,
typename... _Args>
798 struct _Partial : _RangeAdaptorClosure
800 tuple<_Args...> _M_args;
803 _Partial(_Args... __args)
804 : _M_args(
std::
move(__args)...)
809 template<
typename _Range>
810 requires __adaptor_invocable<_Adaptor, _Range,
const _Args&...>
812 operator()(_Range&& __r)
const &
814 auto __forwarder = [&__r] (
const auto&... __args) {
815 return _Adaptor{}(std::forward<_Range>(__r), __args...);
817 return std::apply(__forwarder, _M_args);
820 template<
typename _Range>
821 requires __adaptor_invocable<_Adaptor, _Range, _Args...>
823 operator()(_Range&& __r) &&
825 auto __forwarder = [&__r] (
auto&... __args) {
826 return _Adaptor{}(std::forward<_Range>(__r),
std::move(__args)...);
828 return std::apply(__forwarder, _M_args);
831 template<
typename _Range>
833 operator()(_Range&& __r)
const && =
delete;
838 template<
typename _Adaptor,
typename _Arg>
839 struct _Partial<_Adaptor, _Arg> : _RangeAdaptorClosure
848 template<
typename _Range>
849 requires __adaptor_invocable<_Adaptor, _Range, const _Arg&>
851 operator()(_Range&& __r)
const &
852 {
return _Adaptor{}(std::forward<_Range>(__r), _M_arg); }
854 template<
typename _Range>
855 requires __adaptor_invocable<_Adaptor, _Range, _Arg>
857 operator()(_Range&& __r) &&
858 {
return _Adaptor{}(std::forward<_Range>(__r),
std::move(_M_arg)); }
860 template<
typename _Range>
862 operator()(_Range&& __r)
const && =
delete;
865 template<
typename _Lhs,
typename _Rhs,
typename _Range>
866 concept __pipe_invocable
867 = requires { std::declval<_Rhs>()(std::declval<_Lhs>()(std::declval<_Range>())); };
871 template<
typename _Lhs,
typename _Rhs>
872 struct _Pipe : _RangeAdaptorClosure
874 [[no_unique_address]] _Lhs _M_lhs;
875 [[no_unique_address]] _Rhs _M_rhs;
878 _Pipe(_Lhs __lhs, _Rhs __rhs)
884 template<
typename _Range>
885 requires __pipe_invocable<const _Lhs&, const _Rhs&, _Range>
887 operator()(_Range&& __r)
const &
888 {
return _M_rhs(_M_lhs(std::forward<_Range>(__r))); }
890 template<
typename _Range>
891 requires __pipe_invocable<_Lhs, _Rhs, _Range>
893 operator()(_Range&& __r) &&
896 template<
typename _Range>
898 operator()(_Range&& __r)
const && =
delete;
902 template<range _Range> requires is_object_v<_Range>
903 class ref_view :
public view_interface<ref_view<_Range>>
906 _Range* _M_r =
nullptr;
908 static void _S_fun(_Range&);
909 static void _S_fun(_Range&&) =
delete;
913 ref_view() noexcept = default;
915 template<__detail::__not_same_as<ref_view> _Tp>
916 requires convertible_to<_Tp, _Range&>
917 && requires { _S_fun(declval<_Tp>()); }
927 constexpr iterator_t<_Range>
931 constexpr sentinel_t<_Range>
940 size() const requires sized_range<_Range>
944 data() const requires contiguous_range<_Range>
948 template<
typename _Range>
949 ref_view(_Range&) -> ref_view<_Range>;
951 template<
typename _Tp>
952 inline constexpr
bool enable_borrowed_range<ref_view<_Tp>> =
true;
958 template<
typename _Range>
959 concept __can_ref_view = requires { ref_view{std::declval<_Range>()}; };
961 template<
typename _Range>
962 concept __can_subrange = requires { subrange{std::declval<_Range>()}; };
965 struct _All : __adaptor::_RangeAdaptorClosure
967 template<viewable_range _Range>
968 requires view<decay_t<_Range>>
969 || __detail::__can_ref_view<_Range>
970 || __detail::__can_subrange<_Range>
972 operator()(_Range&& __r)
const 974 if constexpr (view<decay_t<_Range>>)
976 else if constexpr (__detail::__can_ref_view<_Range>)
977 return ref_view{std::forward<_Range>(__r)};
979 return subrange{std::forward<_Range>(__r)};
983 inline constexpr _All all;
985 template<viewable_range _Range>
986 using all_t = decltype(all(std::declval<_Range>()));
993 template<
typename _Iter,
typename _Sent,
typename _Tp>
995 find(_Iter __first, _Sent __last,
const _Tp& __value)
997 while (__first != __last
998 && !(
bool)(*__first == __value))
1003 template<
typename _Iter,
typename _Sent,
typename _Pred>
1005 find_if(_Iter __first, _Sent __last, _Pred __pred)
1007 while (__first != __last
1013 template<
typename _Iter,
typename _Sent,
typename _Pred>
1015 find_if_not(_Iter __first, _Sent __last, _Pred __pred)
1017 while (__first != __last
1023 template<
typename _Iter1,
typename _Sent1,
typename _Iter2,
typename _Sent2>
1024 constexpr pair<_Iter1, _Iter2>
1025 mismatch(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2)
1027 while (__first1 != __last1 && __first2 != __last2
1028 && (
bool)ranges::equal_to{}(*__first1, *__first2))
1039 template<range _Range>
1040 struct _CachedPosition
1043 _M_has_value()
const 1046 constexpr iterator_t<_Range>
1047 _M_get(
const _Range&)
const 1049 __glibcxx_assert(
false);
1054 _M_set(
const _Range&,
const iterator_t<_Range>&)
const 1058 template<forward_range _Range>
1059 struct _CachedPosition<_Range>
1062 iterator_t<_Range> _M_iter{};
1066 _M_has_value()
const 1067 {
return _M_iter != iterator_t<_Range>{}; }
1069 constexpr iterator_t<_Range>
1070 _M_get(
const _Range&)
const 1072 __glibcxx_assert(_M_has_value());
1077 _M_set(
const _Range&,
const iterator_t<_Range>& __it)
1079 __glibcxx_assert(!_M_has_value());
1084 template<random_access_range _Range>
1085 requires (
sizeof(range_difference_t<_Range>)
1086 <=
sizeof(iterator_t<_Range>))
1087 struct _CachedPosition<_Range>
1090 range_difference_t<_Range> _M_offset = -1;
1094 _M_has_value()
const 1095 {
return _M_offset >= 0; }
1097 constexpr iterator_t<_Range>
1098 _M_get(_Range& __r)
const 1100 __glibcxx_assert(_M_has_value());
1105 _M_set(_Range& __r,
const iterator_t<_Range>& __it)
1107 __glibcxx_assert(!_M_has_value());
1115 template<
typename _Base>
1116 struct __filter_view_iter_cat
1119 template<forward_range _Base>
1120 struct __filter_view_iter_cat<_Base>
1126 using _Cat =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
1127 if constexpr (derived_from<_Cat, bidirectional_iterator_tag>)
1128 return bidirectional_iterator_tag{};
1129 else if constexpr (derived_from<_Cat, forward_iterator_tag>)
1130 return forward_iterator_tag{};
1135 using iterator_category = decltype(_S_iter_cat());
1139 template<input_range _Vp,
1140 indirect_unary_predicate<iterator_t<_Vp>> _Pred>
1141 requires view<_Vp> && is_object_v<_Pred>
1142 class filter_view :
public view_interface<filter_view<_Vp, _Pred>>
1147 struct _Iterator : __detail::__filter_view_iter_cat<_Vp>
1150 static constexpr
auto 1153 if constexpr (bidirectional_range<_Vp>)
1154 return bidirectional_iterator_tag{};
1155 else if constexpr (forward_range<_Vp>)
1156 return forward_iterator_tag{};
1158 return input_iterator_tag{};
1163 using _Vp_iter = iterator_t<_Vp>;
1165 _Vp_iter _M_current = _Vp_iter();
1166 filter_view* _M_parent =
nullptr;
1169 using iterator_concept = decltype(_S_iter_concept());
1171 using value_type = range_value_t<_Vp>;
1172 using difference_type = range_difference_t<_Vp>;
1174 _Iterator() =
default;
1177 _Iterator(filter_view* __parent, _Vp_iter __current)
1178 : _M_current(
std::
move(__current)),
1184 requires copyable<_Vp_iter>
1185 {
return _M_current; }
1191 constexpr range_reference_t<_Vp>
1193 {
return *_M_current; }
1197 requires __detail::__has_arrow<_Vp_iter>
1198 && copyable<_Vp_iter>
1199 {
return _M_current; }
1201 constexpr _Iterator&
1204 _M_current = __detail::find_if(
std::move(++_M_current),
1206 std::ref(*_M_parent->_M_pred));
1215 operator++(
int) requires forward_range<_Vp>
1222 constexpr _Iterator&
1223 operator--() requires bidirectional_range<_Vp>
1232 operator--(
int) requires bidirectional_range<_Vp>
1239 friend constexpr
bool 1240 operator==(
const _Iterator& __x,
const _Iterator& __y)
1241 requires equality_comparable<_Vp_iter>
1242 {
return __x._M_current == __y._M_current; }
1244 friend constexpr range_rvalue_reference_t<_Vp>
1245 iter_move(
const _Iterator& __i)
1246 noexcept(noexcept(ranges::iter_move(__i._M_current)))
1247 {
return ranges::iter_move(__i._M_current); }
1249 friend constexpr
void 1250 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
1251 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1252 requires indirectly_swappable<_Vp_iter>
1253 { ranges::iter_swap(__x._M_current, __y._M_current); }
1259 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
1262 __equal(
const _Iterator& __i)
const 1263 {
return __i._M_current == _M_end; }
1266 _Sentinel() =
default;
1269 _Sentinel(filter_view* __parent)
1270 : _M_end(ranges::
end(__parent->_M_base))
1273 constexpr sentinel_t<_Vp>
1277 friend constexpr
bool 1278 operator==(
const _Iterator& __x,
const _Sentinel& __y)
1279 {
return __y.__equal(__x); }
1282 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
1283 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
1284 _Vp _M_base = _Vp();
1287 filter_view() =
default;
1290 filter_view(_Vp
__base, _Pred __pred)
1295 base() const& requires copy_constructible<_Vp>
1302 constexpr
const _Pred&
1304 {
return *_M_pred; }
1309 if (_M_cached_begin._M_has_value())
1310 return {
this, _M_cached_begin._M_get(_M_base)};
1312 __glibcxx_assert(_M_pred.has_value());
1315 std::ref(*_M_pred));
1316 _M_cached_begin._M_set(_M_base, __it);
1323 if constexpr (common_range<_Vp>)
1326 return _Sentinel{
this};
1330 template<
typename _Range,
typename _Pred>
1331 filter_view(_Range&&, _Pred) -> filter_view<views::all_t<_Range>, _Pred>;
1337 template<
typename _Range,
typename _Pred>
1338 concept __can_filter_view
1339 = requires { filter_view{std::declval<_Range>(), std::declval<_Pred>()}; };
1342 struct _Filter : __adaptor::_RangeAdaptor<_Filter>
1344 template<viewable_range _Range,
typename _Pred>
1345 requires __detail::__can_filter_view<_Range, _Pred>
1347 operator()(_Range&& __r, _Pred&& __p)
const 1349 return filter_view{std::forward<_Range>(__r), std::forward<_Pred>(__p)};
1352 using _RangeAdaptor<_Filter>::operator();
1353 static constexpr
int _S_arity = 2;
1356 inline constexpr _Filter filter;
1359 template<input_range _Vp, copy_constructible _Fp>
1360 requires view<_Vp> && is_object_v<_Fp>
1361 && regular_invocable<_Fp&, range_reference_t<_Vp>>
1363 range_reference_t<_Vp>>>
1364 class transform_view :
public view_interface<transform_view<_Vp, _Fp>>
1367 template<
bool _Const>
1368 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
1370 template<
bool _Const>
1374 template<
bool _Const>
1375 requires forward_range<_Base<_Const>>
1376 struct __iter_cat<_Const>
1382 using _Base = transform_view::_Base<_Const>;
1383 using _Res = invoke_result_t<_Fp&, range_reference_t<_Base>>;
1384 if constexpr (is_lvalue_reference_v<_Res>)
1387 =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
1388 if constexpr (derived_from<_Cat, contiguous_iterator_tag>)
1389 return random_access_iterator_tag{};
1394 return input_iterator_tag{};
1397 using iterator_category = decltype(_S_iter_cat());
1400 template<
bool _Const>
1403 template<
bool _Const>
1404 struct _Iterator : __iter_cat<_Const>
1407 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
1408 using _Base = transform_view::_Base<_Const>;
1413 if constexpr (random_access_range<_Vp>)
1414 return random_access_iterator_tag{};
1415 else if constexpr (bidirectional_range<_Vp>)
1416 return bidirectional_iterator_tag{};
1417 else if constexpr (forward_range<_Vp>)
1418 return forward_iterator_tag{};
1420 return input_iterator_tag{};
1423 using _Base_iter = iterator_t<_Base>;
1425 _Base_iter _M_current = _Base_iter();
1426 _Parent* _M_parent =
nullptr;
1429 using iterator_concept = decltype(_S_iter_concept());
1432 = remove_cvref_t<invoke_result_t<_Fp&, range_reference_t<_Base>>>;
1433 using difference_type = range_difference_t<_Base>;
1435 _Iterator() =
default;
1438 _Iterator(_Parent* __parent, _Base_iter __current)
1439 : _M_current(
std::
move(__current)),
1444 _Iterator(_Iterator<!_Const> __i)
1446 && convertible_to<iterator_t<_Vp>, _Base_iter>
1447 : _M_current(
std::move(__i._M_current)), _M_parent(__i._M_parent)
1450 constexpr _Base_iter
1452 requires copyable<_Base_iter>
1453 {
return _M_current; }
1455 constexpr _Base_iter
1459 constexpr decltype(
auto)
1461 noexcept(noexcept(
std::
__invoke(*_M_parent->_M_fun, *_M_current)))
1464 constexpr _Iterator&
1476 operator++(
int) requires forward_range<_Base>
1483 constexpr _Iterator&
1484 operator--() requires bidirectional_range<_Base>
1491 operator--(
int) requires bidirectional_range<_Base>
1498 constexpr _Iterator&
1499 operator+=(difference_type __n) requires random_access_range<_Base>
1505 constexpr _Iterator&
1506 operator-=(difference_type __n) requires random_access_range<_Base>
1512 constexpr decltype(
auto)
1513 operator[](difference_type __n) const
1514 requires random_access_range<_Base>
1515 {
return std::__invoke(*_M_parent->_M_fun, _M_current[__n]); }
1517 friend constexpr
bool 1518 operator==(
const _Iterator& __x,
const _Iterator& __y)
1519 requires equality_comparable<_Base_iter>
1520 {
return __x._M_current == __y._M_current; }
1522 friend constexpr
bool 1523 operator<(
const _Iterator& __x,
const _Iterator& __y)
1524 requires random_access_range<_Base>
1525 {
return __x._M_current < __y._M_current; }
1527 friend constexpr
bool 1528 operator>(
const _Iterator& __x,
const _Iterator& __y)
1529 requires random_access_range<_Base>
1530 {
return __y < __x; }
1532 friend constexpr
bool 1533 operator<=(
const _Iterator& __x,
const _Iterator& __y)
1534 requires random_access_range<_Base>
1535 {
return !(__y < __x); }
1537 friend constexpr
bool 1538 operator>=(
const _Iterator& __x,
const _Iterator& __y)
1539 requires random_access_range<_Base>
1540 {
return !(__x < __y); }
1542 #ifdef __cpp_lib_three_way_comparison 1543 friend constexpr
auto 1544 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
1545 requires random_access_range<_Base>
1546 && three_way_comparable<_Base_iter>
1547 {
return __x._M_current <=> __y._M_current; }
1550 friend constexpr _Iterator
1551 operator+(_Iterator __i, difference_type __n)
1552 requires random_access_range<_Base>
1553 {
return {__i._M_parent, __i._M_current + __n}; }
1555 friend constexpr _Iterator
1556 operator+(difference_type __n, _Iterator __i)
1557 requires random_access_range<_Base>
1558 {
return {__i._M_parent, __i._M_current + __n}; }
1560 friend constexpr _Iterator
1561 operator-(_Iterator __i, difference_type __n)
1562 requires random_access_range<_Base>
1563 {
return {__i._M_parent, __i._M_current - __n}; }
1567 friend constexpr difference_type
1568 operator-(
const _Iterator& __x,
const _Iterator& __y)
1569 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
1570 {
return __x._M_current - __y._M_current; }
1572 friend constexpr decltype(
auto)
1573 iter_move(const _Iterator& __i) noexcept(noexcept(*__i))
1575 if constexpr (is_lvalue_reference_v<decltype(*__i)>)
1581 friend _Iterator<!_Const>;
1582 template<
bool> friend struct _Sentinel;
1585 template<
bool _Const>
1589 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
1590 using _Base = transform_view::_Base<_Const>;
1592 template<
bool _Const2>
1594 __distance_from(
const _Iterator<_Const2>& __i)
const 1595 {
return _M_end - __i._M_current; }
1597 template<
bool _Const2>
1599 __equal(
const _Iterator<_Const2>& __i)
const 1600 {
return __i._M_current == _M_end; }
1602 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
1605 _Sentinel() =
default;
1608 _Sentinel(sentinel_t<_Base> __end)
1613 _Sentinel(_Sentinel<!_Const> __i)
1615 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
1619 constexpr sentinel_t<_Base>
1623 template<
bool _Const2>
1624 requires sentinel_for<sentinel_t<_Base>,
1625 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
1626 friend constexpr
bool 1627 operator==(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
1628 {
return __y.__equal(__x); }
1630 template<
bool _Const2,
1631 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
1632 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
1633 friend constexpr range_difference_t<_Base2>
1634 operator-(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
1635 {
return -__y.__distance_from(__x); }
1637 template<
bool _Const2,
1638 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
1639 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
1640 friend constexpr range_difference_t<_Base2>
1641 operator-(
const _Sentinel& __y,
const _Iterator<_Const2>& __x)
1642 {
return __y.__distance_from(__x); }
1644 friend _Sentinel<!_Const>;
1647 [[no_unique_address]] __detail::__box<_Fp> _M_fun;
1648 _Vp _M_base = _Vp();
1651 transform_view() =
default;
1654 transform_view(_Vp
__base, _Fp __fun)
1659 base() const& requires copy_constructible<_Vp>
1660 {
return _M_base ; }
1666 constexpr _Iterator<false>
1670 constexpr _Iterator<true>
1672 requires range<const _Vp>
1673 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
1676 constexpr _Sentinel<false>
1678 {
return _Sentinel<false>{
ranges::end(_M_base)}; }
1680 constexpr _Iterator<false>
1681 end() requires common_range<_Vp>
1682 {
return _Iterator<false>{
this,
ranges::end(_M_base)}; }
1684 constexpr _Sentinel<true>
1686 requires range<const _Vp>
1687 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
1690 constexpr _Iterator<true>
1692 requires common_range<const _Vp>
1693 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
1694 {
return _Iterator<true>{
this,
ranges::end(_M_base)}; }
1697 size() requires sized_range<_Vp>
1701 size() const requires sized_range<const _Vp>
1705 template<
typename _Range,
typename _Fp>
1706 transform_view(_Range&&, _Fp) -> transform_view<views::all_t<_Range>, _Fp>;
1712 template<
typename _Range,
typename _Fp>
1713 concept __can_transform_view
1714 = requires { transform_view{std::declval<_Range>(), std::declval<_Fp>()}; };
1717 struct _Transform : __adaptor::_RangeAdaptor<_Transform>
1719 template<viewable_range _Range,
typename _Fp>
1720 requires __detail::__can_transform_view<_Range, _Fp>
1722 operator()(_Range&& __r, _Fp&& __f)
const 1724 return transform_view{std::forward<_Range>(__r), std::forward<_Fp>(__f)};
1727 using _RangeAdaptor<_Transform>::operator();
1728 static constexpr
int _S_arity = 2;
1731 inline constexpr _Transform transform;
1735 class take_view :
public view_interface<take_view<_Vp>>
1738 template<
bool _Const>
1739 using _CI = counted_iterator<
1740 iterator_t<__detail::__maybe_const_t<_Const, _Vp>>>;
1742 template<
bool _Const>
1746 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
1747 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
1750 _Sentinel() =
default;
1753 _Sentinel(sentinel_t<_Base> __end)
1758 _Sentinel(_Sentinel<!_Const> __s)
1759 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
1763 constexpr sentinel_t<_Base>
1767 friend constexpr
bool 1768 operator==(
const _CI<_Const>& __y,
const _Sentinel& __x)
1769 {
return __y.count() == 0 || __y.base() == __x._M_end; }
1771 template<
bool _OtherConst = !_Const,
1772 typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
1773 requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
1774 friend constexpr
bool 1775 operator==(
const _CI<_OtherConst>& __y,
const _Sentinel& __x)
1776 {
return __y.count() == 0 || __y.base() == __x._M_end; }
1778 friend _Sentinel<!_Const>;
1781 range_difference_t<_Vp> _M_count = 0;
1782 _Vp _M_base = _Vp();
1785 take_view() =
default;
1788 take_view(_Vp base, range_difference_t<_Vp> __count)
1793 base() const& requires copy_constructible<_Vp>
1801 begin() requires (!__detail::__simple_view<_Vp>)
1803 if constexpr (sized_range<_Vp>)
1805 if constexpr (random_access_range<_Vp>)
1818 begin() const requires range<const _Vp>
1820 if constexpr (sized_range<const _Vp>)
1822 if constexpr (random_access_range<const _Vp>)
1835 end() requires (!__detail::__simple_view<_Vp>)
1837 if constexpr (sized_range<_Vp>)
1839 if constexpr (random_access_range<_Vp>)
1842 return default_sentinel;
1849 end() const requires range<const _Vp>
1851 if constexpr (sized_range<const _Vp>)
1853 if constexpr (random_access_range<const _Vp>)
1856 return default_sentinel;
1863 size() requires sized_range<_Vp>
1866 return std::min(__n,
static_cast<decltype(__n)
>(_M_count));
1870 size() const requires sized_range<const _Vp>
1873 return std::min(__n,
static_cast<decltype(__n)
>(_M_count));
1880 template<
typename _Range>
1881 take_view(_Range&&, range_difference_t<_Range>)
1882 -> take_view<views::all_t<_Range>>;
1884 template<
typename _Tp>
1885 inline constexpr
bool enable_borrowed_range<take_view<_Tp>>
1886 = enable_borrowed_range<_Tp>;
1892 template<
typename _Range,
typename _Tp>
1893 concept __can_take_view
1894 = requires { take_view{std::declval<_Range>(), std::declval<_Tp>()}; };
1897 struct _Take : __adaptor::_RangeAdaptor<_Take>
1899 template<viewable_range _Range,
typename _Tp>
1900 requires __detail::__can_take_view<_Range, _Tp>
1902 operator()(_Range&& __r, _Tp&& __n)
const 1904 return take_view{std::forward<_Range>(__r), std::forward<_Tp>(__n)};
1907 using _RangeAdaptor<_Take>::operator();
1908 static constexpr
int _S_arity = 2;
1911 inline constexpr _Take take;
1914 template<view _Vp,
typename _Pred>
1915 requires input_range<_Vp> && is_object_v<_Pred>
1916 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
1917 class take_while_view :
public view_interface<take_while_view<_Vp, _Pred>>
1919 template<
bool _Const>
1923 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
1925 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
1926 const _Pred* _M_pred =
nullptr;
1929 _Sentinel() =
default;
1932 _Sentinel(sentinel_t<_Base> __end,
const _Pred* __pred)
1933 : _M_end(__end), _M_pred(__pred)
1937 _Sentinel(_Sentinel<!_Const> __s)
1938 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
1939 : _M_end(__s._M_end), _M_pred(__s._M_pred)
1942 constexpr sentinel_t<_Base>
1943 base()
const {
return _M_end; }
1945 friend constexpr
bool 1946 operator==(
const iterator_t<_Base>& __x,
const _Sentinel& __y)
1947 {
return __y._M_end == __x || !
std::__invoke(*__y._M_pred, *__x); }
1949 template<
bool _OtherConst = !_Const,
1950 typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
1951 requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
1952 friend constexpr
bool 1953 operator==(
const iterator_t<_Base2>& __x,
const _Sentinel& __y)
1954 {
return __y._M_end == __x || !
std::__invoke(*__y._M_pred, *__x); }
1956 friend _Sentinel<!_Const>;
1959 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
1960 _Vp _M_base = _Vp();
1963 take_while_view() =
default;
1966 take_while_view(_Vp base, _Pred __pred)
1971 base() const& requires copy_constructible<_Vp>
1978 constexpr
const _Pred&
1980 {
return *_M_pred; }
1983 begin() requires (!__detail::__simple_view<_Vp>)
1987 begin() const requires range<const _Vp>
1988 && indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
1992 end() requires (!__detail::__simple_view<_Vp>)
1997 end() const requires range<const _Vp>
1998 && indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
2003 template<
typename _Range,
typename _Pred>
2004 take_while_view(_Range&&, _Pred)
2005 -> take_while_view<views::all_t<_Range>, _Pred>;
2011 template<
typename _Range,
typename _Pred>
2012 concept __can_take_while_view
2013 = requires { take_while_view{std::declval<_Range>(), std::declval<_Pred>()}; };
2016 struct _TakeWhile : __adaptor::_RangeAdaptor<_TakeWhile>
2018 template<viewable_range _Range,
typename _Pred>
2019 requires __detail::__can_take_while_view<_Range, _Pred>
2021 operator()(_Range&& __r, _Pred&& __p)
const 2023 return take_while_view{std::forward<_Range>(__r), std::forward<_Pred>(__p)};
2026 using _RangeAdaptor<_TakeWhile>::operator();
2027 static constexpr
int _S_arity = 2;
2030 inline constexpr _TakeWhile take_while;
2034 class drop_view :
public view_interface<drop_view<_Vp>>
2037 range_difference_t<_Vp> _M_count = 0;
2038 _Vp _M_base = _Vp();
2042 static constexpr
bool _S_needs_cached_begin
2043 = !(random_access_range<const _Vp> && sized_range<const _Vp>);
2044 [[no_unique_address]]
2045 __detail::__maybe_present_t<_S_needs_cached_begin,
2046 __detail::_CachedPosition<_Vp>>
2050 drop_view() =
default;
2053 drop_view(_Vp
__base, range_difference_t<_Vp> __count)
2055 { __glibcxx_assert(__count >= 0); }
2058 base() const& requires copy_constructible<_Vp>
2068 requires (!(__detail::__simple_view<_Vp>
2069 && random_access_range<const _Vp>
2070 && sized_range<const _Vp>))
2072 if constexpr (_S_needs_cached_begin)
2073 if (_M_cached_begin._M_has_value())
2074 return _M_cached_begin._M_get(_M_base);
2078 if constexpr (_S_needs_cached_begin)
2079 _M_cached_begin._M_set(_M_base, __it);
2087 requires random_access_range<const _Vp> && sized_range<const _Vp>
2094 end() requires (!__detail::__simple_view<_Vp>)
2098 end() const requires range<const _Vp>
2102 size() requires sized_range<_Vp>
2105 const auto __c =
static_cast<decltype(__s)
>(_M_count);
2106 return __s < __c ? 0 : __s - __c;
2110 size() const requires sized_range<const _Vp>
2113 const auto __c =
static_cast<decltype(__s)
>(_M_count);
2114 return __s < __c ? 0 : __s - __c;
2118 template<
typename _Range>
2119 drop_view(_Range&&, range_difference_t<_Range>)
2120 -> drop_view<views::all_t<_Range>>;
2122 template<
typename _Tp>
2123 inline constexpr
bool enable_borrowed_range<drop_view<_Tp>>
2124 = enable_borrowed_range<_Tp>;
2130 template<
typename _Range,
typename _Tp>
2131 concept __can_drop_view
2132 = requires { drop_view{std::declval<_Range>(), std::declval<_Tp>()}; };
2135 struct _Drop : __adaptor::_RangeAdaptor<_Drop>
2137 template<viewable_range _Range,
typename _Tp>
2138 requires __detail::__can_drop_view<_Range, _Tp>
2140 operator()(_Range&& __r, _Tp&& __n)
const 2142 return drop_view{std::forward<_Range>(__r), std::forward<_Tp>(__n)};
2145 using _RangeAdaptor<_Drop>::operator();
2146 static constexpr
int _S_arity = 2;
2149 inline constexpr _Drop drop;
2152 template<view _Vp,
typename _Pred>
2153 requires input_range<_Vp> && is_object_v<_Pred>
2154 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2155 class drop_while_view :
public view_interface<drop_while_view<_Vp, _Pred>>
2158 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
2159 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
2160 _Vp _M_base = _Vp();
2163 drop_while_view() =
default;
2166 drop_while_view(_Vp
__base, _Pred __pred)
2171 base() const& requires copy_constructible<_Vp>
2178 constexpr
const _Pred&
2180 {
return *_M_pred; }
2185 if (_M_cached_begin._M_has_value())
2186 return _M_cached_begin._M_get(_M_base);
2190 std::cref(*_M_pred));
2191 _M_cached_begin._M_set(_M_base, __it);
2200 template<
typename _Range,
typename _Pred>
2201 drop_while_view(_Range&&, _Pred)
2202 -> drop_while_view<views::all_t<_Range>, _Pred>;
2204 template<
typename _Tp,
typename _Pred>
2205 inline constexpr
bool enable_borrowed_range<drop_while_view<_Tp, _Pred>>
2206 = enable_borrowed_range<_Tp>;
2212 template<
typename _Range,
typename _Pred>
2213 concept __can_drop_while_view
2214 = requires { drop_while_view{std::declval<_Range>(), std::declval<_Pred>()}; };
2217 struct _DropWhile : __adaptor::_RangeAdaptor<_DropWhile>
2219 template<viewable_range _Range,
typename _Pred>
2220 requires __detail::__can_drop_while_view<_Range, _Pred>
2222 operator()(_Range&& __r, _Pred&& __p)
const 2224 return drop_while_view{std::forward<_Range>(__r),
2225 std::forward<_Pred>(__p)};
2228 using _RangeAdaptor<_DropWhile>::operator();
2229 static constexpr
int _S_arity = 2;
2232 inline constexpr _DropWhile drop_while;
2235 template<input_range _Vp>
2236 requires view<_Vp> && input_range<range_reference_t<_Vp>>
2237 && (is_reference_v<range_reference_t<_Vp>>
2238 || view<range_value_t<_Vp>>)
2239 class join_view :
public view_interface<join_view<_Vp>>
2242 using _InnerRange = range_reference_t<_Vp>;
2244 template<
bool _Const>
2245 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2247 template<
bool _Const>
2248 using _Outer_iter = iterator_t<_Base<_Const>>;
2250 template<
bool _Const>
2251 using _Inner_iter = iterator_t<range_reference_t<_Base<_Const>>>;
2253 template<
bool _Const>
2254 static constexpr
bool _S_ref_is_glvalue
2255 = is_reference_v<range_reference_t<_Base<_Const>>>;
2257 template<
bool _Const>
2261 template<
bool _Const>
2262 requires _S_ref_is_glvalue<_Const>
2263 && forward_range<_Base<_Const>>
2264 && forward_range<range_reference_t<_Base<_Const>>>
2265 struct __iter_cat<_Const>
2268 static constexpr
auto 2271 using _Outer_iter = join_view::_Outer_iter<_Const>;
2272 using _Inner_iter = join_view::_Inner_iter<_Const>;
2273 using _OuterCat =
typename iterator_traits<_Outer_iter>::iterator_category;
2274 using _InnerCat =
typename iterator_traits<_Inner_iter>::iterator_category;
2275 if constexpr (derived_from<_OuterCat, bidirectional_iterator_tag>
2276 && derived_from<_InnerCat, bidirectional_iterator_tag>)
2277 return bidirectional_iterator_tag{};
2278 else if constexpr (derived_from<_OuterCat, forward_iterator_tag>
2279 && derived_from<_InnerCat, forward_iterator_tag>)
2280 return forward_iterator_tag{};
2282 return input_iterator_tag{};
2285 using iterator_category = decltype(_S_iter_cat());
2288 template<
bool _Const>
2291 template<
bool _Const>
2292 struct _Iterator : __iter_cat<_Const>
2295 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
2296 using _Base = join_view::_Base<_Const>;
2298 static constexpr
bool _S_ref_is_glvalue
2299 = join_view::_S_ref_is_glvalue<_Const>;
2304 auto __update_inner = [
this] (range_reference_t<_Base> __x) ->
auto&
2306 if constexpr (_S_ref_is_glvalue)
2309 return (_M_parent->_M_inner = views::all(
std::move(__x)));
2312 for (; _M_outer !=
ranges::end(_M_parent->_M_base); ++_M_outer)
2314 auto& __inner = __update_inner(*_M_outer);
2320 if constexpr (_S_ref_is_glvalue)
2321 _M_inner = _Inner_iter();
2324 static constexpr
auto 2327 if constexpr (_S_ref_is_glvalue
2328 && bidirectional_range<_Base>
2329 && bidirectional_range<range_reference_t<_Base>>)
2330 return bidirectional_iterator_tag{};
2331 else if constexpr (_S_ref_is_glvalue
2332 && forward_range<_Base>
2333 && forward_range<range_reference_t<_Base>>)
2334 return forward_iterator_tag{};
2336 return input_iterator_tag{};
2339 using _Outer_iter = join_view::_Outer_iter<_Const>;
2340 using _Inner_iter = join_view::_Inner_iter<_Const>;
2342 _Outer_iter _M_outer = _Outer_iter();
2343 _Inner_iter _M_inner = _Inner_iter();
2344 _Parent* _M_parent =
nullptr;
2347 using iterator_concept = decltype(_S_iter_concept());
2349 using value_type = range_value_t<range_reference_t<_Base>>;
2350 using difference_type
2351 = common_type_t<range_difference_t<_Base>,
2352 range_difference_t<range_reference_t<_Base>>>;
2354 _Iterator() =
default;
2357 _Iterator(_Parent* __parent, _Outer_iter __outer)
2358 : _M_outer(
std::
move(__outer)),
2363 _Iterator(_Iterator<!_Const> __i)
2365 && convertible_to<iterator_t<_Vp>, _Outer_iter>
2366 && convertible_to<iterator_t<_InnerRange>, _Inner_iter>
2367 : _M_outer(
std::move(__i._M_outer)), _M_inner(__i._M_inner),
2368 _M_parent(__i._M_parent)
2371 constexpr decltype(
auto)
2373 {
return *_M_inner; }
2377 constexpr _Inner_iter
2379 requires __detail::__has_arrow<_Inner_iter>
2380 && copyable<_Inner_iter>
2381 {
return _M_inner; }
2383 constexpr _Iterator&
2386 auto&& __inner_range = [
this] () ->
auto&& {
2387 if constexpr (_S_ref_is_glvalue)
2390 return _M_parent->_M_inner;
2406 requires _S_ref_is_glvalue && forward_range<_Base>
2407 && forward_range<range_reference_t<_Base>>
2414 constexpr _Iterator&
2416 requires _S_ref_is_glvalue && bidirectional_range<_Base>
2417 && bidirectional_range<range_reference_t<_Base>>
2418 && common_range<range_reference_t<_Base>>
2430 requires _S_ref_is_glvalue && bidirectional_range<_Base>
2431 && bidirectional_range<range_reference_t<_Base>>
2432 && common_range<range_reference_t<_Base>>
2439 friend constexpr
bool 2440 operator==(
const _Iterator& __x,
const _Iterator& __y)
2441 requires _S_ref_is_glvalue
2442 && equality_comparable<_Outer_iter>
2443 && equality_comparable<_Inner_iter>
2445 return (__x._M_outer == __y._M_outer
2446 && __x._M_inner == __y._M_inner);
2449 friend constexpr decltype(
auto)
2450 iter_move(const _Iterator& __i)
2451 noexcept(noexcept(ranges::iter_move(__i._M_inner)))
2452 {
return ranges::iter_move(__i._M_inner); }
2454 friend constexpr
void 2455 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
2456 noexcept(noexcept(ranges::iter_swap(__x._M_inner, __y._M_inner)))
2457 requires indirectly_swappable<_Inner_iter>
2458 {
return ranges::iter_swap(__x._M_inner, __y._M_inner); }
2460 friend _Iterator<!_Const>;
2461 template<
bool>
friend struct _Sentinel;
2464 template<
bool _Const>
2468 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
2469 using _Base = join_view::_Base<_Const>;
2471 template<
bool _Const2>
2473 __equal(
const _Iterator<_Const2>& __i)
const 2474 {
return __i._M_outer == _M_end; }
2476 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2479 _Sentinel() =
default;
2482 _Sentinel(_Parent* __parent)
2483 : _M_end(ranges::
end(__parent->_M_base))
2487 _Sentinel(_Sentinel<!_Const> __s)
2488 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2492 template<
bool _Const2>
2493 requires sentinel_for<sentinel_t<_Base>,
2494 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
2495 friend constexpr
bool 2496 operator==(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
2497 {
return __y.__equal(__x); }
2499 friend _Sentinel<!_Const>;
2503 [[no_unique_address]]
2504 __detail::__maybe_present_t<!is_reference_v<_InnerRange>,
2505 views::all_t<_InnerRange>> _M_inner;
2506 _Vp _M_base = _Vp();
2509 join_view() =
default;
2517 base() const& requires copy_constructible<_Vp>
2527 constexpr
bool __use_const
2528 = (__detail::__simple_view<_Vp>
2529 && is_reference_v<range_reference_t<_Vp>>);
2530 return _Iterator<__use_const>{
this,
ranges::begin(_M_base)};
2535 requires input_range<const _Vp>
2536 && is_reference_v<range_reference_t<const _Vp>>
2544 if constexpr (forward_range<_Vp> && is_reference_v<_InnerRange>
2545 && forward_range<_InnerRange>
2546 && common_range<_Vp> && common_range<_InnerRange>)
2547 return _Iterator<__detail::__simple_view<_Vp>>{
this,
2550 return _Sentinel<__detail::__simple_view<_Vp>>{
this};
2555 requires input_range<const _Vp>
2556 && is_reference_v<range_reference_t<const _Vp>>
2558 if constexpr (forward_range<const _Vp>
2559 && is_reference_v<range_reference_t<const _Vp>>
2560 && forward_range<range_reference_t<const _Vp>>
2561 && common_range<const _Vp>
2562 && common_range<range_reference_t<const _Vp>>)
2563 return _Iterator<true>{
this,
ranges::end(_M_base)};
2565 return _Sentinel<true>{
this};
2569 template<
typename _Range>
2570 explicit join_view(_Range&&) -> join_view<views::all_t<_Range>>;
2576 template<
typename _Range>
2577 concept __can_join_view
2578 = requires { join_view<all_t<_Range>>{std::declval<_Range>()}; };
2581 struct _Join : __adaptor::_RangeAdaptorClosure
2583 template<viewable_range _Range>
2584 requires __detail::__can_join_view<_Range>
2586 operator()(_Range&& __r)
const 2590 return join_view<all_t<_Range>>{std::forward<_Range>(__r)};
2594 inline constexpr _Join join;
2600 struct __require_constant;
2602 template<
typename _Range>
2603 concept __tiny_range = sized_range<_Range>
2608 template<
typename _Base>
2609 struct __split_view_outer_iter_cat
2612 template<forward_range _Base>
2613 struct __split_view_outer_iter_cat<_Base>
2614 {
using iterator_category = input_iterator_tag; };
2616 template<
typename _Base>
2617 struct __split_view_inner_iter_cat
2620 template<forward_range _Base>
2621 struct __split_view_inner_iter_cat<_Base>
2624 static constexpr
auto 2627 using _Cat =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
2628 if constexpr (derived_from<_Cat, forward_iterator_tag>)
2629 return forward_iterator_tag{};
2634 using iterator_category = decltype(_S_iter_cat());
2638 template<input_range _Vp, forward_range _Pattern>
2639 requires view<_Vp> && view<_Pattern>
2640 && indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
2642 && (forward_range<_Vp> || __detail::__tiny_range<_Pattern>)
2643 class split_view :
public view_interface<split_view<_Vp, _Pattern>>
2646 template<
bool _Const>
2647 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2649 template<
bool _Const>
2652 template<
bool _Const>
2654 : __detail::__split_view_outer_iter_cat<_Base<_Const>>
2657 using _Parent = __detail::__maybe_const_t<_Const, split_view>;
2658 using _Base = split_view::_Base<_Const>;
2662 {
return __current() ==
ranges::end(_M_parent->_M_base); }
2669 __current() noexcept
2671 if constexpr (forward_range<_Vp>)
2674 return _M_parent->_M_current;
2678 __current() const noexcept
2680 if constexpr (forward_range<_Vp>)
2683 return _M_parent->_M_current;
2686 _Parent* _M_parent =
nullptr;
2689 [[no_unique_address]]
2690 __detail::__maybe_present_t<forward_range<_Vp>,
2691 iterator_t<_Base>> _M_current;
2694 using iterator_concept = conditional_t<forward_range<_Base>,
2695 forward_iterator_tag,
2696 input_iterator_tag>;
2698 using difference_type = range_difference_t<_Base>;
2700 struct value_type : view_interface<value_type>
2703 _OuterIter _M_i = _OuterIter();
2706 value_type() =
default;
2709 value_type(_OuterIter __i)
2713 constexpr _InnerIter<_Const>
2715 requires copyable<_OuterIter>
2716 {
return _InnerIter<_Const>{_M_i}; }
2718 constexpr _InnerIter<_Const>
2720 requires (!copyable<_OuterIter>)
2721 {
return _InnerIter<_Const>{
std::move(_M_i)}; }
2723 constexpr default_sentinel_t
2725 {
return default_sentinel; }
2728 _OuterIter() =
default;
2731 _OuterIter(_Parent* __parent) requires (!forward_range<_Base>)
2732 : _M_parent(__parent)
2736 _OuterIter(_Parent* __parent, iterator_t<_Base> __current)
2737 requires forward_range<_Base>
2738 : _M_parent(__parent),
2743 _OuterIter(_OuterIter<!_Const> __i)
2745 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
2746 : _M_parent(__i._M_parent), _M_current(
std::move(__i._M_current))
2749 constexpr value_type
2751 {
return value_type{*
this}; }
2753 constexpr _OuterIter&
2758 const auto __end =
ranges::end(_M_parent->_M_base);
2759 if (__current() == __end)
2761 const auto [__pbegin, __pend] = subrange{_M_parent->_M_pattern};
2762 if (__pbegin == __pend)
2764 else if constexpr (__detail::__tiny_range<_Pattern>)
2766 __current() = __detail::find(
std::move(__current()), __end,
2768 if (__current() != __end)
2775 = __detail::mismatch(__current(), __end, __pbegin, __pend);
2781 }
while (++__current() != __end);
2785 constexpr decltype(
auto)
2788 if constexpr (forward_range<_Base>)
2798 friend constexpr
bool 2799 operator==(
const _OuterIter& __x,
const _OuterIter& __y)
2800 requires forward_range<_Base>
2801 {
return __x._M_current == __y._M_current; }
2803 friend constexpr
bool 2804 operator==(
const _OuterIter& __x, default_sentinel_t)
2805 {
return __x.__at_end(); };
2807 friend _OuterIter<!_Const>;
2808 friend _InnerIter<_Const>;
2811 template<
bool _Const>
2813 : __detail::__split_view_inner_iter_cat<_Base<_Const>>
2816 using _Base = split_view::_Base<_Const>;
2821 auto [__pcur, __pend] = subrange{_M_i._M_parent->_M_pattern};
2822 auto __end =
ranges::end(_M_i._M_parent->_M_base);
2823 if constexpr (__detail::__tiny_range<_Pattern>)
2825 const auto& __cur = _M_i_current();
2828 if (__pcur == __pend)
2829 return _M_incremented;
2830 return *__cur == *__pcur;
2834 auto __cur = _M_i_current();
2837 if (__pcur == __pend)
2838 return _M_incremented;
2841 if (*__cur != *__pcur)
2843 if (++__pcur == __pend)
2845 }
while (++__cur != __end);
2851 _M_i_current() noexcept
2852 {
return _M_i.__current(); }
2855 _M_i_current() const noexcept
2856 {
return _M_i.__current(); }
2858 _OuterIter<_Const> _M_i = _OuterIter<_Const>();
2859 bool _M_incremented =
false;
2862 using iterator_concept
2863 =
typename _OuterIter<_Const>::iterator_concept;
2865 using value_type = range_value_t<_Base>;
2866 using difference_type = range_difference_t<_Base>;
2868 _InnerIter() =
default;
2871 _InnerIter(_OuterIter<_Const> __i)
2875 constexpr decltype(
auto)
2877 {
return *_M_i_current(); }
2879 constexpr _InnerIter&
2882 _M_incremented =
true;
2883 if constexpr (!forward_range<_Base>)
2890 constexpr decltype(auto)
2893 if constexpr (forward_range<_Base>)
2903 friend constexpr
bool 2904 operator==(
const _InnerIter& __x,
const _InnerIter& __y)
2905 requires forward_range<_Base>
2906 {
return __x._M_i == __y._M_i; }
2908 friend constexpr
bool 2909 operator==(
const _InnerIter& __x, default_sentinel_t)
2910 {
return __x.__at_end(); }
2912 friend constexpr decltype(
auto)
2913 iter_move(const _InnerIter& __i)
2914 noexcept(noexcept(ranges::iter_move(__i._M_i_current())))
2915 {
return ranges::iter_move(__i._M_i_current()); }
2917 friend constexpr
void 2918 iter_swap(
const _InnerIter& __x,
const _InnerIter& __y)
2919 noexcept(noexcept(ranges::iter_swap(__x._M_i_current(),
2920 __y._M_i_current())))
2921 requires indirectly_swappable<iterator_t<_Base>>
2922 { ranges::iter_swap(__x._M_i_current(), __y._M_i_current()); }
2925 _Pattern _M_pattern = _Pattern();
2927 [[no_unique_address]]
2928 __detail::__maybe_present_t<!forward_range<_Vp>,
2929 iterator_t<_Vp>> _M_current;
2930 _Vp _M_base = _Vp();
2934 split_view() =
default;
2937 split_view(_Vp
__base, _Pattern __pattern)
2941 template<input_range _Range>
2942 requires constructible_from<_Vp, views::all_t<_Range>>
2943 && constructible_from<_Pattern, single_view<range_value_t<_Range>>>
2945 split_view(_Range&& __r, range_value_t<_Range> __e)
2947 _M_base(views::all(
std::
forward<_Range>(__r)))
2951 base() const& requires copy_constructible<_Vp>
2961 if constexpr (forward_range<_Vp>)
2962 return _OuterIter<__detail::__simple_view<_Vp>>{
2967 return _OuterIter<false>{
this};
2972 begin() const requires forward_range<_Vp> && forward_range<const _Vp>
2978 end() requires forward_range<_Vp> && common_range<_Vp>
2980 return _OuterIter<__detail::__simple_view<_Vp>>{
2987 if constexpr (forward_range<_Vp>
2988 && forward_range<const _Vp>
2989 && common_range<const _Vp>)
2990 return _OuterIter<true>{
this,
ranges::end(_M_base)};
2992 return default_sentinel;
2996 template<
typename _Range,
typename _Pattern>
2997 split_view(_Range&&, _Pattern&&)
2998 -> split_view<views::all_t<_Range>, views::all_t<_Pattern>>;
3000 template<input_range _Range>
3001 split_view(_Range&&, range_value_t<_Range>)
3002 -> split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
3008 template<
typename _Range,
typename _Pattern>
3009 concept __can_split_view
3010 = requires { split_view{std::declval<_Range>(), std::declval<_Pattern>()}; };
3013 struct _Split : __adaptor::_RangeAdaptor<_Split>
3015 template<viewable_range _Range,
typename _Pattern>
3016 requires __detail::__can_split_view<_Range, _Pattern>
3018 operator()(_Range&& __r, _Pattern&& __f)
const 3020 return split_view{std::forward<_Range>(__r), std::forward<_Pattern>(__f)};
3023 using _RangeAdaptor<_Split>::operator();
3024 static constexpr
int _S_arity = 2;
3027 inline constexpr _Split split;
3034 template<input_or_output_iterator _Iter>
3036 operator()(_Iter __i, iter_difference_t<_Iter> __n)
const 3038 if constexpr (random_access_iterator<_Iter>)
3039 return subrange{__i, __i + __n};
3041 return subrange{counted_iterator{
std::move(__i), __n},
3046 inline constexpr _Counted counted{};
3050 requires (!common_range<_Vp>) && copyable<iterator_t<_Vp>>
3051 class common_view :
public view_interface<common_view<_Vp>>
3054 _Vp _M_base = _Vp();
3057 common_view() =
default;
3060 common_view(_Vp __r)
3075 base() const& requires copy_constructible<_Vp>
3085 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3088 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
3093 begin() const requires range<const _Vp>
3095 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
3098 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
3105 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3108 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
3113 end() const requires range<const _Vp>
3115 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
3118 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
3123 size() requires sized_range<_Vp>
3127 size() const requires sized_range<const _Vp>
3131 template<
typename _Range>
3132 common_view(_Range&&) -> common_view<views::all_t<_Range>>;
3134 template<
typename _Tp>
3135 inline constexpr
bool enable_borrowed_range<common_view<_Tp>>
3136 = enable_borrowed_range<_Tp>;
3142 template<
typename _Range>
3143 concept __already_common = common_range<_Range>
3144 && requires { views::all(std::declval<_Range>()); };
3146 template<
typename _Range>
3147 concept __can_common_view
3148 = requires { common_view{std::declval<_Range>()}; };
3151 struct _Common : __adaptor::_RangeAdaptorClosure
3153 template<viewable_range _Range>
3154 requires __detail::__already_common<_Range>
3155 || __detail::__can_common_view<_Range>
3157 operator()(_Range&& __r)
const 3159 if constexpr (__detail::__already_common<_Range>)
3160 return views::all(std::forward<_Range>(__r));
3162 return common_view{std::forward<_Range>(__r)};
3166 inline constexpr _Common common;
3170 requires bidirectional_range<_Vp>
3171 class reverse_view :
public view_interface<reverse_view<_Vp>>
3174 static constexpr
bool _S_needs_cached_begin
3175 = !common_range<_Vp> && !random_access_range<_Vp>;
3177 [[no_unique_address]]
3178 __detail::__maybe_present_t<_S_needs_cached_begin,
3179 __detail::_CachedPosition<_Vp>>
3181 _Vp _M_base = _Vp();
3184 reverse_view() =
default;
3187 reverse_view(_Vp __r)
3192 base() const& requires copy_constructible<_Vp>
3199 constexpr reverse_iterator<iterator_t<_Vp>>
3202 if constexpr (_S_needs_cached_begin)
3203 if (_M_cached_begin._M_has_value())
3207 if constexpr (_S_needs_cached_begin)
3208 _M_cached_begin._M_set(_M_base, __it);
3213 begin() requires common_range<_Vp>
3217 begin() const requires common_range<const _Vp>
3220 constexpr reverse_iterator<iterator_t<_Vp>>
3225 end() const requires common_range<const _Vp>
3229 size() requires sized_range<_Vp>
3233 size() const requires sized_range<const _Vp>
3237 template<
typename _Range>
3238 reverse_view(_Range&&) -> reverse_view<views::all_t<_Range>>;
3240 template<
typename _Tp>
3241 inline constexpr
bool enable_borrowed_range<reverse_view<_Tp>>
3242 = enable_borrowed_range<_Tp>;
3249 inline constexpr
bool __is_reversible_subrange =
false;
3251 template<
typename _Iter, subrange_kind _Kind>
3252 inline constexpr
bool 3253 __is_reversible_subrange<subrange<reverse_iterator<_Iter>,
3254 reverse_iterator<_Iter>,
3258 inline constexpr
bool __is_reverse_view =
false;
3260 template<
typename _Vp>
3261 inline constexpr
bool __is_reverse_view<reverse_view<_Vp>> =
true;
3263 template<
typename _Range>
3264 concept __can_reverse_view
3265 = requires { reverse_view{std::declval<_Range>()}; };
3268 struct _Reverse : __adaptor::_RangeAdaptorClosure
3270 template<viewable_range _Range>
3271 requires __detail::__is_reverse_view<remove_cvref_t<_Range>>
3272 || __detail::__is_reversible_subrange<remove_cvref_t<_Range>>
3273 || __detail::__can_reverse_view<_Range>
3275 operator()(_Range&& __r)
const 3277 using _Tp = remove_cvref_t<_Range>;
3278 if constexpr (__detail::__is_reverse_view<_Tp>)
3279 return std::forward<_Range>(__r).base();
3280 else if constexpr (__detail::__is_reversible_subrange<_Tp>)
3283 if constexpr (sized_range<_Tp>)
3284 return subrange<_Iter, _Iter, subrange_kind::sized>
3285 {__r.end().base(), __r.begin().base(), __r.size()};
3287 return subrange<_Iter, _Iter, subrange_kind::unsized>
3288 {__r.end().base(), __r.begin().base()};
3291 return reverse_view{std::forward<_Range>(__r)};
3295 inline constexpr _Reverse reverse;
3300 template<
typename _Tp,
size_t _Nm>
3301 concept __has_tuple_element = requires(_Tp __t)
3303 typename tuple_size<_Tp>::type;
3304 requires _Nm < tuple_size_v<_Tp>;
3305 typename tuple_element_t<_Nm, _Tp>;
3306 { std::get<_Nm>(__t) }
3307 -> convertible_to<const tuple_element_t<_Nm, _Tp>&>;
3310 template<
typename _Tp,
size_t _Nm>
3311 concept __returnable_element
3312 = is_reference_v<_Tp> || move_constructible<tuple_element_t<_Nm, _Tp>>;
3315 template<input_range _Vp,
size_t _Nm>
3317 && __detail::__has_tuple_element<range_value_t<_Vp>, _Nm>
3318 && __detail::__has_tuple_element<remove_reference_t<range_reference_t<_Vp>>,
3320 && __detail::__returnable_element<range_reference_t<_Vp>, _Nm>
3321 class elements_view :
public view_interface<elements_view<_Vp, _Nm>>
3324 elements_view() =
default;
3327 elements_view(_Vp base)
3332 base() const& requires copy_constructible<_Vp>
3340 begin() requires (!__detail::__simple_view<_Vp>)
3344 begin() const requires range<const _Vp>
3348 end() requires (!__detail::__simple_view<_Vp> && !common_range<_Vp>)
3349 {
return _Sentinel<false>{
ranges::end(_M_base)}; }
3352 end() requires (!__detail::__simple_view<_Vp> && common_range<_Vp>)
3353 {
return _Iterator<false>{
ranges::end(_M_base)}; }
3356 end() const requires range<const _Vp>
3360 end() const requires common_range<const _Vp>
3364 size() requires sized_range<_Vp>
3368 size() const requires sized_range<const _Vp>
3372 template<
bool _Const>
3373 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
3375 template<
bool _Const>
3379 template<
bool _Const>
3380 requires forward_range<_Base<_Const>>
3381 struct __iter_cat<_Const>
3384 static auto _S_iter_cat()
3386 using _Base = elements_view::_Base<_Const>;
3387 using _Cat = iterator_traits<iterator_t<_Base>>::iterator_category;
3388 using _Res = decltype((std::get<_Nm>(*std::declval<iterator_t<_Base>>())));
3389 if constexpr (!is_lvalue_reference_v<_Res>)
3390 return input_iterator_tag{};
3391 else if constexpr (derived_from<_Cat, random_access_iterator_tag>)
3392 return random_access_iterator_tag{};
3397 using iterator_category = decltype(_S_iter_cat());
3400 template<
bool _Const>
3403 template<
bool _Const>
3404 struct _Iterator : __iter_cat<_Const>
3407 using _Base = elements_view::_Base<_Const>;
3409 iterator_t<_Base> _M_current = iterator_t<_Base>();
3411 static constexpr decltype(
auto)
3412 _S_get_element(const iterator_t<_Base>& __i)
3414 if constexpr (is_reference_v<range_reference_t<_Base>>)
3415 return
std::get<_Nm>(*__i);
3418 using _Et = remove_cv_t<tuple_element_t<_Nm, range_reference_t<_Base>>>;
3419 return static_cast<_Et
>(std::get<_Nm>(*__i));
3426 if constexpr (random_access_range<_Vp>)
3427 return random_access_iterator_tag{};
3428 else if constexpr (bidirectional_range<_Vp>)
3429 return bidirectional_iterator_tag{};
3430 else if constexpr (forward_range<_Vp>)
3431 return forward_iterator_tag{};
3433 return input_iterator_tag{};
3436 friend _Iterator<!_Const>;
3439 using iterator_concept = decltype(_S_iter_concept());
3442 = remove_cvref_t<tuple_element_t<_Nm, range_value_t<_Base>>>;
3443 using difference_type = range_difference_t<_Base>;
3445 _Iterator() =
default;
3448 _Iterator(iterator_t<_Base> current)
3449 : _M_current(
std::
move(current))
3453 _Iterator(_Iterator<!_Const> i)
3454 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
3458 constexpr iterator_t<_Base>
3460 requires copyable<iterator_t<_Base>>
3461 {
return _M_current; }
3463 constexpr iterator_t<_Base>
3467 constexpr decltype(
auto)
3469 {
return _S_get_element(_M_current); }
3471 constexpr _Iterator&
3483 operator++(
int) requires forward_range<_Base>
3490 constexpr _Iterator&
3491 operator--() requires bidirectional_range<_Base>
3498 operator--(
int) requires bidirectional_range<_Base>
3505 constexpr _Iterator&
3506 operator+=(difference_type __n)
3507 requires random_access_range<_Base>
3513 constexpr _Iterator&
3514 operator-=(difference_type __n)
3515 requires random_access_range<_Base>
3521 constexpr decltype(
auto)
3522 operator[](difference_type __n) const
3523 requires random_access_range<_Base>
3524 {
return _S_get_element(_M_current + __n); }
3526 friend constexpr
bool 3527 operator==(
const _Iterator& __x,
const _Iterator& __y)
3528 requires equality_comparable<iterator_t<_Base>>
3529 {
return __x._M_current == __y._M_current; }
3531 friend constexpr
bool 3532 operator<(
const _Iterator& __x,
const _Iterator& __y)
3533 requires random_access_range<_Base>
3534 {
return __x._M_current < __y._M_current; }
3536 friend constexpr
bool 3537 operator>(
const _Iterator& __x,
const _Iterator& __y)
3538 requires random_access_range<_Base>
3539 {
return __y._M_current < __x._M_current; }
3541 friend constexpr
bool 3542 operator<=(
const _Iterator& __x,
const _Iterator& __y)
3543 requires random_access_range<_Base>
3544 {
return !(__y._M_current > __x._M_current); }
3546 friend constexpr
bool 3547 operator>=(
const _Iterator& __x,
const _Iterator& __y)
3548 requires random_access_range<_Base>
3549 {
return !(__x._M_current > __y._M_current); }
3551 #ifdef __cpp_lib_three_way_comparison 3552 friend constexpr
auto 3553 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
3554 requires random_access_range<_Base>
3555 && three_way_comparable<iterator_t<_Base>>
3556 {
return __x._M_current <=> __y._M_current; }
3559 friend constexpr _Iterator
3560 operator+(
const _Iterator& __x, difference_type __y)
3561 requires random_access_range<_Base>
3562 {
return _Iterator{__x} += __y; }
3564 friend constexpr _Iterator
3565 operator+(difference_type __x,
const _Iterator& __y)
3566 requires random_access_range<_Base>
3567 {
return __y + __x; }
3569 friend constexpr _Iterator
3570 operator-(
const _Iterator& __x, difference_type __y)
3571 requires random_access_range<_Base>
3572 {
return _Iterator{__x} -= __y; }
3576 friend constexpr difference_type
3577 operator-(
const _Iterator& __x,
const _Iterator& __y)
3578 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
3579 {
return __x._M_current - __y._M_current; }
3581 friend _Sentinel<_Const>;
3584 template<
bool _Const>
3589 _M_equal(
const _Iterator<_Const>& __x)
const 3590 {
return __x._M_current == _M_end; }
3592 using _Base = elements_view::_Base<_Const>;
3593 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
3596 _Sentinel() =
default;
3599 _Sentinel(sentinel_t<_Base> __end)
3604 _Sentinel(_Sentinel<!_Const> __other)
3606 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
3610 constexpr sentinel_t<_Base>
3614 template<
bool _Const2>
3615 requires sentinel_for<sentinel_t<_Base>,
3616 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
3617 friend constexpr
bool 3618 operator==(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
3619 {
return __y._M_equal(__x); }
3621 template<
bool _Const2,
3622 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
3623 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
3624 friend constexpr range_difference_t<_Base2>
3625 operator-(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
3626 {
return __x._M_current - __y._M_end; }
3628 template<
bool _Const2,
3629 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
3630 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
3631 friend constexpr range_difference_t<_Base>
3632 operator-(
const _Sentinel& __x,
const _Iterator<_Const2>& __y)
3633 {
return __x._M_end - __y._M_current; }
3635 friend _Sentinel<!_Const>;
3638 _Vp _M_base = _Vp();
3641 template<
typename _Tp,
size_t _Nm>
3642 inline constexpr
bool enable_borrowed_range<elements_view<_Tp, _Nm>>
3643 = enable_borrowed_range<_Tp>;
3645 template<
typename _Range>
3646 using keys_view = elements_view<views::all_t<_Range>, 0>;
3648 template<
typename _Range>
3649 using values_view = elements_view<views::all_t<_Range>, 1>;
3655 template<
size_t _Nm,
typename _Range>
3656 concept __can_elements_view
3657 = requires { elements_view<all_t<_Range>, _Nm>{std::declval<_Range>()}; };
3660 template<
size_t _Nm>
3661 struct _Elements : __adaptor::_RangeAdaptorClosure
3663 template<viewable_range _Range>
3664 requires __detail::__can_elements_view<_Nm, _Range>
3666 operator()(_Range&& __r)
const 3668 return elements_view<all_t<_Range>, _Nm>{std::forward<_Range>(__r)};
3672 template<
size_t _Nm>
3673 inline constexpr _Elements<_Nm> elements;
3674 inline constexpr
auto keys = elements<0>;
3675 inline constexpr
auto values = elements<1>;
3680 namespace views = ranges::views;
3682 _GLIBCXX_END_NAMESPACE_VERSION
3684 #endif // library concepts _Tp * begin(valarray< _Tp > &__va)
Return an iterator pointing to the first element of the valarray.
typename make_unsigned< _Tp >::type make_unsigned_t
Alias template for make_unsigned.
constexpr auto size(const _Container &__cont) noexcept(noexcept(__cont.size())) -> decltype(__cont.size())
Return the size of a container.
_Tp * end(valarray< _Tp > &__va)
Return an iterator pointing to one past the last element of the valarray.
constexpr __invoke_result< _Callable, _Args... >::type __invoke(_Callable &&__fn, _Args &&... __args) noexcept(__is_nothrow_invocable< _Callable, _Args... >::value)
Invoke a callable object.
element_type * operator->() const
Smart pointer dereferencing.
Class template for optional values.
constexpr auto data(_Container &__cont) noexcept(noexcept(__cont.data())) -> decltype(__cont.data())
Return the data pointer of a container.
constexpr complex< _Tp > operator-(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x minus y.
constexpr _Iterator __base(_Iterator __it)
typename invoke_result< _Fn, _Args... >::type invoke_result_t
std::invoke_result_t
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
constexpr auto empty(const _Container &__cont) noexcept(noexcept(__cont.empty())) -> decltype(__cont.empty())
Return whether a container is empty.
constexpr complex< _Tp > operator*(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x times y.
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
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.
constexpr _Tp && forward(typename std::remove_reference< _Tp >::type &__t) noexcept
Forward an lvalue.
ISO C++ entities toplevel namespace is std.
auto_ptr & operator=(auto_ptr &__a)
auto_ptr assignment operator.
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 plus y.
constexpr const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
bitset< _Nb > operator|(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.