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>
356 __tmp.advance(--__n);
361 advance(iter_difference_t<_It> __n)
363 if constexpr (_S_store_size)
367 _M_size._M_size -= __detail::__to_unsigned_like(__d);
369 _M_size._M_size += __detail::__to_unsigned_like(-__d);
377 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
378 subrange(_It, _Sent) -> subrange<_It, _Sent>;
380 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
382 __detail::__make_unsigned_like_t<iter_difference_t<_It>>)
383 -> subrange<_It, _Sent, subrange_kind::sized>;
385 template<__detail::__iterator_sentinel_pair _Pr>
387 -> subrange<tuple_element_t<0, _Pr>, tuple_element_t<1, _Pr>>;
389 template<__detail::__iterator_sentinel_pair _Pr>
390 subrange(_Pr, __detail::__make_unsigned_like_t<iter_difference_t<
391 tuple_element_t<0, _Pr>>>)
392 -> subrange<tuple_element_t<0, _Pr>, tuple_element_t<1, _Pr>,
393 subrange_kind::sized>;
395 template<borrowed_range _Rng>
397 -> subrange<iterator_t<_Rng>, sentinel_t<_Rng>,
399 || sized_sentinel_for<sentinel_t<_Rng>, iterator_t<_Rng>>)
400 ? subrange_kind::sized : subrange_kind::unsized>;
402 template<borrowed_range _Rng>
404 __detail::__make_unsigned_like_t<range_difference_t<_Rng>>)
405 -> subrange<iterator_t<_Rng>, sentinel_t<_Rng>, subrange_kind::sized>;
407 template<
size_t _Num,
class _It,
class _Sent, subrange_kind _Kind>
410 get(const subrange<_It, _Sent, _Kind>& __r)
412 if constexpr (_Num == 0)
418 template<
size_t _Num, class _It, class _Sent, subrange_kind _Kind>
421 get(subrange<_It, _Sent, _Kind>&& __r)
423 if constexpr (_Num == 0)
429 template<input_or_output_iterator _It, sentinel_for<_It> _Sent,
431 inline constexpr
bool
432 enable_borrowed_range<subrange<_It, _Sent, _Kind>> = true;
443 constexpr dangling() noexcept = default;
444 template<typename... _Args>
445 constexpr dangling(_Args&&...) noexcept { }
448 template<range _Range>
449 using borrowed_iterator_t = conditional_t<borrowed_range<_Range>,
453 template<range _Range>
454 using borrowed_subrange_t = conditional_t<borrowed_range<_Range>,
455 subrange<iterator_t<_Range>>,
458 template<
typename _Tp> requires is_object_v<_Tp>
460 :
public view_interface<empty_view<_Tp>>
463 static constexpr _Tp*
begin() noexcept {
return nullptr; }
464 static constexpr _Tp*
end() noexcept {
return nullptr; }
465 static constexpr _Tp* data() noexcept {
return nullptr; }
466 static constexpr
size_t size() noexcept {
return 0; }
467 static constexpr
bool empty() noexcept {
return true; }
470 template<
typename _Tp>
471 inline constexpr
bool enable_borrowed_range<empty_view<_Tp>> =
true;
475 template<copy_constructible _Tp> requires is_object_v<_Tp>
476 struct __box : std::optional<_Tp>
478 using std::optional<_Tp>::optional;
482 noexcept(is_nothrow_default_constructible_v<_Tp>)
483 requires default_initializable<_Tp>
487 __box(
const __box&) =
default;
488 __box(__box&&) =
default;
490 using std::optional<_Tp>::operator=;
493 operator=(
const __box& __that)
494 noexcept(is_nothrow_copy_constructible_v<_Tp>)
495 requires (!assignable_from<_Tp&, const _Tp&>)
498 this->emplace(*__that);
505 operator=(__box&& __that)
506 noexcept(is_nothrow_move_constructible_v<_Tp>)
507 requires (!assignable_from<_Tp&, _Tp>)
520 template<copy_constructible _Tp> requires is_object_v<_Tp>
521 class single_view :
public view_interface<single_view<_Tp>>
524 single_view() =
default;
527 single_view(
const _Tp& __t)
532 single_view(_Tp&& __t)
536 template<
typename... _Args>
537 requires constructible_from<_Tp, _Args...>
539 single_view(in_place_t, _Args&&... __args)
540 : _M_value{
in_place, std::forward<_Args>(__args)...}
548 begin() const noexcept
553 {
return data() + 1; }
557 {
return data() + 1; }
559 static constexpr
size_t
565 {
return _M_value.operator->(); }
568 data() const noexcept
569 {
return _M_value.operator->(); }
572 __detail::__box<_Tp> _M_value;
577 template<
typename _Wp>
578 constexpr
auto __to_signed_like(_Wp __w) noexcept
580 if constexpr (!integral<_Wp>)
581 return iter_difference_t<_Wp>();
582 else if constexpr (
sizeof(iter_difference_t<_Wp>) >
sizeof(_Wp))
583 return iter_difference_t<_Wp>(__w);
584 else if constexpr (
sizeof(ptrdiff_t) >
sizeof(_Wp))
585 return ptrdiff_t(__w);
586 else if constexpr (
sizeof(
long long) >
sizeof(_Wp))
587 return (
long long)(__w);
588 #ifdef __SIZEOF_INT128__
589 else if constexpr (__SIZEOF_INT128__ >
sizeof(_Wp))
590 return __int128(__w);
593 return __max_diff_type(__w);
596 template<
typename _Wp>
597 using __iota_diff_t = decltype(__to_signed_like(std::declval<_Wp>()));
599 template<
typename _It>
600 concept __decrementable = incrementable<_It>
603 { --__i } -> same_as<_It&>;
604 { __i-- } -> same_as<_It>;
607 template<
typename _It>
608 concept __advanceable = __decrementable<_It> && totally_ordered<_It>
609 && requires( _It __i,
const _It __j,
const __iota_diff_t<_It> __n)
611 { __i += __n } -> same_as<_It&>;
612 { __i -= __n } -> same_as<_It&>;
616 { __j - __j } -> convertible_to<__iota_diff_t<_It>>;
621 template<weakly_incrementable _Winc,
622 semiregular _Bound = unreachable_sentinel_t>
623 requires std::__detail::__weakly_eq_cmp_with<_Winc, _Bound>
624 && semiregular<_Winc>
625 class iota_view :
public view_interface<iota_view<_Winc, _Bound>>
636 using namespace __detail;
637 if constexpr (__advanceable<_Winc>)
638 return random_access_iterator_tag{};
639 else if constexpr (__decrementable<_Winc>)
640 return bidirectional_iterator_tag{};
641 else if constexpr (incrementable<_Winc>)
642 return forward_iterator_tag{};
644 return input_iterator_tag{};
648 using iterator_category = decltype(_S_iter_cat());
649 using value_type = _Winc;
650 using difference_type = __detail::__iota_diff_t<_Winc>;
652 _Iterator() =
default;
655 _Iterator(_Winc __value)
656 : _M_value(__value) { }
659 operator*() const noexcept(is_nothrow_copy_constructible_v<_Winc>)
674 operator++(
int) requires incrementable<_Winc>
682 operator--() requires __detail::__decrementable<_Winc>
689 operator--(
int) requires __detail::__decrementable<_Winc>
697 operator+=(difference_type __n) requires __detail::__advanceable<_Winc>
699 using __detail::__is_integer_like;
700 using __detail::__is_signed_integer_like;
701 if constexpr (__is_integer_like<_Winc>
702 && !__is_signed_integer_like<_Winc>)
704 if (__n >= difference_type(0))
705 _M_value += static_cast<_Winc>(__n);
707 _M_value -= static_cast<_Winc>(-__n);
715 operator-=(difference_type __n) requires __detail::__advanceable<_Winc>
717 using __detail::__is_integer_like;
718 using __detail::__is_signed_integer_like;
719 if constexpr (__is_integer_like<_Winc>
720 && !__is_signed_integer_like<_Winc>)
722 if (__n >= difference_type(0))
723 _M_value -= static_cast<_Winc>(__n);
725 _M_value += static_cast<_Winc>(-__n);
733 operator[](difference_type __n)
const
734 requires __detail::__advanceable<_Winc>
735 {
return _Winc(_M_value + __n); }
737 friend constexpr
bool
738 operator==(
const _Iterator& __x,
const _Iterator& __y)
739 requires equality_comparable<_Winc>
740 {
return __x._M_value == __y._M_value; }
742 friend constexpr
bool
743 operator<(
const _Iterator& __x,
const _Iterator& __y)
744 requires totally_ordered<_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 __y < __x; }
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 !(__x < __y); }
762 #ifdef __cpp_lib_three_way_comparison
763 friend constexpr
auto
764 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
765 requires totally_ordered<_Winc> && three_way_comparable<_Winc>
766 {
return __x._M_value <=> __y._M_value; }
769 friend constexpr _Iterator
770 operator+(_Iterator __i, difference_type __n)
771 requires __detail::__advanceable<_Winc>
772 {
return __i += __n; }
774 friend constexpr _Iterator
775 operator+(difference_type __n, _Iterator __i)
776 requires __detail::__advanceable<_Winc>
777 {
return __i += __n; }
779 friend constexpr _Iterator
780 operator-(_Iterator __i, difference_type __n)
781 requires __detail::__advanceable<_Winc>
782 {
return __i -= __n; }
784 friend constexpr difference_type
785 operator-(
const _Iterator& __x,
const _Iterator& __y)
786 requires __detail::__advanceable<_Winc>
788 using __detail::__is_integer_like;
789 using __detail::__is_signed_integer_like;
790 using _Dt = difference_type;
791 if constexpr (__is_integer_like<_Winc>)
793 if constexpr (__is_signed_integer_like<_Winc>)
794 return _Dt(_Dt(__x._M_value) - _Dt(__y._M_value));
796 return (__y._M_value > __x._M_value)
797 ? _Dt(-_Dt(__y._M_value - __x._M_value))
798 : _Dt(__x._M_value - __y._M_value);
801 return __x._M_value - __y._M_value;
805 _Winc _M_value = _Winc();
814 _M_equal(
const _Iterator& __x)
const
815 {
return __x._M_value == _M_bound; }
817 _Bound _M_bound = _Bound();
820 _Sentinel() =
default;
823 _Sentinel(_Bound __bound)
824 : _M_bound(__bound) { }
826 friend constexpr
bool
827 operator==(
const _Iterator& __x,
const _Sentinel& __y)
828 {
return __y._M_equal(__x); }
830 friend constexpr iter_difference_t<_Winc>
831 operator-(
const _Iterator& __x,
const _Sentinel& __y)
832 requires sized_sentinel_for<_Bound, _Winc>
833 {
return __x._M_value - __y._M_bound; }
835 friend constexpr iter_difference_t<_Winc>
836 operator-(
const _Sentinel& __x,
const _Iterator& __y)
837 requires sized_sentinel_for<_Bound, _Winc>
838 {
return -(__y - __x); }
841 _Winc _M_value = _Winc();
842 _Bound _M_bound = _Bound();
845 iota_view() =
default;
848 iota_view(_Winc __value)
853 iota_view(type_identity_t<_Winc> __value,
854 type_identity_t<_Bound> __bound)
855 : _M_value(__value), _M_bound(__bound)
857 if constexpr (totally_ordered_with<_Winc, _Bound>)
859 __glibcxx_assert(
bool(__value <= __bound) );
864 begin()
const {
return _Iterator{_M_value}; }
869 if constexpr (same_as<_Bound, unreachable_sentinel_t>)
870 return unreachable_sentinel;
872 return _Sentinel{_M_bound};
876 end() const requires same_as<_Winc, _Bound>
877 {
return _Iterator{_M_bound}; }
881 requires (same_as<_Winc, _Bound> && __detail::__advanceable<_Winc>)
882 || (integral<_Winc> && integral<_Bound>)
883 || sized_sentinel_for<_Bound, _Winc>
885 using __detail::__is_integer_like;
886 using __detail::__to_unsigned_like;
887 if constexpr (__is_integer_like<_Winc> && __is_integer_like<_Bound>)
888 return (_M_value < 0)
890 ? __to_unsigned_like(-_M_value) - __to_unsigned_like(-_M_bound)
891 : __to_unsigned_like(_M_bound) + __to_unsigned_like(-_M_value))
892 : __to_unsigned_like(_M_bound) - __to_unsigned_like(_M_value);
894 return __to_unsigned_like(_M_bound - _M_value);
898 template<
typename _Winc,
typename _Bound>
899 requires (!__detail::__is_integer_like<_Winc>
900 || !__detail::__is_integer_like<_Bound>
901 || (__detail::__is_signed_integer_like<_Winc>
902 == __detail::__is_signed_integer_like<_Bound>))
903 iota_view(_Winc, _Bound) -> iota_view<_Winc, _Bound>;
905 template<weakly_incrementable _Winc, semiregular _Bound>
906 inline constexpr
bool
907 enable_borrowed_range<iota_view<_Winc, _Bound>> =
true;
911 template<
typename _Tp>
912 inline constexpr empty_view<_Tp> empty{};
916 template<
typename _Tp>
918 operator()(_Tp&& __e)
const
919 {
return single_view{std::forward<_Tp>(__e)}; }
922 inline constexpr _Single single{};
926 template<
typename _Tp>
928 operator()(_Tp&& __e)
const
929 {
return iota_view{std::forward<_Tp>(__e)}; }
931 template<
typename _Tp,
typename _Up>
933 operator()(_Tp&& __e, _Up&& __f)
const
934 {
return iota_view{std::forward<_Tp>(__e), std::forward<_Up>(__f)}; }
937 inline constexpr _Iota
iota{};
942 template<
typename _Val,
typename _CharT,
typename _Traits>
943 concept __stream_extractable
944 = requires(basic_istream<_CharT, _Traits>& is, _Val& t) { is >> t; };
947 template<movable _Val,
typename _CharT,
typename _Traits>
948 requires default_initializable<_Val>
949 && __detail::__stream_extractable<_Val, _CharT, _Traits>
950 class basic_istream_view
951 :
public view_interface<basic_istream_view<_Val, _CharT, _Traits>>
954 basic_istream_view() =
default;
957 basic_istream_view(basic_istream<_CharT, _Traits>& __stream)
964 if (_M_stream !=
nullptr)
965 *_M_stream >> _M_object;
966 return _Iterator{*
this};
969 constexpr default_sentinel_t
971 {
return default_sentinel; }
974 basic_istream<_CharT, _Traits>* _M_stream =
nullptr;
975 _Val _M_object = _Val();
980 using iterator_concept = input_iterator_tag;
981 using difference_type = ptrdiff_t;
982 using value_type = _Val;
984 _Iterator() =
default;
987 _Iterator(basic_istream_view& __parent) noexcept
991 _Iterator(
const _Iterator&) =
delete;
992 _Iterator(_Iterator&&) =
default;
993 _Iterator& operator=(
const _Iterator&) =
delete;
994 _Iterator& operator=(_Iterator&&) =
default;
999 __glibcxx_assert(_M_parent->_M_stream !=
nullptr);
1000 *_M_parent->_M_stream >> _M_parent->_M_object;
1011 __glibcxx_assert(_M_parent->_M_stream !=
nullptr);
1012 return _M_parent->_M_object;
1016 operator==(
const _Iterator& __x, default_sentinel_t)
1017 {
return __x._M_at_end(); }
1020 basic_istream_view* _M_parent =
nullptr;
1024 {
return _M_parent ==
nullptr || !*_M_parent->_M_stream; }
1030 template<
typename _Val,
typename _CharT,
typename _Traits>
1031 basic_istream_view<_Val, _CharT, _Traits>
1032 istream_view(basic_istream<_CharT, _Traits>& __s)
1033 {
return basic_istream_view<_Val, _CharT, _Traits>{__s}; }
1043 template<
bool _Present,
typename _Tp>
1044 using __maybe_present_t = conditional_t<_Present, _Tp, _Empty>;
1047 template<
bool _Const,
typename _Tp>
1048 using __maybe_const_t = conditional_t<_Const, const _Tp, _Tp>;
1056 template<
typename _Tp>
1057 inline constexpr
auto
1058 __maybe_refwrap(_Tp& __arg)
1059 {
return reference_wrapper<_Tp>{__arg}; }
1061 template<
typename _Tp>
1062 inline constexpr
auto
1063 __maybe_refwrap(
const _Tp& __arg)
1064 {
return reference_wrapper<const _Tp>{__arg}; }
1066 template<
typename _Tp>
1067 inline constexpr decltype(
auto)
1068 __maybe_refwrap(_Tp&& __arg)
1069 {
return std::forward<_Tp>(__arg); }
1071 template<
typename _Callable>
1072 struct _RangeAdaptorClosure;
1074 template<
typename _Callable>
1075 struct _RangeAdaptor
1078 [[no_unique_address]]
1079 __detail::__maybe_present_t<!is_default_constructible_v<_Callable>,
1080 _Callable> _M_callable;
1084 _RangeAdaptor(
const _Callable& = {})
1085 requires is_default_constructible_v<_Callable>
1089 _RangeAdaptor(_Callable __callable)
1090 requires (!is_default_constructible_v<_Callable>)
1091 : _M_callable(
std::
move(__callable))
1094 template<
typename... _Args>
1095 requires (
sizeof...(_Args) >= 1)
1097 operator()(_Args&&... __args)
const
1110 if constexpr (is_invocable_v<_Callable, _Args...>)
1112 static_assert(
sizeof...(_Args) != 1,
1113 "a _RangeAdaptor that accepts only one argument "
1114 "should be defined as a _RangeAdaptorClosure");
1117 return _Callable{}(std::forward<_Args>(__args)...);
1130 = [...__args(__maybe_refwrap(std::forward<_Args>(__args)))]
1131 <
typename _Range> (_Range&& __r) {
1135 return _Callable{}(std::forward<_Range>(__r),
1136 (
static_cast<unwrap_reference_t
1140 using _ClosureType = decltype(__closure);
1141 return _RangeAdaptorClosure<_ClosureType>(
std::move(__closure));
1146 template<
typename _Callable>
1147 _RangeAdaptor(_Callable) -> _RangeAdaptor<_Callable>;
1149 template<
typename _Callable>
1150 struct _RangeAdaptorClosure :
public _RangeAdaptor<_Callable>
1152 using _RangeAdaptor<_Callable>::_RangeAdaptor;
1154 template<viewable_range _Range>
1155 requires requires { declval<_Callable>()(declval<_Range>()); }
1157 operator()(_Range&& __r)
const
1159 if constexpr (is_default_constructible_v<_Callable>)
1160 return _Callable{}(std::forward<_Range>(__r));
1162 return this->_M_callable(std::forward<_Range>(__r));
1165 template<viewable_range _Range>
1166 requires requires { declval<_Callable>()(declval<_Range>()); }
1167 friend constexpr
auto
1168 operator|(_Range&& __r,
const _RangeAdaptorClosure& __o)
1169 {
return __o(std::forward<_Range>(__r)); }
1171 template<
typename _Tp>
1172 friend constexpr
auto
1173 operator|(
const _RangeAdaptorClosure<_Tp>& __x,
1174 const _RangeAdaptorClosure& __y)
1176 if constexpr (is_default_constructible_v<_Tp>
1177 && is_default_constructible_v<_Callable>)
1179 auto __closure = [] <
typename _Up> (_Up&& __e) {
1180 return std::forward<_Up>(__e) | decltype(__x){} | decltype(__y){};
1182 return _RangeAdaptorClosure<decltype(__closure)>(__closure);
1184 else if constexpr (is_default_constructible_v<_Tp>
1185 && !is_default_constructible_v<_Callable>)
1187 auto __closure = [__y] <
typename _Up> (_Up&& __e) {
1188 return std::forward<_Up>(__e) | decltype(__x){} | __y;
1190 return _RangeAdaptorClosure<decltype(__closure)>(__closure);
1192 else if constexpr (!is_default_constructible_v<_Tp>
1193 && is_default_constructible_v<_Callable>)
1195 auto __closure = [__x] <
typename _Up> (_Up&& __e) {
1196 return std::forward<_Up>(__e) | __x | decltype(__y){};
1198 return _RangeAdaptorClosure<decltype(__closure)>(__closure);
1202 auto __closure = [__x, __y] <
typename _Up> (_Up&& __e) {
1203 return std::forward<_Up>(__e) | __x | __y;
1205 return _RangeAdaptorClosure<decltype(__closure)>(__closure);
1210 template<
typename _Callable>
1211 _RangeAdaptorClosure(_Callable) -> _RangeAdaptorClosure<_Callable>;
1215 template<range _Range> requires is_object_v<_Range>
1216 class ref_view :
public view_interface<ref_view<_Range>>
1219 _Range* _M_r =
nullptr;
1221 static void _S_fun(_Range&);
1222 static void _S_fun(_Range&&) =
delete;
1226 ref_view() noexcept = default;
1228 template<__detail::__not_same_as<ref_view> _Tp>
1229 requires convertible_to<_Tp, _Range&>
1230 && requires { _S_fun(declval<_Tp>()); }
1240 constexpr iterator_t<_Range>
1244 constexpr sentinel_t<_Range>
1249 empty() const requires requires { ranges::empty(*_M_r); }
1250 {
return ranges::empty(*_M_r); }
1253 size() const requires sized_range<_Range>
1254 {
return ranges::size(*_M_r); }
1257 data() const requires contiguous_range<_Range>
1258 {
return ranges::data(*_M_r); }
1261 template<
typename _Range>
1262 ref_view(_Range&) -> ref_view<_Range>;
1264 template<
typename _Tp>
1265 inline constexpr
bool enable_borrowed_range<ref_view<_Tp>> =
true;
1269 inline constexpr __adaptor::_RangeAdaptorClosure all
1270 = [] <viewable_range _Range> (_Range&& __r)
1272 if constexpr (view<decay_t<_Range>>)
1274 else if constexpr (requires { ref_view{std::forward<_Range>(__r)}; })
1275 return ref_view{std::forward<_Range>(__r)};
1277 return subrange{std::forward<_Range>(__r)};
1280 template<viewable_range _Range>
1281 using all_t = decltype(all(std::declval<_Range>()));
1289 template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
1290 typename _Proj =
identity,
1291 indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
1293 find_if(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {})
1295 while (__first != __last
1301 template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
1302 typename _Proj =
identity,
1303 indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
1305 find_if_not(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {})
1307 while (__first != __last
1313 template<
typename _Tp,
typename _Proj = identity,
1314 indirect_strict_weak_order<projected<const _Tp*, _Proj>>
1315 _Comp = ranges::less>
1316 constexpr
const _Tp&
1317 min(
const _Tp& __a,
const _Tp& __b, _Comp __comp = {}, _Proj __proj = {})
1327 template<input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
1328 input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
1329 typename _Pred = ranges::equal_to,
1330 typename _Proj1 =
identity,
typename _Proj2 =
identity>
1331 requires indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
1332 constexpr pair<_Iter1, _Iter2>
1333 mismatch(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2,
1334 _Pred __pred = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {})
1336 while (__first1 != __last1 && __first2 != __last2
1350 template<range _Range>
1351 struct _CachedPosition
1354 _M_has_value()
const
1357 constexpr iterator_t<_Range>
1358 _M_get(
const _Range&)
const
1360 __glibcxx_assert(
false);
1365 _M_set(
const _Range&,
const iterator_t<_Range>&)
const
1369 template<forward_range _Range>
1370 struct _CachedPosition<_Range>
1373 iterator_t<_Range> _M_iter{};
1377 _M_has_value()
const
1378 {
return _M_iter != iterator_t<_Range>{}; }
1380 constexpr iterator_t<_Range>
1381 _M_get(
const _Range&)
const
1383 __glibcxx_assert(_M_has_value());
1388 _M_set(
const _Range&,
const iterator_t<_Range>& __it)
1390 __glibcxx_assert(!_M_has_value());
1395 template<random_access_range _Range>
1396 requires (
sizeof(range_difference_t<_Range>)
1397 <=
sizeof(iterator_t<_Range>))
1398 struct _CachedPosition<_Range>
1401 range_difference_t<_Range> _M_offset = -1;
1405 _M_has_value()
const
1406 {
return _M_offset >= 0; }
1408 constexpr iterator_t<_Range>
1409 _M_get(_Range& __r)
const
1411 __glibcxx_assert(_M_has_value());
1416 _M_set(_Range& __r,
const iterator_t<_Range>& __it)
1418 __glibcxx_assert(!_M_has_value());
1425 template<input_range _Vp,
1426 indirect_unary_predicate<iterator_t<_Vp>> _Pred>
1427 requires view<_Vp> && is_object_v<_Pred>
1428 class filter_view :
public view_interface<filter_view<_Vp, _Pred>>
1436 static constexpr
auto
1439 if constexpr (bidirectional_range<_Vp>)
1440 return bidirectional_iterator_tag{};
1441 else if constexpr (forward_range<_Vp>)
1442 return forward_iterator_tag{};
1444 return input_iterator_tag{};
1447 static constexpr
auto
1450 using _Cat =
typename iterator_traits<_Vp_iter>::iterator_category;
1451 if constexpr (derived_from<_Cat, bidirectional_iterator_tag>)
1452 return bidirectional_iterator_tag{};
1453 else if constexpr (derived_from<_Cat, forward_iterator_tag>)
1454 return forward_iterator_tag{};
1461 using _Vp_iter = iterator_t<_Vp>;
1463 _Vp_iter _M_current = _Vp_iter();
1464 filter_view* _M_parent =
nullptr;
1467 using iterator_concept = decltype(_S_iter_concept());
1468 using iterator_category = decltype(_S_iter_cat());
1469 using value_type = range_value_t<_Vp>;
1470 using difference_type = range_difference_t<_Vp>;
1472 _Iterator() =
default;
1475 _Iterator(filter_view& __parent, _Vp_iter __current)
1476 : _M_current(
std::
move(__current)),
1482 requires copyable<_Vp_iter>
1483 {
return _M_current; }
1489 constexpr range_reference_t<_Vp>
1491 {
return *_M_current; }
1495 requires __detail::__has_arrow<_Vp_iter>
1496 && copyable<_Vp_iter>
1497 {
return _M_current; }
1499 constexpr _Iterator&
1502 _M_current = __detail::find_if(
std::move(++_M_current),
1504 std::ref(*_M_parent->_M_pred));
1513 operator++(
int) requires forward_range<_Vp>
1520 constexpr _Iterator&
1521 operator--() requires bidirectional_range<_Vp>
1530 operator--(
int) requires bidirectional_range<_Vp>
1537 friend constexpr
bool
1538 operator==(
const _Iterator& __x,
const _Iterator& __y)
1539 requires equality_comparable<_Vp_iter>
1540 {
return __x._M_current == __y._M_current; }
1542 friend constexpr range_rvalue_reference_t<_Vp>
1543 iter_move(
const _Iterator& __i)
1544 noexcept(noexcept(ranges::iter_move(__i._M_current)))
1545 {
return ranges::iter_move(__i._M_current); }
1547 friend constexpr
void
1548 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
1549 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1550 requires indirectly_swappable<_Vp_iter>
1551 { ranges::iter_swap(__x._M_current, __y._M_current); }
1557 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
1560 __equal(
const _Iterator& __i)
const
1561 {
return __i._M_current == _M_end; }
1564 _Sentinel() =
default;
1567 _Sentinel(filter_view& __parent)
1568 : _M_end(ranges::
end(__parent._M_base))
1571 constexpr sentinel_t<_Vp>
1575 friend constexpr
bool
1576 operator==(
const _Iterator& __x,
const _Sentinel& __y)
1577 {
return __y.__equal(__x); }
1580 _Vp _M_base = _Vp();
1581 __detail::__box<_Pred> _M_pred;
1582 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
1585 filter_view() =
default;
1588 filter_view(_Vp
__base, _Pred __pred)
1593 base() const& requires copy_constructible<_Vp>
1600 constexpr
const _Pred&
1602 {
return *_M_pred; }
1607 if (_M_cached_begin._M_has_value())
1608 return {*
this, _M_cached_begin._M_get(_M_base)};
1610 __glibcxx_assert(_M_pred.has_value());
1613 std::ref(*_M_pred));
1614 _M_cached_begin._M_set(_M_base, __it);
1621 if constexpr (common_range<_Vp>)
1624 return _Sentinel{*
this};
1628 template<
typename _Range,
typename _Pred>
1629 filter_view(_Range&&, _Pred) -> filter_view<views::all_t<_Range>, _Pred>;
1633 inline constexpr __adaptor::_RangeAdaptor filter
1634 = [] <viewable_range _Range,
typename _Pred> (_Range&& __r, _Pred&& __p)
1636 return filter_view{std::forward<_Range>(__r), std::forward<_Pred>(__p)};
1640 template<input_range _Vp, copy_constructible _Fp>
1641 requires view<_Vp> && is_object_v<_Fp>
1642 && regular_invocable<_Fp&, range_reference_t<_Vp>>
1643 && std::__detail::__can_reference<invoke_result_t<_Fp&,
1644 range_reference_t<_Vp>>>
1645 class transform_view :
public view_interface<transform_view<_Vp, _Fp>>
1648 template<
bool _Const>
1651 template<
bool _Const>
1655 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
1656 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
1658 static constexpr
auto
1661 if constexpr (random_access_range<_Vp>)
1662 return random_access_iterator_tag{};
1663 else if constexpr (bidirectional_range<_Vp>)
1664 return bidirectional_iterator_tag{};
1665 else if constexpr (forward_range<_Vp>)
1666 return forward_iterator_tag{};
1668 return input_iterator_tag{};
1671 static constexpr
auto
1674 using _Res = invoke_result_t<_Fp&, range_reference_t<_Base>>;
1675 if constexpr (is_lvalue_reference_v<_Res>)
1678 =
typename iterator_traits<_Base_iter>::iterator_category;
1679 if constexpr (derived_from<_Cat, contiguous_iterator_tag>)
1680 return random_access_iterator_tag{};
1685 return input_iterator_tag{};
1688 using _Base_iter = iterator_t<_Base>;
1690 _Base_iter _M_current = _Base_iter();
1691 _Parent* _M_parent =
nullptr;
1694 using iterator_concept = decltype(_S_iter_concept());
1695 using iterator_category = decltype(_S_iter_cat());
1697 = remove_cvref_t<invoke_result_t<_Fp&, range_reference_t<_Base>>>;
1698 using difference_type = range_difference_t<_Base>;
1700 _Iterator() =
default;
1703 _Iterator(_Parent& __parent, _Base_iter __current)
1704 : _M_current(
std::
move(__current)),
1709 _Iterator(_Iterator<!_Const> __i)
1711 && convertible_to<iterator_t<_Vp>, _Base_iter>
1712 : _M_current(
std::move(__i._M_current)), _M_parent(__i._M_parent)
1715 constexpr _Base_iter
1717 requires copyable<_Base_iter>
1718 {
return _M_current; }
1720 constexpr _Base_iter
1724 constexpr decltype(
auto)
1726 noexcept(noexcept(
std::
__invoke(*_M_parent->_M_fun, *_M_current)))
1729 constexpr _Iterator&
1741 operator++(
int) requires forward_range<_Base>
1748 constexpr _Iterator&
1749 operator--() requires bidirectional_range<_Base>
1756 operator--(
int) requires bidirectional_range<_Base>
1763 constexpr _Iterator&
1764 operator+=(difference_type __n) requires random_access_range<_Base>
1770 constexpr _Iterator&
1771 operator-=(difference_type __n) requires random_access_range<_Base>
1777 constexpr decltype(
auto)
1778 operator[](difference_type __n) const
1779 requires random_access_range<_Base>
1780 {
return std::__invoke(*_M_parent->_M_fun, _M_current[__n]); }
1782 friend constexpr
bool
1783 operator==(
const _Iterator& __x,
const _Iterator& __y)
1784 requires equality_comparable<_Base_iter>
1785 {
return __x._M_current == __y._M_current; }
1787 friend constexpr
bool
1788 operator<(
const _Iterator& __x,
const _Iterator& __y)
1789 requires random_access_range<_Base>
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 __y < __x; }
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 !(__x < __y); }
1807 #ifdef __cpp_lib_three_way_comparison
1808 friend constexpr
auto
1809 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
1810 requires random_access_range<_Base>
1811 && three_way_comparable<_Base_iter>
1812 {
return __x._M_current <=> __y._M_current; }
1815 friend constexpr _Iterator
1816 operator+(_Iterator __i, difference_type __n)
1817 requires random_access_range<_Base>
1818 {
return {*__i._M_parent, __i._M_current + __n}; }
1820 friend constexpr _Iterator
1821 operator+(difference_type __n, _Iterator __i)
1822 requires random_access_range<_Base>
1823 {
return {*__i._M_parent, __i._M_current + __n}; }
1825 friend constexpr _Iterator
1826 operator-(_Iterator __i, difference_type __n)
1827 requires random_access_range<_Base>
1828 {
return {*__i._M_parent, __i._M_current - __n}; }
1830 friend constexpr difference_type
1831 operator-(
const _Iterator& __x,
const _Iterator& __y)
1832 requires random_access_range<_Base>
1833 {
return __x._M_current - __y._M_current; }
1835 friend constexpr decltype(
auto)
1836 iter_move(const _Iterator& __i) noexcept(noexcept(*__i))
1838 if constexpr (is_lvalue_reference_v<decltype(*__i)>)
1844 friend constexpr
void
1845 iter_swap(const _Iterator& __x, const _Iterator& __y)
1846 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1847 requires indirectly_swappable<_Base_iter>
1848 {
return ranges::iter_swap(__x._M_current, __y._M_current); }
1850 friend _Iterator<!_Const>;
1851 friend _Sentinel<_Const>;
1854 template<
bool _Const>
1858 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
1859 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
1861 constexpr range_difference_t<_Base>
1862 __distance_from(
const _Iterator<_Const>& __i)
const
1863 {
return _M_end - __i._M_current; }
1866 __equal(
const _Iterator<_Const>& __i)
const
1867 {
return __i._M_current == _M_end; }
1869 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
1872 _Sentinel() =
default;
1875 _Sentinel(sentinel_t<_Base> __end)
1880 _Sentinel(_Sentinel<!_Const> __i)
1882 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
1886 constexpr sentinel_t<_Base>
1890 friend constexpr
bool
1891 operator==(
const _Iterator<_Const>& __x,
const _Sentinel& __y)
1892 {
return __y.__equal(__x); }
1894 friend constexpr range_difference_t<_Base>
1895 operator-(
const _Iterator<_Const>& __x,
const _Sentinel& __y)
1896 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
1897 {
return -__y.__distance_from(__x); }
1899 friend constexpr range_difference_t<_Base>
1900 operator-(
const _Sentinel& __y,
const _Iterator<_Const>& __x)
1901 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
1902 {
return __y.__distance_from(__x); }
1904 friend _Sentinel<!_Const>;
1907 _Vp _M_base = _Vp();
1908 __detail::__box<_Fp> _M_fun;
1911 transform_view() =
default;
1914 transform_view(_Vp
__base, _Fp __fun)
1919 base() const& requires copy_constructible<_Vp>
1920 {
return _M_base ; }
1926 constexpr _Iterator<false>
1930 constexpr _Iterator<true>
1932 requires range<const _Vp>
1933 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
1936 constexpr _Sentinel<false>
1938 {
return _Sentinel<false>{
ranges::end(_M_base)}; }
1940 constexpr _Iterator<false>
1941 end() requires common_range<_Vp>
1942 {
return _Iterator<false>{*
this,
ranges::end(_M_base)}; }
1944 constexpr _Sentinel<true>
1946 requires range<const _Vp>
1947 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
1950 constexpr _Iterator<true>
1952 requires common_range<const _Vp>
1953 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
1954 {
return _Iterator<true>{*
this,
ranges::end(_M_base)}; }
1957 size() requires sized_range<_Vp>
1958 {
return ranges::size(_M_base); }
1961 size() const requires sized_range<const _Vp>
1962 {
return ranges::size(_M_base); }
1965 template<
typename _Range,
typename _Fp>
1966 transform_view(_Range&&, _Fp) -> transform_view<views::all_t<_Range>, _Fp>;
1970 inline constexpr __adaptor::_RangeAdaptor transform
1971 = [] <viewable_range _Range,
typename _Fp> (_Range&& __r, _Fp&& __f)
1973 return transform_view{std::forward<_Range>(__r), std::forward<_Fp>(__f)};
1978 class take_view :
public view_interface<take_view<_Vp>>
1981 template<
bool _Const>
1985 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
1986 using _CI = counted_iterator<iterator_t<_Base>>;
1988 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
1991 _Sentinel() =
default;
1994 _Sentinel(sentinel_t<_Base> __end)
1999 _Sentinel(_Sentinel<!_Const> __s)
2000 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2004 constexpr sentinel_t<_Base>
2008 friend constexpr
bool operator==(
const _CI& __y,
const _Sentinel& __x)
2009 {
return __y.count() == 0 || __y.base() == __x._M_end; }
2011 friend _Sentinel<!_Const>;
2014 _Vp _M_base = _Vp();
2015 range_difference_t<_Vp> _M_count = 0;
2018 take_view() =
default;
2021 take_view(_Vp base, range_difference_t<_Vp> __count)
2026 base() const& requires copy_constructible<_Vp>
2034 begin() requires (!__detail::__simple_view<_Vp>)
2036 if constexpr (sized_range<_Vp>)
2038 if constexpr (random_access_range<_Vp>)
2051 begin() const requires range<const _Vp>
2053 if constexpr (sized_range<const _Vp>)
2055 if constexpr (random_access_range<const _Vp>)
2068 end() requires (!__detail::__simple_view<_Vp>)
2070 if constexpr (sized_range<_Vp>)
2072 if constexpr (random_access_range<_Vp>)
2075 return default_sentinel;
2082 end() const requires range<const _Vp>
2084 if constexpr (sized_range<const _Vp>)
2086 if constexpr (random_access_range<const _Vp>)
2089 return default_sentinel;
2096 size() requires sized_range<_Vp>
2098 auto __n = ranges::size(_M_base);
2099 return __detail::min(__n,
static_cast<decltype(__n)
>(_M_count));
2103 size() const requires sized_range<const _Vp>
2105 auto __n = ranges::size(_M_base);
2106 return __detail::min(__n,
static_cast<decltype(__n)
>(_M_count));
2110 template<range _Range>
2111 take_view(_Range&&, range_difference_t<_Range>)
2112 -> take_view<views::all_t<_Range>>;
2116 inline constexpr __adaptor::_RangeAdaptor take
2117 = [] <viewable_range _Range,
typename _Tp> (_Range&& __r, _Tp&& __n)
2119 return take_view{std::forward<_Range>(__r), std::forward<_Tp>(__n)};
2123 template<view _Vp,
typename _Pred>
2124 requires input_range<_Vp> && is_object_v<_Pred>
2125 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2126 class take_while_view :
public view_interface<take_while_view<_Vp, _Pred>>
2128 template<
bool _Const>
2132 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2134 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2135 const _Pred* _M_pred =
nullptr;
2138 _Sentinel() =
default;
2141 _Sentinel(sentinel_t<_Base> __end,
const _Pred* __pred)
2142 : _M_end(__end), _M_pred(__pred)
2146 _Sentinel(_Sentinel<!_Const> __s)
2147 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2148 : _M_end(__s._M_end), _M_pred(__s._M_pred)
2151 constexpr sentinel_t<_Base>
2152 base()
const {
return _M_end; }
2154 friend constexpr
bool
2155 operator==(
const iterator_t<_Base>& __x,
const _Sentinel& __y)
2156 {
return __y._M_end == __x || !
std::__invoke(*__y._M_pred, *__x); }
2158 friend _Sentinel<!_Const>;
2161 _Vp _M_base = _Vp();
2162 __detail::__box<_Pred> _M_pred;
2165 take_while_view() =
default;
2168 take_while_view(_Vp base, _Pred __pred)
2174 base() const& requires copy_constructible<_Vp>
2181 constexpr
const _Pred&
2183 {
return *_M_pred; }
2186 begin() requires (!__detail::__simple_view<_Vp>)
2190 begin() const requires range<const _Vp>
2194 end() requires (!__detail::__simple_view<_Vp>)
2199 end() const requires range<const _Vp>
2204 template<
typename _Range,
typename _Pred>
2205 take_while_view(_Range&&, _Pred)
2206 -> take_while_view<views::all_t<_Range>, _Pred>;
2210 inline constexpr __adaptor::_RangeAdaptor take_while
2211 = [] <viewable_range _Range,
typename _Pred> (_Range&& __r, _Pred&& __p)
2213 return take_while_view{std::forward<_Range>(__r), std::forward<_Pred>(__p)};
2218 class drop_view :
public view_interface<drop_view<_Vp>>
2221 _Vp _M_base = _Vp();
2222 range_difference_t<_Vp> _M_count = 0;
2224 static constexpr
bool _S_needs_cached_begin = !random_access_range<_Vp>;
2225 [[no_unique_address]]
2226 __detail::__maybe_present_t<_S_needs_cached_begin,
2227 __detail::_CachedPosition<_Vp>>
2231 drop_view() =
default;
2234 drop_view(_Vp
__base, range_difference_t<_Vp> __count)
2236 { __glibcxx_assert(__count >= 0); }
2239 base() const& requires copy_constructible<_Vp>
2247 begin() requires (!(__detail::__simple_view<_Vp>
2248 && random_access_range<_Vp>))
2250 if constexpr (_S_needs_cached_begin)
2251 if (_M_cached_begin._M_has_value())
2252 return _M_cached_begin._M_get(_M_base);
2256 if constexpr (_S_needs_cached_begin)
2257 _M_cached_begin._M_set(_M_base, __it);
2262 begin() const requires random_access_range<const _Vp>
2269 end() requires (!__detail::__simple_view<_Vp>)
2273 end() const requires range<const _Vp>
2277 size() requires sized_range<_Vp>
2279 const auto __s = ranges::size(_M_base);
2280 const auto __c = static_cast<decltype(__s)>(_M_count);
2281 return __s < __c ? 0 : __s - __c;
2285 size() const requires sized_range<const _Vp>
2287 const auto __s = ranges::size(_M_base);
2288 const auto __c = static_cast<decltype(__s)>(_M_count);
2289 return __s < __c ? 0 : __s - __c;
2293 template<
typename _Range>
2294 drop_view(_Range&&, range_difference_t<_Range>)
2295 -> drop_view<views::all_t<_Range>>;
2299 inline constexpr __adaptor::_RangeAdaptor drop
2300 = [] <viewable_range _Range,
typename _Tp> (_Range&& __r, _Tp&& __n)
2302 return drop_view{std::forward<_Range>(__r), std::forward<_Tp>(__n)};
2306 template<view _Vp,
typename _Pred>
2307 requires input_range<_Vp> && is_object_v<_Pred>
2308 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2309 class drop_while_view :
public view_interface<drop_while_view<_Vp, _Pred>>
2312 _Vp _M_base = _Vp();
2313 __detail::__box<_Pred> _M_pred;
2314 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
2317 drop_while_view() =
default;
2320 drop_while_view(_Vp
__base, _Pred __pred)
2325 base() const& requires copy_constructible<_Vp>
2332 constexpr
const _Pred&
2334 {
return *_M_pred; }
2339 if (_M_cached_begin._M_has_value())
2340 return _M_cached_begin._M_get(_M_base);
2344 std::cref(*_M_pred));
2345 _M_cached_begin._M_set(_M_base, __it);
2354 template<
typename _Range,
typename _Pred>
2355 drop_while_view(_Range&&, _Pred)
2356 -> drop_while_view<views::all_t<_Range>, _Pred>;
2360 inline constexpr __adaptor::_RangeAdaptor drop_while
2361 = [] <viewable_range _Range,
typename _Pred> (_Range&& __r, _Pred&& __p)
2363 return drop_while_view{std::forward<_Range>(__r),
2364 std::forward<_Pred>(__p)};
2368 template<input_range _Vp>
2369 requires view<_Vp> && input_range<range_reference_t<_Vp>>
2370 && (is_reference_v<range_reference_t<_Vp>>
2371 || view<range_value_t<_Vp>>)
2372 class join_view :
public view_interface<join_view<_Vp>>
2375 using _InnerRange = range_reference_t<_Vp>;
2377 template<
bool _Const>
2380 template<
bool _Const>
2384 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
2385 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2387 static constexpr
bool _S_ref_is_glvalue
2388 = is_reference_v<range_reference_t<_Base>>;
2393 auto __update_inner = [
this] (range_reference_t<_Base> __x) ->
auto&
2395 if constexpr (_S_ref_is_glvalue)
2398 return (_M_parent->_M_inner = views::all(
std::move(__x)));
2401 for (; _M_outer !=
ranges::end(_M_parent->_M_base); ++_M_outer)
2403 auto& inner = __update_inner(*_M_outer);
2409 if constexpr (_S_ref_is_glvalue)
2410 _M_inner = _Inner_iter();
2413 static constexpr
auto
2416 if constexpr (_S_ref_is_glvalue
2417 && bidirectional_range<_Base>
2418 && bidirectional_range<range_reference_t<_Base>>)
2419 return bidirectional_iterator_tag{};
2420 else if constexpr (_S_ref_is_glvalue
2421 && forward_range<_Base>
2422 && forward_range<range_reference_t<_Base>>)
2423 return forward_iterator_tag{};
2425 return input_iterator_tag{};
2428 static constexpr
auto
2432 =
typename iterator_traits<_Outer_iter>::iterator_category;
2434 =
typename iterator_traits<_Inner_iter>::iterator_category;
2435 if constexpr (_S_ref_is_glvalue
2436 && derived_from<_OuterCat, bidirectional_iterator_tag>
2437 && derived_from<_InnerCat, bidirectional_iterator_tag>)
2438 return bidirectional_iterator_tag{};
2439 else if constexpr (_S_ref_is_glvalue
2440 && derived_from<_OuterCat, forward_iterator_tag>
2441 && derived_from<_InnerCat, forward_iterator_tag>)
2442 return forward_iterator_tag{};
2443 else if constexpr (derived_from<_OuterCat, input_iterator_tag>
2444 && derived_from<_InnerCat, input_iterator_tag>)
2445 return input_iterator_tag{};
2447 return output_iterator_tag{};
2450 using _Outer_iter = iterator_t<_Base>;
2451 using _Inner_iter = iterator_t<range_reference_t<_Base>>;
2453 _Outer_iter _M_outer = _Outer_iter();
2454 _Inner_iter _M_inner = _Inner_iter();
2455 _Parent* _M_parent =
nullptr;
2458 using iterator_concept = decltype(_S_iter_concept());
2459 using iterator_category = decltype(_S_iter_cat());
2460 using value_type = range_value_t<range_reference_t<_Base>>;
2461 using difference_type
2462 = common_type_t<range_difference_t<_Base>,
2463 range_difference_t<range_reference_t<_Base>>>;
2465 _Iterator() =
default;
2468 _Iterator(_Parent& __parent, _Outer_iter __outer)
2469 : _M_outer(
std::
move(__outer)),
2474 _Iterator(_Iterator<!_Const> __i)
2476 && convertible_to<iterator_t<_Vp>, _Outer_iter>
2477 && convertible_to<iterator_t<_InnerRange>, _Inner_iter>
2478 : _M_outer(
std::move(__i._M_outer)), _M_inner(__i._M_inner),
2479 _M_parent(__i._M_parent)
2482 constexpr decltype(
auto)
2484 {
return *_M_inner; }
2486 constexpr _Outer_iter
2488 requires __detail::__has_arrow<_Outer_iter>
2489 && copyable<_Outer_iter>
2490 {
return _M_inner; }
2492 constexpr _Iterator&
2495 auto&& __inner_range = [
this] () -> decltype(
auto) {
2496 if constexpr (_S_ref_is_glvalue)
2499 return _M_parent->_M_inner;
2515 requires _S_ref_is_glvalue && forward_range<_Base>
2516 && forward_range<range_reference_t<_Base>>
2523 constexpr _Iterator&
2525 requires _S_ref_is_glvalue && bidirectional_range<_Base>
2526 && bidirectional_range<range_reference_t<_Base>>
2527 && common_range<range_reference_t<_Base>>
2539 requires _S_ref_is_glvalue && bidirectional_range<_Base>
2540 && bidirectional_range<range_reference_t<_Base>>
2541 && common_range<range_reference_t<_Base>>
2548 friend constexpr
bool
2549 operator==(
const _Iterator& __x,
const _Iterator& __y)
2550 requires _S_ref_is_glvalue
2551 && equality_comparable<_Outer_iter>
2552 && equality_comparable<_Inner_iter>
2554 return (__x._M_outer == __y._M_outer
2555 && __x._M_inner == __y._M_inner);
2558 friend constexpr decltype(
auto)
2559 iter_move(const _Iterator& __i)
2560 noexcept(noexcept(ranges::iter_move(__i._M_inner)))
2561 {
return ranges::iter_move(__i._M_inner); }
2563 friend constexpr
void
2564 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
2565 noexcept(noexcept(ranges::iter_swap(__x._M_inner, __y._M_inner)))
2566 {
return ranges::iter_swap(__x._M_inner, __y._M_inner); }
2568 friend _Iterator<!_Const>;
2569 friend _Sentinel<_Const>;
2572 template<
bool _Const>
2576 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
2577 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2580 __equal(
const _Iterator<_Const>& __i)
const
2581 {
return __i._M_outer == _M_end; }
2583 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2586 _Sentinel() =
default;
2589 _Sentinel(_Parent& __parent)
2590 : _M_end(ranges::
end(__parent._M_base))
2594 _Sentinel(_Sentinel<!_Const> __s)
2595 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2599 friend constexpr
bool
2600 operator==(
const _Iterator<_Const>& __x,
const _Sentinel& __y)
2601 {
return __y.__equal(__x); }
2603 friend _Sentinel<!_Const>;
2606 _Vp _M_base = _Vp();
2609 [[no_unique_address]]
2610 __detail::__maybe_present_t<!is_reference_v<_InnerRange>,
2611 views::all_t<_InnerRange>> _M_inner;
2614 join_view() =
default;
2622 base() const& requires copy_constructible<_Vp>
2632 constexpr
bool __use_const
2633 = (__detail::__simple_view<_Vp>
2634 && is_reference_v<range_reference_t<_Vp>>);
2635 return _Iterator<__use_const>{*
this,
ranges::begin(_M_base)};
2640 requires input_range<const _Vp>
2641 && is_reference_v<range_reference_t<const _Vp>>
2649 if constexpr (forward_range<_Vp> && is_reference_v<_InnerRange>
2650 && forward_range<_InnerRange>
2651 && common_range<_Vp> && common_range<_InnerRange>)
2652 return _Iterator<__detail::__simple_view<_Vp>>{*
this,
2655 return _Sentinel<__detail::__simple_view<_Vp>>{*
this};
2660 requires input_range<const _Vp>
2661 && is_reference_v<range_reference_t<const _Vp>>
2663 if constexpr (forward_range<const _Vp>
2664 && is_reference_v<range_reference_t<const _Vp>>
2665 && forward_range<range_reference_t<const _Vp>>
2666 && common_range<const _Vp>
2667 && common_range<range_reference_t<const _Vp>>)
2668 return _Iterator<true>{*
this,
ranges::end(_M_base)};
2670 return _Sentinel<true>{*
this};
2674 template<
typename _Range>
2675 explicit join_view(_Range&&) -> join_view<views::all_t<_Range>>;
2679 inline constexpr __adaptor::_RangeAdaptorClosure join
2680 = [] <viewable_range _Range> (_Range&& __r)
2682 return join_view{std::forward<_Range>(__r)};
2689 struct __require_constant;
2691 template<
typename _Range>
2692 concept __tiny_range = sized_range<_Range>
2694 {
typename __require_constant<remove_reference_t<_Range>::size()>; }
2695 && (remove_reference_t<_Range>::size() <= 1);
2698 template<input_range _Vp, forward_range _Pattern>
2699 requires view<_Vp> && view<_Pattern>
2700 && indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
2702 && (forward_range<_Vp> || __detail::__tiny_range<_Pattern>)
2703 class split_view :
public view_interface<split_view<_Vp, _Pattern>>
2706 template<
bool _Const>
2709 template<
bool _Const>
2713 using _Parent = __detail::__maybe_const_t<_Const, split_view>;
2714 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2718 {
return __current() ==
ranges::end(_M_parent->_M_base); }
2725 __current() noexcept
2727 if constexpr (forward_range<_Vp>)
2730 return _M_parent->_M_current;
2734 __current() const noexcept
2736 if constexpr (forward_range<_Vp>)
2739 return _M_parent->_M_current;
2742 _Parent* _M_parent =
nullptr;
2745 [[no_unique_address]]
2746 __detail::__maybe_present_t<forward_range<_Vp>,
2747 iterator_t<_Base>> _M_current;
2750 using iterator_concept = conditional_t<forward_range<_Base>,
2751 forward_iterator_tag,
2752 input_iterator_tag>;
2753 using iterator_category = input_iterator_tag;
2754 using difference_type = range_difference_t<_Base>;
2756 struct value_type : view_interface<value_type>
2759 _OuterIter _M_i = _OuterIter();
2762 value_type() =
default;
2765 value_type(_OuterIter __i)
2769 constexpr _InnerIter<_Const>
2771 requires copyable<_OuterIter>
2772 {
return _InnerIter<_Const>{_M_i}; }
2774 constexpr _InnerIter<_Const>
2776 requires (!copyable<_OuterIter>)
2777 {
return _InnerIter<_Const>{
std::move(_M_i)}; }
2779 constexpr default_sentinel_t
2781 {
return default_sentinel; }
2784 _OuterIter() =
default;
2787 _OuterIter(_Parent& __parent) requires (!forward_range<_Base>)
2792 _OuterIter(_Parent& __parent, iterator_t<_Base> __current)
2793 requires forward_range<_Base>
2799 _OuterIter(_OuterIter<!_Const> __i)
2801 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
2802 : _M_parent(__i._M_parent), _M_current(
std::move(__i._M_current))
2805 constexpr value_type
2807 {
return value_type{*
this}; }
2809 constexpr _OuterIter&
2812 const auto __end =
ranges::end(_M_parent->_M_base);
2813 if (__current() == __end)
2815 const auto [__pbegin, __pend] = subrange{_M_parent->_M_pattern};
2816 if (__pbegin == __pend)
2822 = __detail::mismatch(
std::move(__current()), __end,
2827 }
while (++__current() != __end);
2831 constexpr decltype(
auto)
2834 if constexpr (forward_range<_Base>)
2844 friend constexpr
bool
2845 operator==(
const _OuterIter& __x,
const _OuterIter& __y)
2846 requires forward_range<_Base>
2847 {
return __x._M_current == __y._M_current; }
2849 friend constexpr
bool
2850 operator==(
const _OuterIter& __x, default_sentinel_t)
2851 {
return __x.__at_end(); };
2853 friend _OuterIter<!_Const>;
2854 friend _InnerIter<_Const>;
2857 template<
bool _Const>
2861 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2866 auto [__pcur, __pend] = subrange{_M_i._M_parent->_M_pattern};
2867 auto __end =
ranges::end(_M_i._M_parent->_M_base);
2868 if constexpr (__detail::__tiny_range<_Pattern>)
2870 const auto& __cur = _M_i_current();
2873 if (__pcur == __pend)
2874 return _M_incremented;
2875 return *__cur == *__pcur;
2879 auto __cur = _M_i_current();
2882 if (__pcur == __pend)
2883 return _M_incremented;
2886 if (*__cur != *__pcur)
2888 if (++__pcur == __pend)
2890 }
while (++__cur != __end);
2895 static constexpr
auto
2899 =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
2900 if constexpr (derived_from<_Cat, forward_iterator_tag>)
2901 return forward_iterator_tag{};
2907 _M_i_current() noexcept
2908 {
return _M_i.__current(); }
2911 _M_i_current() const noexcept
2912 {
return _M_i.__current(); }
2914 _OuterIter<_Const> _M_i = _OuterIter<_Const>();
2915 bool _M_incremented =
false;
2918 using iterator_concept
2919 =
typename _OuterIter<_Const>::iterator_concept;
2920 using iterator_category = decltype(_S_iter_cat());
2921 using value_type = range_value_t<_Base>;
2922 using difference_type = range_difference_t<_Base>;
2924 _InnerIter() =
default;
2927 _InnerIter(_OuterIter<_Const> __i)
2931 constexpr decltype(
auto)
2933 {
return *_M_i_current(); }
2935 constexpr _InnerIter&
2938 _M_incremented =
true;
2939 if constexpr (!forward_range<_Base>)
2940 if constexpr (_Pattern::size() == 0)
2946 constexpr decltype(auto)
2949 if constexpr (forward_range<_Vp>)
2959 friend constexpr
bool
2960 operator==(
const _InnerIter& __x,
const _InnerIter& __y)
2961 requires forward_range<_Base>
2962 {
return __x._M_i == __y._M_i; }
2964 friend constexpr
bool
2965 operator==(
const _InnerIter& __x, default_sentinel_t)
2966 {
return __x.__at_end(); }
2968 friend constexpr decltype(
auto)
2969 iter_move(const _InnerIter& __i)
2970 noexcept(noexcept(ranges::iter_move(__i._M_i_current())))
2971 {
return ranges::iter_move(__i._M_i_current()); }
2973 friend constexpr
void
2974 iter_swap(
const _InnerIter& __x,
const _InnerIter& __y)
2975 noexcept(noexcept(ranges::iter_swap(__x._M_i_current(),
2976 __y._M_i_current())))
2977 requires indirectly_swappable<iterator_t<_Base>>
2978 { ranges::iter_swap(__x._M_i_current(), __y._M_i_current()); }
2981 _Vp _M_base = _Vp();
2982 _Pattern _M_pattern = _Pattern();
2985 [[no_unique_address]]
2986 __detail::__maybe_present_t<!forward_range<_Vp>, iterator_t<_Vp>>
2991 split_view() =
default;
2994 split_view(_Vp
__base, _Pattern __pattern)
2998 template<input_range _Range>
2999 requires constructible_from<_Vp, views::all_t<_Range>>
3000 && constructible_from<_Pattern, single_view<range_value_t<_Range>>>
3002 split_view(_Range&& __r, range_value_t<_Range> __e)
3003 : _M_base(views::all(
std::
forward<_Range>(__r))),
3008 base() const& requires copy_constructible<_Vp>
3018 if constexpr (forward_range<_Vp>)
3019 return _OuterIter<__detail::__simple_view<_Vp>>{
3024 return _OuterIter<false>{*
this};
3029 begin() const requires forward_range<_Vp> && forward_range<const _Vp>
3035 end() requires forward_range<_Vp> && common_range<_Vp>
3037 return _OuterIter<__detail::__simple_view<_Vp>>{
3044 if constexpr (forward_range<_Vp>
3045 && forward_range<const _Vp>
3046 && common_range<const _Vp>)
3047 return _OuterIter<true>{*
this,
ranges::end(_M_base)};
3049 return default_sentinel;
3053 template<
typename _Range,
typename _Pred>
3054 split_view(_Range&&, _Pred&&)
3055 -> split_view<views::all_t<_Range>, views::all_t<_Pred>>;
3057 template<input_range _Range>
3058 split_view(_Range&&, range_value_t<_Range>)
3059 -> split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
3063 inline constexpr __adaptor::_RangeAdaptor split
3064 = [] <viewable_range _Range,
typename _Fp> (_Range&& __r, _Fp&& __f)
3066 return split_view{std::forward<_Range>(__r), std::forward<_Fp>(__f)};
3074 template<input_or_output_iterator _Iter>
3076 operator()(_Iter __i, iter_difference_t<_Iter> __n)
const
3078 if constexpr (random_access_iterator<_Iter>)
3079 return subrange{__i, __i + __n};
3081 return subrange{counted_iterator{
std::move(__i), __n},
3086 inline constexpr _Counted counted{};
3090 requires (!common_range<_Vp>) && copyable<iterator_t<_Vp>>
3091 class common_view :
public view_interface<common_view<_Vp>>
3094 _Vp _M_base = _Vp();
3097 common_view() =
default;
3100 common_view(_Vp __r)
3115 base() const& requires copy_constructible<_Vp>
3125 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3128 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
3133 begin() const requires range<const _Vp>
3135 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
3138 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
3145 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3148 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
3153 end() const requires range<const _Vp>
3155 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
3158 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
3163 size() requires sized_range<_Vp>
3164 {
return ranges::size(_M_base); }
3167 size() const requires sized_range<const _Vp>
3168 {
return ranges::size(_M_base); }
3171 template<
typename _Range>
3172 common_view(_Range&&) -> common_view<views::all_t<_Range>>;
3176 inline constexpr __adaptor::_RangeAdaptorClosure common
3177 = [] <viewable_range _Range> (_Range&& __r)
3179 if constexpr (common_range<_Range>
3180 && requires { views::all(std::forward<_Range>(__r)); })
3181 return views::all(std::forward<_Range>(__r));
3183 return common_view{std::forward<_Range>(__r)};
3189 requires bidirectional_range<_Vp>
3190 class reverse_view :
public view_interface<reverse_view<_Vp>>
3193 _Vp _M_base = _Vp();
3195 static constexpr
bool _S_needs_cached_begin
3196 = !common_range<_Vp> && !random_access_range<_Vp>;
3197 [[no_unique_address]]
3198 __detail::__maybe_present_t<_S_needs_cached_begin,
3199 __detail::_CachedPosition<_Vp>>
3203 reverse_view() =
default;
3206 reverse_view(_Vp __r)
3211 base() const& requires copy_constructible<_Vp>
3218 constexpr reverse_iterator<iterator_t<_Vp>>
3221 if constexpr (_S_needs_cached_begin)
3222 if (_M_cached_begin._M_has_value())
3226 if constexpr (_S_needs_cached_begin)
3227 _M_cached_begin._M_set(_M_base, __it);
3232 begin() requires common_range<_Vp>
3236 begin() const requires common_range<const _Vp>
3239 constexpr reverse_iterator<iterator_t<_Vp>>
3244 end() const requires common_range<const _Vp>
3248 size() requires sized_range<_Vp>
3249 {
return ranges::size(_M_base); }
3252 size() const requires sized_range<const _Vp>
3253 {
return ranges::size(_M_base); }
3256 template<
typename _Range>
3257 reverse_view(_Range&&) -> reverse_view<views::all_t<_Range>>;
3264 inline constexpr
bool __is_reversible_subrange =
false;
3266 template<
typename _Iter, subrange_kind _Kind>
3267 inline constexpr
bool
3268 __is_reversible_subrange<subrange<reverse_iterator<_Iter>,
3269 reverse_iterator<_Iter>,
3273 inline constexpr
bool __is_reverse_view =
false;
3275 template<
typename _Vp>
3276 inline constexpr
bool __is_reverse_view<reverse_view<_Vp>> =
true;
3279 inline constexpr __adaptor::_RangeAdaptorClosure reverse
3280 = [] <viewable_range _Range> (_Range&& __r)
3282 using _Tp = remove_cvref_t<_Range>;
3283 if constexpr (__detail::__is_reverse_view<_Tp>)
3284 return std::forward<_Range>(__r).base();
3285 else if constexpr (__detail::__is_reversible_subrange<_Tp>)
3288 if constexpr (sized_range<_Tp>)
3289 return subrange<_Iter, _Iter, subrange_kind::sized>
3290 (__r.end().base(), __r.begin().base(), __r.size());
3292 return subrange<_Iter, _Iter, subrange_kind::unsized>
3293 (__r.end().base(), __r.begin().base());
3296 return reverse_view{std::forward<_Range>(__r)};
3302 template<
typename _Tp,
size_t _Nm>
3303 concept __has_tuple_element = requires(_Tp __t)
3305 typename tuple_size<_Tp>::type;
3306 requires _Nm < tuple_size_v<_Tp>;
3307 typename tuple_element_t<_Nm, _Tp>;
3308 { std::get<_Nm>(__t) }
3309 -> convertible_to<const tuple_element_t<_Nm, _Tp>&>;
3313 template<input_range _Vp,
size_t _Nm>
3315 && __detail::__has_tuple_element<range_value_t<_Vp>, _Nm>
3316 && __detail::__has_tuple_element<remove_reference_t<range_reference_t<_Vp>>,
3318 class elements_view :
public view_interface<elements_view<_Vp, _Nm>>
3321 elements_view() =
default;
3324 elements_view(_Vp base)
3329 base() const& requires copy_constructible<_Vp>
3337 begin() requires (!__detail::__simple_view<_Vp>)
3341 begin() const requires __detail::__simple_view<_Vp>
3345 end() requires (!__detail::__simple_view<_Vp>)
3349 end() const requires __detail::__simple_view<_Vp>
3353 size() requires sized_range<_Vp>
3354 {
return ranges::size(_M_base); }
3357 size() const requires sized_range<const _Vp>
3358 {
return ranges::size(_M_base); }
3361 template<
bool _Const>
3364 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
3366 iterator_t<_Base> _M_current = iterator_t<_Base>();
3368 friend _Iterator<!_Const>;
3371 using iterator_category
3372 =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
3374 = remove_cvref_t<tuple_element_t<_Nm, range_value_t<_Base>>>;
3375 using difference_type = range_difference_t<_Base>;
3377 _Iterator() =
default;
3380 _Iterator(iterator_t<_Base> current)
3381 : _M_current(
std::
move(current))
3385 _Iterator(_Iterator<!_Const> i)
3386 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
3390 constexpr iterator_t<_Base>
3392 requires copyable<iterator_t<_Base>>
3393 {
return _M_current; }
3395 constexpr iterator_t<_Base>
3399 constexpr decltype(
auto)
3401 {
return std::get<_Nm>(*_M_current); }
3403 constexpr _Iterator&
3411 operator++(
int) requires (!forward_range<_Base>)
3415 operator++(
int) requires forward_range<_Base>
3422 constexpr _Iterator&
3423 operator--() requires bidirectional_range<_Base>
3430 operator--(
int) requires bidirectional_range<_Base>
3437 constexpr _Iterator&
3438 operator+=(difference_type __n)
3439 requires random_access_range<_Base>
3445 constexpr _Iterator&
3446 operator-=(difference_type __n)
3447 requires random_access_range<_Base>
3453 constexpr decltype(
auto)
3454 operator[](difference_type __n) const
3455 requires random_access_range<_Base>
3456 {
return std::get<_Nm>(*(_M_current + __n)); }
3458 friend constexpr
bool
3459 operator==(
const _Iterator& __x,
const _Iterator& __y)
3460 requires equality_comparable<iterator_t<_Base>>
3461 {
return __x._M_current == __y._M_current; }
3463 friend constexpr
bool
3464 operator==(
const _Iterator& __x,
const sentinel_t<_Base>& __y)
3465 {
return __x._M_current == __y; }
3467 friend constexpr
bool
3468 operator<(
const _Iterator& __x,
const _Iterator& __y)
3469 requires random_access_range<_Base>
3470 {
return __x._M_current < __y._M_current; }
3472 friend constexpr
bool
3473 operator>(
const _Iterator& __x,
const _Iterator& __y)
3474 requires random_access_range<_Base>
3475 {
return __y._M_current < __x._M_current; }
3477 friend constexpr
bool
3478 operator<=(
const _Iterator& __x,
const _Iterator& __y)
3479 requires random_access_range<_Base>
3480 {
return !(__y._M_current > __x._M_current); }
3482 friend constexpr
bool
3483 operator>=(
const _Iterator& __x,
const _Iterator& __y)
3484 requires random_access_range<_Base>
3485 {
return !(__x._M_current > __y._M_current); }
3487 #ifdef __cpp_lib_three_way_comparison
3488 friend constexpr
auto
3489 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
3490 requires random_access_range<_Base>
3491 && three_way_comparable<iterator_t<_Base>>
3492 {
return __x._M_current <=> __y._M_current; }
3495 friend constexpr _Iterator
3496 operator+(
const _Iterator& __x, difference_type __y)
3497 requires random_access_range<_Base>
3498 {
return _Iterator{__x} += __y; }
3500 friend constexpr _Iterator
3501 operator+(difference_type __x,
const _Iterator& __y)
3502 requires random_access_range<_Base>
3503 {
return __y + __x; }
3505 friend constexpr _Iterator
3506 operator-(
const _Iterator& __x, difference_type __y)
3507 requires random_access_range<_Base>
3508 {
return _Iterator{__x} -= __y; }
3510 friend constexpr difference_type
3511 operator-(
const _Iterator& __x,
const _Iterator& __y)
3512 requires random_access_range<_Base>
3513 {
return __x._M_current - __y._M_current; }
3515 friend constexpr difference_type
3516 operator-(
const _Iterator<_Const>& __x,
const sentinel_t<_Base>& __y)
3517 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
3518 {
return __x._M_current - __y; }
3520 friend constexpr difference_type
3521 operator-(
const sentinel_t<_Base>& __x,
const _Iterator<_Const>& __y)
3522 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
3523 {
return -(__y - __x); }
3526 _Vp _M_base = _Vp();
3529 template<
typename _Range>
3530 using keys_view = elements_view<views::all_t<_Range>, 0>;
3532 template<
typename _Range>
3533 using values_view = elements_view<views::all_t<_Range>, 1>;
3537 template<
size_t _Nm>
3538 inline constexpr __adaptor::_RangeAdaptorClosure elements
3539 = [] <viewable_range _Range> (_Range&& __r)
3541 using _El = elements_view<views::all_t<_Range>, _Nm>;
3542 return _El{std::forward<_Range>(__r)};
3545 inline constexpr __adaptor::_RangeAdaptorClosure keys = elements<0>;
3546 inline constexpr __adaptor::_RangeAdaptorClosure values = elements<1>;
3551 namespace views = ranges::views;
3553 template<
typename _Iter,
typename _Sent, ranges::subrange_kind _Kind>
3554 struct tuple_size<ranges::subrange<_Iter, _Sent, _Kind>>
3555 : integral_constant<size_t, 2>
3558 template<
typename _Iter,
typename _Sent, ranges::subrange_kind _Kind>
3559 struct tuple_element<0, ranges::subrange<_Iter, _Sent, _Kind>>
3560 {
using type = _Iter; };
3562 template<
typename _Iter,
typename _Sent, ranges::subrange_kind _Kind>
3563 struct tuple_element<1, ranges::subrange<_Iter, _Sent, _Kind>>
3564 {
using type = _Sent; };
3566 template<
typename _Iter,
typename _Sent, ranges::subrange_kind _Kind>
3567 struct tuple_element<0, const ranges::subrange<_Iter, _Sent, _Kind>>
3568 {
using type = _Iter; };
3570 template<
typename _Iter,
typename _Sent, ranges::subrange_kind _Kind>
3571 struct tuple_element<1, const ranges::subrange<_Iter, _Sent, _Kind>>
3572 {
using type = _Sent; };
3574 _GLIBCXX_END_NAMESPACE_VERSION
3576 #endif // library concepts