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
68 template<
typename _Tp>
69 inline constexpr
bool enable_view = derived_from<_Tp, view_base>;
71 template<
typename _Tp>
73 = range<_Tp> && movable<_Tp> && default_initializable<_Tp>
77 template<
typename _Tp>
78 concept viewable_range = range<_Tp>
79 && (borrowed_range<_Tp> || view<remove_cvref_t<_Tp>>);
83 template<
typename _Range>
84 concept __simple_view = view<_Range> && range<const _Range>
85 && same_as<iterator_t<_Range>, iterator_t<const _Range>>
86 && same_as<sentinel_t<_Range>, sentinel_t<const _Range>>;
88 template<
typename _It>
89 concept __has_arrow = input_iterator<_It>
90 && (is_pointer_v<_It> || requires(_It __it) { __it.operator->(); });
92 template<
typename _Tp,
typename _Up>
94 = !same_as<remove_cvref_t<_Tp>, remove_cvref_t<_Up>>;
97 template<
typename _Derived>
98 requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
99 class view_interface :
public view_base
102 constexpr _Derived& _M_derived() noexcept
104 static_assert(derived_from<_Derived, view_interface<_Derived>>);
105 static_assert(view<_Derived>);
106 return static_cast<_Derived&>(*
this);
109 constexpr
const _Derived& _M_derived() const noexcept
111 static_assert(derived_from<_Derived, view_interface<_Derived>>);
112 static_assert(view<_Derived>);
113 return static_cast<const _Derived&>(*
this);
118 empty() requires forward_range<_Derived>
122 empty() const requires forward_range<const _Derived>
126 operator bool() requires requires { ranges::empty(_M_derived()); }
127 {
return !ranges::empty(_M_derived()); }
130 operator bool() const requires requires { ranges::empty(_M_derived()); }
131 {
return !ranges::empty(_M_derived()); }
134 data() requires contiguous_iterator<iterator_t<_Derived>>
139 requires range<const _Derived>
140 && contiguous_iterator<iterator_t<const _Derived>>
145 requires forward_range<_Derived>
146 && sized_sentinel_for<sentinel_t<_Derived>, iterator_t<_Derived>>
151 requires forward_range<const _Derived>
152 && sized_sentinel_for<sentinel_t<const _Derived>,
153 iterator_t<const _Derived>>
156 constexpr decltype(
auto)
157 front() requires forward_range<_Derived>
159 __glibcxx_assert(!empty());
163 constexpr decltype(
auto)
164 front() const requires forward_range<const _Derived>
166 __glibcxx_assert(!empty());
170 constexpr decltype(
auto)
172 requires bidirectional_range<_Derived> && common_range<_Derived>
174 __glibcxx_assert(!empty());
178 constexpr decltype(
auto)
180 requires bidirectional_range<const _Derived>
181 && common_range<const _Derived>
183 __glibcxx_assert(!empty());
187 template<random_access_range _Range = _Derived>
188 constexpr decltype(
auto)
189 operator[](range_difference_t<_Range> __n)
192 template<random_access_range _Range = const _Derived>
193 constexpr decltype(
auto)
194 operator[](range_difference_t<_Range> __n)
const
200 template<
class _From,
class _To>
201 concept __convertible_to_non_slicing = convertible_to<_From, _To>
202 && !(is_pointer_v<decay_t<_From>> && is_pointer_v<decay_t<_To>>
203 && __not_same_as<remove_pointer_t<decay_t<_From>>,
204 remove_pointer_t<decay_t<_To>>>);
206 template<
typename _Tp>
208 = !is_reference_v<_Tp> && requires(_Tp __t)
210 typename tuple_size<_Tp>::type;
211 requires derived_from<tuple_size<_Tp>, integral_constant<size_t, 2>>;
212 typename tuple_element_t<0, remove_const_t<_Tp>>;
213 typename tuple_element_t<1, remove_const_t<_Tp>>;
214 { get<0>(__t) } -> convertible_to<const tuple_element_t<0, _Tp>&>;
215 { get<1>(__t) } -> convertible_to<const tuple_element_t<1, _Tp>&>;
218 template<
typename _Tp,
typename _Up,
typename _Vp>
219 concept __pair_like_convertible_from
220 = !range<_Tp> && __pair_like<_Tp>
221 && constructible_from<_Tp, _Up, _Vp>
222 && __convertible_to_non_slicing<_Up, tuple_element_t<0, _Tp>>
223 && convertible_to<_Vp, tuple_element_t<1, _Tp>>;
225 template<
typename _Tp>
226 concept __iterator_sentinel_pair
227 = !range<_Tp> && __pair_like<_Tp>
228 && sentinel_for<tuple_element_t<1, _Tp>, tuple_element_t<0, _Tp>>;
232 enum class subrange_kind : bool { unsized, sized };
234 template<input_or_output_iterator _It, sentinel_for<_It> _Sent = _It,
235 subrange_kind _Kind = sized_sentinel_for<_Sent, _It>
236 ? subrange_kind::sized : subrange_kind::unsized>
237 requires (_Kind == subrange_kind::sized || !sized_sentinel_for<_Sent, _It>)
238 class subrange :
public view_interface<subrange<_It, _Sent, _Kind>>
242 static const bool _S_store_size
243 = _Kind == subrange_kind::sized && !sized_sentinel_for<_Sent, _It>;
245 _It _M_begin = _It();
246 _Sent _M_end = _Sent();
248 template<
typename,
bool = _S_store_size>
252 template<
typename _Tp>
253 struct _Size<_Tp, true>
254 { __detail::__make_unsigned_like_t<_Tp> _M_size; };
256 [[no_unique_address]] _Size<iter_difference_t<_It>> _M_size = {};
259 subrange() =
default;
262 subrange(__detail::__convertible_to_non_slicing<_It>
auto __i, _Sent __s)
263 requires (!_S_store_size)
264 : _M_begin(
std::
move(__i)), _M_end(__s)
268 subrange(__detail::__convertible_to_non_slicing<_It>
auto __i, _Sent __s,
269 __detail::__make_unsigned_like_t<iter_difference_t<_It>> __n)
270 requires (_Kind == subrange_kind::sized)
271 : _M_begin(
std::
move(__i)), _M_end(__s)
273 using __detail::__to_unsigned_like;
275 if constexpr (_S_store_size)
276 _M_size._M_size = __n;
279 template<__detail::__not_same_as<subrange> _Rng>
280 requires borrowed_range<_Rng>
281 && __detail::__convertible_to_non_slicing<iterator_t<_Rng>, _It>
282 && convertible_to<sentinel_t<_Rng>, _Sent>
284 subrange(_Rng&& __r) requires (!_S_store_size || sized_range<_Rng>)
287 if constexpr (_S_store_size)
288 _M_size._M_size = ranges::size(__r);
291 template<borrowed_range _Rng>
292 requires __detail::__convertible_to_non_slicing<iterator_t<_Rng>, _It>
293 && convertible_to<sentinel_t<_Rng>, _Sent>
296 __detail::__make_unsigned_like_t<iter_difference_t<_It>> __n)
297 requires (_Kind == subrange_kind::sized)
301 template<__detail::__not_same_as<subrange> _PairLike>
302 requires __detail::__pair_like_convertible_from<_PairLike,
const _It&,
305 operator _PairLike()
const
306 {
return _PairLike(_M_begin, _M_end); }
309 begin() const requires copyable<_It>
312 [[nodiscard]] constexpr _It
313 begin() requires (!copyable<_It>)
316 constexpr _Sent
end()
const {
return _M_end; }
318 constexpr
bool empty()
const {
return _M_begin == _M_end; }
320 constexpr __detail::__make_unsigned_like_t<iter_difference_t<_It>>
321 size() const requires (_Kind == subrange_kind::sized)
323 if constexpr (_S_store_size)
324 return _M_size._M_size;
326 return __detail::__to_unsigned_like(_M_end - _M_begin);
329 [[nodiscard]] constexpr subrange
330 next(iter_difference_t<_It> __n = 1) const &
331 requires forward_iterator<_It>
338 [[nodiscard]] constexpr subrange
339 next(iter_difference_t<_It> __n = 1) &&
345 [[nodiscard]] constexpr subrange
346 prev(iter_difference_t<_It> __n = 1) const
347 requires bidirectional_iterator<_It>
350 __tmp.advance(--__n);
355 advance(iter_difference_t<_It> __n)
357 if constexpr (_S_store_size)
361 _M_size._M_size -= __detail::__to_unsigned_like(__d);
363 _M_size._M_size += __detail::__to_unsigned_like(-__d);
371 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
372 subrange(_It, _Sent) -> subrange<_It, _Sent>;
374 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
376 __detail::__make_unsigned_like_t<iter_difference_t<_It>>)
377 -> subrange<_It, _Sent, subrange_kind::sized>;
379 template<__detail::__iterator_sentinel_pair _Pr>
381 -> subrange<tuple_element_t<0, _Pr>, tuple_element_t<1, _Pr>>;
383 template<__detail::__iterator_sentinel_pair _Pr>
384 subrange(_Pr, __detail::__make_unsigned_like_t<iter_difference_t<
385 tuple_element_t<0, _Pr>>>)
386 -> subrange<tuple_element_t<0, _Pr>, tuple_element_t<1, _Pr>,
387 subrange_kind::sized>;
389 template<borrowed_range _Rng>
391 -> subrange<iterator_t<_Rng>, sentinel_t<_Rng>,
393 || sized_sentinel_for<sentinel_t<_Rng>, iterator_t<_Rng>>)
394 ? subrange_kind::sized : subrange_kind::unsized>;
396 template<borrowed_range _Rng>
398 __detail::__make_unsigned_like_t<range_difference_t<_Rng>>)
399 -> subrange<iterator_t<_Rng>, sentinel_t<_Rng>, subrange_kind::sized>;
401 template<
size_t _Num,
class _It,
class _Sent, subrange_kind _Kind>
404 get(const subrange<_It, _Sent, _Kind>& __r)
406 if constexpr (_Num == 0)
412 template<
size_t _Num, class _It, class _Sent, subrange_kind _Kind>
415 get(subrange<_It, _Sent, _Kind>&& __r)
417 if constexpr (_Num == 0)
423 template<input_or_output_iterator _It, sentinel_for<_It> _Sent,
425 inline constexpr
bool
426 enable_borrowed_range<subrange<_It, _Sent, _Kind>> = true;
437 constexpr dangling() noexcept = default;
438 template<typename... _Args>
439 constexpr dangling(_Args&&...) noexcept { }
442 template<range _Range>
443 using borrowed_iterator_t = conditional_t<borrowed_range<_Range>,
447 template<range _Range>
448 using borrowed_subrange_t = conditional_t<borrowed_range<_Range>,
449 subrange<iterator_t<_Range>>,
452 template<
typename _Tp> requires is_object_v<_Tp>
454 :
public view_interface<empty_view<_Tp>>
457 static constexpr _Tp*
begin() noexcept {
return nullptr; }
458 static constexpr _Tp*
end() noexcept {
return nullptr; }
459 static constexpr _Tp* data() noexcept {
return nullptr; }
460 static constexpr
size_t size() noexcept {
return 0; }
461 static constexpr
bool empty() noexcept {
return true; }
464 template<
typename _Tp>
465 inline constexpr
bool enable_borrowed_range<empty_view<_Tp>> =
true;
469 template<copy_constructible _Tp> requires is_object_v<_Tp>
470 struct __box : std::optional<_Tp>
472 using std::optional<_Tp>::optional;
476 noexcept(is_nothrow_default_constructible_v<_Tp>)
477 requires default_initializable<_Tp>
481 __box(
const __box&) =
default;
482 __box(__box&&) =
default;
484 using std::optional<_Tp>::operator=;
487 operator=(
const __box& __that)
488 noexcept(is_nothrow_copy_constructible_v<_Tp>)
489 requires (!assignable_from<_Tp&, const _Tp&>)
492 this->emplace(*__that);
499 operator=(__box&& __that)
500 noexcept(is_nothrow_move_constructible_v<_Tp>)
501 requires (!assignable_from<_Tp&, _Tp>)
514 template<copy_constructible _Tp> requires is_object_v<_Tp>
515 class single_view :
public view_interface<single_view<_Tp>>
518 single_view() =
default;
521 single_view(
const _Tp& __t)
526 single_view(_Tp&& __t)
530 template<
typename... _Args>
531 requires constructible_from<_Tp, _Args...>
533 single_view(in_place_t, _Args&&... __args)
534 : _M_value{
in_place, std::forward<_Args>(__args)...}
542 begin() const noexcept
547 {
return data() + 1; }
551 {
return data() + 1; }
553 static constexpr
size_t
559 {
return _M_value.operator->(); }
562 data() const noexcept
563 {
return _M_value.operator->(); }
566 __detail::__box<_Tp> _M_value;
571 template<
typename _Wp>
572 constexpr
auto __to_signed_like(_Wp __w) noexcept
574 if constexpr (!integral<_Wp>)
575 return iter_difference_t<_Wp>();
576 else if constexpr (
sizeof(iter_difference_t<_Wp>) >
sizeof(_Wp))
577 return iter_difference_t<_Wp>(__w);
578 else if constexpr (
sizeof(ptrdiff_t) >
sizeof(_Wp))
579 return ptrdiff_t(__w);
580 else if constexpr (
sizeof(
long long) >
sizeof(_Wp))
581 return (
long long)(__w);
582 #ifdef __SIZEOF_INT128__
583 else if constexpr (__SIZEOF_INT128__ >
sizeof(_Wp))
584 return __int128(__w);
587 return __max_diff_type(__w);
590 template<
typename _Wp>
591 using __iota_diff_t = decltype(__to_signed_like(std::declval<_Wp>()));
593 template<
typename _It>
594 concept __decrementable = incrementable<_It>
597 { --__i } -> same_as<_It&>;
598 { __i-- } -> same_as<_It>;
601 template<
typename _It>
602 concept __advanceable = __decrementable<_It> && totally_ordered<_It>
603 && requires( _It __i,
const _It __j,
const __iota_diff_t<_It> __n)
605 { __i += __n } -> same_as<_It&>;
606 { __i -= __n } -> same_as<_It&>;
610 { __j - __j } -> convertible_to<__iota_diff_t<_It>>;
615 template<weakly_incrementable _Winc,
616 semiregular _Bound = unreachable_sentinel_t>
617 requires std::__detail::__weakly_eq_cmp_with<_Winc, _Bound>
618 && semiregular<_Winc>
619 class iota_view :
public view_interface<iota_view<_Winc, _Bound>>
630 using namespace __detail;
631 if constexpr (__advanceable<_Winc>)
632 return random_access_iterator_tag{};
633 else if constexpr (__decrementable<_Winc>)
634 return bidirectional_iterator_tag{};
635 else if constexpr (incrementable<_Winc>)
636 return forward_iterator_tag{};
638 return input_iterator_tag{};
642 using iterator_category = decltype(_S_iter_cat());
643 using value_type = _Winc;
644 using difference_type = __detail::__iota_diff_t<_Winc>;
646 _Iterator() =
default;
649 _Iterator(_Winc __value)
650 : _M_value(__value) { }
653 operator*() const noexcept(is_nothrow_copy_constructible_v<_Winc>)
668 operator++(
int) requires incrementable<_Winc>
676 operator--() requires __detail::__decrementable<_Winc>
683 operator--(
int) requires __detail::__decrementable<_Winc>
691 operator+=(difference_type __n) requires __detail::__advanceable<_Winc>
693 using __detail::__is_integer_like;
694 using __detail::__is_signed_integer_like;
695 if constexpr (__is_integer_like<_Winc>
696 && !__is_signed_integer_like<_Winc>)
698 if (__n >= difference_type(0))
699 _M_value += static_cast<_Winc>(__n);
701 _M_value -= static_cast<_Winc>(-__n);
709 operator-=(difference_type __n) requires __detail::__advanceable<_Winc>
711 using __detail::__is_integer_like;
712 using __detail::__is_signed_integer_like;
713 if constexpr (__is_integer_like<_Winc>
714 && !__is_signed_integer_like<_Winc>)
716 if (__n >= difference_type(0))
717 _M_value -= static_cast<_Winc>(__n);
719 _M_value += static_cast<_Winc>(-__n);
727 operator[](difference_type __n)
const
728 requires __detail::__advanceable<_Winc>
729 {
return _Winc(_M_value + __n); }
731 friend constexpr
bool
732 operator==(
const _Iterator& __x,
const _Iterator& __y)
733 requires equality_comparable<_Winc>
734 {
return __x._M_value == __y._M_value; }
736 friend constexpr
bool
737 operator<(
const _Iterator& __x,
const _Iterator& __y)
738 requires totally_ordered<_Winc>
739 {
return __x._M_value < __y._M_value; }
741 friend constexpr
bool
742 operator>(
const _Iterator& __x,
const _Iterator& __y)
743 requires totally_ordered<_Winc>
744 {
return __y < __x; }
746 friend constexpr
bool
747 operator<=(
const _Iterator& __x,
const _Iterator& __y)
748 requires totally_ordered<_Winc>
749 {
return !(__y < __x); }
751 friend constexpr
bool
752 operator>=(
const _Iterator& __x,
const _Iterator& __y)
753 requires totally_ordered<_Winc>
754 {
return !(__x < __y); }
756 #ifdef __cpp_lib_three_way_comparison
757 friend constexpr
auto
758 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
759 requires totally_ordered<_Winc> && three_way_comparable<_Winc>
760 {
return __x._M_value <=> __y._M_value; }
763 friend constexpr _Iterator
764 operator+(_Iterator __i, difference_type __n)
765 requires __detail::__advanceable<_Winc>
766 {
return __i += __n; }
768 friend constexpr _Iterator
769 operator+(difference_type __n, _Iterator __i)
770 requires __detail::__advanceable<_Winc>
771 {
return __i += __n; }
773 friend constexpr _Iterator
774 operator-(_Iterator __i, difference_type __n)
775 requires __detail::__advanceable<_Winc>
776 {
return __i -= __n; }
778 friend constexpr difference_type
779 operator-(
const _Iterator& __x,
const _Iterator& __y)
780 requires __detail::__advanceable<_Winc>
782 using __detail::__is_integer_like;
783 using __detail::__is_signed_integer_like;
784 using _Dt = difference_type;
785 if constexpr (__is_integer_like<_Winc>)
787 if constexpr (__is_signed_integer_like<_Winc>)
788 return _Dt(_Dt(__x._M_value) - _Dt(__y._M_value));
790 return (__y._M_value > __x._M_value)
791 ? _Dt(-_Dt(__y._M_value - __x._M_value))
792 : _Dt(__x._M_value - __y._M_value);
795 return __x._M_value - __y._M_value;
799 _Winc _M_value = _Winc();
808 _M_equal(
const _Iterator& __x)
const
809 {
return __x._M_value == _M_bound; }
811 _Bound _M_bound = _Bound();
814 _Sentinel() =
default;
817 _Sentinel(_Bound __bound)
818 : _M_bound(__bound) { }
820 friend constexpr
bool
821 operator==(
const _Iterator& __x,
const _Sentinel& __y)
822 {
return __y._M_equal(__x); }
824 friend constexpr iter_difference_t<_Winc>
825 operator-(
const _Iterator& __x,
const _Sentinel& __y)
826 requires sized_sentinel_for<_Bound, _Winc>
827 {
return __x._M_value - __y._M_bound; }
829 friend constexpr iter_difference_t<_Winc>
830 operator-(
const _Sentinel& __x,
const _Iterator& __y)
831 requires sized_sentinel_for<_Bound, _Winc>
832 {
return -(__y - __x); }
835 _Winc _M_value = _Winc();
836 _Bound _M_bound = _Bound();
839 iota_view() =
default;
842 iota_view(_Winc __value)
847 iota_view(type_identity_t<_Winc> __value,
848 type_identity_t<_Bound> __bound)
849 : _M_value(__value), _M_bound(__bound)
851 if constexpr (totally_ordered_with<_Winc, _Bound>)
853 __glibcxx_assert(
bool(__value <= __bound) );
858 begin()
const {
return _Iterator{_M_value}; }
863 if constexpr (same_as<_Bound, unreachable_sentinel_t>)
864 return unreachable_sentinel;
866 return _Sentinel{_M_bound};
870 end() const requires same_as<_Winc, _Bound>
871 {
return _Iterator{_M_bound}; }
875 requires (same_as<_Winc, _Bound> && __detail::__advanceable<_Winc>)
876 || (integral<_Winc> && integral<_Bound>)
877 || sized_sentinel_for<_Bound, _Winc>
879 using __detail::__is_integer_like;
880 using __detail::__to_unsigned_like;
881 if constexpr (__is_integer_like<_Winc> && __is_integer_like<_Bound>)
882 return (_M_value < 0)
884 ? __to_unsigned_like(-_M_value) - __to_unsigned_like(-_M_bound)
885 : __to_unsigned_like(_M_bound) + __to_unsigned_like(-_M_value))
886 : __to_unsigned_like(_M_bound) - __to_unsigned_like(_M_value);
888 return __to_unsigned_like(_M_bound - _M_value);
892 template<
typename _Winc,
typename _Bound>
893 requires (!__detail::__is_integer_like<_Winc>
894 || !__detail::__is_integer_like<_Bound>
895 || (__detail::__is_signed_integer_like<_Winc>
896 == __detail::__is_signed_integer_like<_Bound>))
897 iota_view(_Winc, _Bound) -> iota_view<_Winc, _Bound>;
899 template<weakly_incrementable _Winc, semiregular _Bound>
900 inline constexpr
bool
901 enable_borrowed_range<iota_view<_Winc, _Bound>> =
true;
905 template<
typename _Tp>
906 inline constexpr empty_view<_Tp> empty{};
910 template<
typename _Tp>
912 operator()(_Tp&& __e)
const
913 {
return single_view{std::forward<_Tp>(__e)}; }
916 inline constexpr _Single single{};
920 template<
typename _Tp>
922 operator()(_Tp&& __e)
const
923 {
return iota_view{std::forward<_Tp>(__e)}; }
925 template<
typename _Tp,
typename _Up>
927 operator()(_Tp&& __e, _Up&& __f)
const
928 {
return iota_view{std::forward<_Tp>(__e), std::forward<_Up>(__f)}; }
931 inline constexpr _Iota
iota{};
936 template<
typename _Val,
typename _CharT,
typename _Traits>
937 concept __stream_extractable
938 = requires(basic_istream<_CharT, _Traits>& is, _Val& t) { is >> t; };
941 template<movable _Val,
typename _CharT,
typename _Traits>
942 requires default_initializable<_Val>
943 && __detail::__stream_extractable<_Val, _CharT, _Traits>
944 class basic_istream_view
945 :
public view_interface<basic_istream_view<_Val, _CharT, _Traits>>
948 basic_istream_view() =
default;
951 basic_istream_view(basic_istream<_CharT, _Traits>& __stream)
958 if (_M_stream !=
nullptr)
959 *_M_stream >> _M_object;
960 return _Iterator{*
this};
963 constexpr default_sentinel_t
965 {
return default_sentinel; }
968 basic_istream<_CharT, _Traits>* _M_stream =
nullptr;
969 _Val _M_object = _Val();
974 using iterator_concept = input_iterator_tag;
975 using difference_type = ptrdiff_t;
976 using value_type = _Val;
978 _Iterator() =
default;
981 _Iterator(basic_istream_view& __parent) noexcept
985 _Iterator(
const _Iterator&) =
delete;
986 _Iterator(_Iterator&&) =
default;
987 _Iterator& operator=(
const _Iterator&) =
delete;
988 _Iterator& operator=(_Iterator&&) =
default;
993 __glibcxx_assert(_M_parent->_M_stream !=
nullptr);
994 *_M_parent->_M_stream >> _M_parent->_M_object;
1005 __glibcxx_assert(_M_parent->_M_stream !=
nullptr);
1006 return _M_parent->_M_object;
1010 operator==(
const _Iterator& __x, default_sentinel_t)
1011 {
return __x._M_at_end(); }
1014 basic_istream_view* _M_parent =
nullptr;
1018 {
return _M_parent ==
nullptr || !*_M_parent->_M_stream; }
1024 template<
typename _Val,
typename _CharT,
typename _Traits>
1025 basic_istream_view<_Val, _CharT, _Traits>
1026 istream_view(basic_istream<_CharT, _Traits>& __s)
1027 {
return basic_istream_view<_Val, _CharT, _Traits>{__s}; }
1037 template<
bool _Present,
typename _Tp>
1038 using __maybe_present_t = conditional_t<_Present, _Tp, _Empty>;
1041 template<
bool _Const,
typename _Tp>
1042 using __maybe_const_t = conditional_t<_Const, const _Tp, _Tp>;
1050 template<
typename _Tp>
1051 inline constexpr
auto
1052 __maybe_refwrap(_Tp& __arg)
1053 {
return reference_wrapper<_Tp>{__arg}; }
1055 template<
typename _Tp>
1056 inline constexpr
auto
1057 __maybe_refwrap(
const _Tp& __arg)
1058 {
return reference_wrapper<const _Tp>{__arg}; }
1060 template<
typename _Tp>
1061 inline constexpr decltype(
auto)
1062 __maybe_refwrap(_Tp&& __arg)
1063 {
return std::forward<_Tp>(__arg); }
1065 template<
typename _Callable>
1066 struct _RangeAdaptorClosure;
1068 template<
typename _Callable>
1069 struct _RangeAdaptor
1072 [[no_unique_address]]
1073 __detail::__maybe_present_t<!is_default_constructible_v<_Callable>,
1074 _Callable> _M_callable;
1078 _RangeAdaptor(
const _Callable& = {})
1079 requires is_default_constructible_v<_Callable>
1083 _RangeAdaptor(_Callable __callable)
1084 requires (!is_default_constructible_v<_Callable>)
1085 : _M_callable(
std::
move(__callable))
1088 template<
typename... _Args>
1089 requires (
sizeof...(_Args) >= 1)
1091 operator()(_Args&&... __args)
const
1104 if constexpr (is_invocable_v<_Callable, _Args...>)
1106 static_assert(
sizeof...(_Args) != 1,
1107 "a _RangeAdaptor that accepts only one argument "
1108 "should be defined as a _RangeAdaptorClosure");
1111 return _Callable{}(std::forward<_Args>(__args)...);
1124 = [...__args(__maybe_refwrap(std::forward<_Args>(__args)))]
1125 <
typename _Range> (_Range&& __r) {
1129 return _Callable{}(std::forward<_Range>(__r),
1130 (
static_cast<unwrap_reference_t
1134 using _ClosureType = decltype(__closure);
1135 return _RangeAdaptorClosure<_ClosureType>(
std::move(__closure));
1140 template<
typename _Callable>
1141 _RangeAdaptor(_Callable) -> _RangeAdaptor<_Callable>;
1143 template<
typename _Callable>
1144 struct _RangeAdaptorClosure :
public _RangeAdaptor<_Callable>
1146 using _RangeAdaptor<_Callable>::_RangeAdaptor;
1148 template<viewable_range _Range>
1149 requires requires { declval<_Callable>()(declval<_Range>()); }
1151 operator()(_Range&& __r)
const
1153 if constexpr (is_default_constructible_v<_Callable>)
1154 return _Callable{}(std::forward<_Range>(__r));
1156 return this->_M_callable(std::forward<_Range>(__r));
1159 template<viewable_range _Range>
1160 requires requires { declval<_Callable>()(declval<_Range>()); }
1161 friend constexpr
auto
1162 operator|(_Range&& __r,
const _RangeAdaptorClosure& __o)
1163 {
return __o(std::forward<_Range>(__r)); }
1165 template<
typename _Tp>
1166 friend constexpr
auto
1167 operator|(
const _RangeAdaptorClosure<_Tp>& __x,
1168 const _RangeAdaptorClosure& __y)
1170 if constexpr (is_default_constructible_v<_Tp>
1171 && is_default_constructible_v<_Callable>)
1173 auto __closure = [] <
typename _Up> (_Up&& __e) {
1174 return std::forward<_Up>(__e) | decltype(__x){} | decltype(__y){};
1176 return _RangeAdaptorClosure<decltype(__closure)>(__closure);
1178 else if constexpr (is_default_constructible_v<_Tp>
1179 && !is_default_constructible_v<_Callable>)
1181 auto __closure = [__y] <
typename _Up> (_Up&& __e) {
1182 return std::forward<_Up>(__e) | decltype(__x){} | __y;
1184 return _RangeAdaptorClosure<decltype(__closure)>(__closure);
1186 else if constexpr (!is_default_constructible_v<_Tp>
1187 && is_default_constructible_v<_Callable>)
1189 auto __closure = [__x] <
typename _Up> (_Up&& __e) {
1190 return std::forward<_Up>(__e) | __x | decltype(__y){};
1192 return _RangeAdaptorClosure<decltype(__closure)>(__closure);
1196 auto __closure = [__x, __y] <
typename _Up> (_Up&& __e) {
1197 return std::forward<_Up>(__e) | __x | __y;
1199 return _RangeAdaptorClosure<decltype(__closure)>(__closure);
1204 template<
typename _Callable>
1205 _RangeAdaptorClosure(_Callable) -> _RangeAdaptorClosure<_Callable>;
1209 template<range _Range> requires is_object_v<_Range>
1210 class ref_view :
public view_interface<ref_view<_Range>>
1213 _Range* _M_r =
nullptr;
1215 static void _S_fun(_Range&);
1216 static void _S_fun(_Range&&) =
delete;
1220 ref_view() noexcept = default;
1222 template<__detail::__not_same_as<ref_view> _Tp>
1223 requires convertible_to<_Tp, _Range&>
1224 && requires { _S_fun(declval<_Tp>()); }
1234 constexpr iterator_t<_Range>
1238 constexpr sentinel_t<_Range>
1243 empty() const requires requires { ranges::empty(*_M_r); }
1244 {
return ranges::empty(*_M_r); }
1247 size() const requires sized_range<_Range>
1248 {
return ranges::size(*_M_r); }
1251 data() const requires contiguous_range<_Range>
1252 {
return ranges::data(*_M_r); }
1255 template<
typename _Range>
1256 ref_view(_Range&) -> ref_view<_Range>;
1258 template<
typename _Tp>
1259 inline constexpr
bool enable_borrowed_range<ref_view<_Tp>> =
true;
1263 inline constexpr __adaptor::_RangeAdaptorClosure all
1264 = [] <viewable_range _Range> (_Range&& __r)
1266 if constexpr (view<decay_t<_Range>>)
1268 else if constexpr (requires { ref_view{std::forward<_Range>(__r)}; })
1269 return ref_view{std::forward<_Range>(__r)};
1271 return subrange{std::forward<_Range>(__r)};
1274 template<viewable_range _Range>
1275 using all_t = decltype(all(std::declval<_Range>()));
1283 template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
1284 typename _Proj =
identity,
1285 indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
1287 find_if(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {})
1289 while (__first != __last
1295 template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
1296 typename _Proj =
identity,
1297 indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
1299 find_if_not(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {})
1301 while (__first != __last
1307 template<
typename _Tp,
typename _Proj = identity,
1308 indirect_strict_weak_order<projected<const _Tp*, _Proj>>
1309 _Comp = ranges::less>
1310 constexpr
const _Tp&
1311 min(
const _Tp& __a,
const _Tp& __b, _Comp __comp = {}, _Proj __proj = {})
1321 template<input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
1322 input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
1323 typename _Pred = ranges::equal_to,
1324 typename _Proj1 =
identity,
typename _Proj2 =
identity>
1325 requires indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
1326 constexpr pair<_Iter1, _Iter2>
1327 mismatch(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2,
1328 _Pred __pred = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {})
1330 while (__first1 != __last1 && __first2 != __last2
1344 template<range _Range>
1345 struct _CachedPosition
1348 _M_has_value()
const
1351 constexpr iterator_t<_Range>
1352 _M_get(
const _Range&)
const
1354 __glibcxx_assert(
false);
1359 _M_set(
const _Range&,
const iterator_t<_Range>&)
const
1363 template<forward_range _Range>
1364 struct _CachedPosition<_Range>
1367 iterator_t<_Range> _M_iter{};
1371 _M_has_value()
const
1372 {
return _M_iter != iterator_t<_Range>{}; }
1374 constexpr iterator_t<_Range>
1375 _M_get(
const _Range&)
const
1377 __glibcxx_assert(_M_has_value());
1382 _M_set(
const _Range&,
const iterator_t<_Range>& __it)
1384 __glibcxx_assert(!_M_has_value());
1389 template<random_access_range _Range>
1390 requires (
sizeof(range_difference_t<_Range>)
1391 <=
sizeof(iterator_t<_Range>))
1392 struct _CachedPosition<_Range>
1395 range_difference_t<_Range> _M_offset = -1;
1399 _M_has_value()
const
1400 {
return _M_offset >= 0; }
1402 constexpr iterator_t<_Range>
1403 _M_get(_Range& __r)
const
1405 __glibcxx_assert(_M_has_value());
1410 _M_set(_Range& __r,
const iterator_t<_Range>& __it)
1412 __glibcxx_assert(!_M_has_value());
1419 template<input_range _Vp,
1420 indirect_unary_predicate<iterator_t<_Vp>> _Pred>
1421 requires view<_Vp> && is_object_v<_Pred>
1422 class filter_view :
public view_interface<filter_view<_Vp, _Pred>>
1430 static constexpr
auto
1433 if constexpr (bidirectional_range<_Vp>)
1434 return bidirectional_iterator_tag{};
1435 else if constexpr (forward_range<_Vp>)
1436 return forward_iterator_tag{};
1438 return input_iterator_tag{};
1441 static constexpr
auto
1444 using _Cat =
typename iterator_traits<_Vp_iter>::iterator_category;
1445 if constexpr (derived_from<_Cat, bidirectional_iterator_tag>)
1446 return bidirectional_iterator_tag{};
1447 else if constexpr (derived_from<_Cat, forward_iterator_tag>)
1448 return forward_iterator_tag{};
1455 using _Vp_iter = iterator_t<_Vp>;
1457 _Vp_iter _M_current = _Vp_iter();
1458 filter_view* _M_parent =
nullptr;
1461 using iterator_concept = decltype(_S_iter_concept());
1462 using iterator_category = decltype(_S_iter_cat());
1463 using value_type = range_value_t<_Vp>;
1464 using difference_type = range_difference_t<_Vp>;
1466 _Iterator() =
default;
1469 _Iterator(filter_view& __parent, _Vp_iter __current)
1470 : _M_current(
std::
move(__current)),
1476 requires copyable<_Vp_iter>
1477 {
return _M_current; }
1483 constexpr range_reference_t<_Vp>
1485 {
return *_M_current; }
1489 requires __detail::__has_arrow<_Vp_iter>
1490 && copyable<_Vp_iter>
1491 {
return _M_current; }
1493 constexpr _Iterator&
1496 _M_current = __detail::find_if(
std::move(++_M_current),
1498 std::ref(*_M_parent->_M_pred));
1507 operator++(
int) requires forward_range<_Vp>
1514 constexpr _Iterator&
1515 operator--() requires bidirectional_range<_Vp>
1524 operator--(
int) requires bidirectional_range<_Vp>
1531 friend constexpr
bool
1532 operator==(
const _Iterator& __x,
const _Iterator& __y)
1533 requires equality_comparable<_Vp_iter>
1534 {
return __x._M_current == __y._M_current; }
1536 friend constexpr range_rvalue_reference_t<_Vp>
1537 iter_move(
const _Iterator& __i)
1538 noexcept(noexcept(ranges::iter_move(__i._M_current)))
1539 {
return ranges::iter_move(__i._M_current); }
1541 friend constexpr
void
1542 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
1543 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1544 requires indirectly_swappable<_Vp_iter>
1545 { ranges::iter_swap(__x._M_current, __y._M_current); }
1551 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
1554 __equal(
const _Iterator& __i)
const
1555 {
return __i._M_current == _M_end; }
1558 _Sentinel() =
default;
1561 _Sentinel(filter_view& __parent)
1562 : _M_end(ranges::
end(__parent._M_base))
1565 constexpr sentinel_t<_Vp>
1569 friend constexpr
bool
1570 operator==(
const _Iterator& __x,
const _Sentinel& __y)
1571 {
return __y.__equal(__x); }
1574 _Vp _M_base = _Vp();
1575 __detail::__box<_Pred> _M_pred;
1576 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
1579 filter_view() =
default;
1582 filter_view(_Vp
__base, _Pred __pred)
1587 base() const& requires copy_constructible<_Vp>
1594 constexpr
const _Pred&
1596 {
return *_M_pred; }
1601 if (_M_cached_begin._M_has_value())
1602 return {*
this, _M_cached_begin._M_get(_M_base)};
1604 __glibcxx_assert(_M_pred.has_value());
1607 std::ref(*_M_pred));
1608 _M_cached_begin._M_set(_M_base, __it);
1615 if constexpr (common_range<_Vp>)
1618 return _Sentinel{*
this};
1622 template<
typename _Range,
typename _Pred>
1623 filter_view(_Range&&, _Pred) -> filter_view<views::all_t<_Range>, _Pred>;
1627 inline constexpr __adaptor::_RangeAdaptor filter
1628 = [] <viewable_range _Range,
typename _Pred> (_Range&& __r, _Pred&& __p)
1630 return filter_view{std::forward<_Range>(__r), std::forward<_Pred>(__p)};
1634 template<input_range _Vp, copy_constructible _Fp>
1635 requires view<_Vp> && is_object_v<_Fp>
1636 && regular_invocable<_Fp&, range_reference_t<_Vp>>
1637 && std::__detail::__can_reference<invoke_result_t<_Fp&,
1638 range_reference_t<_Vp>>>
1639 class transform_view :
public view_interface<transform_view<_Vp, _Fp>>
1642 template<
bool _Const>
1645 template<
bool _Const>
1649 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
1650 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
1652 static constexpr
auto
1655 if constexpr (random_access_range<_Vp>)
1656 return random_access_iterator_tag{};
1657 else if constexpr (bidirectional_range<_Vp>)
1658 return bidirectional_iterator_tag{};
1659 else if constexpr (forward_range<_Vp>)
1660 return forward_iterator_tag{};
1662 return input_iterator_tag{};
1665 static constexpr
auto
1668 using _Res = invoke_result_t<_Fp&, range_reference_t<_Base>>;
1669 if constexpr (is_lvalue_reference_v<_Res>)
1672 =
typename iterator_traits<_Base_iter>::iterator_category;
1673 if constexpr (derived_from<_Cat, contiguous_iterator_tag>)
1674 return random_access_iterator_tag{};
1679 return input_iterator_tag{};
1682 static constexpr decltype(
auto)
1683 __iter_move(const _Iterator& __i = {})
1687 if constexpr (is_lvalue_reference_v<decltype(*__i)>)
1693 using _Base_iter = iterator_t<_Base>;
1695 _Base_iter _M_current = _Base_iter();
1696 _Parent* _M_parent =
nullptr;
1699 using iterator_concept = decltype(_S_iter_concept());
1700 using iterator_category = decltype(_S_iter_cat());
1702 = remove_cvref_t<invoke_result_t<_Fp&, range_reference_t<_Base>>>;
1703 using difference_type = range_difference_t<_Base>;
1705 _Iterator() = default;
1708 _Iterator(_Parent& __parent, _Base_iter __current)
1709 : _M_current(
std::
move(__current)),
1714 _Iterator(_Iterator<!_Const> __i)
1716 && convertible_to<iterator_t<_Vp>, _Base_iter>
1717 : _M_current(
std::move(__i._M_current)), _M_parent(__i._M_parent)
1720 constexpr _Base_iter
1722 requires copyable<_Base_iter>
1723 {
return _M_current; }
1725 constexpr _Base_iter
1729 constexpr decltype(
auto)
1733 constexpr _Iterator&
1745 operator++(
int) requires forward_range<_Base>
1752 constexpr _Iterator&
1753 operator--() requires bidirectional_range<_Base>
1760 operator--(
int) requires bidirectional_range<_Base>
1767 constexpr _Iterator&
1768 operator+=(difference_type __n) requires random_access_range<_Base>
1774 constexpr _Iterator&
1775 operator-=(difference_type __n) requires random_access_range<_Base>
1781 constexpr decltype(
auto)
1782 operator[](difference_type __n) const
1783 requires random_access_range<_Base>
1784 {
return std::__invoke(*_M_parent->_M_fun, _M_current[__n]); }
1786 friend constexpr
bool
1787 operator==(
const _Iterator& __x,
const _Iterator& __y)
1788 requires equality_comparable<_Base_iter>
1789 {
return __x._M_current == __y._M_current; }
1791 friend constexpr
bool
1792 operator<(
const _Iterator& __x,
const _Iterator& __y)
1793 requires random_access_range<_Base>
1794 {
return __x._M_current < __y._M_current; }
1796 friend constexpr
bool
1797 operator>(
const _Iterator& __x,
const _Iterator& __y)
1798 requires random_access_range<_Base>
1799 {
return __y < __x; }
1801 friend constexpr
bool
1802 operator<=(
const _Iterator& __x,
const _Iterator& __y)
1803 requires random_access_range<_Base>
1804 {
return !(__y < __x); }
1806 friend constexpr
bool
1807 operator>=(
const _Iterator& __x,
const _Iterator& __y)
1808 requires random_access_range<_Base>
1809 {
return !(__x < __y); }
1811 #ifdef __cpp_lib_three_way_comparison
1812 friend constexpr
auto
1813 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
1814 requires random_access_range<_Base>
1815 && three_way_comparable<_Base_iter>
1816 {
return __x._M_current <=> __y._M_current; }
1819 friend constexpr _Iterator
1820 operator+(_Iterator __i, difference_type __n)
1821 requires random_access_range<_Base>
1822 {
return {*__i._M_parent, __i._M_current + __n}; }
1824 friend constexpr _Iterator
1825 operator+(difference_type __n, _Iterator __i)
1826 requires random_access_range<_Base>
1827 {
return {*__i._M_parent, __i._M_current + __n}; }
1829 friend constexpr _Iterator
1830 operator-(_Iterator __i, difference_type __n)
1831 requires random_access_range<_Base>
1832 {
return {*__i._M_parent, __i._M_current - __n}; }
1834 friend constexpr difference_type
1835 operator-(
const _Iterator& __x,
const _Iterator& __y)
1836 requires random_access_range<_Base>
1837 {
return __x._M_current - __y._M_current; }
1839 friend constexpr decltype(
auto)
1840 iter_move(const _Iterator& __i) noexcept(noexcept(__iter_move()))
1841 {
return __iter_move(__i); }
1843 friend constexpr
void
1844 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
1845 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1846 requires indirectly_swappable<_Base_iter>
1847 {
return ranges::iter_swap(__x._M_current, __y._M_current); }
1849 friend _Iterator<!_Const>;
1850 friend _Sentinel<_Const>;
1853 template<
bool _Const>
1857 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
1858 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
1860 constexpr range_difference_t<_Base>
1861 __distance_from(
const _Iterator<_Const>& __i)
const
1862 {
return _M_end - __i._M_current; }
1865 __equal(
const _Iterator<_Const>& __i)
const
1866 {
return __i._M_current == _M_end; }
1868 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
1871 _Sentinel() =
default;
1874 _Sentinel(sentinel_t<_Base> __end)
1879 _Sentinel(_Sentinel<!_Const> __i)
1881 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
1885 constexpr sentinel_t<_Base>
1889 friend constexpr
bool
1890 operator==(
const _Iterator<_Const>& __x,
const _Sentinel& __y)
1891 {
return __y.__equal(__x); }
1893 friend constexpr range_difference_t<_Base>
1894 operator-(
const _Iterator<_Const>& __x,
const _Sentinel& __y)
1895 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
1896 {
return -__y.__distance_from(__x); }
1898 friend constexpr range_difference_t<_Base>
1899 operator-(
const _Sentinel& __y,
const _Iterator<_Const>& __x)
1900 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
1901 {
return __y.__distance_from(__x); }
1903 friend _Sentinel<!_Const>;
1906 _Vp _M_base = _Vp();
1907 __detail::__box<_Fp> _M_fun;
1910 transform_view() =
default;
1913 transform_view(_Vp
__base, _Fp __fun)
1918 base() const& requires copy_constructible<_Vp>
1919 {
return _M_base ; }
1925 constexpr _Iterator<false>
1929 constexpr _Iterator<true>
1931 requires range<const _Vp>
1932 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
1935 constexpr _Sentinel<false>
1937 {
return _Sentinel<false>{
ranges::end(_M_base)}; }
1939 constexpr _Iterator<false>
1940 end() requires common_range<_Vp>
1941 {
return _Iterator<false>{*
this,
ranges::end(_M_base)}; }
1943 constexpr _Sentinel<true>
1945 requires range<const _Vp>
1946 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
1949 constexpr _Iterator<true>
1951 requires common_range<const _Vp>
1952 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
1953 {
return _Iterator<true>{*
this,
ranges::end(_M_base)}; }
1956 size() requires sized_range<_Vp>
1957 {
return ranges::size(_M_base); }
1960 size() const requires sized_range<const _Vp>
1961 {
return ranges::size(_M_base); }
1964 template<
typename _Range,
typename _Fp>
1965 transform_view(_Range&&, _Fp) -> transform_view<views::all_t<_Range>, _Fp>;
1969 inline constexpr __adaptor::_RangeAdaptor transform
1970 = [] <viewable_range _Range,
typename _Fp> (_Range&& __r, _Fp&& __f)
1972 return transform_view{std::forward<_Range>(__r), std::forward<_Fp>(__f)};
1977 class take_view :
public view_interface<take_view<_Vp>>
1980 template<
bool _Const>
1984 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
1985 using _CI = counted_iterator<iterator_t<_Base>>;
1987 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
1990 _Sentinel() =
default;
1993 _Sentinel(sentinel_t<_Base> __end)
1998 _Sentinel(_Sentinel<!_Const> __s)
1999 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2003 constexpr sentinel_t<_Base>
2007 friend constexpr
bool operator==(
const _CI& __y,
const _Sentinel& __x)
2008 {
return __y.count() == 0 || __y.base() == __x._M_end; }
2010 friend _Sentinel<!_Const>;
2013 _Vp _M_base = _Vp();
2014 range_difference_t<_Vp> _M_count = 0;
2017 take_view() =
default;
2020 take_view(_Vp base, range_difference_t<_Vp> __count)
2025 base() const& requires copy_constructible<_Vp>
2033 begin() requires (!__detail::__simple_view<_Vp>)
2035 if constexpr (sized_range<_Vp>)
2037 if constexpr (random_access_range<_Vp>)
2047 begin() const requires range<const _Vp>
2049 if constexpr (sized_range<const _Vp>)
2051 if constexpr (random_access_range<const _Vp>)
2061 end() requires (!__detail::__simple_view<_Vp>)
2063 if constexpr (sized_range<_Vp>)
2065 if constexpr (random_access_range<_Vp>)
2068 return default_sentinel;
2075 end() const requires range<const _Vp>
2077 if constexpr (sized_range<const _Vp>)
2079 if constexpr (random_access_range<const _Vp>)
2082 return default_sentinel;
2089 size() requires sized_range<_Vp>
2091 auto __n = ranges::size(_M_base);
2092 return __detail::min(__n,
static_cast<decltype(__n)
>(_M_count));
2096 size() const requires sized_range<const _Vp>
2098 auto __n = ranges::size(_M_base);
2099 return __detail::min(__n,
static_cast<decltype(__n)
>(_M_count));
2103 template<range _Range>
2104 take_view(_Range&&, range_difference_t<_Range>)
2105 -> take_view<views::all_t<_Range>>;
2109 inline constexpr __adaptor::_RangeAdaptor take
2110 = [] <viewable_range _Range,
typename _Tp> (_Range&& __r, _Tp&& __n)
2112 return take_view{std::forward<_Range>(__r), std::forward<_Tp>(__n)};
2116 template<view _Vp,
typename _Pred>
2117 requires input_range<_Vp> && is_object_v<_Pred>
2118 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2119 class take_while_view :
public view_interface<take_while_view<_Vp, _Pred>>
2121 template<
bool _Const>
2125 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2127 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2128 const _Pred* _M_pred =
nullptr;
2131 _Sentinel() =
default;
2134 _Sentinel(sentinel_t<_Base> __end,
const _Pred* __pred)
2135 : _M_end(__end), _M_pred(__pred)
2139 _Sentinel(_Sentinel<!_Const> __s)
2140 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2141 : _M_end(__s._M_end), _M_pred(__s._M_pred)
2144 constexpr sentinel_t<_Base>
2145 base()
const {
return _M_end; }
2147 friend constexpr
bool
2148 operator==(
const iterator_t<_Base>& __x,
const _Sentinel& __y)
2149 {
return __y._M_end == __x || !
std::__invoke(*__y._M_pred, *__x); }
2151 friend _Sentinel<!_Const>;
2154 _Vp _M_base = _Vp();
2155 __detail::__box<_Pred> _M_pred;
2158 take_while_view() =
default;
2161 take_while_view(_Vp base, _Pred __pred)
2167 base() const& requires copy_constructible<_Vp>
2174 constexpr
const _Pred&
2176 {
return *_M_pred; }
2179 begin() requires (!__detail::__simple_view<_Vp>)
2183 begin() const requires range<const _Vp>
2187 end() requires (!__detail::__simple_view<_Vp>)
2192 end() const requires range<const _Vp>
2197 template<
typename _Range,
typename _Pred>
2198 take_while_view(_Range&&, _Pred)
2199 -> take_while_view<views::all_t<_Range>, _Pred>;
2203 inline constexpr __adaptor::_RangeAdaptor take_while
2204 = [] <viewable_range _Range,
typename _Pred> (_Range&& __r, _Pred&& __p)
2206 return take_while_view{std::forward<_Range>(__r), std::forward<_Pred>(__p)};
2211 class drop_view :
public view_interface<drop_view<_Vp>>
2214 _Vp _M_base = _Vp();
2215 range_difference_t<_Vp> _M_count = 0;
2217 static constexpr
bool _S_needs_cached_begin = !random_access_range<_Vp>;
2218 [[no_unique_address]]
2219 __detail::__maybe_present_t<_S_needs_cached_begin,
2220 __detail::_CachedPosition<_Vp>>
2224 drop_view() =
default;
2227 drop_view(_Vp
__base, range_difference_t<_Vp> __count)
2229 { __glibcxx_assert(__count >= 0); }
2232 base() const& requires copy_constructible<_Vp>
2240 begin() requires (!(__detail::__simple_view<_Vp>
2241 && random_access_range<_Vp>))
2243 if constexpr (_S_needs_cached_begin)
2244 if (_M_cached_begin._M_has_value())
2245 return _M_cached_begin._M_get(_M_base);
2249 if constexpr (_S_needs_cached_begin)
2250 _M_cached_begin._M_set(_M_base, __it);
2255 begin() const requires random_access_range<const _Vp>
2262 end() requires (!__detail::__simple_view<_Vp>)
2266 end() const requires range<const _Vp>
2270 size() requires sized_range<_Vp>
2272 const auto __s = ranges::size(_M_base);
2273 const auto __c = static_cast<decltype(__s)>(_M_count);
2274 return __s < __c ? 0 : __s - __c;
2278 size() const requires sized_range<const _Vp>
2280 const auto __s = ranges::size(_M_base);
2281 const auto __c = static_cast<decltype(__s)>(_M_count);
2282 return __s < __c ? 0 : __s - __c;
2286 template<
typename _Range>
2287 drop_view(_Range&&, range_difference_t<_Range>)
2288 -> drop_view<views::all_t<_Range>>;
2292 inline constexpr __adaptor::_RangeAdaptor drop
2293 = [] <viewable_range _Range,
typename _Tp> (_Range&& __r, _Tp&& __n)
2295 return drop_view{std::forward<_Range>(__r), std::forward<_Tp>(__n)};
2299 template<view _Vp,
typename _Pred>
2300 requires input_range<_Vp> && is_object_v<_Pred>
2301 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2302 class drop_while_view :
public view_interface<drop_while_view<_Vp, _Pred>>
2305 _Vp _M_base = _Vp();
2306 __detail::__box<_Pred> _M_pred;
2307 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
2310 drop_while_view() =
default;
2313 drop_while_view(_Vp
__base, _Pred __pred)
2318 base() const& requires copy_constructible<_Vp>
2325 constexpr
const _Pred&
2327 {
return *_M_pred; }
2332 if (_M_cached_begin._M_has_value())
2333 return _M_cached_begin._M_get(_M_base);
2337 std::cref(*_M_pred));
2338 _M_cached_begin._M_set(_M_base, __it);
2347 template<
typename _Range,
typename _Pred>
2348 drop_while_view(_Range&&, _Pred)
2349 -> drop_while_view<views::all_t<_Range>, _Pred>;
2353 inline constexpr __adaptor::_RangeAdaptor drop_while
2354 = [] <viewable_range _Range,
typename _Pred> (_Range&& __r, _Pred&& __p)
2356 return drop_while_view{std::forward<_Range>(__r),
2357 std::forward<_Pred>(__p)};
2361 template<input_range _Vp>
2362 requires view<_Vp> && input_range<range_reference_t<_Vp>>
2363 && (is_reference_v<range_reference_t<_Vp>>
2364 || view<range_value_t<_Vp>>)
2365 class join_view :
public view_interface<join_view<_Vp>>
2368 using _InnerRange = range_reference_t<_Vp>;
2370 template<
bool _Const>
2373 template<
bool _Const>
2377 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
2378 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2380 static constexpr
bool _S_ref_is_glvalue
2381 = is_reference_v<range_reference_t<_Base>>;
2386 auto __update_inner = [
this] (range_reference_t<_Base> __x) ->
auto&
2388 if constexpr (_S_ref_is_glvalue)
2391 return (_M_parent->_M_inner = views::all(
std::move(__x)));
2394 for (; _M_outer !=
ranges::end(_M_parent->_M_base); ++_M_outer)
2396 auto& inner = __update_inner(*_M_outer);
2402 if constexpr (_S_ref_is_glvalue)
2403 _M_inner = _Inner_iter();
2406 static constexpr
auto
2409 if constexpr (_S_ref_is_glvalue
2410 && bidirectional_range<_Base>
2411 && bidirectional_range<range_reference_t<_Base>>)
2412 return bidirectional_iterator_tag{};
2413 else if constexpr (_S_ref_is_glvalue
2414 && forward_range<_Base>
2415 && forward_range<range_reference_t<_Base>>)
2416 return forward_iterator_tag{};
2418 return input_iterator_tag{};
2421 static constexpr
auto
2425 =
typename iterator_traits<_Outer_iter>::iterator_category;
2427 =
typename iterator_traits<_Inner_iter>::iterator_category;
2428 if constexpr (_S_ref_is_glvalue
2429 && derived_from<_OuterCat, bidirectional_iterator_tag>
2430 && derived_from<_InnerCat, bidirectional_iterator_tag>)
2431 return bidirectional_iterator_tag{};
2432 else if constexpr (_S_ref_is_glvalue
2433 && derived_from<_OuterCat, forward_iterator_tag>
2434 && derived_from<_InnerCat, forward_iterator_tag>)
2435 return forward_iterator_tag{};
2436 else if constexpr (derived_from<_OuterCat, input_iterator_tag>
2437 && derived_from<_InnerCat, input_iterator_tag>)
2438 return input_iterator_tag{};
2440 return output_iterator_tag{};
2443 using _Outer_iter = iterator_t<_Base>;
2444 using _Inner_iter = iterator_t<range_reference_t<_Base>>;
2446 _Outer_iter _M_outer = _Outer_iter();
2447 _Inner_iter _M_inner = _Inner_iter();
2448 _Parent* _M_parent =
nullptr;
2451 using iterator_concept = decltype(_S_iter_concept());
2452 using iterator_category = decltype(_S_iter_cat());
2453 using value_type = range_value_t<range_reference_t<_Base>>;
2454 using difference_type
2455 = common_type_t<range_difference_t<_Base>,
2456 range_difference_t<range_reference_t<_Base>>>;
2458 _Iterator() =
default;
2461 _Iterator(_Parent& __parent, _Outer_iter __outer)
2462 : _M_outer(
std::
move(__outer)),
2467 _Iterator(_Iterator<!_Const> __i)
2469 && convertible_to<iterator_t<_Vp>, _Outer_iter>
2470 && convertible_to<iterator_t<_InnerRange>, _Inner_iter>
2471 : _M_outer(
std::move(__i._M_outer)), _M_inner(__i._M_inner),
2472 _M_parent(__i._M_parent)
2475 constexpr decltype(
auto)
2477 {
return *_M_inner; }
2479 constexpr _Outer_iter
2481 requires __detail::__has_arrow<_Outer_iter>
2482 && copyable<_Outer_iter>
2483 {
return _M_inner; }
2485 constexpr _Iterator&
2488 auto&& __inner_range = [
this] () -> decltype(
auto) {
2489 if constexpr (_S_ref_is_glvalue)
2492 return _M_parent->_M_inner;
2508 requires _S_ref_is_glvalue && forward_range<_Base>
2509 && forward_range<range_reference_t<_Base>>
2516 constexpr _Iterator&
2518 requires _S_ref_is_glvalue && bidirectional_range<_Base>
2519 && bidirectional_range<range_reference_t<_Base>>
2520 && common_range<range_reference_t<_Base>>
2532 requires _S_ref_is_glvalue && bidirectional_range<_Base>
2533 && bidirectional_range<range_reference_t<_Base>>
2534 && common_range<range_reference_t<_Base>>
2541 friend constexpr
bool
2542 operator==(
const _Iterator& __x,
const _Iterator& __y)
2543 requires _S_ref_is_glvalue
2544 && equality_comparable<_Outer_iter>
2545 && equality_comparable<_Inner_iter>
2547 return (__x._M_outer == __y._M_outer
2548 && __x._M_inner == __y._M_inner);
2551 friend constexpr decltype(
auto)
2552 iter_move(const _Iterator& __i)
2553 noexcept(noexcept(ranges::iter_move(__i._M_inner)))
2554 {
return ranges::iter_move(__i._M_inner); }
2556 friend constexpr
void
2557 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
2558 noexcept(noexcept(ranges::iter_swap(__x._M_inner, __y._M_inner)))
2559 {
return ranges::iter_swap(__x._M_inner, __y._M_inner); }
2561 friend _Iterator<!_Const>;
2562 friend _Sentinel<_Const>;
2565 template<
bool _Const>
2569 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
2570 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2573 __equal(
const _Iterator<_Const>& __i)
const
2574 {
return __i._M_outer == _M_end; }
2576 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2579 _Sentinel() =
default;
2582 _Sentinel(_Parent& __parent)
2583 : _M_end(ranges::
end(__parent._M_base))
2587 _Sentinel(_Sentinel<!_Const> __s)
2588 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2592 friend constexpr
bool
2593 operator==(
const _Iterator<_Const>& __x,
const _Sentinel& __y)
2594 {
return __y.__equal(__x); }
2597 _Vp _M_base = _Vp();
2600 [[no_unique_address]]
2601 __detail::__maybe_present_t<!is_reference_v<_InnerRange>,
2602 views::all_t<_InnerRange>> _M_inner;
2605 join_view() =
default;
2613 base() const& requires copy_constructible<_Vp>
2623 constexpr
bool __use_const
2624 = (__detail::__simple_view<_Vp>
2625 && is_reference_v<range_reference_t<_Vp>>);
2626 return _Iterator<__use_const>{*
this,
ranges::begin(_M_base)};
2631 requires input_range<const _Vp>
2632 && is_reference_v<range_reference_t<const _Vp>>
2640 if constexpr (forward_range<_Vp> && is_reference_v<_InnerRange>
2641 && forward_range<_InnerRange>
2642 && common_range<_Vp> && common_range<_InnerRange>)
2643 return _Iterator<__detail::__simple_view<_Vp>>{*
this,
2646 return _Sentinel<__detail::__simple_view<_Vp>>{*
this};
2651 requires input_range<const _Vp>
2652 && is_reference_v<range_reference_t<const _Vp>>
2654 if constexpr (forward_range<const _Vp>
2655 && is_reference_v<range_reference_t<const _Vp>>
2656 && forward_range<range_reference_t<const _Vp>>
2657 && common_range<const _Vp>
2658 && common_range<range_reference_t<const _Vp>>)
2659 return _Iterator<true>{*
this,
ranges::end(_M_base)};
2661 return _Sentinel<true>{*
this};
2665 template<
typename _Range>
2666 explicit join_view(_Range&&) -> join_view<views::all_t<_Range>>;
2670 inline constexpr __adaptor::_RangeAdaptorClosure join
2671 = [] <viewable_range _Range> (_Range&& __r)
2673 return join_view{std::forward<_Range>(__r)};
2680 struct __require_constant;
2682 template<
typename _Range>
2683 concept __tiny_range = sized_range<_Range>
2685 {
typename __require_constant<remove_reference_t<_Range>::size()>; }
2686 && (remove_reference_t<_Range>::size() <= 1);
2689 template<input_range _Vp, forward_range _Pattern>
2690 requires view<_Vp> && view<_Pattern>
2691 && indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
2693 && (forward_range<_Vp> || __detail::__tiny_range<_Pattern>)
2694 class split_view :
public view_interface<split_view<_Vp, _Pattern>>
2697 template<
bool _Const>
2700 template<
bool _Const>
2704 using _Parent = __detail::__maybe_const_t<_Const, split_view>;
2705 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2709 {
return _M_current ==
ranges::end(_M_parent->_M_base); }
2718 if constexpr (forward_range<_Vp>)
2721 return _M_parent->_M_current;
2727 if constexpr (forward_range<_Vp>)
2730 return _M_parent->_M_current;
2733 _Parent* _M_parent =
nullptr;
2736 [[no_unique_address]]
2737 __detail::__maybe_present_t<forward_range<_Vp>,
2738 iterator_t<_Base>> _M_current;
2741 using iterator_concept = conditional_t<forward_range<_Base>,
2742 forward_iterator_tag,
2743 input_iterator_tag>;
2744 using iterator_category = input_iterator_tag;
2745 using difference_type = range_difference_t<_Base>;
2747 struct value_type : view_interface<value_type>
2750 _OuterIter _M_i = _OuterIter();
2753 value_type() =
default;
2756 value_type(_OuterIter __i)
2760 constexpr _InnerIter<_Const>
2762 requires copyable<_OuterIter>
2763 {
return _InnerIter<_Const>{_M_i}; }
2765 constexpr _InnerIter<_Const>
2767 requires (!copyable<_OuterIter>)
2768 {
return _InnerIter<_Const>{
std::move(_M_i)}; }
2770 constexpr default_sentinel_t
2772 {
return default_sentinel; }
2775 _OuterIter() =
default;
2778 _OuterIter(_Parent& __parent) requires (!forward_range<_Base>)
2779 : _M_parent(address(__parent))
2783 _OuterIter(_Parent& __parent, iterator_t<_Base> __current)
2784 requires forward_range<_Base>
2790 _OuterIter(_OuterIter<!_Const> __i)
2792 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
2793 : _M_parent(__i._M_parent), _M_current(
std::move(__i._M_current))
2796 constexpr value_type
2798 {
return value_type{*
this}; }
2800 constexpr _OuterIter&
2803 const auto __end =
ranges::end(_M_parent->_M_base);
2804 if (_M_current == __end)
2806 const auto [__pbegin, __pend] = subrange{_M_parent->_M_pattern};
2807 if (__pbegin == __pend)
2813 = __detail::mismatch(
std::move(_M_current), __end,
2818 }
while (++_M_current != __end);
2822 constexpr decltype(
auto)
2825 if constexpr (forward_range<_Base>)
2835 friend constexpr
bool
2836 operator==(
const _OuterIter& __x,
const _OuterIter& __y)
2837 requires forward_range<_Base>
2838 {
return __x._M_current == __y._M_current; }
2840 friend constexpr
bool
2841 operator==(
const _OuterIter& __x, default_sentinel_t)
2842 {
return __x.__at_end(); };
2844 friend _OuterIter<!_Const>;
2845 friend _InnerIter<_Const>;
2848 template<
bool _Const>
2852 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2857 auto [__pcur, __pend] = subrange{_M_i._M_parent->_M_pattern};
2858 auto __end =
ranges::end(_M_i._M_parent->_M_base);
2859 if constexpr (__detail::__tiny_range<_Pattern>)
2861 const auto& __cur = _M_i.__current();
2864 if (__pcur == __pend)
2865 return _M_incremented;
2866 return *__cur == *__pcur;
2870 auto __cur = _M_i.__current();
2873 if (__pcur == __pend)
2874 return _M_incremented;
2877 if (*__cur != *__pcur)
2879 if (++__pcur == __pend)
2881 }
while (++__cur != __end);
2886 static constexpr
auto
2890 =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
2891 if constexpr (derived_from<_Cat, forward_iterator_tag>)
2892 return forward_iterator_tag{};
2897 static constexpr decltype(
auto)
2898 __iter_move(const _InnerIter& __i = {})
2899 noexcept(noexcept(ranges::iter_move(__i._M_i.__current())))
2900 {
return ranges::iter_move(__i._M_i.__current()); }
2902 static constexpr
void
2903 __iter_swap(
const _InnerIter& __x = {},
const _InnerIter& __y = {})
2904 noexcept(noexcept(ranges::iter_swap(__x._M_i.__current(),
2905 __y._M_i.__current())))
2906 { ranges::iter_swap(__x._M_i.__current(), __y._M_i.__current()); }
2908 _OuterIter<_Const> _M_i = _OuterIter<_Const>();
2909 bool _M_incremented =
false;
2912 using iterator_concept
2913 =
typename _OuterIter<_Const>::iterator_concept;
2914 using iterator_category = decltype(_S_iter_cat());
2915 using value_type = range_value_t<_Base>;
2916 using difference_type = range_difference_t<_Base>;
2918 _InnerIter() =
default;
2921 _InnerIter(_OuterIter<_Const> __i)
2925 constexpr decltype(
auto)
2927 {
return *_M_i._M_current; }
2929 constexpr _InnerIter&
2932 _M_incremented =
true;
2933 if constexpr (!forward_range<_Base>)
2934 if constexpr (_Pattern::size() == 0)
2940 constexpr decltype(auto)
2943 if constexpr (forward_range<_Vp>)
2953 friend constexpr
bool
2954 operator==(
const _InnerIter& __x,
const _InnerIter& __y)
2955 requires forward_range<_Base>
2956 {
return __x._M_i == __y._M_i; }
2958 friend constexpr
bool
2959 operator==(
const _InnerIter& __x, default_sentinel_t)
2960 {
return __x.__at_end(); }
2962 friend constexpr decltype(
auto)
2963 iter_move(const _InnerIter& __i) noexcept(noexcept(__iter_move()))
2964 {
return __iter_move(__i); }
2966 friend constexpr
void
2967 iter_swap(
const _InnerIter& __x,
const _InnerIter& __y)
2968 noexcept(noexcept(__iter_swap()))
2969 requires indirectly_swappable<iterator_t<_Base>>
2970 { __iter_swap(__x, __y); }
2973 _Vp _M_base = _Vp();
2974 _Pattern _M_pattern = _Pattern();
2977 [[no_unique_address]]
2978 __detail::__maybe_present_t<!forward_range<_Vp>, iterator_t<_Vp>>
2983 split_view() =
default;
2986 split_view(_Vp
__base, _Pattern __pattern)
2990 template<input_range _Range>
2991 requires constructible_from<_Vp, views::all_t<_Range>>
2992 && constructible_from<_Pattern, single_view<range_value_t<_Range>>>
2994 split_view(_Range&& __r, range_value_t<_Range> __e)
2995 : _M_base(views::all(
std::
forward<_Range>(__r))),
3000 base() const& requires copy_constructible<_Vp>
3010 if constexpr (forward_range<_Vp>)
3011 return _OuterIter<__detail::__simple_view<_Vp>>{*
this,
3016 return _OuterIter<false>{*
this};
3021 begin() const requires forward_range<_Vp> && forward_range<const _Vp>
3027 end() requires forward_range<_Vp> && common_range<_Vp>
3029 return _OuterIter<__detail::__simple_view<_Vp>>{*
this,
ranges::end(_M_base)};
3035 if constexpr (forward_range<_Vp>
3036 && forward_range<const _Vp>
3037 && common_range<const _Vp>)
3038 return _OuterIter<true>{*
this,
ranges::end(_M_base)};
3040 return default_sentinel;
3044 template<
typename _Range,
typename _Pred>
3045 split_view(_Range&&, _Pred&&)
3046 -> split_view<views::all_t<_Range>, views::all_t<_Pred>>;
3048 template<input_range _Range>
3049 split_view(_Range&&, range_value_t<_Range>)
3050 -> split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
3054 inline constexpr __adaptor::_RangeAdaptor split
3055 = [] <viewable_range _Range,
typename _Fp> (_Range&& __r, _Fp&& __f)
3057 return split_view{std::forward<_Range>(__r), std::forward<_Fp>(__f)};
3065 template<input_or_output_iterator _Iter>
3067 operator()(_Iter __i, iter_difference_t<_Iter> __n)
const
3069 if constexpr (random_access_iterator<_Iter>)
3070 return subrange{__i, __i + __n};
3072 return subrange{counted_iterator{
std::move(__i), __n},
3077 inline constexpr _Counted counted{};
3081 requires (!common_range<_Vp>) && copyable<iterator_t<_Vp>>
3082 class common_view :
public view_interface<common_view<_Vp>>
3085 _Vp _M_base = _Vp();
3088 common_view() =
default;
3091 common_view(_Vp __r)
3106 base() const& requires copy_constructible<_Vp>
3116 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3119 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
3124 begin() const requires range<const _Vp>
3126 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
3129 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
3136 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3139 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
3144 end() const requires range<const _Vp>
3146 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
3149 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
3154 size() requires sized_range<_Vp>
3155 {
return ranges::size(_M_base); }
3158 size() const requires sized_range<const _Vp>
3159 {
return ranges::size(_M_base); }
3162 template<
typename _Range>
3163 common_view(_Range&&) -> common_view<views::all_t<_Range>>;
3167 inline constexpr __adaptor::_RangeAdaptorClosure common
3168 = [] <viewable_range _Range> (_Range&& __r)
3170 if constexpr (common_range<_Range>
3171 && requires { views::all(std::forward<_Range>(__r)); })
3172 return views::all(std::forward<_Range>(__r));
3174 return common_view{std::forward<_Range>(__r)};
3180 requires bidirectional_range<_Vp>
3181 class reverse_view :
public view_interface<reverse_view<_Vp>>
3184 _Vp _M_base = _Vp();
3186 static constexpr
bool _S_needs_cached_begin
3187 = !common_range<_Vp> && !random_access_range<_Vp>;
3188 [[no_unique_address]]
3189 __detail::__maybe_present_t<_S_needs_cached_begin,
3190 __detail::_CachedPosition<_Vp>>
3194 reverse_view() =
default;
3197 reverse_view(_Vp __r)
3202 base() const& requires copy_constructible<_Vp>
3209 constexpr reverse_iterator<iterator_t<_Vp>>
3212 if constexpr (_S_needs_cached_begin)
3213 if (_M_cached_begin._M_has_value())
3217 if constexpr (_S_needs_cached_begin)
3218 _M_cached_begin._M_set(_M_base, __it);
3223 begin() requires common_range<_Vp>
3227 begin() const requires common_range<const _Vp>
3230 constexpr reverse_iterator<iterator_t<_Vp>>
3235 end() const requires common_range<const _Vp>
3239 size() requires sized_range<_Vp>
3240 {
return ranges::size(_M_base); }
3243 size() const requires sized_range<const _Vp>
3244 {
return ranges::size(_M_base); }
3247 template<
typename _Range>
3248 reverse_view(_Range&&) -> reverse_view<views::all_t<_Range>>;
3255 inline constexpr
bool __is_reversible_subrange =
false;
3257 template<
typename _Iter, subrange_kind _Kind>
3258 inline constexpr
bool
3259 __is_reversible_subrange<subrange<reverse_iterator<_Iter>,
3260 reverse_iterator<_Iter>,
3264 inline constexpr
bool __is_reverse_view =
false;
3266 template<
typename _Vp>
3267 inline constexpr
bool __is_reverse_view<reverse_view<_Vp>> =
true;
3270 inline constexpr __adaptor::_RangeAdaptorClosure reverse
3271 = [] <viewable_range _Range> (_Range&& __r)
3273 using _Tp = remove_cvref_t<_Range>;
3274 if constexpr (__detail::__is_reverse_view<_Tp>)
3275 return std::forward<_Range>(__r).base();
3276 else if constexpr (__detail::__is_reversible_subrange<_Tp>)
3279 if constexpr (sized_range<_Tp>)
3280 return subrange<_Iter, _Iter, subrange_kind::sized>
3281 (__r.end().base(), __r.begin().base(), __r.size());
3283 return subrange<_Iter, _Iter, subrange_kind::unsized>
3284 (__r.end().base(), __r.begin().base());
3287 return reverse_view{std::forward<_Range>(__r)};
3293 template<
typename _Tp,
size_t _Nm>
3294 concept __has_tuple_element = requires(_Tp __t)
3296 typename tuple_size<_Tp>::type;
3297 requires _Nm < tuple_size_v<_Tp>;
3298 typename tuple_element_t<_Nm, _Tp>;
3299 { std::get<_Nm>(__t) }
3300 -> convertible_to<const tuple_element_t<_Nm, _Tp>&>;
3304 template<input_range _Vp,
size_t _Nm>
3306 && __detail::__has_tuple_element<range_value_t<_Vp>, _Nm>
3307 && __detail::__has_tuple_element<remove_reference_t<range_reference_t<_Vp>>,
3309 class elements_view :
public view_interface<elements_view<_Vp, _Nm>>
3312 elements_view() =
default;
3315 elements_view(_Vp base)
3320 base() const& requires copy_constructible<_Vp>
3328 begin() requires (!__detail::__simple_view<_Vp>)
3332 begin() const requires __detail::__simple_view<_Vp>
3336 end() requires (!__detail::__simple_view<_Vp>)
3340 end() const requires __detail::__simple_view<_Vp>
3344 size() requires sized_range<_Vp>
3345 {
return ranges::size(_M_base); }
3348 size() const requires sized_range<const _Vp>
3349 {
return ranges::size(_M_base); }
3352 template<
bool _Const>
3355 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
3357 iterator_t<_Base> _M_current = iterator_t<_Base>();
3359 friend _Iterator<!_Const>;
3362 using iterator_category
3363 =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
3365 = remove_cvref_t<tuple_element_t<_Nm, range_value_t<_Base>>>;
3366 using difference_type = range_difference_t<_Base>;
3368 _Iterator() =
default;
3371 _Iterator(iterator_t<_Base> current)
3372 : _M_current(
std::
move(current))
3376 _Iterator(_Iterator<!_Const> i)
3377 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
3381 constexpr iterator_t<_Base>
3383 requires copyable<iterator_t<_Base>>
3384 {
return _M_current; }
3386 constexpr iterator_t<_Base>
3390 constexpr decltype(
auto)
3392 {
return std::get<_Nm>(*_M_current); }
3394 constexpr _Iterator&
3402 operator++(
int) requires (!forward_range<_Base>)
3406 operator++(
int) requires forward_range<_Base>
3413 constexpr _Iterator&
3414 operator--() requires bidirectional_range<_Base>
3421 operator--(
int) requires bidirectional_range<_Base>
3428 constexpr _Iterator&
3429 operator+=(difference_type __n)
3430 requires random_access_range<_Base>
3436 constexpr _Iterator&
3437 operator-=(difference_type __n)
3438 requires random_access_range<_Base>
3444 constexpr decltype(
auto)
3445 operator[](difference_type __n) const
3446 requires random_access_range<_Base>
3447 {
return std::get<_Nm>(*(_M_current + __n)); }
3449 friend constexpr
bool
3450 operator==(
const _Iterator& __x,
const _Iterator& __y)
3451 requires equality_comparable<iterator_t<_Base>>
3452 {
return __x._M_current == __y._M_current; }
3454 friend constexpr
bool
3455 operator==(
const _Iterator& __x,
const sentinel_t<_Base>& __y)
3456 {
return __x._M_current == __y; }
3458 friend constexpr
bool
3459 operator<(
const _Iterator& __x,
const _Iterator& __y)
3460 requires random_access_range<_Base>
3461 {
return __x._M_current < __y._M_current; }
3463 friend constexpr
bool
3464 operator>(
const _Iterator& __x,
const _Iterator& __y)
3465 requires random_access_range<_Base>
3466 {
return __y._M_current < __x._M_current; }
3468 friend constexpr
bool
3469 operator<=(
const _Iterator& __x,
const _Iterator& __y)
3470 requires random_access_range<_Base>
3471 {
return !(__y._M_current > __x._M_current); }
3473 friend constexpr
bool
3474 operator>=(
const _Iterator& __x,
const _Iterator& __y)
3475 requires random_access_range<_Base>
3476 {
return !(__x._M_current > __y._M_current); }
3478 #ifdef __cpp_lib_three_way_comparison
3479 friend constexpr
auto
3480 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
3481 requires random_access_range<_Base>
3482 && three_way_comparable<iterator_t<_Base>>
3483 {
return __x._M_current <=> __y._M_current; }
3486 friend constexpr _Iterator
3487 operator+(
const _Iterator& __x, difference_type __y)
3488 requires random_access_range<_Base>
3489 {
return _Iterator{__x} += __y; }
3491 friend constexpr _Iterator
3492 operator+(difference_type __x,
const _Iterator& __y)
3493 requires random_access_range<_Base>
3494 {
return __y + __x; }
3496 friend constexpr _Iterator
3497 operator-(
const _Iterator& __x, difference_type __y)
3498 requires random_access_range<_Base>
3499 {
return _Iterator{__x} -= __y; }
3501 friend constexpr difference_type
3502 operator-(
const _Iterator& __x,
const _Iterator& __y)
3503 requires random_access_range<_Base>
3504 {
return __x._M_current - __y._M_current; }
3506 friend constexpr difference_type
3507 operator-(
const _Iterator<_Const>& __x,
const sentinel_t<_Base>& __y)
3508 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
3509 {
return __x._M_current - __y; }
3511 friend constexpr difference_type
3512 operator-(
const sentinel_t<_Base>& __x,
const _Iterator<_Const>& __y)
3513 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
3514 {
return -(__y - __x); }
3517 _Vp _M_base = _Vp();
3520 template<
typename _Range>
3521 using keys_view = elements_view<views::all_t<_Range>, 0>;
3523 template<
typename _Range>
3524 using values_view = elements_view<views::all_t<_Range>, 1>;
3528 template<
size_t _Nm>
3529 inline constexpr __adaptor::_RangeAdaptorClosure elements
3530 = [] <viewable_range _Range> (_Range&& __r)
3532 using _El = elements_view<views::all_t<_Range>, _Nm>;
3533 return _El{std::forward<_Range>(__r)};
3536 inline constexpr __adaptor::_RangeAdaptorClosure keys = elements<0>;
3537 inline constexpr __adaptor::_RangeAdaptorClosure values = elements<1>;
3542 namespace views = ranges::views;
3544 template<
typename _Iter,
typename _Sent, ranges::subrange_kind _Kind>
3545 struct tuple_size<ranges::subrange<_Iter, _Sent, _Kind>>
3546 : integral_constant<size_t, 2>
3549 template<
typename _Iter,
typename _Sent, ranges::subrange_kind _Kind>
3550 struct tuple_element<0, ranges::subrange<_Iter, _Sent, _Kind>>
3551 {
using type = _Iter; };
3553 template<
typename _Iter,
typename _Sent, ranges::subrange_kind _Kind>
3554 struct tuple_element<1, ranges::subrange<_Iter, _Sent, _Kind>>
3555 {
using type = _Sent; };
3557 template<
typename _Iter,
typename _Sent, ranges::subrange_kind _Kind>
3558 struct tuple_element<0, const ranges::subrange<_Iter, _Sent, _Kind>>
3559 {
using type = _Iter; };
3561 template<
typename _Iter,
typename _Sent, ranges::subrange_kind _Kind>
3562 struct tuple_element<1, const ranges::subrange<_Iter, _Sent, _Kind>>
3563 {
using type = _Sent; };
3565 _GLIBCXX_END_NAMESPACE_VERSION
3567 #endif // library concepts