30 #ifndef _GLIBCXX_RANGES
31 #define _GLIBCXX_RANGES 1
33 #if __cplusplus > 201703L
35 #pragma GCC system_header
39 #if __cpp_lib_concepts
54 namespace std _GLIBCXX_VISIBILITY(default)
56 _GLIBCXX_BEGIN_NAMESPACE_VERSION
70 template<
typename _Tp>
71 concept __deep_const_range = range<_Tp> && range<const _Tp>
72 && same_as<range_reference_t<_Tp>, range_reference_t<const _Tp>>;
74 template<
typename _Tp>
75 inline constexpr
bool __enable_view_impl
76 = derived_from<_Tp, view_base> || (!__deep_const_range<_Tp>);
78 template<
typename _Tp>
79 inline constexpr
bool __enable_view_impl<std::initializer_list<_Tp>>
84 template<
typename _Tp>
85 inline constexpr
bool enable_view
86 = __detail::__enable_view_impl<remove_cv_t<_Tp>>;
88 template<
typename _Tp>
90 = range<_Tp> && movable<_Tp> && default_initializable<_Tp>
94 template<
typename _Tp>
95 concept viewable_range = range<_Tp>
96 && (borrowed_range<_Tp> || view<remove_cvref_t<_Tp>>);
100 template<
typename _Range>
101 concept __simple_view = view<_Range> && range<const _Range>
102 && same_as<iterator_t<_Range>, iterator_t<const _Range>>
103 && same_as<sentinel_t<_Range>, sentinel_t<const _Range>>;
105 template<
typename _It>
106 concept __has_arrow = input_iterator<_It>
107 && (is_pointer_v<_It> || requires(_It __it) { __it.operator->(); });
109 template<
typename _Tp,
typename _Up>
110 concept __not_same_as
111 = !same_as<remove_cvref_t<_Tp>, remove_cvref_t<_Up>>;
114 template<
typename _Derived>
115 requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
116 class view_interface :
public view_base
119 constexpr _Derived& _M_derived() noexcept
121 static_assert(derived_from<_Derived, view_interface<_Derived>>);
122 static_assert(view<_Derived>);
123 return static_cast<_Derived&>(*
this);
126 constexpr
const _Derived& _M_derived() const noexcept
128 static_assert(derived_from<_Derived, view_interface<_Derived>>);
129 static_assert(view<_Derived>);
130 return static_cast<const _Derived&>(*
this);
135 empty() requires forward_range<_Derived>
139 empty() const requires forward_range<const _Derived>
143 operator bool() requires requires { ranges::empty(_M_derived()); }
144 {
return !ranges::empty(_M_derived()); }
147 operator bool() const requires requires { ranges::empty(_M_derived()); }
148 {
return !ranges::empty(_M_derived()); }
151 data() requires contiguous_iterator<iterator_t<_Derived>>
156 requires range<const _Derived>
157 && contiguous_iterator<iterator_t<const _Derived>>
162 requires forward_range<_Derived>
163 && sized_sentinel_for<sentinel_t<_Derived>, iterator_t<_Derived>>
168 requires forward_range<const _Derived>
169 && sized_sentinel_for<sentinel_t<const _Derived>,
170 iterator_t<const _Derived>>
173 constexpr decltype(
auto)
174 front() requires forward_range<_Derived>
176 __glibcxx_assert(!empty());
180 constexpr decltype(
auto)
181 front() const requires forward_range<const _Derived>
183 __glibcxx_assert(!empty());
187 constexpr decltype(
auto)
189 requires bidirectional_range<_Derived> && common_range<_Derived>
191 __glibcxx_assert(!empty());
195 constexpr decltype(
auto)
197 requires bidirectional_range<const _Derived>
198 && common_range<const _Derived>
200 __glibcxx_assert(!empty());
204 template<random_access_range _Range = _Derived>
205 constexpr decltype(
auto)
206 operator[](range_difference_t<_Range> __n)
209 template<random_access_range _Range = const _Derived>
210 constexpr decltype(
auto)
211 operator[](range_difference_t<_Range> __n)
const
217 template<
class _From,
class _To>
218 concept __convertible_to_non_slicing = convertible_to<_From, _To>
219 && !(is_pointer_v<decay_t<_From>> && is_pointer_v<decay_t<_To>>
220 && __not_same_as<remove_pointer_t<decay_t<_From>>,
221 remove_pointer_t<decay_t<_To>>>);
223 template<
typename _Tp>
225 = !is_reference_v<_Tp> && requires(_Tp __t)
227 typename tuple_size<_Tp>::type;
228 requires derived_from<tuple_size<_Tp>, integral_constant<size_t, 2>>;
229 typename tuple_element_t<0, remove_const_t<_Tp>>;
230 typename tuple_element_t<1, remove_const_t<_Tp>>;
231 { get<0>(__t) } -> convertible_to<const tuple_element_t<0, _Tp>&>;
232 { get<1>(__t) } -> convertible_to<const tuple_element_t<1, _Tp>&>;
235 template<
typename _Tp,
typename _Up,
typename _Vp>
236 concept __pair_like_convertible_from
237 = !range<_Tp> && __pair_like<_Tp>
238 && constructible_from<_Tp, _Up, _Vp>
239 && __convertible_to_non_slicing<_Up, tuple_element_t<0, _Tp>>
240 && convertible_to<_Vp, tuple_element_t<1, _Tp>>;
242 template<
typename _Tp>
243 concept __iterator_sentinel_pair
244 = !range<_Tp> && __pair_like<_Tp>
245 && sentinel_for<tuple_element_t<1, _Tp>, tuple_element_t<0, _Tp>>;
249 enum class subrange_kind : bool { unsized, sized };
251 template<input_or_output_iterator _It, sentinel_for<_It> _Sent = _It,
252 subrange_kind _Kind = sized_sentinel_for<_Sent, _It>
253 ? subrange_kind::sized : subrange_kind::unsized>
254 requires (_Kind == subrange_kind::sized || !sized_sentinel_for<_Sent, _It>)
255 class subrange :
public view_interface<subrange<_It, _Sent, _Kind>>
259 static const bool _S_store_size
260 = _Kind == subrange_kind::sized && !sized_sentinel_for<_Sent, _It>;
262 _It _M_begin = _It();
263 _Sent _M_end = _Sent();
265 template<
typename,
bool = _S_store_size>
269 template<
typename _Tp>
270 struct _Size<_Tp, true>
271 { __detail::__make_unsigned_like_t<_Tp> _M_size; };
273 [[no_unique_address]] _Size<iter_difference_t<_It>> _M_size = {};
276 subrange() =
default;
279 subrange(__detail::__convertible_to_non_slicing<_It>
auto __i, _Sent __s)
280 requires (!_S_store_size)
281 : _M_begin(
std::
move(__i)), _M_end(__s)
285 subrange(__detail::__convertible_to_non_slicing<_It>
auto __i, _Sent __s,
286 __detail::__make_unsigned_like_t<iter_difference_t<_It>> __n)
287 requires (_Kind == subrange_kind::sized)
288 : _M_begin(
std::
move(__i)), _M_end(__s)
290 using __detail::__to_unsigned_like;
292 if constexpr (_S_store_size)
293 _M_size._M_size = __n;
296 template<__detail::__not_same_as<subrange> _Rng>
297 requires borrowed_range<_Rng>
298 && __detail::__convertible_to_non_slicing<iterator_t<_Rng>, _It>
299 && convertible_to<sentinel_t<_Rng>, _Sent>
301 subrange(_Rng&& __r) requires (!_S_store_size || sized_range<_Rng>)
304 if constexpr (_S_store_size)
305 _M_size._M_size = ranges::size(__r);
308 template<borrowed_range _Rng>
309 requires __detail::__convertible_to_non_slicing<iterator_t<_Rng>, _It>
310 && convertible_to<sentinel_t<_Rng>, _Sent>
313 __detail::__make_unsigned_like_t<iter_difference_t<_It>> __n)
314 requires (_Kind == subrange_kind::sized)
318 template<__detail::__not_same_as<subrange> _PairLike>
319 requires __detail::__pair_like_convertible_from<_PairLike,
const _It&,
322 operator _PairLike()
const
323 {
return _PairLike(_M_begin, _M_end); }
326 begin() const requires copyable<_It>
329 [[nodiscard]] constexpr _It
330 begin() requires (!copyable<_It>)
333 constexpr _Sent
end()
const {
return _M_end; }
335 constexpr
bool empty()
const {
return _M_begin == _M_end; }
337 constexpr __detail::__make_unsigned_like_t<iter_difference_t<_It>>
338 size() const requires (_Kind == subrange_kind::sized)
340 if constexpr (_S_store_size)
341 return _M_size._M_size;
343 return __detail::__to_unsigned_like(_M_end - _M_begin);
346 [[nodiscard]] constexpr subrange
347 next(iter_difference_t<_It> __n = 1) const &
348 requires forward_iterator<_It>
355 [[nodiscard]] constexpr subrange
356 next(iter_difference_t<_It> __n = 1) &&
362 [[nodiscard]] constexpr subrange
363 prev(iter_difference_t<_It> __n = 1) const
364 requires bidirectional_iterator<_It>
367 __tmp.advance(--__n);
372 advance(iter_difference_t<_It> __n)
374 if constexpr (_S_store_size)
378 _M_size._M_size -= __detail::__to_unsigned_like(__d);
380 _M_size._M_size += __detail::__to_unsigned_like(-__d);
388 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
389 subrange(_It, _Sent) -> subrange<_It, _Sent>;
391 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
393 __detail::__make_unsigned_like_t<iter_difference_t<_It>>)
394 -> subrange<_It, _Sent, subrange_kind::sized>;
396 template<__detail::__iterator_sentinel_pair _Pr>
398 -> subrange<tuple_element_t<0, _Pr>, tuple_element_t<1, _Pr>>;
400 template<__detail::__iterator_sentinel_pair _Pr>
401 subrange(_Pr, __detail::__make_unsigned_like_t<iter_difference_t<
402 tuple_element_t<0, _Pr>>>)
403 -> subrange<tuple_element_t<0, _Pr>, tuple_element_t<1, _Pr>,
404 subrange_kind::sized>;
406 template<borrowed_range _Rng>
408 -> subrange<iterator_t<_Rng>, sentinel_t<_Rng>,
410 || sized_sentinel_for<sentinel_t<_Rng>, iterator_t<_Rng>>)
411 ? subrange_kind::sized : subrange_kind::unsized>;
413 template<borrowed_range _Rng>
415 __detail::__make_unsigned_like_t<range_difference_t<_Rng>>)
416 -> subrange<iterator_t<_Rng>, sentinel_t<_Rng>, subrange_kind::sized>;
418 template<
size_t _Num,
class _It,
class _Sent, subrange_kind _Kind>
421 get(const subrange<_It, _Sent, _Kind>& __r)
423 if constexpr (_Num == 0)
429 template<
size_t _Num, class _It, class _Sent, subrange_kind _Kind>
432 get(subrange<_It, _Sent, _Kind>&& __r)
434 if constexpr (_Num == 0)
440 template<input_or_output_iterator _It, sentinel_for<_It> _Sent,
442 inline constexpr
bool
443 enable_borrowed_range<subrange<_It, _Sent, _Kind>> = true;
454 constexpr dangling() noexcept = default;
455 template<typename... _Args>
456 constexpr dangling(_Args&&...) noexcept { }
459 template<range _Range>
460 using borrowed_iterator_t = conditional_t<borrowed_range<_Range>,
464 template<range _Range>
465 using borrowed_subrange_t = conditional_t<borrowed_range<_Range>,
466 subrange<iterator_t<_Range>>,
469 template<
typename _Tp> requires is_object_v<_Tp>
471 :
public view_interface<empty_view<_Tp>>
474 static constexpr _Tp*
begin() noexcept {
return nullptr; }
475 static constexpr _Tp*
end() noexcept {
return nullptr; }
476 static constexpr _Tp* data() noexcept {
return nullptr; }
477 static constexpr
size_t size() noexcept {
return 0; }
478 static constexpr
bool empty() noexcept {
return true; }
481 template<
typename _Tp>
482 inline constexpr
bool enable_borrowed_range<empty_view<_Tp>> =
true;
486 template<copy_constructible _Tp> requires is_object_v<_Tp>
487 struct __box : std::optional<_Tp>
489 using std::optional<_Tp>::optional;
493 noexcept(is_nothrow_default_constructible_v<_Tp>)
494 requires default_initializable<_Tp>
498 __box(
const __box&) =
default;
499 __box(__box&&) =
default;
501 using std::optional<_Tp>::operator=;
504 operator=(
const __box& __that)
505 noexcept(is_nothrow_copy_constructible_v<_Tp>)
506 requires (!assignable_from<_Tp&, const _Tp&>)
509 this->emplace(*__that);
516 operator=(__box&& __that)
517 noexcept(is_nothrow_move_constructible_v<_Tp>)
518 requires (!assignable_from<_Tp&, _Tp>)
531 template<copy_constructible _Tp> requires is_object_v<_Tp>
532 class single_view :
public view_interface<single_view<_Tp>>
535 single_view() =
default;
538 single_view(
const _Tp& __t)
543 single_view(_Tp&& __t)
547 template<
typename... _Args>
548 requires constructible_from<_Tp, _Args...>
550 single_view(in_place_t, _Args&&... __args)
551 : _M_value{
in_place, std::forward<_Args>(__args)...}
559 begin() const noexcept
564 {
return data() + 1; }
568 {
return data() + 1; }
570 static constexpr
size_t
576 {
return _M_value.operator->(); }
579 data() const noexcept
580 {
return _M_value.operator->(); }
583 __detail::__box<_Tp> _M_value;
588 template<
typename _Wp>
589 constexpr
auto __to_signed_like(_Wp __w) noexcept
591 if constexpr (!integral<_Wp>)
592 return iter_difference_t<_Wp>();
593 else if constexpr (
sizeof(iter_difference_t<_Wp>) >
sizeof(_Wp))
594 return iter_difference_t<_Wp>(__w);
595 else if constexpr (
sizeof(ptrdiff_t) >
sizeof(_Wp))
596 return ptrdiff_t(__w);
597 else if constexpr (
sizeof(
long long) >
sizeof(_Wp))
598 return (
long long)(__w);
599 #ifdef __SIZEOF_INT128__
600 else if constexpr (__SIZEOF_INT128__ >
sizeof(_Wp))
601 return __int128(__w);
604 return __max_diff_type(__w);
607 template<
typename _Wp>
608 using __iota_diff_t = decltype(__to_signed_like(std::declval<_Wp>()));
610 template<
typename _It>
611 concept __decrementable = incrementable<_It>
614 { --__i } -> same_as<_It&>;
615 { __i-- } -> same_as<_It>;
618 template<
typename _It>
619 concept __advanceable = __decrementable<_It> && totally_ordered<_It>
620 && requires( _It __i,
const _It __j,
const __iota_diff_t<_It> __n)
622 { __i += __n } -> same_as<_It&>;
623 { __i -= __n } -> same_as<_It&>;
627 { __j - __j } -> convertible_to<__iota_diff_t<_It>>;
632 template<weakly_incrementable _Winc,
633 semiregular _Bound = unreachable_sentinel_t>
634 requires std::__detail::__weakly_eq_cmp_with<_Winc, _Bound>
635 class iota_view :
public view_interface<iota_view<_Winc, _Bound>>
646 using namespace __detail;
647 if constexpr (__advanceable<_Winc>)
648 return random_access_iterator_tag{};
649 else if constexpr (__decrementable<_Winc>)
650 return bidirectional_iterator_tag{};
651 else if constexpr (incrementable<_Winc>)
652 return forward_iterator_tag{};
654 return input_iterator_tag{};
658 using iterator_category = decltype(_S_iter_cat());
659 using value_type = _Winc;
660 using difference_type = __detail::__iota_diff_t<_Winc>;
662 _Iterator() =
default;
665 _Iterator(_Winc __value)
666 : _M_value(__value) { }
669 operator*() const noexcept(is_nothrow_copy_constructible_v<_Winc>)
684 operator++(
int) requires incrementable<_Winc>
692 operator--() requires __detail::__decrementable<_Winc>
699 operator--(
int) requires __detail::__decrementable<_Winc>
707 operator+=(difference_type __n) requires __detail::__advanceable<_Winc>
709 using __detail::__is_integer_like;
710 using __detail::__is_signed_integer_like;
711 if constexpr (__is_integer_like<_Winc>
712 && !__is_signed_integer_like<_Winc>)
714 if (__n >= difference_type(0))
715 _M_value += static_cast<_Winc>(__n);
717 _M_value -= static_cast<_Winc>(-__n);
725 operator-=(difference_type __n) requires __detail::__advanceable<_Winc>
727 using __detail::__is_integer_like;
728 using __detail::__is_signed_integer_like;
729 if constexpr (__is_integer_like<_Winc>
730 && !__is_signed_integer_like<_Winc>)
732 if (__n >= difference_type(0))
733 _M_value -= static_cast<_Winc>(__n);
735 _M_value += static_cast<_Winc>(-__n);
743 operator[](difference_type __n)
const
744 requires __detail::__advanceable<_Winc>
745 {
return _Winc(_M_value + __n); }
747 friend constexpr
bool
748 operator==(
const _Iterator& __x,
const _Iterator& __y)
749 requires equality_comparable<_Winc>
750 {
return __x._M_value == __y._M_value; }
752 friend constexpr
bool
753 operator<(
const _Iterator& __x,
const _Iterator& __y)
754 requires totally_ordered<_Winc>
755 {
return __x._M_value < __y._M_value; }
757 friend constexpr
bool
758 operator>(
const _Iterator& __x,
const _Iterator& __y)
759 requires totally_ordered<_Winc>
760 {
return __y < __x; }
762 friend constexpr
bool
763 operator<=(
const _Iterator& __x,
const _Iterator& __y)
764 requires totally_ordered<_Winc>
765 {
return !(__y < __x); }
767 friend constexpr
bool
768 operator>=(
const _Iterator& __x,
const _Iterator& __y)
769 requires totally_ordered<_Winc>
770 {
return !(__x < __y); }
772 #ifdef __cpp_lib_three_way_comparison
773 friend constexpr
auto
774 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
775 requires totally_ordered<_Winc> && three_way_comparable<_Winc>
776 {
return __x._M_value <=> __y._M_value; }
779 friend constexpr _Iterator
780 operator+(_Iterator __i, difference_type __n)
781 requires __detail::__advanceable<_Winc>
782 {
return __i += __n; }
784 friend constexpr _Iterator
785 operator+(difference_type __n, _Iterator __i)
786 requires __detail::__advanceable<_Winc>
787 {
return __i += __n; }
789 friend constexpr _Iterator
790 operator-(_Iterator __i, difference_type __n)
791 requires __detail::__advanceable<_Winc>
792 {
return __i -= __n; }
794 friend constexpr difference_type
795 operator-(
const _Iterator& __x,
const _Iterator& __y)
796 requires __detail::__advanceable<_Winc>
798 using __detail::__is_integer_like;
799 using __detail::__is_signed_integer_like;
800 using _Dt = difference_type;
801 if constexpr (__is_integer_like<_Winc>)
803 if constexpr (__is_signed_integer_like<_Winc>)
804 return _Dt(_Dt(__x._M_value) - _Dt(__y._M_value));
806 return (__y._M_value > __x._M_value)
807 ? _Dt(-_Dt(__y._M_value - __x._M_value))
808 : _Dt(__x._M_value - __y._M_value);
811 return __x._M_value - __y._M_value;
815 _Winc _M_value = _Winc();
824 _M_equal(
const _Iterator& __x)
const
825 {
return __x._M_value == _M_bound; }
827 _Bound _M_bound = _Bound();
830 _Sentinel() =
default;
833 _Sentinel(_Bound __bound)
834 : _M_bound(__bound) { }
836 friend constexpr
bool
837 operator==(
const _Iterator& __x,
const _Sentinel& __y)
838 {
return __y._M_equal(__x); }
840 friend constexpr iter_difference_t<_Winc>
841 operator-(
const _Iterator& __x,
const _Sentinel& __y)
842 requires sized_sentinel_for<_Bound, _Winc>
843 {
return __x._M_value - __y._M_bound; }
845 friend constexpr iter_difference_t<_Winc>
846 operator-(
const _Sentinel& __x,
const _Iterator& __y)
847 requires sized_sentinel_for<_Bound, _Winc>
848 {
return -(__y - __x); }
851 _Winc _M_value = _Winc();
852 _Bound _M_bound = _Bound();
855 iota_view() =
default;
858 iota_view(_Winc __value)
863 iota_view(type_identity_t<_Winc> __value,
864 type_identity_t<_Bound> __bound)
865 : _M_value(__value), _M_bound(__bound)
867 if constexpr (totally_ordered_with<_Winc, _Bound>)
869 __glibcxx_assert(
bool(__value <= __bound) );
874 begin()
const {
return _Iterator{_M_value}; }
879 if constexpr (same_as<_Bound, unreachable_sentinel_t>)
880 return unreachable_sentinel;
882 return _Sentinel{_M_bound};
886 end() const requires same_as<_Winc, _Bound>
887 {
return _Iterator{_M_bound}; }
891 requires (same_as<_Winc, _Bound> && __detail::__advanceable<_Winc>)
892 || (integral<_Winc> && integral<_Bound>)
893 || sized_sentinel_for<_Bound, _Winc>
895 using __detail::__is_integer_like;
896 using __detail::__to_unsigned_like;
897 if constexpr (__is_integer_like<_Winc> && __is_integer_like<_Bound>)
898 return (_M_value < 0)
900 ? __to_unsigned_like(-_M_value) - __to_unsigned_like(-_M_bound)
901 : __to_unsigned_like(_M_bound) + __to_unsigned_like(-_M_value))
902 : __to_unsigned_like(_M_bound) - __to_unsigned_like(_M_value);
904 return __to_unsigned_like(_M_bound - _M_value);
908 template<
typename _Winc,
typename _Bound>
909 requires (!__detail::__is_integer_like<_Winc>
910 || !__detail::__is_integer_like<_Bound>
911 || (__detail::__is_signed_integer_like<_Winc>
912 == __detail::__is_signed_integer_like<_Bound>))
913 iota_view(_Winc, _Bound) -> iota_view<_Winc, _Bound>;
915 template<weakly_incrementable _Winc, semiregular _Bound>
916 inline constexpr
bool
917 enable_borrowed_range<iota_view<_Winc, _Bound>> =
true;
921 template<
typename _Tp>
922 inline constexpr empty_view<_Tp> empty{};
926 template<
typename _Tp>
928 operator()(_Tp&& __e)
const
929 {
return single_view{std::forward<_Tp>(__e)}; }
932 inline constexpr _Single single{};
936 template<
typename _Tp>
938 operator()(_Tp&& __e)
const
939 {
return iota_view{std::forward<_Tp>(__e)}; }
941 template<
typename _Tp,
typename _Up>
943 operator()(_Tp&& __e, _Up&& __f)
const
944 {
return iota_view{std::forward<_Tp>(__e), std::forward<_Up>(__f)}; }
947 inline constexpr _Iota
iota{};
952 template<
typename _Val,
typename _CharT,
typename _Traits>
953 concept __stream_extractable
954 = requires(basic_istream<_CharT, _Traits>& is, _Val& t) { is >> t; };
957 template<movable _Val,
typename _CharT,
typename _Traits>
958 requires default_initializable<_Val>
959 && __detail::__stream_extractable<_Val, _CharT, _Traits>
960 class basic_istream_view
961 :
public view_interface<basic_istream_view<_Val, _CharT, _Traits>>
964 basic_istream_view() =
default;
967 basic_istream_view(basic_istream<_CharT, _Traits>& __stream)
974 if (_M_stream !=
nullptr)
975 *_M_stream >> _M_object;
976 return _Iterator{*
this};
979 constexpr default_sentinel_t
981 {
return default_sentinel; }
984 basic_istream<_CharT, _Traits>* _M_stream =
nullptr;
985 _Val _M_object = _Val();
990 using iterator_category = input_iterator_tag;
991 using difference_type = ptrdiff_t;
992 using value_type = _Val;
994 _Iterator() =
default;
997 _Iterator(basic_istream_view& __parent) noexcept
1001 _Iterator(
const _Iterator&) =
delete;
1002 _Iterator(_Iterator&&) =
default;
1003 _Iterator& operator=(
const _Iterator&) =
delete;
1004 _Iterator& operator=(_Iterator&&) =
default;
1009 __glibcxx_assert(_M_parent->_M_stream !=
nullptr);
1010 *_M_parent->_M_stream >> _M_parent->_M_object;
1021 __glibcxx_assert(_M_parent->_M_stream !=
nullptr);
1022 return _M_parent->_M_object;
1026 operator==(
const _Iterator& __x, default_sentinel_t)
1027 {
return __x._M_at_end(); }
1030 basic_istream_view* _M_parent =
nullptr;
1034 {
return _M_parent ==
nullptr || !*_M_parent->_M_stream; }
1040 template<
typename _Val,
typename _CharT,
typename _Traits>
1041 basic_istream_view<_Val, _CharT, _Traits>
1042 istream_view(basic_istream<_CharT, _Traits>& __s)
1043 {
return basic_istream_view<_Val, _CharT, _Traits>{__s}; }
1054 template<
typename _Tp>
1055 inline constexpr
auto
1056 __maybe_refwrap(_Tp& __arg)
1057 {
return reference_wrapper<_Tp>{__arg}; }
1059 template<
typename _Tp>
1060 inline constexpr
auto
1061 __maybe_refwrap(
const _Tp& __arg)
1062 {
return reference_wrapper<const _Tp>{__arg}; }
1064 template<
typename _Tp>
1065 inline constexpr decltype(
auto)
1066 __maybe_refwrap(_Tp&& __arg)
1067 {
return std::forward<_Tp>(__arg); }
1069 template<
typename _Callable>
1070 struct _RangeAdaptorClosure;
1072 template<
typename _Callable>
1073 struct _RangeAdaptor
1076 [[no_unique_address]]
1077 conditional_t<!is_default_constructible_v<_Callable>,
1078 _Callable, __detail::_Empty> _M_callable;
1082 _RangeAdaptor(
const _Callable& = {})
1083 requires is_default_constructible_v<_Callable>
1087 _RangeAdaptor(_Callable __callable)
1088 requires (!is_default_constructible_v<_Callable>)
1089 : _M_callable(
std::
move(__callable))
1092 template<
typename... _Args>
1093 requires (
sizeof...(_Args) >= 1)
1095 operator()(_Args&&... __args)
const
1108 if constexpr (is_invocable_v<_Callable, _Args...>)
1110 static_assert(
sizeof...(_Args) != 1,
1111 "a _RangeAdaptor that accepts only one argument "
1112 "should be defined as a _RangeAdaptorClosure");
1115 return _Callable{}(std::forward<_Args>(__args)...);
1128 = [...__args(__maybe_refwrap(std::forward<_Args>(__args)))]
1129 <
typename _Range> (_Range&& __r) {
1133 return _Callable{}(std::forward<_Range>(__r),
1134 (
static_cast<unwrap_reference_t
1138 using _ClosureType = decltype(__closure);
1139 return _RangeAdaptorClosure<_ClosureType>(
std::move(__closure));
1144 template<
typename _Callable>
1145 _RangeAdaptor(_Callable) -> _RangeAdaptor<_Callable>;
1147 template<
typename _Callable>
1148 struct _RangeAdaptorClosure :
public _RangeAdaptor<_Callable>
1150 using _RangeAdaptor<_Callable>::_RangeAdaptor;
1152 template<viewable_range _Range>
1153 requires requires { declval<_Callable>()(declval<_Range>()); }
1155 operator()(_Range&& __r)
const
1157 if constexpr (is_default_constructible_v<_Callable>)
1158 return _Callable{}(std::forward<_Range>(__r));
1160 return this->_M_callable(std::forward<_Range>(__r));
1163 template<viewable_range _Range>
1164 requires requires { declval<_Callable>()(declval<_Range>()); }
1165 friend constexpr
auto
1166 operator|(_Range&& __r,
const _RangeAdaptorClosure& __o)
1167 {
return __o(std::forward<_Range>(__r)); }
1169 template<
typename _Tp>
1170 friend constexpr
auto
1171 operator|(
const _RangeAdaptorClosure<_Tp>& __x,
1172 const _RangeAdaptorClosure& __y)
1174 if constexpr (is_default_constructible_v<_Tp>
1175 && is_default_constructible_v<_Callable>)
1177 auto __closure = [] <
typename _Up> (_Up&& __e) {
1178 return std::forward<_Up>(__e) | decltype(__x){} | decltype(__y){};
1180 return _RangeAdaptorClosure<decltype(__closure)>(__closure);
1182 else if constexpr (is_default_constructible_v<_Tp>
1183 && !is_default_constructible_v<_Callable>)
1185 auto __closure = [__y] <
typename _Up> (_Up&& __e) {
1186 return std::forward<_Up>(__e) | decltype(__x){} | __y;
1188 return _RangeAdaptorClosure<decltype(__closure)>(__closure);
1190 else if constexpr (!is_default_constructible_v<_Tp>
1191 && is_default_constructible_v<_Callable>)
1193 auto __closure = [__x] <
typename _Up> (_Up&& __e) {
1194 return std::forward<_Up>(__e) | __x | decltype(__y){};
1196 return _RangeAdaptorClosure<decltype(__closure)>(__closure);
1200 auto __closure = [__x, __y] <
typename _Up> (_Up&& __e) {
1201 return std::forward<_Up>(__e) | __x | __y;
1203 return _RangeAdaptorClosure<decltype(__closure)>(__closure);
1208 template<
typename _Callable>
1209 _RangeAdaptorClosure(_Callable) -> _RangeAdaptorClosure<_Callable>;
1213 template<range _Range> requires is_object_v<_Range>
1214 class ref_view :
public view_interface<ref_view<_Range>>
1217 _Range* _M_r =
nullptr;
1219 static void _S_fun(_Range&);
1220 static void _S_fun(_Range&&) =
delete;
1224 ref_view() noexcept = default;
1226 template<__detail::__not_same_as<ref_view> _Tp>
1227 requires convertible_to<_Tp, _Range&>
1228 && requires { _S_fun(declval<_Tp>()); }
1238 constexpr iterator_t<_Range>
1242 constexpr sentinel_t<_Range>
1247 empty() const requires requires { ranges::empty(*_M_r); }
1248 {
return ranges::empty(*_M_r); }
1251 size() const requires sized_range<_Range>
1252 {
return ranges::size(*_M_r); }
1255 data() const requires contiguous_range<_Range>
1256 {
return ranges::data(*_M_r); }
1259 template<
typename _Range>
1260 ref_view(_Range&) -> ref_view<_Range>;
1262 template<
typename _Tp>
1263 inline constexpr
bool enable_borrowed_range<ref_view<_Tp>> =
true;
1267 inline constexpr __adaptor::_RangeAdaptorClosure all
1268 = [] <viewable_range _Range> (_Range&& __r)
1270 if constexpr (view<decay_t<_Range>>)
1272 else if constexpr (requires { ref_view{std::forward<_Range>(__r)}; })
1273 return ref_view{std::forward<_Range>(__r)};
1275 return subrange{std::forward<_Range>(__r)};
1278 template<viewable_range _Range>
1279 using all_t = decltype(all(std::declval<_Range>()));
1287 template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
1288 typename _Proj =
identity,
1289 indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
1291 find_if(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {})
1293 while (__first != __last
1299 template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
1300 typename _Proj =
identity,
1301 indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
1303 find_if_not(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {})
1305 while (__first != __last
1311 template<
typename _Tp,
typename _Proj = identity,
1312 indirect_strict_weak_order<projected<const _Tp*, _Proj>>
1313 _Comp = ranges::less>
1314 constexpr
const _Tp&
1315 min(
const _Tp& __a,
const _Tp& __b, _Comp __comp = {}, _Proj __proj = {})
1325 template<input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
1326 input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
1327 typename _Pred = ranges::equal_to,
1328 typename _Proj1 =
identity,
typename _Proj2 =
identity>
1329 requires indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
1330 constexpr pair<_Iter1, _Iter2>
1331 mismatch(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2,
1332 _Pred __pred = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {})
1334 while (__first1 != __last1 && __first2 != __last2
1346 template<input_range _Vp,
1347 indirect_unary_predicate<iterator_t<_Vp>> _Pred>
1348 requires view<_Vp> && is_object_v<_Pred>
1349 class filter_view :
public view_interface<filter_view<_Vp, _Pred>>
1357 static constexpr
auto
1360 if constexpr (bidirectional_range<_Vp>)
1361 return bidirectional_iterator_tag{};
1362 else if constexpr (forward_range<_Vp>)
1363 return forward_iterator_tag{};
1365 return input_iterator_tag{};
1368 static constexpr
auto
1371 using _Cat =
typename iterator_traits<_Vp_iter>::iterator_category;
1372 if constexpr (derived_from<_Cat, bidirectional_iterator_tag>)
1373 return bidirectional_iterator_tag{};
1374 else if constexpr (derived_from<_Cat, forward_iterator_tag>)
1375 return forward_iterator_tag{};
1382 using _Vp_iter = iterator_t<_Vp>;
1384 _Vp_iter _M_current = _Vp_iter();
1385 filter_view* _M_parent =
nullptr;
1388 using iterator_concept = decltype(_S_iter_concept());
1389 using iterator_category = decltype(_S_iter_cat());
1390 using value_type = range_value_t<_Vp>;
1391 using difference_type = range_difference_t<_Vp>;
1393 _Iterator() =
default;
1396 _Iterator(filter_view& __parent, _Vp_iter __current)
1397 : _M_current(
std::
move(__current)),
1403 requires copyable<_Vp_iter>
1404 {
return _M_current; }
1410 constexpr range_reference_t<_Vp>
1412 {
return *_M_current; }
1416 requires __detail::__has_arrow<_Vp_iter>
1417 && copyable<_Vp_iter>
1418 {
return _M_current; }
1420 constexpr _Iterator&
1423 _M_current = __detail::find_if(
std::move(++_M_current),
1425 std::ref(*_M_parent->_M_pred));
1434 operator++(
int) requires forward_range<_Vp>
1441 constexpr _Iterator&
1442 operator--() requires bidirectional_range<_Vp>
1451 operator--(
int) requires bidirectional_range<_Vp>
1458 friend constexpr
bool
1459 operator==(
const _Iterator& __x,
const _Iterator& __y)
1460 requires equality_comparable<_Vp_iter>
1461 {
return __x._M_current == __y._M_current; }
1463 friend constexpr range_rvalue_reference_t<_Vp>
1464 iter_move(
const _Iterator& __i)
1465 noexcept(noexcept(ranges::iter_move(__i._M_current)))
1466 {
return ranges::iter_move(__i._M_current); }
1468 friend constexpr
void
1469 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
1470 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1471 requires indirectly_swappable<_Vp_iter>
1472 { ranges::iter_swap(__x._M_current, __y._M_current); }
1478 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
1481 __equal(
const _Iterator& __i)
const
1482 {
return __i._M_current == _M_end; }
1485 _Sentinel() =
default;
1488 _Sentinel(filter_view& __parent)
1489 : _M_end(ranges::
end(__parent._M_base))
1492 constexpr sentinel_t<_Vp>
1496 friend constexpr
bool
1497 operator==(
const _Iterator& __x,
const _Sentinel& __y)
1498 {
return __y.__equal(__x); }
1501 _Vp _M_base = _Vp();
1502 __detail::__box<_Pred> _M_pred;
1505 filter_view() =
default;
1508 filter_view(_Vp
__base, _Pred __pred)
1513 base() const& requires copy_constructible<_Vp>
1520 constexpr
const _Pred&
1522 {
return *_M_pred; }
1528 __glibcxx_assert(_M_pred.has_value());
1531 std::ref(*_M_pred))};
1537 if constexpr (common_range<_Vp>)
1540 return _Sentinel{*
this};
1544 template<
typename _Range,
typename _Pred>
1545 filter_view(_Range&&, _Pred) -> filter_view<views::all_t<_Range>, _Pred>;
1549 inline constexpr __adaptor::_RangeAdaptor filter
1550 = [] <viewable_range _Range,
typename _Pred> (_Range&& __r, _Pred&& __p)
1552 return filter_view{std::forward<_Range>(__r), std::forward<_Pred>(__p)};
1556 template<input_range _Vp, copy_constructible _Fp>
1557 requires view<_Vp> && is_object_v<_Fp>
1558 && regular_invocable<_Fp&, range_reference_t<_Vp>>
1559 class transform_view :
public view_interface<transform_view<_Vp, _Fp>>
1562 template<
bool _Const>
1565 template<
bool _Const>
1570 = conditional_t<_Const, const transform_view, transform_view>;
1571 using _Base = conditional_t<_Const, const _Vp, _Vp>;
1573 static constexpr
auto
1576 if constexpr (random_access_range<_Vp>)
1577 return random_access_iterator_tag{};
1578 else if constexpr (bidirectional_range<_Vp>)
1579 return bidirectional_iterator_tag{};
1580 else if constexpr (forward_range<_Vp>)
1581 return forward_iterator_tag{};
1583 return input_iterator_tag{};
1586 static constexpr
auto
1590 =
typename iterator_traits<_Base_iter>::iterator_category;
1591 if constexpr (derived_from<_Cat, contiguous_iterator_tag>)
1592 return random_access_iterator_tag{};
1597 static constexpr decltype(
auto)
1598 __iter_move(const _Iterator& __i = {})
1602 if constexpr (is_lvalue_reference_v<decltype(*__i)>)
1608 using _Base_iter = iterator_t<_Base>;
1610 _Base_iter _M_current = _Base_iter();
1611 _Parent* _M_parent =
nullptr;
1614 using iterator_concept = decltype(_S_iter_concept());
1615 using iterator_category = decltype(_S_iter_cat());
1617 = remove_cvref_t<invoke_result_t<_Fp&, range_reference_t<_Base>>>;
1618 using difference_type = range_difference_t<_Base>;
1620 _Iterator() = default;
1623 _Iterator(_Parent& __parent, _Base_iter __current)
1624 : _M_current(
std::
move(__current)),
1629 _Iterator(_Iterator<!_Const> __i)
1631 && convertible_to<iterator_t<_Vp>, _Base_iter>
1632 : _M_current(
std::move(__i._M_current)), _M_parent(__i._M_parent)
1635 constexpr _Base_iter
1637 requires copyable<_Base_iter>
1638 {
return _M_current; }
1640 constexpr _Base_iter
1644 constexpr decltype(
auto)
1648 constexpr _Iterator&
1660 operator++(
int) requires forward_range<_Base>
1667 constexpr _Iterator&
1668 operator--() requires bidirectional_range<_Base>
1675 operator--(
int) requires bidirectional_range<_Base>
1682 constexpr _Iterator&
1683 operator+=(difference_type __n) requires random_access_range<_Base>
1689 constexpr _Iterator&
1690 operator-=(difference_type __n) requires random_access_range<_Base>
1696 constexpr decltype(
auto)
1697 operator[](difference_type __n) const
1698 requires random_access_range<_Base>
1699 {
return std::__invoke(*_M_parent->_M_fun, _M_current[__n]); }
1701 friend constexpr
bool
1702 operator==(
const _Iterator& __x,
const _Iterator& __y)
1703 requires equality_comparable<_Base_iter>
1704 {
return __x._M_current == __y._M_current; }
1706 friend constexpr
bool
1707 operator<(
const _Iterator& __x,
const _Iterator& __y)
1708 requires random_access_range<_Base>
1709 {
return __x._M_current < __y._M_current; }
1711 friend constexpr
bool
1712 operator>(
const _Iterator& __x,
const _Iterator& __y)
1713 requires random_access_range<_Base>
1714 {
return __y < __x; }
1716 friend constexpr
bool
1717 operator<=(
const _Iterator& __x,
const _Iterator& __y)
1718 requires random_access_range<_Base>
1719 {
return !(__y < __x); }
1721 friend constexpr
bool
1722 operator>=(
const _Iterator& __x,
const _Iterator& __y)
1723 requires random_access_range<_Base>
1724 {
return !(__x < __y); }
1726 #ifdef __cpp_lib_three_way_comparison
1727 friend constexpr
auto
1728 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
1729 requires random_access_range<_Base>
1730 && three_way_comparable<_Base_iter>
1731 {
return __x._M_current <=> __y._M_current; }
1734 friend constexpr _Iterator
1735 operator+(_Iterator __i, difference_type __n)
1736 requires random_access_range<_Base>
1737 {
return {*__i._M_parent, __i._M_current + __n}; }
1739 friend constexpr _Iterator
1740 operator+(difference_type __n, _Iterator __i)
1741 requires random_access_range<_Base>
1742 {
return {*__i._M_parent, __i._M_current + __n}; }
1744 friend constexpr _Iterator
1745 operator-(_Iterator __i, difference_type __n)
1746 requires random_access_range<_Base>
1747 {
return {*__i._M_parent, __i._M_current - __n}; }
1749 friend constexpr difference_type
1750 operator-(
const _Iterator& __x,
const _Iterator& __y)
1751 requires random_access_range<_Base>
1752 {
return __x._M_current - __y._M_current; }
1754 friend constexpr decltype(
auto)
1755 iter_move(const _Iterator& __i) noexcept(noexcept(__iter_move()))
1756 {
return __iter_move(__i); }
1758 friend constexpr
void
1759 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
1760 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1761 requires indirectly_swappable<_Base_iter>
1762 {
return ranges::iter_swap(__x._M_current, __y._M_current); }
1764 friend _Sentinel<_Const>;
1767 template<
bool _Const>
1772 = conditional_t<_Const, const transform_view, transform_view>;
1773 using _Base = conditional_t<_Const, const _Vp, _Vp>;
1775 constexpr range_difference_t<_Base>
1776 __distance_from(
const _Iterator<_Const>& __i)
const
1777 {
return _M_end - __i._M_current; }
1780 __equal(
const _Iterator<_Const>& __i)
const
1781 {
return __i._M_current == _M_end; }
1783 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
1786 _Sentinel() =
default;
1789 _Sentinel(sentinel_t<_Base> __end)
1794 _Sentinel(_Sentinel<!_Const> __i)
1796 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
1800 constexpr sentinel_t<_Base>
1804 friend constexpr
bool
1805 operator==(
const _Iterator<_Const>& __x,
const _Sentinel& __y)
1806 {
return __y.__equal(__x); }
1808 friend constexpr range_difference_t<_Base>
1809 operator-(
const _Iterator<_Const>& __x,
const _Sentinel& __y)
1810 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
1811 {
return -__y.__distance_from(__x); }
1813 friend constexpr range_difference_t<_Base>
1814 operator-(
const _Sentinel& __y,
const _Iterator<_Const>& __x)
1815 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
1816 {
return __y.__distance_from(__x); }
1819 _Vp _M_base = _Vp();
1820 __detail::__box<_Fp> _M_fun;
1823 transform_view() =
default;
1826 transform_view(_Vp
__base, _Fp __fun)
1831 base() const& requires copy_constructible<_Vp>
1832 {
return _M_base ; }
1838 constexpr _Iterator<false>
1842 constexpr _Iterator<true>
1844 requires range<const _Vp>
1845 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
1848 constexpr _Sentinel<false>
1850 {
return _Sentinel<false>{
ranges::end(_M_base)}; }
1852 constexpr _Iterator<false>
1853 end() requires common_range<_Vp>
1854 {
return _Iterator<false>{*
this,
ranges::end(_M_base)}; }
1856 constexpr _Sentinel<true>
1858 requires range<const _Vp>
1859 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
1862 constexpr _Iterator<true>
1864 requires common_range<const _Vp>
1865 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
1866 {
return _Iterator<true>{*
this,
ranges::end(_M_base)}; }
1869 size() requires sized_range<_Vp>
1870 {
return ranges::size(_M_base); }
1873 size() const requires sized_range<const _Vp>
1874 {
return ranges::size(_M_base); }
1877 template<
typename _Range,
typename _Fp>
1878 transform_view(_Range&&, _Fp) -> transform_view<views::all_t<_Range>, _Fp>;
1882 inline constexpr __adaptor::_RangeAdaptor transform
1883 = [] <viewable_range _Range,
typename _Fp> (_Range&& __r, _Fp&& __f)
1885 return transform_view{std::forward<_Range>(__r), std::forward<_Fp>(__f)};
1890 class take_view :
public view_interface<take_view<_Vp>>
1893 template<
bool _Const>
1897 using _Base = conditional_t<_Const, const _Vp, _Vp>;
1898 using _CI = counted_iterator<iterator_t<_Base>>;
1900 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
1903 _Sentinel() =
default;
1906 _Sentinel(sentinel_t<_Base> __end)
1911 _Sentinel(_Sentinel<!_Const> __s)
1912 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
1916 constexpr sentinel_t<_Base>
1920 friend constexpr
bool operator==(
const _CI& __y,
const _Sentinel& __x)
1921 {
return __y.count() == 0 || __y.base() == __x._M_end; }
1924 _Vp _M_base = _Vp();
1925 range_difference_t<_Vp> _M_count = 0;
1928 take_view() =
default;
1931 take_view(_Vp base, range_difference_t<_Vp> __count)
1936 base() const& requires copy_constructible<_Vp>
1944 begin() requires (!__detail::__simple_view<_Vp>)
1946 if constexpr (sized_range<_Vp>)
1948 if constexpr (random_access_range<_Vp>)
1958 begin() const requires range<const _Vp>
1960 if constexpr (sized_range<const _Vp>)
1962 if constexpr (random_access_range<const _Vp>)
1972 end() requires (!__detail::__simple_view<_Vp>)
1974 if constexpr (sized_range<_Vp>)
1976 if constexpr (random_access_range<_Vp>)
1979 return default_sentinel;
1986 end() const requires range<const _Vp>
1988 if constexpr (sized_range<const _Vp>)
1990 if constexpr (random_access_range<const _Vp>)
1993 return default_sentinel;
2000 size() requires sized_range<_Vp>
2002 auto __n = ranges::size(_M_base);
2003 return __detail::min(__n,
static_cast<decltype(__n)
>(_M_count));
2007 size() const requires sized_range<const _Vp>
2009 auto __n = ranges::size(_M_base);
2010 return __detail::min(__n,
static_cast<decltype(__n)
>(_M_count));
2014 template<range _Range>
2015 take_view(_Range&&, range_difference_t<_Range>)
2016 -> take_view<views::all_t<_Range>>;
2020 inline constexpr __adaptor::_RangeAdaptor take
2021 = [] <viewable_range _Range,
typename _Tp> (_Range&& __r, _Tp&& __n)
2023 return take_view{std::forward<_Range>(__r), std::forward<_Tp>(__n)};
2027 template<view _Vp,
typename _Pred>
2028 requires input_range<_Vp> && is_object_v<_Pred>
2029 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2030 class take_while_view :
public view_interface<take_while_view<_Vp, _Pred>>
2032 template<
bool _Const>
2036 using _Base = conditional_t<_Const, const _Vp, _Vp>;
2038 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2039 const _Pred* _M_pred =
nullptr;
2042 _Sentinel() =
default;
2045 _Sentinel(sentinel_t<_Base> __end,
const _Pred* __pred)
2046 : _M_end(__end), _M_pred(__pred)
2050 _Sentinel(_Sentinel<!_Const> __s)
2051 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2052 : _M_end(__s._M_end), _M_pred(__s._M_pred)
2055 constexpr sentinel_t<_Base>
2056 base()
const {
return _M_end; }
2058 friend constexpr
bool
2059 operator==(
const iterator_t<_Base>& __x,
const _Sentinel& __y)
2060 {
return __y._M_end == __x || !
std::__invoke(*__y._M_pred, *__x); }
2063 _Vp _M_base = _Vp();
2064 __detail::__box<_Pred> _M_pred;
2067 take_while_view() =
default;
2070 take_while_view(_Vp base, _Pred __pred)
2076 base() const& requires copy_constructible<_Vp>
2083 constexpr
const _Pred&
2085 {
return *_M_pred; }
2088 begin() requires (!__detail::__simple_view<_Vp>)
2092 begin() const requires range<const _Vp>
2096 end() requires (!__detail::__simple_view<_Vp>)
2101 end() const requires range<const _Vp>
2106 template<
typename _Range,
typename _Pred>
2107 take_while_view(_Range&&, _Pred)
2108 -> take_while_view<views::all_t<_Range>, _Pred>;
2112 inline constexpr __adaptor::_RangeAdaptor take_while
2113 = [] <viewable_range _Range,
typename _Pred> (_Range&& __r, _Pred&& __p)
2115 return take_while_view{std::forward<_Range>(__r), std::forward<_Pred>(__p)};
2120 class drop_view :
public view_interface<drop_view<_Vp>>
2123 _Vp _M_base = _Vp();
2124 range_difference_t<_Vp> _M_count = 0;
2127 drop_view() =
default;
2130 drop_view(_Vp
__base, range_difference_t<_Vp> __count)
2132 { __glibcxx_assert(__count >= 0); }
2135 base() const& requires copy_constructible<_Vp>
2143 begin() requires (!(__detail::__simple_view<_Vp>
2144 && random_access_range<_Vp>))
2152 begin() const requires random_access_range<const _Vp>
2159 end() requires (!__detail::__simple_view<_Vp>)
2163 end() const requires range<const _Vp>
2167 size() requires sized_range<_Vp>
2169 const auto __s = ranges::size(_M_base);
2170 const auto __c = static_cast<decltype(__s)>(_M_count);
2171 return __s < __c ? 0 : __s - __c;
2175 size() const requires sized_range<const _Vp>
2177 const auto __s = ranges::size(_M_base);
2178 const auto __c = static_cast<decltype(__s)>(_M_count);
2179 return __s < __c ? 0 : __s - __c;
2183 template<
typename _Range>
2184 drop_view(_Range&&, range_difference_t<_Range>)
2185 -> drop_view<views::all_t<_Range>>;
2189 inline constexpr __adaptor::_RangeAdaptor drop
2190 = [] <viewable_range _Range,
typename _Tp> (_Range&& __r, _Tp&& __n)
2192 return drop_view{std::forward<_Range>(__r), std::forward<_Tp>(__n)};
2196 template<view _Vp,
typename _Pred>
2197 requires input_range<_Vp> && is_object_v<_Pred>
2198 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2199 class drop_while_view :
public view_interface<drop_while_view<_Vp, _Pred>>
2202 _Vp _M_base = _Vp();
2203 __detail::__box<_Pred> _M_pred;
2206 drop_while_view() =
default;
2209 drop_while_view(_Vp
__base, _Pred __pred)
2214 base() const& requires copy_constructible<_Vp>
2221 constexpr
const _Pred&
2223 {
return *_M_pred; }
2231 std::cref(*_M_pred));
2239 template<
typename _Range,
typename _Pred>
2240 drop_while_view(_Range&&, _Pred)
2241 -> drop_while_view<views::all_t<_Range>, _Pred>;
2245 inline constexpr __adaptor::_RangeAdaptor drop_while
2246 = [] <viewable_range _Range,
typename _Pred> (_Range&& __r, _Pred&& __p)
2248 return drop_while_view{std::forward<_Range>(__r),
2249 std::forward<_Pred>(__p)};
2253 template<input_range _Vp>
2254 requires view<_Vp> && input_range<range_reference_t<_Vp>>
2255 && (is_reference_v<range_reference_t<_Vp>>
2256 || view<range_value_t<_Vp>>)
2257 class join_view :
public view_interface<join_view<_Vp>>
2260 using _InnerRange = range_reference_t<_Vp>;
2262 template<
bool _Const>
2265 template<
bool _Const>
2269 using _Parent = conditional_t<_Const, const join_view, join_view>;
2270 using _Base = conditional_t<_Const, const _Vp, _Vp>;
2272 static constexpr
bool _S_ref_is_glvalue
2273 = is_reference_v<range_reference_t<_Base>>;
2278 auto __update_inner = [
this] (range_reference_t<_Base> __x) ->
auto&
2280 if constexpr (_S_ref_is_glvalue)
2283 return (_M_parent->_M_inner = views::all(
std::move(__x)));
2286 for (; _M_outer !=
ranges::end(_M_parent->_M_base); ++_M_outer)
2288 auto& inner = __update_inner(*_M_outer);
2294 if constexpr (_S_ref_is_glvalue)
2295 _M_inner = _Inner_iter();
2298 static constexpr
auto
2301 if constexpr (_S_ref_is_glvalue
2302 && bidirectional_range<_Base>
2303 && bidirectional_range<range_reference_t<_Base>>)
2304 return bidirectional_iterator_tag{};
2305 else if constexpr (_S_ref_is_glvalue
2306 && forward_range<_Base>
2307 && forward_range<range_reference_t<_Base>>)
2308 return forward_iterator_tag{};
2310 return input_iterator_tag{};
2313 static constexpr
auto
2317 =
typename iterator_traits<_Outer_iter>::iterator_category;
2319 =
typename iterator_traits<_Inner_iter>::iterator_category;
2320 if constexpr (_S_ref_is_glvalue
2321 && derived_from<_OuterCat, bidirectional_iterator_tag>
2322 && derived_from<_InnerCat, bidirectional_iterator_tag>)
2323 return bidirectional_iterator_tag{};
2324 else if constexpr (_S_ref_is_glvalue
2325 && derived_from<_OuterCat, forward_iterator_tag>
2326 && derived_from<_InnerCat, forward_iterator_tag>)
2327 return forward_iterator_tag{};
2328 else if constexpr (derived_from<_OuterCat, input_iterator_tag>
2329 && derived_from<_InnerCat, input_iterator_tag>)
2330 return input_iterator_tag{};
2332 return output_iterator_tag{};
2335 using _Outer_iter = iterator_t<_Base>;
2336 using _Inner_iter = iterator_t<range_reference_t<_Base>>;
2338 _Outer_iter _M_outer = _Outer_iter();
2339 _Inner_iter _M_inner = _Inner_iter();
2340 _Parent* _M_parent =
nullptr;
2343 using iterator_concept = decltype(_S_iter_concept());
2344 using iterator_category = decltype(_S_iter_cat());
2345 using value_type = range_value_t<range_reference_t<_Base>>;
2346 using difference_type
2347 = common_type_t<range_difference_t<_Base>,
2348 range_difference_t<range_reference_t<_Base>>>;
2350 _Iterator() =
default;
2353 _Iterator(_Parent& __parent, _Outer_iter __outer)
2354 : _M_outer(
std::
move(__outer)),
2359 _Iterator(_Iterator<!_Const> __i)
2361 && convertible_to<iterator_t<_Vp>, _Outer_iter>
2362 && convertible_to<iterator_t<_InnerRange>, _Inner_iter>
2363 : _M_outer(
std::move(__i._M_outer)), _M_inner(__i._M_inner),
2364 _M_parent(__i._M_parent)
2367 constexpr decltype(
auto)
2369 {
return *_M_inner; }
2371 constexpr _Outer_iter
2373 requires __detail::__has_arrow<_Outer_iter>
2374 && copyable<_Outer_iter>
2375 {
return _M_inner; }
2377 constexpr _Iterator&
2380 auto&& __inner_range = [
this] () -> decltype(
auto) {
2381 if constexpr (_S_ref_is_glvalue)
2384 return _M_parent->_M_inner;
2400 requires _S_ref_is_glvalue && forward_range<_Base>
2401 && forward_range<range_reference_t<_Base>>
2408 constexpr _Iterator&
2410 requires _S_ref_is_glvalue && bidirectional_range<_Base>
2411 && bidirectional_range<range_reference_t<_Base>>
2423 requires _S_ref_is_glvalue && bidirectional_range<_Base>
2424 && bidirectional_range<range_reference_t<_Base>>
2431 friend constexpr
bool
2432 operator==(
const _Iterator& __x,
const _Iterator& __y)
2433 requires _S_ref_is_glvalue
2434 && equality_comparable<_Outer_iter>
2435 && equality_comparable<_Inner_iter>
2437 return (__x._M_outer == __y._M_outer
2438 && __x._M_inner == __y._M_inner);
2441 friend constexpr decltype(
auto)
2442 iter_move(const _Iterator& __i)
2443 noexcept(noexcept(ranges::iter_move(__i._M_inner)))
2444 {
return ranges::iter_move(__i._M_inner); }
2446 friend constexpr
void
2447 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
2448 noexcept(noexcept(ranges::iter_swap(__x._M_inner, __y._M_inner)))
2449 {
return ranges::iter_swap(__x._M_inner, __y._M_inner); }
2451 friend _Iterator<!_Const>;
2452 friend _Sentinel<_Const>;
2455 template<
bool _Const>
2459 using _Parent = conditional_t<_Const, const join_view, join_view>;
2460 using _Base = conditional_t<_Const, const _Vp, _Vp>;
2463 __equal(
const _Iterator<_Const>& __i)
const
2464 {
return __i._M_outer == _M_end; }
2466 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2469 _Sentinel() =
default;
2472 _Sentinel(_Parent& __parent)
2473 : _M_end(ranges::
end(__parent._M_base))
2477 _Sentinel(_Sentinel<!_Const> __s)
2478 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2482 friend constexpr
bool
2483 operator==(
const _Iterator<_Const>& __x,
const _Sentinel& __y)
2484 {
return __y.__equal(__x); }
2487 _Vp _M_base = _Vp();
2490 [[no_unique_address]]
2491 conditional_t<!is_reference_v<_InnerRange>,
2492 views::all_t<_InnerRange>, __detail::_Empty> _M_inner;
2495 join_view() =
default;
2503 base() const& requires copy_constructible<_Vp>
2513 constexpr
bool __use_const
2514 = (__detail::__simple_view<_Vp>
2515 && is_reference_v<range_reference_t<_Vp>>);
2516 return _Iterator<__use_const>{*
this,
ranges::begin(_M_base)};
2521 requires input_range<const _Vp>
2522 && is_reference_v<range_reference_t<const _Vp>>
2530 if constexpr (forward_range<_Vp> && is_reference_v<_InnerRange>
2531 && forward_range<_InnerRange>
2532 && common_range<_Vp> && common_range<_InnerRange>)
2533 return _Iterator<__detail::__simple_view<_Vp>>{*
this,
2536 return _Sentinel<__detail::__simple_view<_Vp>>{*
this};
2541 requires input_range<const _Vp>
2542 && is_reference_v<range_reference_t<const _Vp>>
2544 if constexpr (forward_range<const _Vp>
2545 && is_reference_v<range_reference_t<const _Vp>>
2546 && forward_range<range_reference_t<const _Vp>>
2547 && common_range<const _Vp>
2548 && common_range<range_reference_t<const _Vp>>)
2549 return _Iterator<true>{*
this,
ranges::end(_M_base)};
2551 return _Sentinel<true>{*
this};
2555 template<
typename _Range>
2556 explicit join_view(_Range&&) -> join_view<views::all_t<_Range>>;
2560 inline constexpr __adaptor::_RangeAdaptorClosure join
2561 = [] <viewable_range _Range> (_Range&& __r)
2563 return join_view{std::forward<_Range>(__r)};
2570 struct __require_constant;
2572 template<
typename _Range>
2573 concept __tiny_range = sized_range<_Range>
2575 {
typename __require_constant<remove_reference_t<_Range>::size()>; }
2576 && (remove_reference_t<_Range>::size() <= 1);
2579 template<input_range _Vp, forward_range _Pattern>
2580 requires view<_Vp> && view<_Pattern>
2581 && indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
2583 && (forward_range<_Vp> || __detail::__tiny_range<_Pattern>)
2584 class split_view :
public view_interface<split_view<_Vp, _Pattern>>
2587 template<
bool _Const>
2590 template<
bool _Const>
2594 using _Parent = conditional_t<_Const, const split_view, split_view>;
2595 using _Base = conditional_t<_Const, const _Vp, _Vp>;
2599 {
return _M_current ==
ranges::end(_M_parent->_M_base); }
2608 if constexpr (forward_range<_Vp>)
2611 return _M_parent->_M_current;
2617 if constexpr (forward_range<_Vp>)
2620 return _M_parent->_M_current;
2623 _Parent* _M_parent =
nullptr;
2626 [[no_unique_address]]
2627 conditional_t<forward_range<_Vp>,
2628 iterator_t<_Base>, __detail::_Empty> _M_current;
2631 using iterator_concept = conditional_t<forward_range<_Base>,
2632 forward_iterator_tag,
2633 input_iterator_tag>;
2634 using iterator_category = input_iterator_tag;
2635 using difference_type = range_difference_t<_Base>;
2637 struct value_type : view_interface<value_type>
2640 _OuterIter _M_i = _OuterIter();
2643 value_type() =
default;
2646 value_type(_OuterIter __i)
2650 constexpr _InnerIter<_Const>
2652 requires copyable<_OuterIter>
2653 {
return _InnerIter<_Const>{_M_i}; }
2655 constexpr _InnerIter<_Const>
2657 requires (!copyable<_OuterIter>)
2658 {
return _InnerIter<_Const>{
std::move(_M_i)}; }
2660 constexpr default_sentinel_t
2662 {
return default_sentinel; }
2665 _OuterIter() =
default;
2668 _OuterIter(_Parent& __parent) requires (!forward_range<_Base>)
2669 : _M_parent(address(__parent))
2673 _OuterIter(_Parent& __parent, iterator_t<_Base> __current)
2674 requires forward_range<_Base>
2680 _OuterIter(_OuterIter<!_Const> __i)
2682 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
2683 : _M_parent(__i._M_parent), _M_current(
std::move(__i._M_current))
2686 constexpr value_type
2688 {
return value_type{*
this}; }
2690 constexpr _OuterIter&
2693 const auto __end =
ranges::end(_M_parent->_M_base);
2694 if (_M_current == __end)
2696 const auto [__pbegin, __pend] = subrange{_M_parent->_M_pattern};
2697 if (__pbegin == __pend)
2703 = __detail::mismatch(
std::move(_M_current), __end,
2708 }
while (++_M_current != __end);
2712 constexpr decltype(
auto)
2715 if constexpr (forward_range<_Base>)
2725 friend constexpr
bool
2726 operator==(
const _OuterIter& __x,
const _OuterIter& __y)
2727 requires forward_range<_Base>
2728 {
return __x._M_current == __y._M_current; }
2730 friend constexpr
bool
2731 operator==(
const _OuterIter& __x, default_sentinel_t)
2732 {
return __x.__at_end(); };
2734 friend _InnerIter<_Const>;
2737 template<
bool _Const>
2741 using _Base = conditional_t<_Const, const _Vp, _Vp>;
2746 auto [__pcur, __pend] = subrange{_M_i._M_parent->_M_pattern};
2747 auto __end =
ranges::end(_M_i._M_parent->_M_base);
2748 if constexpr (__detail::__tiny_range<_Pattern>)
2750 const auto& __cur = _M_i.__current();
2753 if (__pcur == __pend)
2754 return _M_incremented;
2755 return *__cur == *__pcur;
2759 auto __cur = _M_i.__current();
2762 if (__pcur == __pend)
2763 return _M_incremented;
2766 if (*__cur != *__pcur)
2768 if (++__pcur == __pend)
2770 }
while (++__cur != __end);
2775 static constexpr
auto
2779 =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
2780 if constexpr (derived_from<_Cat, forward_iterator_tag>)
2781 return forward_iterator_tag{};
2786 static constexpr decltype(
auto)
2787 __iter_move(const _InnerIter& __i = {})
2788 noexcept(noexcept(ranges::iter_move(__i._M_i.__current())))
2789 {
return ranges::iter_move(__i._M_i.__current()); }
2791 static constexpr
void
2792 __iter_swap(
const _InnerIter& __x = {},
const _InnerIter& __y = {})
2793 noexcept(noexcept(ranges::iter_swap(__x._M_i.__current(),
2794 __y._M_i.__current())))
2795 { ranges::iter_swap(__x._M_i.__current(), __y._M_i.__current()); }
2797 _OuterIter<_Const> _M_i = _OuterIter<_Const>();
2798 bool _M_incremented =
false;
2801 using iterator_concept
2802 =
typename _OuterIter<_Const>::iterator_concept;
2803 using iterator_category = decltype(_S_iter_cat());
2804 using value_type = range_value_t<_Base>;
2805 using difference_type = range_difference_t<_Base>;
2807 _InnerIter() =
default;
2810 _InnerIter(_OuterIter<_Const> __i)
2814 constexpr decltype(
auto)
2816 {
return *_M_i._M_current; }
2818 constexpr _InnerIter&
2821 _M_incremented =
true;
2822 if constexpr (!forward_range<_Base>)
2823 if constexpr (_Pattern::size() == 0)
2829 constexpr decltype(auto)
2832 if constexpr (forward_range<_Vp>)
2842 friend constexpr
bool
2843 operator==(
const _InnerIter& __x,
const _InnerIter& __y)
2844 requires forward_range<_Base>
2845 {
return __x._M_i.__current() == __y._M_i.__current(); }
2847 friend constexpr
bool
2848 operator==(
const _InnerIter& __x, default_sentinel_t)
2849 {
return __x.__at_end(); }
2851 friend constexpr decltype(
auto)
2852 iter_move(const _InnerIter& __i) noexcept(noexcept(__iter_move()))
2853 {
return __iter_move(__i); }
2855 friend constexpr
void
2856 iter_swap(
const _InnerIter& __x,
const _InnerIter& __y)
2857 noexcept(noexcept(__iter_swap()))
2858 requires indirectly_swappable<iterator_t<_Base>>
2859 { __iter_swap(__x, __y); }
2862 _Vp _M_base = _Vp();
2863 _Pattern _M_pattern = _Pattern();
2866 [[no_unique_address]]
2867 conditional_t<!forward_range<_Vp>,
2868 iterator_t<_Vp>, __detail::_Empty> _M_current;
2872 split_view() =
default;
2875 split_view(_Vp
__base, _Pattern __pattern)
2879 template<input_range _Range>
2880 requires constructible_from<_Vp, views::all_t<_Range>>
2881 && constructible_from<_Pattern, single_view<range_value_t<_Range>>>
2883 split_view(_Range&& __r, range_value_t<_Range> __e)
2884 : _M_base(views::all(
std::
forward<_Range>(__r))),
2889 base() const& requires copy_constructible<_Vp>
2899 if constexpr (forward_range<_Vp>)
2900 return _OuterIter<__detail::__simple_view<_Vp>>{*
this,
2905 return _OuterIter<false>{*
this};
2910 begin() const requires forward_range<_Vp> && forward_range<const _Vp>
2916 end() requires forward_range<_Vp> && common_range<_Vp>
2918 return _OuterIter<__detail::__simple_view<_Vp>>{*
this,
ranges::end(_M_base)};
2924 if constexpr (forward_range<_Vp>
2925 && forward_range<const _Vp>
2926 && common_range<const _Vp>)
2927 return _OuterIter<true>{*
this,
ranges::end(_M_base)};
2929 return default_sentinel;
2933 template<
typename _Range,
typename _Pred>
2934 split_view(_Range&&, _Pred&&)
2935 -> split_view<views::all_t<_Range>, views::all_t<_Pred>>;
2937 template<input_range _Range>
2938 split_view(_Range&&, range_value_t<_Range>)
2939 -> split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
2943 inline constexpr __adaptor::_RangeAdaptor split
2944 = [] <viewable_range _Range,
typename _Fp> (_Range&& __r, _Fp&& __f)
2946 return split_view{std::forward<_Range>(__r), std::forward<_Fp>(__f)};
2954 template<input_or_output_iterator _Iter>
2956 operator()(_Iter __i, iter_difference_t<_Iter> __n)
const
2958 if constexpr (random_access_iterator<_Iter>)
2959 return subrange{__i, __i + __n};
2961 return subrange{counted_iterator{
std::move(__i), __n},
2966 inline constexpr _Counted counted{};
2970 requires (!common_range<_Vp>) && copyable<iterator_t<_Vp>>
2971 class common_view :
public view_interface<common_view<_Vp>>
2974 _Vp _M_base = _Vp();
2977 common_view() =
default;
2980 common_view(_Vp __r)
2995 base() const& requires copy_constructible<_Vp>
3005 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3008 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
3013 begin() const requires range<const _Vp>
3015 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
3018 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
3025 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3028 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
3033 end() const requires range<const _Vp>
3035 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
3038 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
3043 size() requires sized_range<_Vp>
3044 {
return ranges::size(_M_base); }
3047 size() const requires sized_range<const _Vp>
3048 {
return ranges::size(_M_base); }
3051 template<
typename _Range>
3052 common_view(_Range&&) -> common_view<views::all_t<_Range>>;
3056 inline constexpr __adaptor::_RangeAdaptorClosure common
3057 = [] <viewable_range _Range> (_Range&& __r)
3059 if constexpr (common_range<_Range>
3060 && requires { views::all(std::forward<_Range>(__r)); })
3061 return views::all(std::forward<_Range>(__r));
3063 return common_view{std::forward<_Range>(__r)};
3069 requires bidirectional_range<_Vp>
3070 class reverse_view :
public view_interface<reverse_view<_Vp>>
3073 _Vp _M_base = _Vp();
3076 reverse_view() =
default;
3079 reverse_view(_Vp __r)
3084 base() const& requires copy_constructible<_Vp>
3091 constexpr reverse_iterator<iterator_t<_Vp>>
3100 begin() requires common_range<_Vp>
3104 begin() const requires common_range<const _Vp>
3107 constexpr reverse_iterator<iterator_t<_Vp>>
3112 end() const requires common_range<const _Vp>
3116 size() requires sized_range<_Vp>
3117 {
return ranges::size(_M_base); }
3120 size() const requires sized_range<const _Vp>
3121 {
return ranges::size(_M_base); }
3124 template<
typename _Range>
3125 reverse_view(_Range&&) -> reverse_view<views::all_t<_Range>>;
3132 inline constexpr
bool __is_reversible_subrange =
false;
3134 template<
typename _Iter, subrange_kind _Kind>
3135 inline constexpr
bool
3136 __is_reversible_subrange<subrange<reverse_iterator<_Iter>,
3137 reverse_iterator<_Iter>,
3141 inline constexpr
bool __is_reverse_view =
false;
3143 template<
typename _Vp>
3144 inline constexpr
bool __is_reverse_view<reverse_view<_Vp>> =
true;
3147 inline constexpr __adaptor::_RangeAdaptorClosure reverse
3148 = [] <viewable_range _Range> (_Range&& __r)
3150 using _Tp = remove_cvref_t<_Range>;
3151 if constexpr (__detail::__is_reverse_view<_Tp>)
3152 return std::forward<_Range>(__r).base();
3153 else if constexpr (__detail::__is_reversible_subrange<_Tp>)
3156 if constexpr (sized_range<_Tp>)
3157 return subrange<_Iter, _Iter, subrange_kind::sized>
3158 (__r.end().base(), __r.begin().base(), __r.size());
3160 return subrange<_Iter, _Iter, subrange_kind::unsized>
3161 (__r.end().base(), __r.begin().base());
3164 return reverse_view{std::forward<_Range>(__r)};
3170 template<
typename _Tp,
size_t _Nm>
3171 concept __has_tuple_element = requires(_Tp __t)
3173 typename tuple_size<_Tp>::type;
3174 requires _Nm < tuple_size_v<_Tp>;
3175 typename tuple_element_t<_Nm, _Tp>;
3176 { std::get<_Nm>(__t) }
3177 -> convertible_to<const tuple_element_t<_Nm, _Tp>&>;
3181 template<input_range _Vp,
size_t _Nm>
3183 && __detail::__has_tuple_element<range_value_t<_Vp>, _Nm>
3184 && __detail::__has_tuple_element<remove_reference_t<range_reference_t<_Vp>>,
3186 class elements_view :
public view_interface<elements_view<_Vp, _Nm>>
3189 elements_view() =
default;
3192 elements_view(_Vp base)
3197 base() const& requires copy_constructible<_Vp>
3205 begin() requires (!__detail::__simple_view<_Vp>)
3209 begin() const requires __detail::__simple_view<_Vp>
3213 end() requires (!__detail::__simple_view<_Vp>)
3217 end() const requires __detail::__simple_view<_Vp>
3221 size() requires sized_range<_Vp>
3222 {
return ranges::size(_M_base); }
3225 size() const requires sized_range<const _Vp>
3226 {
return ranges::size(_M_base); }
3229 template<
bool _Const>
3232 using _Base = conditional_t<_Const, const _Vp, _Vp>;
3234 iterator_t<_Base> _M_current = iterator_t<_Base>();
3236 friend _Iterator<!_Const>;
3239 using iterator_category
3240 =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
3242 = remove_cvref_t<tuple_element_t<_Nm, range_value_t<_Base>>>;
3243 using difference_type = range_difference_t<_Base>;
3245 _Iterator() =
default;
3248 _Iterator(iterator_t<_Base> current)
3249 : _M_current(
std::
move(current))
3253 _Iterator(_Iterator<!_Const> i)
3254 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
3258 constexpr iterator_t<_Base>
3260 requires copyable<iterator_t<_Base>>
3261 {
return _M_current; }
3263 constexpr iterator_t<_Base>
3267 constexpr decltype(
auto)
3269 {
return std::get<_Nm>(*_M_current); }
3271 constexpr _Iterator&
3279 operator++(
int) requires (!forward_range<_Base>)
3283 operator++(
int) requires forward_range<_Base>
3290 constexpr _Iterator&
3291 operator--() requires bidirectional_range<_Base>
3298 operator--(
int) requires bidirectional_range<_Base>
3305 constexpr _Iterator&
3306 operator+=(difference_type __n)
3307 requires random_access_range<_Base>
3313 constexpr _Iterator&
3314 operator-=(difference_type __n)
3315 requires random_access_range<_Base>
3321 constexpr decltype(
auto)
3322 operator[](difference_type __n) const
3323 requires random_access_range<_Base>
3324 {
return std::get<_Nm>(*(_M_current + __n)); }
3326 friend constexpr
bool
3327 operator==(
const _Iterator& __x,
const _Iterator& __y)
3328 requires equality_comparable<iterator_t<_Base>>
3329 {
return __x._M_current == __y._M_current; }
3331 friend constexpr
bool
3332 operator==(
const _Iterator& __x,
const sentinel_t<_Base>& __y)
3333 {
return __x._M_current == __y; }
3335 friend constexpr
bool
3336 operator<(
const _Iterator& __x,
const _Iterator& __y)
3337 requires random_access_range<_Base>
3338 {
return __x._M_current < __y._M_current; }
3340 friend constexpr
bool
3341 operator>(
const _Iterator& __x,
const _Iterator& __y)
3342 requires random_access_range<_Base>
3343 {
return __y._M_current < __x._M_current; }
3345 friend constexpr
bool
3346 operator<=(
const _Iterator& __x,
const _Iterator& __y)
3347 requires random_access_range<_Base>
3348 {
return !(__y._M_current > __x._M_current); }
3350 friend constexpr
bool
3351 operator>=(
const _Iterator& __x,
const _Iterator& __y)
3352 requires random_access_range<_Base>
3353 {
return !(__x._M_current > __y._M_current); }
3355 #ifdef __cpp_lib_three_way_comparison
3356 friend constexpr
auto
3357 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
3358 requires random_access_range<_Base>
3359 && three_way_comparable<iterator_t<_Base>>
3360 {
return __x._M_current <=> __y._M_current; }
3363 friend constexpr _Iterator
3364 operator+(
const _Iterator& __x, difference_type __y)
3365 requires random_access_range<_Base>
3366 {
return _Iterator{__x} += __y; }
3368 friend constexpr _Iterator
3369 operator+(difference_type __x,
const _Iterator& __y)
3370 requires random_access_range<_Base>
3371 {
return __y + __x; }
3373 friend constexpr _Iterator
3374 operator-(
const _Iterator& __x, difference_type __y)
3375 requires random_access_range<_Base>
3376 {
return _Iterator{__x} -= __y; }
3378 friend constexpr difference_type
3379 operator-(
const _Iterator& __x,
const _Iterator& __y)
3380 requires random_access_range<_Base>
3381 {
return __x._M_current - __y._M_current; }
3383 friend constexpr difference_type
3384 operator-(
const _Iterator<_Const>& __x,
const sentinel_t<_Base>& __y)
3385 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
3386 {
return __x._M_current - __y; }
3388 friend constexpr difference_type
3389 operator-(
const sentinel_t<_Base>& __x,
const _Iterator<_Const>& __y)
3390 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
3391 {
return -(__y - __x); }
3394 _Vp _M_base = _Vp();
3397 template<
typename _Range>
3398 using keys_view = elements_view<views::all_t<_Range>, 0>;
3400 template<
typename _Range>
3401 using values_view = elements_view<views::all_t<_Range>, 1>;
3405 template<
size_t _Nm>
3406 inline constexpr __adaptor::_RangeAdaptorClosure elements
3407 = [] <viewable_range _Range> (_Range&& __r)
3409 using _El = elements_view<views::all_t<_Range>, _Nm>;
3410 return _El{std::forward<_Range>(__r)};
3413 inline constexpr __adaptor::_RangeAdaptorClosure keys = elements<0>;
3414 inline constexpr __adaptor::_RangeAdaptorClosure values = elements<1>;
3419 namespace views = ranges::views;
3421 template<
typename _Iter,
typename _Sent, ranges::subrange_kind _Kind>
3422 struct tuple_size<ranges::subrange<_Iter, _Sent, _Kind>>
3423 : integral_constant<size_t, 2>
3426 template<
typename _Iter,
typename _Sent, ranges::subrange_kind _Kind>
3427 struct tuple_element<0, ranges::subrange<_Iter, _Sent, _Kind>>
3428 {
using type = _Iter; };
3430 template<
typename _Iter,
typename _Sent, ranges::subrange_kind _Kind>
3431 struct tuple_element<1, ranges::subrange<_Iter, _Sent, _Kind>>
3432 {
using type = _Sent; };
3434 template<
typename _Iter,
typename _Sent, ranges::subrange_kind _Kind>
3435 struct tuple_element<0, const ranges::subrange<_Iter, _Sent, _Kind>>
3436 {
using type = _Iter; };
3438 template<
typename _Iter,
typename _Sent, ranges::subrange_kind _Kind>
3439 struct tuple_element<1, const ranges::subrange<_Iter, _Sent, _Kind>>
3440 {
using type = _Sent; };
3442 _GLIBCXX_END_NAMESPACE_VERSION
3444 #endif // library concepts