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>
285 : subrange{__r, ranges::size(__r)}
288 template<__detail::__not_same_as<subrange> _Rng>
289 requires borrowed_range<_Rng>
290 && __detail::__convertible_to_non_slicing<iterator_t<_Rng>, _It>
291 && convertible_to<sentinel_t<_Rng>, _Sent>
293 subrange(_Rng&& __r) requires (!_S_store_size)
297 template<borrowed_range _Rng>
298 requires __detail::__convertible_to_non_slicing<iterator_t<_Rng>, _It>
299 && convertible_to<sentinel_t<_Rng>, _Sent>
302 __detail::__make_unsigned_like_t<iter_difference_t<_It>> __n)
303 requires (_Kind == subrange_kind::sized)
307 template<__detail::__not_same_as<subrange> _PairLike>
308 requires __detail::__pair_like_convertible_from<_PairLike,
const _It&,
311 operator _PairLike()
const
312 {
return _PairLike(_M_begin, _M_end); }
315 begin() const requires copyable<_It>
318 [[nodiscard]] constexpr _It
319 begin() requires (!copyable<_It>)
322 constexpr _Sent
end()
const {
return _M_end; }
324 constexpr
bool empty()
const {
return _M_begin == _M_end; }
326 constexpr __detail::__make_unsigned_like_t<iter_difference_t<_It>>
327 size() const requires (_Kind == subrange_kind::sized)
329 if constexpr (_S_store_size)
330 return _M_size._M_size;
332 return __detail::__to_unsigned_like(_M_end - _M_begin);
335 [[nodiscard]] constexpr subrange
336 next(iter_difference_t<_It> __n = 1) const &
337 requires forward_iterator<_It>
344 [[nodiscard]] constexpr subrange
345 next(iter_difference_t<_It> __n = 1) &&
351 [[nodiscard]] constexpr subrange
352 prev(iter_difference_t<_It> __n = 1) const
353 requires bidirectional_iterator<_It>
361 advance(iter_difference_t<_It> __n)
365 if constexpr (bidirectional_iterator<_It>)
369 if constexpr (_S_store_size)
370 _M_size._M_size += __detail::__to_unsigned_like(-__n);
374 __glibcxx_assert(__n >= 0);
375 auto __d = __n - ranges::
advance(_M_begin, __n, _M_end);
376 if constexpr (_S_store_size)
377 _M_size._M_size -= __detail::__to_unsigned_like(__d);
382 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
383 subrange(_It, _Sent) -> subrange<_It, _Sent>;
385 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
387 __detail::__make_unsigned_like_t<iter_difference_t<_It>>)
388 -> subrange<_It, _Sent, subrange_kind::sized>;
390 template<__detail::__iterator_sentinel_pair _Pr>
392 -> subrange<tuple_element_t<0, _Pr>, tuple_element_t<1, _Pr>>;
394 template<__detail::__iterator_sentinel_pair _Pr>
395 subrange(_Pr, __detail::__make_unsigned_like_t<iter_difference_t<
396 tuple_element_t<0, _Pr>>>)
397 -> subrange<tuple_element_t<0, _Pr>, tuple_element_t<1, _Pr>,
398 subrange_kind::sized>;
400 template<borrowed_range _Rng>
402 -> subrange<iterator_t<_Rng>, sentinel_t<_Rng>,
404 || sized_sentinel_for<sentinel_t<_Rng>, iterator_t<_Rng>>)
405 ? subrange_kind::sized : subrange_kind::unsized>;
407 template<borrowed_range _Rng>
409 __detail::__make_unsigned_like_t<range_difference_t<_Rng>>)
410 -> subrange<iterator_t<_Rng>, sentinel_t<_Rng>, subrange_kind::sized>;
412 template<
size_t _Num, class _It, class _Sent, subrange_kind _Kind>
415 get(const subrange<_It, _Sent, _Kind>& __r)
417 if constexpr (_Num == 0)
423 template<
size_t _Num, class _It, class _Sent, subrange_kind _Kind>
426 get(subrange<_It, _Sent, _Kind>&& __r)
428 if constexpr (_Num == 0)
434 template<input_or_output_iterator _It, sentinel_for<_It> _Sent,
436 inline constexpr
bool
437 enable_borrowed_range<subrange<_It, _Sent, _Kind>> = true;
448 constexpr dangling() noexcept = default;
449 template<typename... _Args>
450 constexpr dangling(_Args&&...) noexcept { }
453 template<range _Range>
454 using borrowed_iterator_t = conditional_t<borrowed_range<_Range>,
458 template<range _Range>
459 using borrowed_subrange_t = conditional_t<borrowed_range<_Range>,
460 subrange<iterator_t<_Range>>,
463 template<
typename _Tp> requires is_object_v<_Tp>
465 :
public view_interface<empty_view<_Tp>>
468 static constexpr _Tp*
begin() noexcept {
return nullptr; }
469 static constexpr _Tp*
end() noexcept {
return nullptr; }
470 static constexpr _Tp* data() noexcept {
return nullptr; }
471 static constexpr
size_t size() noexcept {
return 0; }
472 static constexpr
bool empty() noexcept {
return true; }
475 template<
typename _Tp>
476 inline constexpr
bool enable_borrowed_range<empty_view<_Tp>> =
true;
480 template<copy_constructible _Tp> requires is_object_v<_Tp>
481 struct __box : std::optional<_Tp>
483 using std::optional<_Tp>::optional;
487 noexcept(is_nothrow_default_constructible_v<_Tp>)
488 requires default_initializable<_Tp>
492 __box(
const __box&) =
default;
493 __box(__box&&) =
default;
495 using std::optional<_Tp>::operator=;
498 operator=(
const __box& __that)
499 noexcept(is_nothrow_copy_constructible_v<_Tp>)
500 requires (!assignable_from<_Tp&, const _Tp&>)
503 this->emplace(*__that);
510 operator=(__box&& __that)
511 noexcept(is_nothrow_move_constructible_v<_Tp>)
512 requires (!assignable_from<_Tp&, _Tp>)
525 template<copy_constructible _Tp> requires is_object_v<_Tp>
526 class single_view :
public view_interface<single_view<_Tp>>
529 single_view() =
default;
532 single_view(
const _Tp& __t)
537 single_view(_Tp&& __t)
538 : _M_value(std::
move(__t))
541 template<
typename... _Args>
542 requires constructible_from<_Tp, _Args...>
544 single_view(in_place_t, _Args&&... __args)
545 : _M_value{
in_place, std::forward<_Args>(__args)...}
553 begin() const noexcept
558 {
return data() + 1; }
562 {
return data() + 1; }
564 static constexpr
size_t
570 {
return _M_value.operator->(); }
573 data() const noexcept
574 {
return _M_value.operator->(); }
577 __detail::__box<_Tp> _M_value;
582 template<
typename _Wp>
583 constexpr
auto __to_signed_like(_Wp __w) noexcept
585 if constexpr (!integral<_Wp>)
586 return iter_difference_t<_Wp>();
587 else if constexpr (sizeof(iter_difference_t<_Wp>) > sizeof(_Wp))
588 return iter_difference_t<_Wp>(__w);
589 else if constexpr (sizeof(ptrdiff_t) > sizeof(_Wp))
590 return ptrdiff_t(__w);
591 else if constexpr (sizeof(
long long) > sizeof(_Wp))
592 return (
long long)(__w);
593 #ifdef __SIZEOF_INT128__
594 else if constexpr (__SIZEOF_INT128__ >
sizeof(_Wp))
595 return __int128(__w);
598 return __max_diff_type(__w);
601 template<
typename _Wp>
602 using __iota_diff_t = decltype(__to_signed_like(std::declval<_Wp>()));
604 template<
typename _It>
605 concept __decrementable = incrementable<_It>
608 { --__i } -> same_as<_It&>;
609 { __i-- } -> same_as<_It>;
612 template<
typename _It>
613 concept __advanceable = __decrementable<_It> && totally_ordered<_It>
614 && requires( _It __i,
const _It __j,
const __iota_diff_t<_It> __n)
616 { __i += __n } -> same_as<_It&>;
617 { __i -= __n } -> same_as<_It&>;
621 { __j - __j } -> convertible_to<__iota_diff_t<_It>>;
626 template<weakly_incrementable _Winc,
627 semiregular _Bound = unreachable_sentinel_t>
628 requires std::__detail::__weakly_eq_cmp_with<_Winc, _Bound>
629 && semiregular<_Winc>
630 class iota_view :
public view_interface<iota_view<_Winc, _Bound>>
641 using namespace __detail;
642 if constexpr (__advanceable<_Winc>)
643 return random_access_iterator_tag{};
644 else if constexpr (__decrementable<_Winc>)
645 return bidirectional_iterator_tag{};
646 else if constexpr (incrementable<_Winc>)
647 return forward_iterator_tag{};
649 return input_iterator_tag{};
653 using iterator_category = decltype(_S_iter_cat());
654 using value_type = _Winc;
655 using difference_type = __detail::__iota_diff_t<_Winc>;
657 _Iterator() =
default;
660 _Iterator(_Winc __value)
661 : _M_value(__value) { }
664 operator*() const noexcept(is_nothrow_copy_constructible_v<_Winc>)
679 operator++(
int) requires incrementable<_Winc>
687 operator--() requires __detail::__decrementable<_Winc>
694 operator--(
int) requires __detail::__decrementable<_Winc>
702 operator+=(difference_type __n) requires __detail::__advanceable<_Winc>
704 using __detail::__is_integer_like;
705 using __detail::__is_signed_integer_like;
706 if constexpr (__is_integer_like<_Winc>
707 && !__is_signed_integer_like<_Winc>)
709 if (__n >= difference_type(0))
710 _M_value +=
static_cast<_Winc
>(__n);
712 _M_value -=
static_cast<_Winc
>(-__n);
720 operator-=(difference_type __n) requires __detail::__advanceable<_Winc>
722 using __detail::__is_integer_like;
723 using __detail::__is_signed_integer_like;
724 if constexpr (__is_integer_like<_Winc>
725 && !__is_signed_integer_like<_Winc>)
727 if (__n >= difference_type(0))
728 _M_value -=
static_cast<_Winc
>(__n);
730 _M_value +=
static_cast<_Winc
>(-__n);
738 operator[](difference_type __n)
const
739 requires __detail::__advanceable<_Winc>
740 {
return _Winc(_M_value + __n); }
742 friend constexpr
bool
743 operator==(
const _Iterator& __x,
const _Iterator& __y)
744 requires equality_comparable<_Winc>
745 {
return __x._M_value == __y._M_value; }
747 friend constexpr
bool
748 operator<(
const _Iterator& __x,
const _Iterator& __y)
749 requires totally_ordered<_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 __y < __x; }
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 !(__x < __y); }
767 #ifdef __cpp_lib_three_way_comparison
768 friend constexpr
auto
769 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
770 requires totally_ordered<_Winc> && three_way_comparable<_Winc>
771 {
return __x._M_value <=> __y._M_value; }
774 friend constexpr _Iterator
775 operator+(_Iterator __i, difference_type __n)
776 requires __detail::__advanceable<_Winc>
777 {
return __i += __n; }
779 friend constexpr _Iterator
780 operator+(difference_type __n, _Iterator __i)
781 requires __detail::__advanceable<_Winc>
782 {
return __i += __n; }
784 friend constexpr _Iterator
785 operator-(_Iterator __i, difference_type __n)
786 requires __detail::__advanceable<_Winc>
787 {
return __i -= __n; }
789 friend constexpr difference_type
790 operator-(
const _Iterator& __x,
const _Iterator& __y)
791 requires __detail::__advanceable<_Winc>
793 using __detail::__is_integer_like;
794 using __detail::__is_signed_integer_like;
795 using _Dt = difference_type;
796 if constexpr (__is_integer_like<_Winc>)
798 if constexpr (__is_signed_integer_like<_Winc>)
799 return _Dt(_Dt(__x._M_value) - _Dt(__y._M_value));
801 return (__y._M_value > __x._M_value)
802 ? _Dt(-_Dt(__y._M_value - __x._M_value))
803 : _Dt(__x._M_value - __y._M_value);
806 return __x._M_value - __y._M_value;
810 _Winc _M_value = _Winc();
819 _M_equal(
const _Iterator& __x)
const
820 {
return __x._M_value == _M_bound; }
822 _Bound _M_bound = _Bound();
825 _Sentinel() =
default;
828 _Sentinel(_Bound __bound)
829 : _M_bound(__bound) { }
831 friend constexpr
bool
832 operator==(
const _Iterator& __x,
const _Sentinel& __y)
833 {
return __y._M_equal(__x); }
835 friend constexpr iter_difference_t<_Winc>
836 operator-(
const _Iterator& __x,
const _Sentinel& __y)
837 requires sized_sentinel_for<_Bound, _Winc>
838 {
return __x._M_value - __y._M_bound; }
840 friend constexpr iter_difference_t<_Winc>
841 operator-(
const _Sentinel& __x,
const _Iterator& __y)
842 requires sized_sentinel_for<_Bound, _Winc>
843 {
return -(__y - __x); }
846 _Winc _M_value = _Winc();
847 _Bound _M_bound = _Bound();
850 iota_view() =
default;
853 iota_view(_Winc __value)
858 iota_view(type_identity_t<_Winc> __value,
859 type_identity_t<_Bound> __bound)
860 : _M_value(__value), _M_bound(__bound)
862 if constexpr (totally_ordered_with<_Winc, _Bound>)
864 __glibcxx_assert(
bool(__value <= __bound) );
869 begin()
const {
return _Iterator{_M_value}; }
874 if constexpr (same_as<_Bound, unreachable_sentinel_t>)
875 return unreachable_sentinel;
877 return _Sentinel{_M_bound};
881 end() const requires same_as<_Winc, _Bound>
882 {
return _Iterator{_M_bound}; }
886 requires (same_as<_Winc, _Bound> && __detail::__advanceable<_Winc>)
887 || (integral<_Winc> && integral<_Bound>)
888 || sized_sentinel_for<_Bound, _Winc>
890 using __detail::__is_integer_like;
891 using __detail::__to_unsigned_like;
892 if constexpr (__is_integer_like<_Winc> && __is_integer_like<_Bound>)
893 return (_M_value < 0)
895 ? __to_unsigned_like(-_M_value) - __to_unsigned_like(-_M_bound)
896 : __to_unsigned_like(_M_bound) + __to_unsigned_like(-_M_value))
897 : __to_unsigned_like(_M_bound) - __to_unsigned_like(_M_value);
899 return __to_unsigned_like(_M_bound - _M_value);
903 template<typename _Winc, typename _Bound>
904 requires (!__detail::__is_integer_like<_Winc>
905 || !__detail::__is_integer_like<_Bound>
906 || (__detail::__is_signed_integer_like<_Winc>
907 == __detail::__is_signed_integer_like<_Bound>))
908 iota_view(_Winc, _Bound) -> iota_view<_Winc, _Bound>;
910 template<weakly_incrementable _Winc, semiregular _Bound>
911 inline constexpr
bool
912 enable_borrowed_range<iota_view<_Winc, _Bound>> = true;
916 template<
typename _Tp>
917 inline constexpr empty_view<_Tp> empty{};
921 template<
typename _Tp>
923 operator()(_Tp&& __e)
const
924 {
return single_view{std::forward<_Tp>(__e)}; }
927 inline constexpr _Single single{};
931 template<
typename _Tp>
933 operator()(_Tp&& __e)
const
934 {
return iota_view{std::forward<_Tp>(__e)}; }
936 template<
typename _Tp,
typename _Up>
938 operator()(_Tp&& __e, _Up&& __f)
const
939 {
return iota_view{std::forward<_Tp>(__e), std::forward<_Up>(__f)}; }
942 inline constexpr _Iota
iota{};
947 template<
typename _Val,
typename _CharT,
typename _Traits>
948 concept __stream_extractable
949 = requires(basic_istream<_CharT, _Traits>& is, _Val& t) { is >> t; };
952 template<movable _Val,
typename _CharT,
typename _Traits>
953 requires default_initializable<_Val>
954 && __detail::__stream_extractable<_Val, _CharT, _Traits>
955 class basic_istream_view
956 :
public view_interface<basic_istream_view<_Val, _CharT, _Traits>>
959 basic_istream_view() =
default;
962 basic_istream_view(basic_istream<_CharT, _Traits>& __stream)
969 if (_M_stream !=
nullptr)
970 *_M_stream >> _M_object;
971 return _Iterator{*
this};
974 constexpr default_sentinel_t
976 {
return default_sentinel; }
979 basic_istream<_CharT, _Traits>* _M_stream =
nullptr;
980 _Val _M_object = _Val();
985 using iterator_concept = input_iterator_tag;
986 using difference_type = ptrdiff_t;
987 using value_type = _Val;
989 _Iterator() =
default;
992 _Iterator(basic_istream_view& __parent) noexcept
996 _Iterator(
const _Iterator&) =
delete;
997 _Iterator(_Iterator&&) =
default;
998 _Iterator& operator=(
const _Iterator&) =
delete;
999 _Iterator& operator=(_Iterator&&) =
default;
1004 __glibcxx_assert(_M_parent->_M_stream !=
nullptr);
1005 *_M_parent->_M_stream >> _M_parent->_M_object;
1016 __glibcxx_assert(_M_parent->_M_stream !=
nullptr);
1017 return _M_parent->_M_object;
1021 operator==(
const _Iterator& __x, default_sentinel_t)
1022 {
return __x._M_at_end(); }
1025 basic_istream_view* _M_parent =
nullptr;
1029 {
return _M_parent ==
nullptr || !*_M_parent->_M_stream; }
1035 template<
typename _Val,
typename _CharT,
typename _Traits>
1036 basic_istream_view<_Val, _CharT, _Traits>
1037 istream_view(basic_istream<_CharT, _Traits>& __s)
1038 {
return basic_istream_view<_Val, _CharT, _Traits>{__s}; }
1048 template<
bool _Present,
typename _Tp>
1049 using __maybe_present_t = conditional_t<_Present, _Tp, _Empty>;
1052 template<
bool _Const,
typename _Tp>
1053 using __maybe_const_t = conditional_t<_Const, const _Tp, _Tp>;
1061 template<
typename _Tp>
1062 inline constexpr
auto
1063 __maybe_refwrap(_Tp& __arg)
1064 {
return reference_wrapper<_Tp>{__arg}; }
1066 template<
typename _Tp>
1067 inline constexpr
auto
1068 __maybe_refwrap(
const _Tp& __arg)
1069 {
return reference_wrapper<const _Tp>{__arg}; }
1071 template<
typename _Tp>
1072 inline constexpr decltype(
auto)
1073 __maybe_refwrap(_Tp&& __arg)
1074 {
return std::forward<_Tp>(__arg); }
1076 template<
typename _Callable>
1077 struct _RangeAdaptorClosure;
1079 template<
typename _Callable>
1080 struct _RangeAdaptor
1083 [[no_unique_address]]
1084 __detail::__maybe_present_t<!is_default_constructible_v<_Callable>,
1085 _Callable> _M_callable;
1089 _RangeAdaptor(
const _Callable& = {})
1090 requires is_default_constructible_v<_Callable>
1094 _RangeAdaptor(_Callable __callable)
1095 requires (!is_default_constructible_v<_Callable>)
1096 : _M_callable(std::
move(__callable))
1099 template<
typename... _Args>
1100 requires (
sizeof...(_Args) >= 1)
1102 operator()(_Args&&... __args)
const
1115 if constexpr (is_invocable_v<_Callable, _Args...>)
1117 static_assert(
sizeof...(_Args) != 1,
1118 "a _RangeAdaptor that accepts only one argument "
1119 "should be defined as a _RangeAdaptorClosure");
1122 return _Callable{}(std::forward<_Args>(__args)...);
1135 = [...__args(__maybe_refwrap(std::forward<_Args>(__args)))]
1136 <
typename _Range> (_Range&& __r) {
1140 return _Callable{}(std::forward<_Range>(__r),
1141 (
static_cast<unwrap_reference_t
1142 <remove_const_t<decltype(__args)>
>>
1145 using _ClosureType = decltype(__closure);
1146 return _RangeAdaptorClosure<_ClosureType>(
std::move(__closure));
1151 template<
typename _Callable>
1152 _RangeAdaptor(_Callable) -> _RangeAdaptor<_Callable>;
1154 template<
typename _Callable>
1155 struct _RangeAdaptorClosure :
public _RangeAdaptor<_Callable>
1157 using _RangeAdaptor<_Callable>::_RangeAdaptor;
1159 template<viewable_range _Range>
1160 requires requires { declval<_Callable>()(declval<_Range>()); }
1162 operator()(_Range&& __r)
const
1164 if constexpr (is_default_constructible_v<_Callable>)
1165 return _Callable{}(std::forward<_Range>(__r));
1167 return this->_M_callable(std::forward<_Range>(__r));
1170 template<viewable_range _Range>
1171 requires requires { declval<_Callable>()(declval<_Range>()); }
1172 friend constexpr
auto
1173 operator|(_Range&& __r,
const _RangeAdaptorClosure& __o)
1174 {
return __o(std::forward<_Range>(__r)); }
1176 template<
typename _Tp>
1177 friend constexpr
auto
1178 operator|(
const _RangeAdaptorClosure<_Tp>& __x,
1179 const _RangeAdaptorClosure& __y)
1181 if constexpr (is_default_constructible_v<_Tp>
1182 && is_default_constructible_v<_Callable>)
1184 auto __closure = [] <
typename _Up> (_Up&& __e) {
1185 return std::forward<_Up>(__e) | decltype(__x){} | decltype(__y){};
1187 return _RangeAdaptorClosure<decltype(__closure)>(__closure);
1189 else if constexpr (is_default_constructible_v<_Tp>
1190 && !is_default_constructible_v<_Callable>)
1192 auto __closure = [__y] <
typename _Up> (_Up&& __e) {
1193 return std::forward<_Up>(__e) | decltype(__x){} | __y;
1195 return _RangeAdaptorClosure<decltype(__closure)>(__closure);
1197 else if constexpr (!is_default_constructible_v<_Tp>
1198 && is_default_constructible_v<_Callable>)
1200 auto __closure = [__x] <
typename _Up> (_Up&& __e) {
1201 return std::forward<_Up>(__e) | __x | decltype(__y){};
1203 return _RangeAdaptorClosure<decltype(__closure)>(__closure);
1207 auto __closure = [__x, __y] <
typename _Up> (_Up&& __e) {
1208 return std::forward<_Up>(__e) | __x | __y;
1210 return _RangeAdaptorClosure<decltype(__closure)>(__closure);
1215 template<
typename _Callable>
1216 _RangeAdaptorClosure(_Callable) -> _RangeAdaptorClosure<_Callable>;
1220 template<range _Range> requires is_object_v<_Range>
1221 class ref_view :
public view_interface<ref_view<_Range>>
1224 _Range* _M_r =
nullptr;
1226 static void _S_fun(_Range&);
1227 static void _S_fun(_Range&&) =
delete;
1231 ref_view() noexcept = default;
1233 template<__detail::__not_same_as<ref_view> _Tp>
1234 requires convertible_to<_Tp, _Range&>
1235 && requires { _S_fun(declval<_Tp>()); }
1245 constexpr iterator_t<_Range>
1249 constexpr sentinel_t<_Range>
1254 empty() const requires requires { ranges::empty(*_M_r); }
1255 {
return ranges::empty(*_M_r); }
1258 size() const requires sized_range<_Range>
1259 {
return ranges::size(*_M_r); }
1262 data() const requires contiguous_range<_Range>
1263 {
return ranges::data(*_M_r); }
1266 template<
typename _Range>
1267 ref_view(_Range&) -> ref_view<_Range>;
1269 template<
typename _Tp>
1270 inline constexpr
bool enable_borrowed_range<ref_view<_Tp>> =
true;
1274 inline constexpr __adaptor::_RangeAdaptorClosure all
1275 = [] <viewable_range _Range> (_Range&& __r)
1277 if constexpr (view<decay_t<_Range>>)
1278 return std::
forward<_Range>(__r);
1279 else if constexpr (requires { ref_view{std::forward<_Range>(__r)}; })
1280 return ref_view{std::forward<_Range>(__r)};
1282 return subrange{std::forward<_Range>(__r)};
1285 template<viewable_range _Range>
1286 using all_t = decltype(all(std::declval<_Range>()));
1294 template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
1295 typename _Proj =
identity,
1296 indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
1298 find_if(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {})
1300 while (__first != __last
1301 && !(
bool)std::__invoke(__pred, std::__invoke(__proj, *__first)))
1306 template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
1307 typename _Proj =
identity,
1308 indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
1310 find_if_not(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {})
1312 while (__first != __last
1313 && (
bool)std::__invoke(__pred, std::__invoke(__proj, *__first)))
1318 template<
typename _Tp,
typename _Proj = identity,
1319 indirect_strict_weak_order<projected<const _Tp*, _Proj>>
1320 _Comp = ranges::less>
1321 constexpr
const _Tp&
1322 min(
const _Tp& __a,
const _Tp& __b, _Comp __comp = {}, _Proj __proj = {})
1325 std::__invoke(__proj, __b),
1326 std::__invoke(__proj, __a)))
1332 template<input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
1333 input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
1334 typename _Pred = ranges::equal_to,
1335 typename _Proj1 =
identity,
typename _Proj2 =
identity>
1336 requires indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
1337 constexpr pair<_Iter1, _Iter2>
1338 mismatch(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2,
1339 _Pred __pred = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {})
1341 while (__first1 != __last1 && __first2 != __last2
1342 && (
bool)std::__invoke(__pred,
1343 std::__invoke(__proj1, *__first1),
1344 std::__invoke(__proj2, *__first2)))
1355 template<range _Range>
1356 struct _CachedPosition
1359 _M_has_value()
const
1362 constexpr iterator_t<_Range>
1363 _M_get(
const _Range&)
const
1365 __glibcxx_assert(
false);
1370 _M_set(
const _Range&,
const iterator_t<_Range>&)
const
1374 template<forward_range _Range>
1375 struct _CachedPosition<_Range>
1378 iterator_t<_Range> _M_iter{};
1382 _M_has_value()
const
1383 {
return _M_iter != iterator_t<_Range>{}; }
1385 constexpr iterator_t<_Range>
1386 _M_get(
const _Range&)
const
1388 __glibcxx_assert(_M_has_value());
1393 _M_set(
const _Range&,
const iterator_t<_Range>& __it)
1395 __glibcxx_assert(!_M_has_value());
1400 template<random_access_range _Range>
1401 requires (
sizeof(range_difference_t<_Range>)
1402 <=
sizeof(iterator_t<_Range>))
1403 struct _CachedPosition<_Range>
1406 range_difference_t<_Range> _M_offset = -1;
1410 _M_has_value()
const
1411 {
return _M_offset >= 0; }
1413 constexpr iterator_t<_Range>
1414 _M_get(_Range& __r)
const
1416 __glibcxx_assert(_M_has_value());
1421 _M_set(_Range& __r,
const iterator_t<_Range>& __it)
1423 __glibcxx_assert(!_M_has_value());
1430 template<input_range _Vp,
1431 indirect_unary_predicate<iterator_t<_Vp>> _Pred>
1432 requires view<_Vp> && is_object_v<_Pred>
1433 class filter_view :
public view_interface<filter_view<_Vp, _Pred>>
1441 static constexpr
auto
1444 if constexpr (bidirectional_range<_Vp>)
1445 return bidirectional_iterator_tag{};
1446 else if constexpr (forward_range<_Vp>)
1447 return forward_iterator_tag{};
1449 return input_iterator_tag{};
1452 static constexpr
auto
1455 using _Cat =
typename iterator_traits<_Vp_iter>::iterator_category;
1456 if constexpr (derived_from<_Cat, bidirectional_iterator_tag>)
1457 return bidirectional_iterator_tag{};
1458 else if constexpr (derived_from<_Cat, forward_iterator_tag>)
1459 return forward_iterator_tag{};
1466 using _Vp_iter = iterator_t<_Vp>;
1468 _Vp_iter _M_current = _Vp_iter();
1469 filter_view* _M_parent =
nullptr;
1472 using iterator_concept = decltype(_S_iter_concept());
1473 using iterator_category = decltype(_S_iter_cat());
1474 using value_type = range_value_t<_Vp>;
1475 using difference_type = range_difference_t<_Vp>;
1477 _Iterator() =
default;
1480 _Iterator(filter_view& __parent, _Vp_iter __current)
1481 : _M_current(std::
move(__current)),
1487 requires copyable<_Vp_iter>
1488 {
return _M_current; }
1494 constexpr range_reference_t<_Vp>
1496 {
return *_M_current; }
1500 requires __detail::__has_arrow<_Vp_iter>
1501 && copyable<_Vp_iter>
1502 {
return _M_current; }
1504 constexpr _Iterator&
1507 _M_current = __detail::find_if(
std::move(++_M_current),
1509 std::ref(*_M_parent->_M_pred));
1518 operator++(
int) requires forward_range<_Vp>
1525 constexpr _Iterator&
1526 operator--() requires bidirectional_range<_Vp>
1530 while (!std::__invoke(*_M_parent->_M_pred, *_M_current));
1535 operator--(
int) requires bidirectional_range<_Vp>
1542 friend constexpr
bool
1543 operator==(
const _Iterator& __x,
const _Iterator& __y)
1544 requires equality_comparable<_Vp_iter>
1545 {
return __x._M_current == __y._M_current; }
1547 friend constexpr range_rvalue_reference_t<_Vp>
1548 iter_move(
const _Iterator& __i)
1549 noexcept(noexcept(ranges::iter_move(__i._M_current)))
1550 {
return ranges::iter_move(__i._M_current); }
1552 friend constexpr
void
1553 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
1554 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1555 requires indirectly_swappable<_Vp_iter>
1556 { ranges::iter_swap(__x._M_current, __y._M_current); }
1562 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
1565 __equal(
const _Iterator& __i)
const
1566 {
return __i._M_current == _M_end; }
1569 _Sentinel() =
default;
1572 _Sentinel(filter_view& __parent)
1573 : _M_end(ranges::end(__parent._M_base))
1576 constexpr sentinel_t<_Vp>
1580 friend constexpr
bool
1581 operator==(
const _Iterator& __x,
const _Sentinel& __y)
1582 {
return __y.__equal(__x); }
1585 _Vp _M_base = _Vp();
1586 __detail::__box<_Pred> _M_pred;
1587 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
1590 filter_view() =
default;
1593 filter_view(_Vp
__base, _Pred __pred)
1594 : _M_base(std::
move(__base)), _M_pred(std::
move(__pred))
1598 base() const& requires copy_constructible<_Vp>
1605 constexpr
const _Pred&
1607 {
return *_M_pred; }
1612 if (_M_cached_begin._M_has_value())
1613 return {*
this, _M_cached_begin._M_get(_M_base)};
1615 __glibcxx_assert(_M_pred.has_value());
1618 std::ref(*_M_pred));
1619 _M_cached_begin._M_set(_M_base, __it);
1626 if constexpr (common_range<_Vp>)
1629 return _Sentinel{*
this};
1633 template<
typename _Range,
typename _Pred>
1634 filter_view(_Range&&, _Pred) -> filter_view<views::all_t<_Range>, _Pred>;
1638 inline constexpr __adaptor::_RangeAdaptor filter
1639 = [] <viewable_range _Range,
typename _Pred> (_Range&& __r, _Pred&& __p)
1641 return filter_view{std::forward<_Range>(__r), std::forward<_Pred>(__p)};
1645 template<input_range _Vp, copy_constructible _Fp>
1646 requires view<_Vp> && is_object_v<_Fp>
1647 && regular_invocable<_Fp&, range_reference_t<_Vp>>
1648 && std::__detail::__can_reference<invoke_result_t<_Fp&,
1649 range_reference_t<_Vp>>>
1650 class transform_view :
public view_interface<transform_view<_Vp, _Fp>>
1653 template<
bool _Const>
1656 template<
bool _Const>
1660 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
1661 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
1663 static constexpr
auto
1666 if constexpr (random_access_range<_Vp>)
1667 return random_access_iterator_tag{};
1668 else if constexpr (bidirectional_range<_Vp>)
1669 return bidirectional_iterator_tag{};
1670 else if constexpr (forward_range<_Vp>)
1671 return forward_iterator_tag{};
1673 return input_iterator_tag{};
1676 static constexpr
auto
1679 using _Res = invoke_result_t<_Fp&, range_reference_t<_Base>>;
1680 if constexpr (is_lvalue_reference_v<_Res>)
1683 =
typename iterator_traits<_Base_iter>::iterator_category;
1684 if constexpr (derived_from<_Cat, contiguous_iterator_tag>)
1685 return random_access_iterator_tag{};
1690 return input_iterator_tag{};
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)
1731 noexcept(noexcept(std::__invoke(*_M_parent->_M_fun, *_M_current)))
1732 {
return std::__invoke(*_M_parent->_M_fun, *_M_current); }
1734 constexpr _Iterator&
1746 operator++(
int) requires forward_range<_Base>
1753 constexpr _Iterator&
1754 operator--() requires bidirectional_range<_Base>
1761 operator--(
int) requires bidirectional_range<_Base>
1768 constexpr _Iterator&
1769 operator+=(difference_type __n) requires random_access_range<_Base>
1775 constexpr _Iterator&
1776 operator-=(difference_type __n) requires random_access_range<_Base>
1782 constexpr decltype(
auto)
1783 operator[](difference_type __n) const
1784 requires random_access_range<_Base>
1785 {
return std::__invoke(*_M_parent->_M_fun, _M_current[__n]); }
1787 friend constexpr
bool
1788 operator==(
const _Iterator& __x,
const _Iterator& __y)
1789 requires equality_comparable<_Base_iter>
1790 {
return __x._M_current == __y._M_current; }
1792 friend constexpr
bool
1793 operator<(
const _Iterator& __x,
const _Iterator& __y)
1794 requires random_access_range<_Base>
1795 {
return __x._M_current < __y._M_current; }
1797 friend constexpr
bool
1798 operator>(
const _Iterator& __x,
const _Iterator& __y)
1799 requires random_access_range<_Base>
1800 {
return __y < __x; }
1802 friend constexpr
bool
1803 operator<=(
const _Iterator& __x,
const _Iterator& __y)
1804 requires random_access_range<_Base>
1805 {
return !(__y < __x); }
1807 friend constexpr
bool
1808 operator>=(
const _Iterator& __x,
const _Iterator& __y)
1809 requires random_access_range<_Base>
1810 {
return !(__x < __y); }
1812 #ifdef __cpp_lib_three_way_comparison
1813 friend constexpr
auto
1814 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
1815 requires random_access_range<_Base>
1816 && three_way_comparable<_Base_iter>
1817 {
return __x._M_current <=> __y._M_current; }
1820 friend constexpr _Iterator
1821 operator+(_Iterator __i, difference_type __n)
1822 requires random_access_range<_Base>
1823 {
return {*__i._M_parent, __i._M_current + __n}; }
1825 friend constexpr _Iterator
1826 operator+(difference_type __n, _Iterator __i)
1827 requires random_access_range<_Base>
1828 {
return {*__i._M_parent, __i._M_current + __n}; }
1830 friend constexpr _Iterator
1831 operator-(_Iterator __i, difference_type __n)
1832 requires random_access_range<_Base>
1833 {
return {*__i._M_parent, __i._M_current - __n}; }
1835 friend constexpr difference_type
1836 operator-(
const _Iterator& __x,
const _Iterator& __y)
1837 requires random_access_range<_Base>
1838 {
return __x._M_current - __y._M_current; }
1840 friend constexpr decltype(
auto)
1841 iter_move(const _Iterator& __i) noexcept(noexcept(*__i))
1843 if constexpr (is_lvalue_reference_v<decltype(*__i)>)
1844 return std::
move(*__i);
1849 friend constexpr
void
1850 iter_swap(const _Iterator& __x, const _Iterator& __y)
1851 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1852 requires indirectly_swappable<_Base_iter>
1853 {
return ranges::iter_swap(__x._M_current, __y._M_current); }
1855 friend _Iterator<!_Const>;
1856 template<
bool>
friend struct _Sentinel;
1859 template<
bool _Const>
1863 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
1864 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
1866 template<
bool _Const2>
1867 constexpr range_difference_t<_Base>
1868 __distance_from(
const _Iterator<_Const2>& __i)
const
1869 {
return _M_end - __i._M_current; }
1871 template<
bool _Const2>
1873 __equal(
const _Iterator<_Const2>& __i)
const
1874 {
return __i._M_current == _M_end; }
1876 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
1879 _Sentinel() =
default;
1882 _Sentinel(sentinel_t<_Base> __end)
1887 _Sentinel(_Sentinel<!_Const> __i)
1889 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
1893 constexpr sentinel_t<_Base>
1897 template<
bool _Const2>
1898 requires sentinel_for<sentinel_t<_Base>,
1899 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
1900 friend constexpr
bool
1901 operator==(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
1902 {
return __y.__equal(__x); }
1904 template<
bool _Const2>
1905 requires sized_sentinel_for<sentinel_t<_Base>,
1906 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
1907 friend constexpr range_difference_t<_Base>
1908 operator-(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
1909 {
return -__y.__distance_from(__x); }
1911 template<
bool _Const2>
1912 requires sized_sentinel_for<sentinel_t<_Base>,
1913 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
1914 friend constexpr range_difference_t<_Base>
1915 operator-(
const _Sentinel& __y,
const _Iterator<_Const2>& __x)
1916 {
return __y.__distance_from(__x); }
1918 friend _Sentinel<!_Const>;
1921 _Vp _M_base = _Vp();
1922 __detail::__box<_Fp> _M_fun;
1925 transform_view() =
default;
1928 transform_view(_Vp
__base, _Fp __fun)
1929 : _M_base(std::
move(__base)), _M_fun(std::
move(__fun))
1933 base() const& requires copy_constructible<_Vp>
1934 {
return _M_base ; }
1940 constexpr _Iterator<false>
1944 constexpr _Iterator<true>
1946 requires range<const _Vp>
1947 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
1950 constexpr _Sentinel<false>
1952 {
return _Sentinel<false>{
ranges::end(_M_base)}; }
1954 constexpr _Iterator<false>
1955 end() requires common_range<_Vp>
1956 {
return _Iterator<false>{*
this,
ranges::end(_M_base)}; }
1958 constexpr _Sentinel<true>
1960 requires range<const _Vp>
1961 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
1964 constexpr _Iterator<true>
1966 requires common_range<const _Vp>
1967 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
1968 {
return _Iterator<true>{*
this,
ranges::end(_M_base)}; }
1971 size() requires sized_range<_Vp>
1972 {
return ranges::size(_M_base); }
1975 size() const requires sized_range<const _Vp>
1976 {
return ranges::size(_M_base); }
1979 template<
typename _Range,
typename _Fp>
1980 transform_view(_Range&&, _Fp) -> transform_view<views::all_t<_Range>, _Fp>;
1984 inline constexpr __adaptor::_RangeAdaptor transform
1985 = [] <viewable_range _Range,
typename _Fp> (_Range&& __r, _Fp&& __f)
1987 return transform_view{std::forward<_Range>(__r), std::forward<_Fp>(__f)};
1992 class take_view :
public view_interface<take_view<_Vp>>
1995 template<
bool _Const>
1999 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2000 using _CI = counted_iterator<iterator_t<_Base>>;
2002 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2005 _Sentinel() =
default;
2008 _Sentinel(sentinel_t<_Base> __end)
2013 _Sentinel(_Sentinel<!_Const> __s)
2014 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2018 constexpr sentinel_t<_Base>
2022 friend constexpr
bool operator==(
const _CI& __y,
const _Sentinel& __x)
2023 {
return __y.count() == 0 || __y.base() == __x._M_end; }
2025 friend _Sentinel<!_Const>;
2028 _Vp _M_base = _Vp();
2029 range_difference_t<_Vp> _M_count = 0;
2032 take_view() =
default;
2035 take_view(_Vp base, range_difference_t<_Vp> __count)
2036 : _M_base(std::
move(base)), _M_count(std::
move(__count))
2040 base() const& requires copy_constructible<_Vp>
2048 begin() requires (!__detail::__simple_view<_Vp>)
2050 if constexpr (sized_range<_Vp>)
2052 if constexpr (random_access_range<_Vp>)
2053 return ranges::begin(_M_base);
2065 begin() const requires range<const _Vp>
2067 if constexpr (sized_range<const _Vp>)
2069 if constexpr (random_access_range<const _Vp>)
2070 return ranges::begin(_M_base);
2082 end() requires (!__detail::__simple_view<_Vp>)
2084 if constexpr (sized_range<_Vp>)
2086 if constexpr (random_access_range<_Vp>)
2087 return ranges::begin(_M_base) + size();
2089 return default_sentinel;
2096 end() const requires range<const _Vp>
2098 if constexpr (sized_range<const _Vp>)
2100 if constexpr (random_access_range<const _Vp>)
2101 return ranges::begin(_M_base) + size();
2103 return default_sentinel;
2110 size() requires sized_range<_Vp>
2112 auto __n = ranges::size(_M_base);
2113 return __detail::min(__n,
static_cast<decltype(__n)
>(_M_count));
2117 size() const requires sized_range<const _Vp>
2119 auto __n = ranges::size(_M_base);
2120 return __detail::min(__n,
static_cast<decltype(__n)
>(_M_count));
2124 template<range _Range>
2125 take_view(_Range&&, range_difference_t<_Range>)
2126 -> take_view<views::all_t<_Range>>;
2130 inline constexpr __adaptor::_RangeAdaptor take
2131 = [] <viewable_range _Range,
typename _Tp> (_Range&& __r, _Tp&& __n)
2133 return take_view{std::forward<_Range>(__r), std::forward<_Tp>(__n)};
2137 template<view _Vp,
typename _Pred>
2138 requires input_range<_Vp> && is_object_v<_Pred>
2139 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2140 class take_while_view :
public view_interface<take_while_view<_Vp, _Pred>>
2142 template<
bool _Const>
2146 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2148 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2149 const _Pred* _M_pred =
nullptr;
2152 _Sentinel() =
default;
2155 _Sentinel(sentinel_t<_Base> __end,
const _Pred* __pred)
2156 : _M_end(__end), _M_pred(__pred)
2160 _Sentinel(_Sentinel<!_Const> __s)
2161 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2162 : _M_end(__s._M_end), _M_pred(__s._M_pred)
2165 constexpr sentinel_t<_Base>
2166 base()
const {
return _M_end; }
2168 friend constexpr
bool
2169 operator==(
const iterator_t<_Base>& __x,
const _Sentinel& __y)
2170 {
return __y._M_end == __x || !std::__invoke(*__y._M_pred, *__x); }
2172 friend _Sentinel<!_Const>;
2175 _Vp _M_base = _Vp();
2176 __detail::__box<_Pred> _M_pred;
2179 take_while_view() =
default;
2182 take_while_view(_Vp base, _Pred __pred)
2183 : _M_base(std::
move(base)), _M_pred(std::
move(__pred))
2188 base() const& requires copy_constructible<_Vp>
2195 constexpr
const _Pred&
2197 {
return *_M_pred; }
2200 begin() requires (!__detail::__simple_view<_Vp>)
2204 begin() const requires range<const _Vp>
2208 end() requires (!__detail::__simple_view<_Vp>)
2213 end() const requires range<const _Vp>
2218 template<
typename _Range,
typename _Pred>
2219 take_while_view(_Range&&, _Pred)
2220 -> take_while_view<views::all_t<_Range>, _Pred>;
2224 inline constexpr __adaptor::_RangeAdaptor take_while
2225 = [] <viewable_range _Range,
typename _Pred> (_Range&& __r, _Pred&& __p)
2227 return take_while_view{std::forward<_Range>(__r), std::forward<_Pred>(__p)};
2232 class drop_view :
public view_interface<drop_view<_Vp>>
2235 _Vp _M_base = _Vp();
2236 range_difference_t<_Vp> _M_count = 0;
2238 static constexpr
bool _S_needs_cached_begin = !random_access_range<_Vp>;
2239 [[no_unique_address]]
2240 __detail::__maybe_present_t<_S_needs_cached_begin,
2241 __detail::_CachedPosition<_Vp>>
2245 drop_view() =
default;
2248 drop_view(_Vp
__base, range_difference_t<_Vp> __count)
2249 : _M_base(std::
move(__base)), _M_count(__count)
2250 { __glibcxx_assert(__count >= 0); }
2253 base() const& requires copy_constructible<_Vp>
2261 begin() requires (!(__detail::__simple_view<_Vp>
2262 && random_access_range<_Vp>))
2264 if constexpr (_S_needs_cached_begin)
2265 if (_M_cached_begin._M_has_value())
2266 return _M_cached_begin._M_get(_M_base);
2268 auto __it = ranges::next(ranges::begin(_M_base),
2269 _M_count, ranges::end(_M_base));
2270 if constexpr (_S_needs_cached_begin)
2271 _M_cached_begin._M_set(_M_base, __it);
2276 begin() const requires random_access_range<const _Vp>
2283 end() requires (!__detail::__simple_view<_Vp>)
2287 end() const requires range<const _Vp>
2291 size() requires sized_range<_Vp>
2293 const auto __s = ranges::size(_M_base);
2294 const auto __c =
static_cast<decltype(__s)
>(_M_count);
2295 return __s < __c ? 0 : __s - __c;
2299 size() const requires sized_range<const _Vp>
2301 const auto __s = ranges::size(_M_base);
2302 const auto __c =
static_cast<decltype(__s)
>(_M_count);
2303 return __s < __c ? 0 : __s - __c;
2307 template<
typename _Range>
2308 drop_view(_Range&&, range_difference_t<_Range>)
2309 -> drop_view<views::all_t<_Range>>;
2313 inline constexpr __adaptor::_RangeAdaptor drop
2314 = [] <viewable_range _Range,
typename _Tp> (_Range&& __r, _Tp&& __n)
2316 return drop_view{std::forward<_Range>(__r), std::forward<_Tp>(__n)};
2320 template<view _Vp,
typename _Pred>
2321 requires input_range<_Vp> && is_object_v<_Pred>
2322 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2323 class drop_while_view :
public view_interface<drop_while_view<_Vp, _Pred>>
2326 _Vp _M_base = _Vp();
2327 __detail::__box<_Pred> _M_pred;
2328 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
2331 drop_while_view() =
default;
2334 drop_while_view(_Vp
__base, _Pred __pred)
2335 : _M_base(std::
move(__base)), _M_pred(std::
move(__pred))
2339 base() const& requires copy_constructible<_Vp>
2346 constexpr
const _Pred&
2348 {
return *_M_pred; }
2353 if (_M_cached_begin._M_has_value())
2354 return _M_cached_begin._M_get(_M_base);
2358 std::cref(*_M_pred));
2359 _M_cached_begin._M_set(_M_base, __it);
2368 template<
typename _Range,
typename _Pred>
2369 drop_while_view(_Range&&, _Pred)
2370 -> drop_while_view<views::all_t<_Range>, _Pred>;
2374 inline constexpr __adaptor::_RangeAdaptor drop_while
2375 = [] <viewable_range _Range,
typename _Pred> (_Range&& __r, _Pred&& __p)
2377 return drop_while_view{std::forward<_Range>(__r),
2378 std::forward<_Pred>(__p)};
2382 template<input_range _Vp>
2383 requires view<_Vp> && input_range<range_reference_t<_Vp>>
2384 && (is_reference_v<range_reference_t<_Vp>>
2385 || view<range_value_t<_Vp>>)
2386 class join_view :
public view_interface<join_view<_Vp>>
2389 using _InnerRange = range_reference_t<_Vp>;
2391 template<
bool _Const>
2394 template<
bool _Const>
2398 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
2399 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2401 static constexpr
bool _S_ref_is_glvalue
2402 = is_reference_v<range_reference_t<_Base>>;
2407 auto __update_inner = [
this] (range_reference_t<_Base> __x) ->
auto&
2409 if constexpr (_S_ref_is_glvalue)
2412 return (_M_parent->_M_inner = views::all(std::
move(__x)));
2415 for (; _M_outer != ranges::end(_M_parent->_M_base); ++_M_outer)
2417 auto& inner = __update_inner(*_M_outer);
2423 if constexpr (_S_ref_is_glvalue)
2424 _M_inner = _Inner_iter();
2427 static constexpr auto
2430 if constexpr (_S_ref_is_glvalue
2431 && bidirectional_range<_Base>
2432 && bidirectional_range<range_reference_t<_Base>>)
2433 return bidirectional_iterator_tag{};
2434 else if constexpr (_S_ref_is_glvalue
2435 && forward_range<_Base>
2436 && forward_range<range_reference_t<_Base>>)
2437 return forward_iterator_tag{};
2439 return input_iterator_tag{};
2442 static constexpr
auto
2446 =
typename iterator_traits<_Outer_iter>::iterator_category;
2448 =
typename iterator_traits<_Inner_iter>::iterator_category;
2449 if constexpr (_S_ref_is_glvalue
2450 && derived_from<_OuterCat, bidirectional_iterator_tag>
2451 && derived_from<_InnerCat, bidirectional_iterator_tag>)
2452 return bidirectional_iterator_tag{};
2453 else if constexpr (_S_ref_is_glvalue
2454 && derived_from<_OuterCat, forward_iterator_tag>
2455 && derived_from<_InnerCat, forward_iterator_tag>)
2456 return forward_iterator_tag{};
2457 else if constexpr (derived_from<_OuterCat, input_iterator_tag>
2458 && derived_from<_InnerCat, input_iterator_tag>)
2459 return input_iterator_tag{};
2461 return output_iterator_tag{};
2464 using _Outer_iter = iterator_t<_Base>;
2465 using _Inner_iter = iterator_t<range_reference_t<_Base>>;
2467 _Outer_iter _M_outer = _Outer_iter();
2468 _Inner_iter _M_inner = _Inner_iter();
2469 _Parent* _M_parent =
nullptr;
2472 using iterator_concept = decltype(_S_iter_concept());
2473 using iterator_category = decltype(_S_iter_cat());
2474 using value_type = range_value_t<range_reference_t<_Base>>;
2475 using difference_type
2476 = common_type_t<range_difference_t<_Base>,
2477 range_difference_t<range_reference_t<_Base>>>;
2479 _Iterator() =
default;
2482 _Iterator(_Parent& __parent, _Outer_iter __outer)
2483 : _M_outer(std::
move(__outer)),
2488 _Iterator(_Iterator<!_Const> __i)
2490 && convertible_to<iterator_t<_Vp>, _Outer_iter>
2491 && convertible_to<iterator_t<_InnerRange>, _Inner_iter>
2492 : _M_outer(
std::move(__i._M_outer)), _M_inner(__i._M_inner),
2493 _M_parent(__i._M_parent)
2496 constexpr decltype(
auto)
2498 {
return *_M_inner; }
2500 constexpr _Outer_iter
2502 requires __detail::__has_arrow<_Outer_iter>
2503 && copyable<_Outer_iter>
2504 {
return _M_inner; }
2506 constexpr _Iterator&
2509 auto&& __inner_range = [
this] () -> decltype(
auto) {
2510 if constexpr (_S_ref_is_glvalue)
2513 return _M_parent->_M_inner;
2515 if (++_M_inner == ranges::end(__inner_range))
2529 requires _S_ref_is_glvalue && forward_range<_Base>
2530 && forward_range<range_reference_t<_Base>>
2537 constexpr _Iterator&
2539 requires _S_ref_is_glvalue && bidirectional_range<_Base>
2540 && bidirectional_range<range_reference_t<_Base>>
2541 && common_range<range_reference_t<_Base>>
2553 requires _S_ref_is_glvalue && bidirectional_range<_Base>
2554 && bidirectional_range<range_reference_t<_Base>>
2555 && common_range<range_reference_t<_Base>>
2562 friend constexpr
bool
2563 operator==(
const _Iterator& __x,
const _Iterator& __y)
2564 requires _S_ref_is_glvalue
2565 && equality_comparable<_Outer_iter>
2566 && equality_comparable<_Inner_iter>
2568 return (__x._M_outer == __y._M_outer
2569 && __x._M_inner == __y._M_inner);
2572 friend constexpr decltype(
auto)
2573 iter_move(const _Iterator& __i)
2574 noexcept(noexcept(ranges::iter_move(__i._M_inner)))
2575 {
return ranges::iter_move(__i._M_inner); }
2577 friend constexpr
void
2578 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
2579 noexcept(noexcept(ranges::iter_swap(__x._M_inner, __y._M_inner)))
2580 {
return ranges::iter_swap(__x._M_inner, __y._M_inner); }
2582 friend _Iterator<!_Const>;
2583 template<
bool>
friend struct _Sentinel;
2586 template<
bool _Const>
2590 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
2591 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2593 template<
bool _Const2>
2595 __equal(
const _Iterator<_Const2>& __i)
const
2596 {
return __i._M_outer == _M_end; }
2598 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2601 _Sentinel() =
default;
2604 _Sentinel(_Parent& __parent)
2605 : _M_end(ranges::end(__parent._M_base))
2609 _Sentinel(_Sentinel<!_Const> __s)
2610 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2614 template<
bool _Const2>
2615 requires sentinel_for<sentinel_t<_Base>,
2616 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
2617 friend constexpr
bool
2618 operator==(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
2619 {
return __y.__equal(__x); }
2621 friend _Sentinel<!_Const>;
2624 _Vp _M_base = _Vp();
2627 [[no_unique_address]]
2628 __detail::__maybe_present_t<!is_reference_v<_InnerRange>,
2629 views::all_t<_InnerRange>> _M_inner;
2632 join_view() =
default;
2636 : _M_base(std::
move(__base))
2640 base() const& requires copy_constructible<_Vp>
2650 constexpr
bool __use_const
2651 = (__detail::__simple_view<_Vp>
2652 && is_reference_v<range_reference_t<_Vp>>);
2653 return _Iterator<__use_const>{*
this,
ranges::begin(_M_base)};
2658 requires input_range<const _Vp>
2659 && is_reference_v<range_reference_t<const _Vp>>
2667 if constexpr (forward_range<_Vp> && is_reference_v<_InnerRange>
2668 && forward_range<_InnerRange>
2669 && common_range<_Vp> && common_range<_InnerRange>)
2670 return _Iterator<__detail::__simple_view<_Vp>>{*
this,
2673 return _Sentinel<__detail::__simple_view<_Vp>>{*
this};
2678 requires input_range<const _Vp>
2679 && is_reference_v<range_reference_t<const _Vp>>
2681 if constexpr (forward_range<const _Vp>
2682 && is_reference_v<range_reference_t<const _Vp>>
2683 && forward_range<range_reference_t<const _Vp>>
2684 && common_range<const _Vp>
2685 && common_range<range_reference_t<const _Vp>>)
2686 return _Iterator<true>{*
this,
ranges::end(_M_base)};
2688 return _Sentinel<true>{*
this};
2692 template<
typename _Range>
2693 explicit join_view(_Range&&) -> join_view<views::all_t<_Range>>;
2697 inline constexpr __adaptor::_RangeAdaptorClosure join
2698 = [] <viewable_range _Range> (_Range&& __r)
2700 return join_view{std::forward<_Range>(__r)};
2707 struct __require_constant;
2709 template<
typename _Range>
2710 concept __tiny_range = sized_range<_Range>
2712 {
typename __require_constant<remove_reference_t<_Range>::size()>; }
2713 && (remove_reference_t<_Range>::size() <= 1);
2716 template<input_range _Vp, forward_range _Pattern>
2717 requires view<_Vp> && view<_Pattern>
2718 && indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
2720 && (forward_range<_Vp> || __detail::__tiny_range<_Pattern>)
2721 class split_view :
public view_interface<split_view<_Vp, _Pattern>>
2724 template<
bool _Const>
2727 template<
bool _Const>
2731 using _Parent = __detail::__maybe_const_t<_Const, split_view>;
2732 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2736 {
return __current() ==
ranges::end(_M_parent->_M_base); }
2743 __current() noexcept
2745 if constexpr (forward_range<_Vp>)
2748 return _M_parent->_M_current;
2752 __current() const noexcept
2754 if constexpr (forward_range<_Vp>)
2757 return _M_parent->_M_current;
2760 _Parent* _M_parent =
nullptr;
2763 [[no_unique_address]]
2764 __detail::__maybe_present_t<forward_range<_Vp>,
2765 iterator_t<_Base>> _M_current;
2768 using iterator_concept =
conditional_t<forward_range<_Base>,
2769 forward_iterator_tag,
2770 input_iterator_tag>;
2771 using iterator_category = input_iterator_tag;
2772 using difference_type = range_difference_t<_Base>;
2774 struct value_type : view_interface<value_type>
2777 _OuterIter _M_i = _OuterIter();
2780 value_type() =
default;
2783 value_type(_OuterIter __i)
2784 : _M_i(std::
move(__i))
2787 constexpr _InnerIter<_Const>
2789 requires copyable<_OuterIter>
2790 {
return _InnerIter<_Const>{_M_i}; }
2792 constexpr _InnerIter<_Const>
2794 requires (!copyable<_OuterIter>)
2795 {
return _InnerIter<_Const>{
std::move(_M_i)}; }
2797 constexpr default_sentinel_t
2799 {
return default_sentinel; }
2802 _OuterIter() =
default;
2805 _OuterIter(_Parent& __parent) requires (!forward_range<_Base>)
2810 _OuterIter(_Parent& __parent, iterator_t<_Base> __current)
2811 requires forward_range<_Base>
2817 _OuterIter(_OuterIter<!_Const> __i)
2819 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
2820 : _M_parent(__i._M_parent), _M_current(
std::move(__i._M_current))
2823 constexpr value_type
2825 {
return value_type{*
this}; }
2827 constexpr _OuterIter&
2830 const auto __end =
ranges::end(_M_parent->_M_base);
2831 if (__current() == __end)
2833 const auto [__pbegin, __pend] = subrange{_M_parent->_M_pattern};
2834 if (__pbegin == __pend)
2840 = __detail::mismatch(
std::move(__current()), __end,
2845 }
while (++__current() != __end);
2849 constexpr decltype(
auto)
2852 if constexpr (forward_range<_Base>)
2862 friend constexpr
bool
2863 operator==(
const _OuterIter& __x,
const _OuterIter& __y)
2864 requires forward_range<_Base>
2865 {
return __x._M_current == __y._M_current; }
2867 friend constexpr
bool
2868 operator==(
const _OuterIter& __x, default_sentinel_t)
2869 {
return __x.__at_end(); };
2871 friend _OuterIter<!_Const>;
2872 friend _InnerIter<_Const>;
2875 template<
bool _Const>
2879 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2884 auto [__pcur, __pend] = subrange{_M_i._M_parent->_M_pattern};
2885 auto __end =
ranges::end(_M_i._M_parent->_M_base);
2886 if constexpr (__detail::__tiny_range<_Pattern>)
2888 const auto& __cur = _M_i_current();
2891 if (__pcur == __pend)
2892 return _M_incremented;
2893 return *__cur == *__pcur;
2897 auto __cur = _M_i_current();
2900 if (__pcur == __pend)
2901 return _M_incremented;
2904 if (*__cur != *__pcur)
2906 if (++__pcur == __pend)
2908 }
while (++__cur != __end);
2913 static constexpr
auto
2917 =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
2918 if constexpr (derived_from<_Cat, forward_iterator_tag>)
2919 return forward_iterator_tag{};
2925 _M_i_current() noexcept
2926 {
return _M_i.__current(); }
2929 _M_i_current() const noexcept
2930 {
return _M_i.__current(); }
2932 _OuterIter<_Const> _M_i = _OuterIter<_Const>();
2933 bool _M_incremented =
false;
2936 using iterator_concept
2937 =
typename _OuterIter<_Const>::iterator_concept;
2938 using iterator_category = decltype(_S_iter_cat());
2939 using value_type = range_value_t<_Base>;
2940 using difference_type = range_difference_t<_Base>;
2942 _InnerIter() =
default;
2945 _InnerIter(_OuterIter<_Const> __i)
2946 : _M_i(std::
move(__i))
2949 constexpr decltype(
auto)
2951 {
return *_M_i_current(); }
2953 constexpr _InnerIter&
2956 _M_incremented =
true;
2957 if constexpr (!forward_range<_Base>)
2958 if constexpr (_Pattern::size() == 0)
2964 constexpr decltype(auto)
2967 if constexpr (forward_range<_Vp>)
2977 friend constexpr
bool
2978 operator==(
const _InnerIter& __x,
const _InnerIter& __y)
2979 requires forward_range<_Base>
2980 {
return __x._M_i == __y._M_i; }
2982 friend constexpr
bool
2983 operator==(
const _InnerIter& __x, default_sentinel_t)
2984 {
return __x.__at_end(); }
2986 friend constexpr decltype(
auto)
2987 iter_move(const _InnerIter& __i)
2988 noexcept(noexcept(ranges::iter_move(__i._M_i_current())))
2989 {
return ranges::iter_move(__i._M_i_current()); }
2991 friend constexpr
void
2992 iter_swap(
const _InnerIter& __x,
const _InnerIter& __y)
2993 noexcept(noexcept(ranges::iter_swap(__x._M_i_current(),
2994 __y._M_i_current())))
2995 requires indirectly_swappable<iterator_t<_Base>>
2996 { ranges::iter_swap(__x._M_i_current(), __y._M_i_current()); }
2999 _Vp _M_base = _Vp();
3000 _Pattern _M_pattern = _Pattern();
3003 [[no_unique_address]]
3004 __detail::__maybe_present_t<!forward_range<_Vp>, iterator_t<_Vp>>
3009 split_view() =
default;
3012 split_view(_Vp
__base, _Pattern __pattern)
3013 : _M_base(std::
move(__base)), _M_pattern(std::
move(__pattern))
3016 template<input_range _Range>
3017 requires constructible_from<_Vp, views::all_t<_Range>>
3018 && constructible_from<_Pattern, single_view<range_value_t<_Range>>>
3020 split_view(_Range&& __r, range_value_t<_Range> __e)
3021 : _M_base(views::all(std::
forward<_Range>(__r))),
3022 _M_pattern(std::
move(__e))
3026 base() const& requires copy_constructible<_Vp>
3036 if constexpr (forward_range<_Vp>)
3037 return _OuterIter<__detail::__simple_view<_Vp>>{
3042 return _OuterIter<false>{*
this};
3047 begin() const requires forward_range<_Vp> && forward_range<const _Vp>
3053 end() requires forward_range<_Vp> && common_range<_Vp>
3055 return _OuterIter<__detail::__simple_view<_Vp>>{
3062 if constexpr (forward_range<_Vp>
3063 && forward_range<const _Vp>
3064 && common_range<const _Vp>)
3065 return _OuterIter<true>{*
this,
ranges::end(_M_base)};
3067 return default_sentinel;
3071 template<
typename _Range,
typename _Pred>
3072 split_view(_Range&&, _Pred&&)
3073 -> split_view<views::all_t<_Range>, views::all_t<_Pred>>;
3075 template<input_range _Range>
3076 split_view(_Range&&, range_value_t<_Range>)
3077 -> split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
3081 inline constexpr __adaptor::_RangeAdaptor split
3082 = [] <viewable_range _Range,
typename _Fp> (_Range&& __r, _Fp&& __f)
3084 return split_view{std::forward<_Range>(__r), std::forward<_Fp>(__f)};
3092 template<input_or_output_iterator _Iter>
3094 operator()(_Iter __i, iter_difference_t<_Iter> __n)
const
3096 if constexpr (random_access_iterator<_Iter>)
3097 return subrange{__i, __i + __n};
3099 return subrange{counted_iterator{
std::move(__i), __n},
3104 inline constexpr _Counted counted{};
3108 requires (!common_range<_Vp>) && copyable<iterator_t<_Vp>>
3109 class common_view :
public view_interface<common_view<_Vp>>
3112 _Vp _M_base = _Vp();
3115 common_view() =
default;
3118 common_view(_Vp __r)
3119 : _M_base(std::
move(__r))
3133 base() const& requires copy_constructible<_Vp>
3143 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3144 return ranges::begin(_M_base);
3146 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
3147 (ranges::begin(_M_base));
3151 begin() const requires range<const _Vp>
3153 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
3154 return ranges::begin(_M_base);
3156 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
3157 (ranges::begin(_M_base));
3163 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3164 return ranges::begin(_M_base) + ranges::size(_M_base);
3166 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
3167 (ranges::end(_M_base));
3171 end() const requires range<const _Vp>
3173 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
3174 return ranges::begin(_M_base) + ranges::size(_M_base);
3176 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
3177 (ranges::end(_M_base));
3181 size() requires sized_range<_Vp>
3182 {
return ranges::size(_M_base); }
3185 size() const requires sized_range<const _Vp>
3186 {
return ranges::size(_M_base); }
3189 template<
typename _Range>
3190 common_view(_Range&&) -> common_view<views::all_t<_Range>>;
3194 inline constexpr __adaptor::_RangeAdaptorClosure common
3195 = [] <viewable_range _Range> (_Range&& __r)
3197 if constexpr (common_range<_Range>
3198 && requires { views::all(std::forward<_Range>(__r)); })
3199 return views::all(std::forward<_Range>(__r));
3201 return common_view{std::forward<_Range>(__r)};
3207 requires bidirectional_range<_Vp>
3208 class reverse_view :
public view_interface<reverse_view<_Vp>>
3211 _Vp _M_base = _Vp();
3213 static constexpr
bool _S_needs_cached_begin
3214 = !common_range<_Vp> && !random_access_range<_Vp>;
3215 [[no_unique_address]]
3216 __detail::__maybe_present_t<_S_needs_cached_begin,
3217 __detail::_CachedPosition<_Vp>>
3221 reverse_view() =
default;
3224 reverse_view(_Vp __r)
3225 : _M_base(std::
move(__r))
3229 base() const& requires copy_constructible<_Vp>
3236 constexpr reverse_iterator<iterator_t<_Vp>>
3239 if constexpr (_S_needs_cached_begin)
3240 if (_M_cached_begin._M_has_value())
3243 auto __it = ranges::next(ranges::begin(_M_base), ranges::end(_M_base));
3244 if constexpr (_S_needs_cached_begin)
3245 _M_cached_begin._M_set(_M_base, __it);
3250 begin() requires common_range<_Vp>
3254 begin() const requires common_range<const _Vp>
3257 constexpr reverse_iterator<iterator_t<_Vp>>
3262 end() const requires common_range<const _Vp>
3266 size() requires sized_range<_Vp>
3267 {
return ranges::size(_M_base); }
3270 size() const requires sized_range<const _Vp>
3271 {
return ranges::size(_M_base); }
3274 template<
typename _Range>
3275 reverse_view(_Range&&) -> reverse_view<views::all_t<_Range>>;
3282 inline constexpr
bool __is_reversible_subrange =
false;
3284 template<
typename _Iter, subrange_kind _Kind>
3285 inline constexpr
bool
3286 __is_reversible_subrange<subrange<reverse_iterator<_Iter>,
3287 reverse_iterator<_Iter>,
3291 inline constexpr
bool __is_reverse_view =
false;
3293 template<
typename _Vp>
3294 inline constexpr
bool __is_reverse_view<reverse_view<_Vp>> =
true;
3297 inline constexpr __adaptor::_RangeAdaptorClosure reverse
3298 = [] <viewable_range _Range> (_Range&& __r)
3300 using _Tp = remove_cvref_t<_Range>;
3301 if constexpr (__detail::__is_reverse_view<_Tp>)
3302 return std::
forward<_Range>(__r).base();
3303 else if constexpr (__detail::__is_reversible_subrange<_Tp>)
3306 if constexpr (sized_range<_Tp>)
3307 return subrange<_Iter, _Iter, subrange_kind::sized>
3308 (__r.end().base(), __r.begin().base(), __r.size());
3310 return subrange<_Iter, _Iter, subrange_kind::unsized>
3311 (__r.end().base(), __r.begin().base());
3314 return reverse_view{std::forward<_Range>(__r)};
3320 template<
typename _Tp,
size_t _Nm>
3321 concept __has_tuple_element = requires(_Tp __t)
3323 typename tuple_size<_Tp>::type;
3324 requires _Nm < tuple_size_v<_Tp>;
3325 typename tuple_element_t<_Nm, _Tp>;
3326 { std::get<_Nm>(__t) }
3327 -> convertible_to<
const tuple_element_t<_Nm, _Tp>&>;
3331 template<input_range _Vp,
size_t _Nm>
3333 && __detail::__has_tuple_element<range_value_t<_Vp>, _Nm>
3334 && __detail::__has_tuple_element<remove_reference_t<range_reference_t<_Vp>>,
3336 class elements_view :
public view_interface<elements_view<_Vp, _Nm>>
3339 elements_view() =
default;
3342 elements_view(_Vp base)
3343 : _M_base(std::
move(base))
3347 base() const& requires copy_constructible<_Vp>
3355 begin() requires (!__detail::__simple_view<_Vp>)
3359 begin() const requires __detail::__simple_view<_Vp>
3363 end() requires (!__detail::__simple_view<_Vp>)
3367 end() const requires __detail::__simple_view<_Vp>
3371 size() requires sized_range<_Vp>
3372 {
return ranges::size(_M_base); }
3375 size() const requires sized_range<const _Vp>
3376 {
return ranges::size(_M_base); }
3379 template<
bool _Const>
3382 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
3384 iterator_t<_Base> _M_current = iterator_t<_Base>();
3386 friend _Iterator<!_Const>;
3389 using iterator_category
3390 =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
3392 = remove_cvref_t<tuple_element_t<_Nm, range_value_t<_Base>>>;
3393 using difference_type = range_difference_t<_Base>;
3395 _Iterator() =
default;
3398 _Iterator(iterator_t<_Base> current)
3399 : _M_current(std::
move(current))
3403 _Iterator(_Iterator<!_Const> i)
3404 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
3408 constexpr iterator_t<_Base>
3410 requires copyable<iterator_t<_Base>>
3411 {
return _M_current; }
3413 constexpr iterator_t<_Base>
3417 constexpr decltype(
auto)
3419 {
return std::get<_Nm>(*_M_current); }
3421 constexpr _Iterator&
3429 operator++(
int) requires (!forward_range<_Base>)
3433 operator++(
int) requires forward_range<_Base>
3440 constexpr _Iterator&
3441 operator--() requires bidirectional_range<_Base>
3448 operator--(
int) requires bidirectional_range<_Base>
3455 constexpr _Iterator&
3456 operator+=(difference_type __n)
3457 requires random_access_range<_Base>
3463 constexpr _Iterator&
3464 operator-=(difference_type __n)
3465 requires random_access_range<_Base>
3471 constexpr decltype(
auto)
3472 operator[](difference_type __n) const
3473 requires random_access_range<_Base>
3474 {
return std::get<_Nm>(*(_M_current + __n)); }
3476 friend constexpr
bool
3477 operator==(
const _Iterator& __x,
const _Iterator& __y)
3478 requires equality_comparable<iterator_t<_Base>>
3479 {
return __x._M_current == __y._M_current; }
3481 friend constexpr
bool
3482 operator==(
const _Iterator& __x,
const sentinel_t<_Base>& __y)
3483 {
return __x._M_current == __y; }
3485 friend constexpr
bool
3486 operator<(
const _Iterator& __x,
const _Iterator& __y)
3487 requires random_access_range<_Base>
3488 {
return __x._M_current < __y._M_current; }
3490 friend constexpr
bool
3491 operator>(
const _Iterator& __x,
const _Iterator& __y)
3492 requires random_access_range<_Base>
3493 {
return __y._M_current < __x._M_current; }
3495 friend constexpr
bool
3496 operator<=(
const _Iterator& __x,
const _Iterator& __y)
3497 requires random_access_range<_Base>
3498 {
return !(__y._M_current > __x._M_current); }
3500 friend constexpr
bool
3501 operator>=(
const _Iterator& __x,
const _Iterator& __y)
3502 requires random_access_range<_Base>
3503 {
return !(__x._M_current > __y._M_current); }
3505 #ifdef __cpp_lib_three_way_comparison
3506 friend constexpr
auto
3507 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
3508 requires random_access_range<_Base>
3509 && three_way_comparable<iterator_t<_Base>>
3510 {
return __x._M_current <=> __y._M_current; }
3513 friend constexpr _Iterator
3514 operator+(
const _Iterator& __x, difference_type __y)
3515 requires random_access_range<_Base>
3516 {
return _Iterator{__x} += __y; }
3518 friend constexpr _Iterator
3519 operator+(difference_type __x,
const _Iterator& __y)
3520 requires random_access_range<_Base>
3521 {
return __y + __x; }
3523 friend constexpr _Iterator
3524 operator-(
const _Iterator& __x, difference_type __y)
3525 requires random_access_range<_Base>
3526 {
return _Iterator{__x} -= __y; }
3528 friend constexpr difference_type
3529 operator-(
const _Iterator& __x,
const _Iterator& __y)
3530 requires random_access_range<_Base>
3531 {
return __x._M_current - __y._M_current; }
3533 friend constexpr difference_type
3534 operator-(
const _Iterator<_Const>& __x,
const sentinel_t<_Base>& __y)
3535 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
3536 {
return __x._M_current - __y; }
3538 friend constexpr difference_type
3539 operator-(
const sentinel_t<_Base>& __x,
const _Iterator<_Const>& __y)
3540 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
3541 {
return -(__y - __x); }
3544 _Vp _M_base = _Vp();
3547 template<
typename _Range>
3548 using keys_view = elements_view<views::all_t<_Range>, 0>;
3550 template<
typename _Range>
3551 using values_view = elements_view<views::all_t<_Range>, 1>;
3555 template<
size_t _Nm>
3556 inline constexpr __adaptor::_RangeAdaptorClosure elements
3557 = [] <viewable_range _Range> (_Range&& __r)
3559 using _El = elements_view<views::all_t<_Range>, _Nm>;
3560 return _El{std::forward<_Range>(__r)};
3563 inline constexpr __adaptor::_RangeAdaptorClosure keys = elements<0>;
3564 inline constexpr __adaptor::_RangeAdaptorClosure values = elements<1>;
3569 namespace views = ranges::views;
3571 template<
typename _Iter,
typename _Sent, ranges::subrange_kind _Kind>
3572 struct tuple_size<ranges::subrange<_Iter, _Sent, _Kind>>
3573 : integral_constant<size_t, 2>
3576 template<
typename _Iter,
typename _Sent, ranges::subrange_kind _Kind>
3577 struct tuple_element<0, ranges::subrange<_Iter, _Sent, _Kind>>
3578 {
using type = _Iter; };
3580 template<
typename _Iter,
typename _Sent, ranges::subrange_kind _Kind>
3581 struct tuple_element<1, ranges::subrange<_Iter, _Sent, _Kind>>
3582 {
using type = _Sent; };
3584 template<
typename _Iter,
typename _Sent, ranges::subrange_kind _Kind>
3585 struct tuple_element<0, const ranges::subrange<_Iter, _Sent, _Kind>>
3586 {
using type = _Iter; };
3588 template<
typename _Iter,
typename _Sent, ranges::subrange_kind _Kind>
3589 struct tuple_element<1, const ranges::subrange<_Iter, _Sent, _Kind>>
3590 {
using type = _Sent; };
3592 _GLIBCXX_END_NAMESPACE_VERSION
3594 #endif // library concepts
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
constexpr void advance(_InputIterator &__i, _Distance __n)
A generalization of pointer arithmetic.
constexpr complex< _Tp > operator+(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x plus y.
constexpr reverse_iterator< _Iterator > make_reverse_iterator(_Iterator __i)
Generator function for reverse_iterator.
constexpr void iota(_ForwardIterator __first, _ForwardIterator __last, _Tp __value)
Create a range of sequentially increasing values.
constexpr complex< _Tp > operator-(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x minus y.
constexpr iterator_traits< _InputIterator >::difference_type distance(_InputIterator __first, _InputIterator __last)
A generalization of pointer arithmetic.
constexpr _Iterator __base(_Iterator __it)
bitset< _Nb > operator|(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
typename conditional< _Cond, _Iftrue, _Iffalse >::type conditional_t
Alias template for conditional.
constexpr const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
_Tp * end(valarray< _Tp > &__va)
Return an iterator pointing to one past the last element of the valarray.
_Tp * begin(valarray< _Tp > &__va)
Return an iterator pointing to the first element of the valarray.
constexpr in_place_t in_place
Tag for in-place construction.
constexpr _Tp && forward(typename std::remove_reference< _Tp >::type &__t) noexcept
Forward an lvalue.
constexpr complex< _Tp > operator*(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x times y.