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>>;
227 enum class subrange_kind : bool { unsized, sized };
229 template<input_or_output_iterator _It, sentinel_for<_It> _Sent = _It,
230 subrange_kind _Kind = sized_sentinel_for<_Sent, _It>
231 ? subrange_kind::sized : subrange_kind::unsized>
232 requires (_Kind == subrange_kind::sized || !sized_sentinel_for<_Sent, _It>)
233 class subrange :
public view_interface<subrange<_It, _Sent, _Kind>>
237 static const bool _S_store_size
238 = _Kind == subrange_kind::sized && !sized_sentinel_for<_Sent, _It>;
240 _It _M_begin = _It();
241 _Sent _M_end = _Sent();
243 template<
typename,
bool = _S_store_size>
247 template<
typename _Tp>
248 struct _Size<_Tp, true>
249 { __detail::__make_unsigned_like_t<_Tp> _M_size; };
251 [[no_unique_address]] _Size<iter_difference_t<_It>> _M_size = {};
254 subrange() =
default;
257 subrange(__detail::__convertible_to_non_slicing<_It>
auto __i, _Sent __s)
258 requires (!_S_store_size)
259 : _M_begin(
std::
move(__i)), _M_end(__s)
263 subrange(__detail::__convertible_to_non_slicing<_It>
auto __i, _Sent __s,
264 __detail::__make_unsigned_like_t<iter_difference_t<_It>> __n)
265 requires (_Kind == subrange_kind::sized)
266 : _M_begin(
std::
move(__i)), _M_end(__s)
268 using __detail::__to_unsigned_like;
270 if constexpr (_S_store_size)
271 _M_size._M_size = __n;
274 template<__detail::__not_same_as<subrange> _Rng>
275 requires borrowed_range<_Rng>
276 && __detail::__convertible_to_non_slicing<iterator_t<_Rng>, _It>
277 && convertible_to<sentinel_t<_Rng>, _Sent>
279 subrange(_Rng&& __r) requires _S_store_size && sized_range<_Rng>
280 : subrange(__r, ranges::size(__r))
283 template<__detail::__not_same_as<subrange> _Rng>
284 requires borrowed_range<_Rng>
285 && __detail::__convertible_to_non_slicing<iterator_t<_Rng>, _It>
286 && convertible_to<sentinel_t<_Rng>, _Sent>
288 subrange(_Rng&& __r) requires (!_S_store_size)
289 : subrange{ranges::
begin(__r), ranges::
end(__r)}
292 template<borrowed_range _Rng>
293 requires __detail::__convertible_to_non_slicing<iterator_t<_Rng>, _It>
294 && convertible_to<sentinel_t<_Rng>, _Sent>
297 __detail::__make_unsigned_like_t<iter_difference_t<_It>> __n)
298 requires (_Kind == subrange_kind::sized)
299 : subrange{ranges::
begin(__r), ranges::
end(__r), __n}
302 template<__detail::__not_same_as<subrange> _PairLike>
303 requires __detail::__pair_like_convertible_from<_PairLike,
const _It&,
306 operator _PairLike()
const
307 {
return _PairLike(_M_begin, _M_end); }
310 begin() const requires copyable<_It>
313 [[nodiscard]] constexpr _It
314 begin() requires (!copyable<_It>)
317 constexpr _Sent
end()
const {
return _M_end; }
319 constexpr
bool empty()
const {
return _M_begin == _M_end; }
321 constexpr __detail::__make_unsigned_like_t<iter_difference_t<_It>>
322 size() const requires (_Kind == subrange_kind::sized)
324 if constexpr (_S_store_size)
325 return _M_size._M_size;
327 return __detail::__to_unsigned_like(_M_end - _M_begin);
330 [[nodiscard]] constexpr subrange
331 next(iter_difference_t<_It> __n = 1) const &
332 requires forward_iterator<_It>
339 [[nodiscard]] constexpr subrange
340 next(iter_difference_t<_It> __n = 1) &&
346 [[nodiscard]] constexpr subrange
347 prev(iter_difference_t<_It> __n = 1) const
348 requires bidirectional_iterator<_It>
356 advance(iter_difference_t<_It> __n)
360 if constexpr (bidirectional_iterator<_It>)
364 if constexpr (_S_store_size)
365 _M_size._M_size += __detail::__to_unsigned_like(-__n);
369 __glibcxx_assert(__n >= 0);
371 if constexpr (_S_store_size)
372 _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<borrowed_range _Rng>
387 -> subrange<iterator_t<_Rng>, sentinel_t<_Rng>,
389 || sized_sentinel_for<sentinel_t<_Rng>, iterator_t<_Rng>>)
390 ? subrange_kind::sized : subrange_kind::unsized>;
392 template<borrowed_range _Rng>
394 __detail::__make_unsigned_like_t<range_difference_t<_Rng>>)
395 -> subrange<iterator_t<_Rng>, sentinel_t<_Rng>, subrange_kind::sized>;
397 template<
size_t _Num,
class _It,
class _Sent, subrange_kind _Kind>
400 get(const subrange<_It, _Sent, _Kind>& __r)
402 if constexpr (_Num == 0)
408 template<
size_t _Num, class _It, class _Sent, subrange_kind _Kind>
411 get(subrange<_It, _Sent, _Kind>&& __r)
413 if constexpr (_Num == 0)
419 template<input_or_output_iterator _It, sentinel_for<_It> _Sent,
421 inline constexpr
bool
422 enable_borrowed_range<subrange<_It, _Sent, _Kind>> = true;
433 constexpr dangling() noexcept = default;
434 template<typename... _Args>
435 constexpr dangling(_Args&&...) noexcept { }
438 template<range _Range>
439 using borrowed_iterator_t = conditional_t<borrowed_range<_Range>,
443 template<range _Range>
444 using borrowed_subrange_t = conditional_t<borrowed_range<_Range>,
445 subrange<iterator_t<_Range>>,
448 template<
typename _Tp> requires is_object_v<_Tp>
450 :
public view_interface<empty_view<_Tp>>
453 static constexpr _Tp*
begin() noexcept {
return nullptr; }
454 static constexpr _Tp*
end() noexcept {
return nullptr; }
455 static constexpr _Tp* data() noexcept {
return nullptr; }
456 static constexpr
size_t size() noexcept {
return 0; }
457 static constexpr
bool empty() noexcept {
return true; }
460 template<
typename _Tp>
461 inline constexpr
bool enable_borrowed_range<empty_view<_Tp>> =
true;
465 template<copy_constructible _Tp> requires is_object_v<_Tp>
466 struct __box : std::optional<_Tp>
468 using std::optional<_Tp>::optional;
472 noexcept(is_nothrow_default_constructible_v<_Tp>)
473 requires default_initializable<_Tp>
477 __box(
const __box&) =
default;
478 __box(__box&&) =
default;
480 using std::optional<_Tp>::operator=;
485 operator=(
const __box& __that)
486 noexcept(is_nothrow_copy_constructible_v<_Tp>)
487 requires (!copyable<_Tp>)
490 this->emplace(*__that);
497 operator=(__box&& __that)
498 noexcept(is_nothrow_move_constructible_v<_Tp>)
499 requires (!movable<_Tp>)
512 template<copy_constructible _Tp> requires is_object_v<_Tp>
513 class single_view :
public view_interface<single_view<_Tp>>
516 single_view() =
default;
519 single_view(
const _Tp& __t)
524 single_view(_Tp&& __t)
530 template<
typename... _Args>
531 requires constructible_from<_Tp, _Args...>
533 single_view(in_place_t, _Args&&... __args)
542 begin() const noexcept
547 {
return data() + 1; }
551 {
return data() + 1; }
553 static constexpr
size_t
559 {
return _M_value.operator->(); }
562 data() const noexcept
563 {
return _M_value.operator->(); }
566 __detail::__box<_Tp> _M_value;
571 template<
typename _Wp>
572 constexpr
auto __to_signed_like(_Wp __w) noexcept
574 if constexpr (!integral<_Wp>)
575 return iter_difference_t<_Wp>();
576 else if constexpr (
sizeof(iter_difference_t<_Wp>) >
sizeof(_Wp))
577 return iter_difference_t<_Wp>(__w);
578 else if constexpr (
sizeof(ptrdiff_t) >
sizeof(_Wp))
579 return ptrdiff_t(__w);
580 else if constexpr (
sizeof(
long long) >
sizeof(_Wp))
581 return (
long long)(__w);
582 #ifdef __SIZEOF_INT128__
583 else if constexpr (__SIZEOF_INT128__ >
sizeof(_Wp))
584 return __int128(__w);
587 return __max_diff_type(__w);
590 template<
typename _Wp>
591 using __iota_diff_t = decltype(__to_signed_like(std::declval<_Wp>()));
593 template<
typename _It>
594 concept __decrementable = incrementable<_It>
597 { --__i } -> same_as<_It&>;
598 { __i-- } -> same_as<_It>;
601 template<
typename _It>
602 concept __advanceable = __decrementable<_It> && totally_ordered<_It>
603 && requires( _It __i,
const _It __j,
const __iota_diff_t<_It> __n)
605 { __i += __n } -> same_as<_It&>;
606 { __i -= __n } -> same_as<_It&>;
610 { __j - __j } -> convertible_to<__iota_diff_t<_It>>;
613 template<
typename _Winc>
614 struct __iota_view_iter_cat
617 template<incrementable _Winc>
618 struct __iota_view_iter_cat<_Winc>
619 {
using iterator_category = input_iterator_tag; };
622 template<weakly_incrementable _Winc,
623 semiregular _Bound = unreachable_sentinel_t>
624 requires std::__detail::__weakly_eq_cmp_with<_Winc, _Bound>
625 && semiregular<_Winc>
626 class iota_view :
public view_interface<iota_view<_Winc, _Bound>>
631 struct _Iterator : __detail::__iota_view_iter_cat<_Winc>
637 using namespace __detail;
638 if constexpr (__advanceable<_Winc>)
639 return random_access_iterator_tag{};
640 else if constexpr (__decrementable<_Winc>)
641 return bidirectional_iterator_tag{};
642 else if constexpr (incrementable<_Winc>)
643 return forward_iterator_tag{};
645 return input_iterator_tag{};
649 using iterator_concept = decltype(_S_iter_concept());
651 using value_type = _Winc;
652 using difference_type = __detail::__iota_diff_t<_Winc>;
654 _Iterator() =
default;
657 _Iterator(_Winc __value)
658 : _M_value(__value) { }
661 operator*() const noexcept(is_nothrow_copy_constructible_v<_Winc>)
676 operator++(
int) requires incrementable<_Winc>
684 operator--() requires __detail::__decrementable<_Winc>
691 operator--(
int) requires __detail::__decrementable<_Winc>
699 operator+=(difference_type __n) requires __detail::__advanceable<_Winc>
701 using __detail::__is_integer_like;
702 using __detail::__is_signed_integer_like;
703 if constexpr (__is_integer_like<_Winc>
704 && !__is_signed_integer_like<_Winc>)
706 if (__n >= difference_type(0))
707 _M_value +=
static_cast<_Winc
>(__n);
709 _M_value -=
static_cast<_Winc
>(-__n);
717 operator-=(difference_type __n) requires __detail::__advanceable<_Winc>
719 using __detail::__is_integer_like;
720 using __detail::__is_signed_integer_like;
721 if constexpr (__is_integer_like<_Winc>
722 && !__is_signed_integer_like<_Winc>)
724 if (__n >= difference_type(0))
725 _M_value -=
static_cast<_Winc
>(__n);
727 _M_value +=
static_cast<_Winc
>(-__n);
735 operator[](difference_type __n)
const
736 requires __detail::__advanceable<_Winc>
737 {
return _Winc(_M_value + __n); }
739 friend constexpr
bool
740 operator==(
const _Iterator& __x,
const _Iterator& __y)
741 requires equality_comparable<_Winc>
742 {
return __x._M_value == __y._M_value; }
744 friend constexpr
bool
745 operator<(
const _Iterator& __x,
const _Iterator& __y)
746 requires totally_ordered<_Winc>
747 {
return __x._M_value < __y._M_value; }
749 friend constexpr
bool
750 operator>(
const _Iterator& __x,
const _Iterator& __y)
751 requires totally_ordered<_Winc>
752 {
return __y < __x; }
754 friend constexpr
bool
755 operator<=(
const _Iterator& __x,
const _Iterator& __y)
756 requires totally_ordered<_Winc>
757 {
return !(__y < __x); }
759 friend constexpr
bool
760 operator>=(
const _Iterator& __x,
const _Iterator& __y)
761 requires totally_ordered<_Winc>
762 {
return !(__x < __y); }
764 #ifdef __cpp_lib_three_way_comparison
765 friend constexpr
auto
766 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
767 requires totally_ordered<_Winc> && three_way_comparable<_Winc>
768 {
return __x._M_value <=> __y._M_value; }
771 friend constexpr _Iterator
772 operator+(_Iterator __i, difference_type __n)
773 requires __detail::__advanceable<_Winc>
774 {
return __i += __n; }
776 friend constexpr _Iterator
777 operator+(difference_type __n, _Iterator __i)
778 requires __detail::__advanceable<_Winc>
779 {
return __i += __n; }
781 friend constexpr _Iterator
782 operator-(_Iterator __i, difference_type __n)
783 requires __detail::__advanceable<_Winc>
784 {
return __i -= __n; }
786 friend constexpr difference_type
787 operator-(
const _Iterator& __x,
const _Iterator& __y)
788 requires __detail::__advanceable<_Winc>
790 using __detail::__is_integer_like;
791 using __detail::__is_signed_integer_like;
792 using _Dt = difference_type;
793 if constexpr (__is_integer_like<_Winc>)
795 if constexpr (__is_signed_integer_like<_Winc>)
796 return _Dt(_Dt(__x._M_value) - _Dt(__y._M_value));
798 return (__y._M_value > __x._M_value)
799 ? _Dt(-_Dt(__y._M_value - __x._M_value))
800 : _Dt(__x._M_value - __y._M_value);
803 return __x._M_value - __y._M_value;
807 _Winc _M_value = _Winc();
816 _M_equal(
const _Iterator& __x)
const
817 {
return __x._M_value == _M_bound; }
820 _M_distance_from(
const _Iterator& __x)
const
821 {
return _M_bound - __x._M_value; }
823 _Bound _M_bound = _Bound();
826 _Sentinel() =
default;
829 _Sentinel(_Bound __bound)
830 : _M_bound(__bound) { }
832 friend constexpr
bool
833 operator==(
const _Iterator& __x,
const _Sentinel& __y)
834 {
return __y._M_equal(__x); }
836 friend constexpr iter_difference_t<_Winc>
837 operator-(
const _Iterator& __x,
const _Sentinel& __y)
838 requires sized_sentinel_for<_Bound, _Winc>
839 {
return -__y._M_distance_from(__x); }
841 friend constexpr iter_difference_t<_Winc>
842 operator-(
const _Sentinel& __x,
const _Iterator& __y)
843 requires sized_sentinel_for<_Bound, _Winc>
844 {
return __x._M_distance_from(__y); }
847 _Winc _M_value = _Winc();
848 _Bound _M_bound = _Bound();
851 iota_view() =
default;
854 iota_view(_Winc __value)
859 iota_view(type_identity_t<_Winc> __value,
860 type_identity_t<_Bound> __bound)
861 : _M_value(__value), _M_bound(__bound)
863 if constexpr (totally_ordered_with<_Winc, _Bound>)
865 __glibcxx_assert(
bool(__value <= __bound) );
870 begin()
const {
return _Iterator{_M_value}; }
875 if constexpr (same_as<_Bound, unreachable_sentinel_t>)
876 return unreachable_sentinel;
878 return _Sentinel{_M_bound};
882 end() const requires same_as<_Winc, _Bound>
883 {
return _Iterator{_M_bound}; }
887 requires (same_as<_Winc, _Bound> && __detail::__advanceable<_Winc>)
888 || (integral<_Winc> && integral<_Bound>)
889 || sized_sentinel_for<_Bound, _Winc>
891 using __detail::__is_integer_like;
892 using __detail::__to_unsigned_like;
893 if constexpr (integral<_Winc> && integral<_Bound>)
896 return _Up(_M_bound) - _Up(_M_value);
898 else if constexpr (__is_integer_like<_Winc>)
899 return __to_unsigned_like(_M_bound) - __to_unsigned_like(_M_value);
901 return __to_unsigned_like(_M_bound - _M_value);
905 template<
typename _Winc,
typename _Bound>
906 requires (!__detail::__is_integer_like<_Winc>
907 || !__detail::__is_integer_like<_Bound>
908 || (__detail::__is_signed_integer_like<_Winc>
909 == __detail::__is_signed_integer_like<_Bound>))
910 iota_view(_Winc, _Bound) -> iota_view<_Winc, _Bound>;
912 template<weakly_incrementable _Winc, semiregular _Bound>
913 inline constexpr
bool
914 enable_borrowed_range<iota_view<_Winc, _Bound>> =
true;
918 template<
typename _Tp>
919 inline constexpr empty_view<_Tp> empty{};
923 template<
typename _Tp>
925 operator()(_Tp&& __e)
const
926 {
return single_view{std::forward<_Tp>(__e)}; }
929 inline constexpr _Single single{};
933 template<
typename _Tp>
935 operator()(_Tp&& __e)
const
936 {
return iota_view{std::forward<_Tp>(__e)}; }
938 template<
typename _Tp,
typename _Up>
940 operator()(_Tp&& __e, _Up&& __f)
const
941 {
return iota_view{std::forward<_Tp>(__e), std::forward<_Up>(__f)}; }
944 inline constexpr _Iota
iota{};
949 template<
typename _Val,
typename _CharT,
typename _Traits>
950 concept __stream_extractable
951 = requires(basic_istream<_CharT, _Traits>& is, _Val& t) { is >> t; };
954 template<movable _Val,
typename _CharT,
955 typename _Traits = char_traits<_CharT>>
956 requires default_initializable<_Val>
957 && __detail::__stream_extractable<_Val, _CharT, _Traits>
958 class basic_istream_view
959 :
public view_interface<basic_istream_view<_Val, _CharT, _Traits>>
962 basic_istream_view() =
default;
965 basic_istream_view(basic_istream<_CharT, _Traits>& __stream)
972 if (_M_stream !=
nullptr)
973 *_M_stream >> _M_object;
974 return _Iterator{
this};
977 constexpr default_sentinel_t
979 {
return default_sentinel; }
982 basic_istream<_CharT, _Traits>* _M_stream =
nullptr;
983 _Val _M_object = _Val();
988 using iterator_concept = input_iterator_tag;
989 using difference_type = ptrdiff_t;
990 using value_type = _Val;
992 _Iterator() =
default;
995 _Iterator(basic_istream_view* __parent) noexcept
996 : _M_parent(__parent)
999 _Iterator(
const _Iterator&) =
delete;
1000 _Iterator(_Iterator&&) =
default;
1001 _Iterator& operator=(
const _Iterator&) =
delete;
1002 _Iterator& operator=(_Iterator&&) =
default;
1007 __glibcxx_assert(_M_parent->_M_stream !=
nullptr);
1008 *_M_parent->_M_stream >> _M_parent->_M_object;
1019 __glibcxx_assert(_M_parent->_M_stream !=
nullptr);
1020 return _M_parent->_M_object;
1024 operator==(
const _Iterator& __x, default_sentinel_t)
1025 {
return __x._M_at_end(); }
1028 basic_istream_view* _M_parent =
nullptr;
1032 {
return _M_parent ==
nullptr || !*_M_parent->_M_stream; }
1038 template<
typename _Val,
typename _CharT,
typename _Traits>
1039 basic_istream_view<_Val, _CharT, _Traits>
1040 istream_view(basic_istream<_CharT, _Traits>& __s)
1041 {
return basic_istream_view<_Val, _CharT, _Traits>{__s}; }
1051 template<
bool _Present,
typename _Tp>
1052 using __maybe_present_t = conditional_t<_Present, _Tp, _Empty>;
1055 template<
bool _Const,
typename _Tp>
1056 using __maybe_const_t = conditional_t<_Const, const _Tp, _Tp>;
1064 template<
typename _Tp>
1065 inline constexpr
auto
1066 __maybe_refwrap(_Tp& __arg)
1067 {
return reference_wrapper<_Tp>{__arg}; }
1069 template<
typename _Tp>
1070 inline constexpr
auto
1071 __maybe_refwrap(
const _Tp& __arg)
1072 {
return reference_wrapper<const _Tp>{__arg}; }
1074 template<
typename _Tp>
1075 inline constexpr decltype(
auto)
1076 __maybe_refwrap(_Tp&& __arg)
1077 {
return std::forward<_Tp>(__arg); }
1079 template<
typename _Callable>
1080 struct _RangeAdaptorClosure;
1082 template<
typename _Callable>
1083 struct _RangeAdaptor
1086 [[no_unique_address]]
1087 __detail::__maybe_present_t<!is_default_constructible_v<_Callable>,
1088 _Callable> _M_callable;
1092 _RangeAdaptor(
const _Callable& = {})
1093 requires is_default_constructible_v<_Callable>
1097 _RangeAdaptor(_Callable __callable)
1098 requires (!is_default_constructible_v<_Callable>)
1099 : _M_callable(
std::
move(__callable))
1102 template<
typename... _Args>
1103 requires (
sizeof...(_Args) >= 1)
1105 operator()(_Args&&... __args)
const
1118 if constexpr (is_invocable_v<_Callable, _Args...>)
1120 static_assert(
sizeof...(_Args) != 1,
1121 "a _RangeAdaptor that accepts only one argument "
1122 "should be defined as a _RangeAdaptorClosure");
1125 return _Callable{}(std::forward<_Args>(__args)...);
1138 = [...__args(__maybe_refwrap(std::forward<_Args>(__args)))]
1139 <
typename _Range> (_Range&& __r) {
1143 return _Callable{}(std::forward<_Range>(__r),
1144 (
static_cast<unwrap_reference_t
1148 using _ClosureType = decltype(__closure);
1149 return _RangeAdaptorClosure<_ClosureType>(
std::move(__closure));
1154 template<
typename _Callable>
1155 _RangeAdaptor(_Callable) -> _RangeAdaptor<_Callable>;
1157 template<
typename _Callable>
1158 struct _RangeAdaptorClosure :
public _RangeAdaptor<_Callable>
1160 using _RangeAdaptor<_Callable>::_RangeAdaptor;
1162 template<viewable_range _Range>
1163 requires requires { declval<_Callable>()(declval<_Range>()); }
1165 operator()(_Range&& __r)
const
1167 if constexpr (is_default_constructible_v<_Callable>)
1168 return _Callable{}(std::forward<_Range>(__r));
1170 return this->_M_callable(std::forward<_Range>(__r));
1173 template<viewable_range _Range>
1174 requires requires { declval<_Callable>()(declval<_Range>()); }
1175 friend constexpr
auto
1176 operator|(_Range&& __r,
const _RangeAdaptorClosure& __o)
1177 {
return __o(std::forward<_Range>(__r)); }
1179 template<
typename _Tp>
1180 friend constexpr
auto
1181 operator|(
const _RangeAdaptorClosure<_Tp>& __x,
1182 const _RangeAdaptorClosure& __y)
1184 if constexpr (is_default_constructible_v<_Tp>
1185 && is_default_constructible_v<_Callable>)
1187 auto __closure = [] <
typename _Up> (_Up&& __e) {
1188 return std::forward<_Up>(__e) | decltype(__x){} | decltype(__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 = [__y] <
typename _Up> (_Up&& __e) {
1196 return std::forward<_Up>(__e) | decltype(__x){} | __y;
1198 return _RangeAdaptorClosure<decltype(__closure)>(__closure);
1200 else if constexpr (!is_default_constructible_v<_Tp>
1201 && is_default_constructible_v<_Callable>)
1203 auto __closure = [__x] <
typename _Up> (_Up&& __e) {
1204 return std::forward<_Up>(__e) | __x | decltype(__y){};
1206 return _RangeAdaptorClosure<decltype(__closure)>(__closure);
1210 auto __closure = [__x, __y] <
typename _Up> (_Up&& __e) {
1211 return std::forward<_Up>(__e) | __x | __y;
1213 return _RangeAdaptorClosure<decltype(__closure)>(__closure);
1218 template<
typename _Callable>
1219 _RangeAdaptorClosure(_Callable) -> _RangeAdaptorClosure<_Callable>;
1223 template<range _Range> requires is_object_v<_Range>
1224 class ref_view :
public view_interface<ref_view<_Range>>
1227 _Range* _M_r =
nullptr;
1229 static void _S_fun(_Range&);
1230 static void _S_fun(_Range&&) =
delete;
1234 ref_view() noexcept = default;
1236 template<__detail::__not_same_as<ref_view> _Tp>
1237 requires convertible_to<_Tp, _Range&>
1238 && requires { _S_fun(declval<_Tp>()); }
1248 constexpr iterator_t<_Range>
1252 constexpr sentinel_t<_Range>
1257 empty() const requires requires { ranges::empty(*_M_r); }
1258 {
return ranges::empty(*_M_r); }
1261 size() const requires sized_range<_Range>
1262 {
return ranges::size(*_M_r); }
1265 data() const requires contiguous_range<_Range>
1266 {
return ranges::data(*_M_r); }
1269 template<
typename _Range>
1270 ref_view(_Range&) -> ref_view<_Range>;
1272 template<
typename _Tp>
1273 inline constexpr
bool enable_borrowed_range<ref_view<_Tp>> =
true;
1277 inline constexpr __adaptor::_RangeAdaptorClosure all
1278 = [] <viewable_range _Range> (_Range&& __r)
1280 if constexpr (view<decay_t<_Range>>)
1282 else if constexpr (requires { ref_view{std::forward<_Range>(__r)}; })
1283 return ref_view{std::forward<_Range>(__r)};
1285 return subrange{std::forward<_Range>(__r)};
1288 template<viewable_range _Range>
1289 using all_t = decltype(all(std::declval<_Range>()));
1297 template<
typename _Iter,
typename _Sent,
typename _Tp>
1299 find(_Iter __first, _Sent __last,
const _Tp& __value)
1301 while (__first != __last
1302 && !(
bool)(*__first == __value))
1307 template<
typename _Iter,
typename _Sent,
typename _Pred>
1309 find_if(_Iter __first, _Sent __last, _Pred __pred)
1311 while (__first != __last
1317 template<
typename _Iter,
typename _Sent,
typename _Pred>
1319 find_if_not(_Iter __first, _Sent __last, _Pred __pred)
1321 while (__first != __last
1327 template<
typename _Iter1,
typename _Sent1,
typename _Iter2,
typename _Sent2>
1328 constexpr pair<_Iter1, _Iter2>
1329 mismatch(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2)
1331 while (__first1 != __last1 && __first2 != __last2
1332 && (
bool)ranges::equal_to{}(*__first1, *__first2))
1343 template<range _Range>
1344 struct _CachedPosition
1347 _M_has_value()
const
1350 constexpr iterator_t<_Range>
1351 _M_get(
const _Range&)
const
1353 __glibcxx_assert(
false);
1358 _M_set(
const _Range&,
const iterator_t<_Range>&)
const
1362 template<forward_range _Range>
1363 struct _CachedPosition<_Range>
1366 iterator_t<_Range> _M_iter{};
1370 _M_has_value()
const
1371 {
return _M_iter != iterator_t<_Range>{}; }
1373 constexpr iterator_t<_Range>
1374 _M_get(
const _Range&)
const
1376 __glibcxx_assert(_M_has_value());
1381 _M_set(
const _Range&,
const iterator_t<_Range>& __it)
1383 __glibcxx_assert(!_M_has_value());
1388 template<random_access_range _Range>
1389 requires (
sizeof(range_difference_t<_Range>)
1390 <=
sizeof(iterator_t<_Range>))
1391 struct _CachedPosition<_Range>
1394 range_difference_t<_Range> _M_offset = -1;
1398 _M_has_value()
const
1399 {
return _M_offset >= 0; }
1401 constexpr iterator_t<_Range>
1402 _M_get(_Range& __r)
const
1404 __glibcxx_assert(_M_has_value());
1409 _M_set(_Range& __r,
const iterator_t<_Range>& __it)
1411 __glibcxx_assert(!_M_has_value());
1419 template<
typename _Base>
1420 struct __filter_view_iter_cat
1423 template<forward_range _Base>
1424 struct __filter_view_iter_cat<_Base>
1430 using _Cat =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
1431 if constexpr (derived_from<_Cat, bidirectional_iterator_tag>)
1432 return bidirectional_iterator_tag{};
1433 else if constexpr (derived_from<_Cat, forward_iterator_tag>)
1434 return forward_iterator_tag{};
1439 using iterator_category = decltype(_S_iter_cat());
1443 template<input_range _Vp,
1444 indirect_unary_predicate<iterator_t<_Vp>> _Pred>
1445 requires view<_Vp> && is_object_v<_Pred>
1446 class filter_view :
public view_interface<filter_view<_Vp, _Pred>>
1451 struct _Iterator : __detail::__filter_view_iter_cat<_Vp>
1454 static constexpr
auto
1457 if constexpr (bidirectional_range<_Vp>)
1458 return bidirectional_iterator_tag{};
1459 else if constexpr (forward_range<_Vp>)
1460 return forward_iterator_tag{};
1462 return input_iterator_tag{};
1467 using _Vp_iter = iterator_t<_Vp>;
1469 _Vp_iter _M_current = _Vp_iter();
1470 filter_view* _M_parent =
nullptr;
1473 using iterator_concept = decltype(_S_iter_concept());
1475 using value_type = range_value_t<_Vp>;
1476 using difference_type = range_difference_t<_Vp>;
1478 _Iterator() =
default;
1481 _Iterator(filter_view* __parent, _Vp_iter __current)
1482 : _M_current(
std::
move(__current)),
1486 constexpr
const _Vp_iter&
1487 base() const & noexcept
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>
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)
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>
1654 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
1656 template<
bool _Const>
1660 template<
bool _Const>
1661 requires forward_range<_Base<_Const>>
1662 struct __iter_cat<_Const>
1668 using _Base = transform_view::_Base<_Const>;
1669 using _Res = invoke_result_t<_Fp&, range_reference_t<_Base>>;
1670 if constexpr (is_lvalue_reference_v<_Res>)
1673 =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
1674 if constexpr (derived_from<_Cat, contiguous_iterator_tag>)
1675 return random_access_iterator_tag{};
1680 return input_iterator_tag{};
1683 using iterator_category = decltype(_S_iter_cat());
1686 template<
bool _Const>
1689 template<
bool _Const>
1690 struct _Iterator : __iter_cat<_Const>
1693 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
1694 using _Base = transform_view::_Base<_Const>;
1699 if constexpr (random_access_range<_Base>)
1700 return random_access_iterator_tag{};
1701 else if constexpr (bidirectional_range<_Base>)
1702 return bidirectional_iterator_tag{};
1703 else if constexpr (forward_range<_Base>)
1704 return forward_iterator_tag{};
1706 return input_iterator_tag{};
1709 using _Base_iter = iterator_t<_Base>;
1711 _Base_iter _M_current = _Base_iter();
1712 _Parent* _M_parent =
nullptr;
1715 using iterator_concept = decltype(_S_iter_concept());
1718 = remove_cvref_t<invoke_result_t<_Fp&, range_reference_t<_Base>>>;
1719 using difference_type = range_difference_t<_Base>;
1721 _Iterator() =
default;
1724 _Iterator(_Parent* __parent, _Base_iter __current)
1725 : _M_current(
std::
move(__current)),
1730 _Iterator(_Iterator<!_Const> __i)
1732 && convertible_to<iterator_t<_Vp>, _Base_iter>
1733 : _M_current(
std::move(__i._M_current)), _M_parent(__i._M_parent)
1736 constexpr
const _Base_iter&
1737 base() const & noexcept
1738 {
return _M_current; }
1740 constexpr _Base_iter
1744 constexpr decltype(
auto)
1746 noexcept(noexcept(
std::
__invoke(*_M_parent->_M_fun, *_M_current)))
1749 constexpr _Iterator&
1761 operator++(
int) requires forward_range<_Base>
1768 constexpr _Iterator&
1769 operator--() requires bidirectional_range<_Base>
1776 operator--(
int) requires bidirectional_range<_Base>
1783 constexpr _Iterator&
1784 operator+=(difference_type __n) requires random_access_range<_Base>
1790 constexpr _Iterator&
1791 operator-=(difference_type __n) requires random_access_range<_Base>
1797 constexpr decltype(
auto)
1798 operator[](difference_type __n) const
1799 requires random_access_range<_Base>
1800 {
return std::__invoke(*_M_parent->_M_fun, _M_current[__n]); }
1802 friend constexpr
bool
1803 operator==(
const _Iterator& __x,
const _Iterator& __y)
1804 requires equality_comparable<_Base_iter>
1805 {
return __x._M_current == __y._M_current; }
1807 friend constexpr
bool
1808 operator<(
const _Iterator& __x,
const _Iterator& __y)
1809 requires random_access_range<_Base>
1810 {
return __x._M_current < __y._M_current; }
1812 friend constexpr
bool
1813 operator>(
const _Iterator& __x,
const _Iterator& __y)
1814 requires random_access_range<_Base>
1815 {
return __y < __x; }
1817 friend constexpr
bool
1818 operator<=(
const _Iterator& __x,
const _Iterator& __y)
1819 requires random_access_range<_Base>
1820 {
return !(__y < __x); }
1822 friend constexpr
bool
1823 operator>=(
const _Iterator& __x,
const _Iterator& __y)
1824 requires random_access_range<_Base>
1825 {
return !(__x < __y); }
1827 #ifdef __cpp_lib_three_way_comparison
1828 friend constexpr
auto
1829 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
1830 requires random_access_range<_Base>
1831 && three_way_comparable<_Base_iter>
1832 {
return __x._M_current <=> __y._M_current; }
1835 friend constexpr _Iterator
1836 operator+(_Iterator __i, difference_type __n)
1837 requires random_access_range<_Base>
1838 {
return {__i._M_parent, __i._M_current + __n}; }
1840 friend constexpr _Iterator
1841 operator+(difference_type __n, _Iterator __i)
1842 requires random_access_range<_Base>
1843 {
return {__i._M_parent, __i._M_current + __n}; }
1845 friend constexpr _Iterator
1846 operator-(_Iterator __i, difference_type __n)
1847 requires random_access_range<_Base>
1848 {
return {__i._M_parent, __i._M_current - __n}; }
1852 friend constexpr difference_type
1853 operator-(
const _Iterator& __x,
const _Iterator& __y)
1854 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
1855 {
return __x._M_current - __y._M_current; }
1857 friend constexpr decltype(
auto)
1858 iter_move(const _Iterator& __i) noexcept(noexcept(*__i))
1860 if constexpr (is_lvalue_reference_v<decltype(*__i)>)
1866 friend _Iterator<!_Const>;
1867 template<
bool> friend struct _Sentinel;
1870 template<
bool _Const>
1874 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
1875 using _Base = transform_view::_Base<_Const>;
1877 template<
bool _Const2>
1879 __distance_from(
const _Iterator<_Const2>& __i)
const
1880 {
return _M_end - __i._M_current; }
1882 template<
bool _Const2>
1884 __equal(
const _Iterator<_Const2>& __i)
const
1885 {
return __i._M_current == _M_end; }
1887 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
1890 _Sentinel() =
default;
1893 _Sentinel(sentinel_t<_Base> __end)
1898 _Sentinel(_Sentinel<!_Const> __i)
1900 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
1904 constexpr sentinel_t<_Base>
1908 template<
bool _Const2>
1909 requires sentinel_for<sentinel_t<_Base>,
1910 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
1911 friend constexpr
bool
1912 operator==(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
1913 {
return __y.__equal(__x); }
1915 template<
bool _Const2,
1916 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
1917 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
1918 friend constexpr range_difference_t<_Base2>
1919 operator-(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
1920 {
return -__y.__distance_from(__x); }
1922 template<
bool _Const2,
1923 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
1924 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
1925 friend constexpr range_difference_t<_Base2>
1926 operator-(
const _Sentinel& __y,
const _Iterator<_Const2>& __x)
1927 {
return __y.__distance_from(__x); }
1929 friend _Sentinel<!_Const>;
1932 _Vp _M_base = _Vp();
1933 __detail::__box<_Fp> _M_fun;
1936 transform_view() =
default;
1939 transform_view(_Vp
__base, _Fp __fun)
1944 base() const& requires copy_constructible<_Vp>
1945 {
return _M_base ; }
1951 constexpr _Iterator<false>
1955 constexpr _Iterator<true>
1957 requires range<const _Vp>
1958 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
1961 constexpr _Sentinel<false>
1963 {
return _Sentinel<false>{
ranges::end(_M_base)}; }
1965 constexpr _Iterator<false>
1966 end() requires common_range<_Vp>
1967 {
return _Iterator<false>{
this,
ranges::end(_M_base)}; }
1969 constexpr _Sentinel<true>
1971 requires range<const _Vp>
1972 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
1975 constexpr _Iterator<true>
1977 requires common_range<const _Vp>
1978 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
1979 {
return _Iterator<true>{
this,
ranges::end(_M_base)}; }
1982 size() requires sized_range<_Vp>
1983 {
return ranges::size(_M_base); }
1986 size() const requires sized_range<const _Vp>
1987 {
return ranges::size(_M_base); }
1990 template<
typename _Range,
typename _Fp>
1991 transform_view(_Range&&, _Fp) -> transform_view<views::all_t<_Range>, _Fp>;
1995 inline constexpr __adaptor::_RangeAdaptor transform
1996 = [] <viewable_range _Range,
typename _Fp> (_Range&& __r, _Fp&& __f)
1998 return transform_view{std::forward<_Range>(__r), std::forward<_Fp>(__f)};
2003 class take_view :
public view_interface<take_view<_Vp>>
2006 template<
bool _Const>
2007 using _CI = counted_iterator<
2008 iterator_t<__detail::__maybe_const_t<_Const, _Vp>>>;
2010 template<
bool _Const>
2014 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2015 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2018 _Sentinel() =
default;
2021 _Sentinel(sentinel_t<_Base> __end)
2026 _Sentinel(_Sentinel<!_Const> __s)
2027 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2031 constexpr sentinel_t<_Base>
2035 friend constexpr
bool
2036 operator==(
const _CI<_Const>& __y,
const _Sentinel& __x)
2037 {
return __y.count() == 0 || __y.base() == __x._M_end; }
2039 template<
bool _OtherConst = !_Const,
2040 typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
2041 requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2042 friend constexpr
bool
2043 operator==(
const _CI<_OtherConst>& __y,
const _Sentinel& __x)
2044 {
return __y.count() == 0 || __y.base() == __x._M_end; }
2046 friend _Sentinel<!_Const>;
2049 _Vp _M_base = _Vp();
2050 range_difference_t<_Vp> _M_count = 0;
2053 take_view() =
default;
2056 take_view(_Vp base, range_difference_t<_Vp> __count)
2061 base() const& requires copy_constructible<_Vp>
2069 begin() requires (!__detail::__simple_view<_Vp>)
2071 if constexpr (sized_range<_Vp>)
2073 if constexpr (random_access_range<_Vp>)
2086 begin() const requires range<const _Vp>
2088 if constexpr (sized_range<const _Vp>)
2090 if constexpr (random_access_range<const _Vp>)
2103 end() requires (!__detail::__simple_view<_Vp>)
2105 if constexpr (sized_range<_Vp>)
2107 if constexpr (random_access_range<_Vp>)
2110 return default_sentinel;
2117 end() const requires range<const _Vp>
2119 if constexpr (sized_range<const _Vp>)
2121 if constexpr (random_access_range<const _Vp>)
2124 return default_sentinel;
2131 size() requires sized_range<_Vp>
2133 auto __n = ranges::size(_M_base);
2134 return std::min(__n,
static_cast<decltype(__n)
>(_M_count));
2138 size() const requires sized_range<const _Vp>
2140 auto __n = ranges::size(_M_base);
2141 return std::min(__n,
static_cast<decltype(__n)
>(_M_count));
2148 template<
typename _Range>
2149 take_view(_Range&&, range_difference_t<_Range>)
2150 -> take_view<views::all_t<_Range>>;
2152 template<
typename _Tp>
2153 inline constexpr
bool enable_borrowed_range<take_view<_Tp>>
2154 = enable_borrowed_range<_Tp>;
2158 inline constexpr __adaptor::_RangeAdaptor take
2159 = [] <viewable_range _Range,
typename _Tp> (_Range&& __r, _Tp&& __n)
2161 return take_view{std::forward<_Range>(__r), std::forward<_Tp>(__n)};
2165 template<view _Vp,
typename _Pred>
2166 requires input_range<_Vp> && is_object_v<_Pred>
2167 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2168 class take_while_view :
public view_interface<take_while_view<_Vp, _Pred>>
2170 template<
bool _Const>
2174 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2176 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2177 const _Pred* _M_pred =
nullptr;
2180 _Sentinel() =
default;
2183 _Sentinel(sentinel_t<_Base> __end,
const _Pred* __pred)
2184 : _M_end(__end), _M_pred(__pred)
2188 _Sentinel(_Sentinel<!_Const> __s)
2189 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2190 : _M_end(__s._M_end), _M_pred(__s._M_pred)
2193 constexpr sentinel_t<_Base>
2194 base()
const {
return _M_end; }
2196 friend constexpr
bool
2197 operator==(
const iterator_t<_Base>& __x,
const _Sentinel& __y)
2198 {
return __y._M_end == __x || !
std::__invoke(*__y._M_pred, *__x); }
2200 template<
bool _OtherConst = !_Const,
2201 typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
2202 requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2203 friend constexpr
bool
2204 operator==(
const iterator_t<_Base2>& __x,
const _Sentinel& __y)
2205 {
return __y._M_end == __x || !
std::__invoke(*__y._M_pred, *__x); }
2207 friend _Sentinel<!_Const>;
2210 _Vp _M_base = _Vp();
2211 __detail::__box<_Pred> _M_pred;
2214 take_while_view() =
default;
2217 take_while_view(_Vp base, _Pred __pred)
2223 base() const& requires copy_constructible<_Vp>
2230 constexpr
const _Pred&
2232 {
return *_M_pred; }
2235 begin() requires (!__detail::__simple_view<_Vp>)
2239 begin() const requires range<const _Vp>
2240 && indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
2244 end() requires (!__detail::__simple_view<_Vp>)
2249 end() const requires range<const _Vp>
2250 && indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
2255 template<
typename _Range,
typename _Pred>
2256 take_while_view(_Range&&, _Pred)
2257 -> take_while_view<views::all_t<_Range>, _Pred>;
2261 inline constexpr __adaptor::_RangeAdaptor take_while
2262 = [] <viewable_range _Range,
typename _Pred> (_Range&& __r, _Pred&& __p)
2264 return take_while_view{std::forward<_Range>(__r), std::forward<_Pred>(__p)};
2269 class drop_view :
public view_interface<drop_view<_Vp>>
2272 _Vp _M_base = _Vp();
2273 range_difference_t<_Vp> _M_count = 0;
2277 static constexpr
bool _S_needs_cached_begin
2278 = !(random_access_range<const _Vp> && sized_range<const _Vp>);
2279 [[no_unique_address]]
2280 __detail::__maybe_present_t<_S_needs_cached_begin,
2281 __detail::_CachedPosition<_Vp>>
2285 drop_view() =
default;
2288 drop_view(_Vp
__base, range_difference_t<_Vp> __count)
2290 { __glibcxx_assert(__count >= 0); }
2293 base() const& requires copy_constructible<_Vp>
2303 requires (!(__detail::__simple_view<_Vp>
2304 && random_access_range<const _Vp>
2305 && sized_range<const _Vp>))
2307 if constexpr (_S_needs_cached_begin)
2308 if (_M_cached_begin._M_has_value())
2309 return _M_cached_begin._M_get(_M_base);
2313 if constexpr (_S_needs_cached_begin)
2314 _M_cached_begin._M_set(_M_base, __it);
2322 requires random_access_range<const _Vp> && sized_range<const _Vp>
2329 end() requires (!__detail::__simple_view<_Vp>)
2333 end() const requires range<const _Vp>
2337 size() requires sized_range<_Vp>
2339 const auto __s = ranges::size(_M_base);
2340 const auto __c =
static_cast<decltype(__s)
>(_M_count);
2341 return __s < __c ? 0 : __s - __c;
2345 size() const requires sized_range<const _Vp>
2347 const auto __s = ranges::size(_M_base);
2348 const auto __c =
static_cast<decltype(__s)
>(_M_count);
2349 return __s < __c ? 0 : __s - __c;
2353 template<
typename _Range>
2354 drop_view(_Range&&, range_difference_t<_Range>)
2355 -> drop_view<views::all_t<_Range>>;
2357 template<
typename _Tp>
2358 inline constexpr
bool enable_borrowed_range<drop_view<_Tp>>
2359 = enable_borrowed_range<_Tp>;
2363 inline constexpr __adaptor::_RangeAdaptor drop
2364 = [] <viewable_range _Range,
typename _Tp> (_Range&& __r, _Tp&& __n)
2366 return drop_view{std::forward<_Range>(__r), std::forward<_Tp>(__n)};
2370 template<view _Vp,
typename _Pred>
2371 requires input_range<_Vp> && is_object_v<_Pred>
2372 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2373 class drop_while_view :
public view_interface<drop_while_view<_Vp, _Pred>>
2376 _Vp _M_base = _Vp();
2377 __detail::__box<_Pred> _M_pred;
2378 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
2381 drop_while_view() =
default;
2384 drop_while_view(_Vp
__base, _Pred __pred)
2389 base() const& requires copy_constructible<_Vp>
2396 constexpr
const _Pred&
2398 {
return *_M_pred; }
2403 if (_M_cached_begin._M_has_value())
2404 return _M_cached_begin._M_get(_M_base);
2406 __glibcxx_assert(_M_pred.has_value());
2409 std::cref(*_M_pred));
2410 _M_cached_begin._M_set(_M_base, __it);
2419 template<
typename _Range,
typename _Pred>
2420 drop_while_view(_Range&&, _Pred)
2421 -> drop_while_view<views::all_t<_Range>, _Pred>;
2423 template<
typename _Tp,
typename _Pred>
2424 inline constexpr
bool enable_borrowed_range<drop_while_view<_Tp, _Pred>>
2425 = enable_borrowed_range<_Tp>;
2429 inline constexpr __adaptor::_RangeAdaptor drop_while
2430 = [] <viewable_range _Range,
typename _Pred> (_Range&& __r, _Pred&& __p)
2432 return drop_while_view{std::forward<_Range>(__r),
2433 std::forward<_Pred>(__p)};
2437 template<input_range _Vp>
2438 requires view<_Vp> && input_range<range_reference_t<_Vp>>
2439 && (is_reference_v<range_reference_t<_Vp>>
2440 || view<range_value_t<_Vp>>)
2441 class join_view :
public view_interface<join_view<_Vp>>
2444 using _InnerRange = range_reference_t<_Vp>;
2446 template<
bool _Const>
2447 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2449 template<
bool _Const>
2450 using _Outer_iter = iterator_t<_Base<_Const>>;
2452 template<
bool _Const>
2453 using _Inner_iter = iterator_t<range_reference_t<_Base<_Const>>>;
2455 template<
bool _Const>
2456 static constexpr
bool _S_ref_is_glvalue
2457 = is_reference_v<range_reference_t<_Base<_Const>>>;
2459 template<
bool _Const>
2463 template<
bool _Const>
2464 requires _S_ref_is_glvalue<_Const>
2465 && forward_range<_Base<_Const>>
2466 && forward_range<range_reference_t<_Base<_Const>>>
2467 struct __iter_cat<_Const>
2470 static constexpr
auto
2473 using _Outer_iter = join_view::_Outer_iter<_Const>;
2474 using _Inner_iter = join_view::_Inner_iter<_Const>;
2475 using _OuterCat =
typename iterator_traits<_Outer_iter>::iterator_category;
2476 using _InnerCat =
typename iterator_traits<_Inner_iter>::iterator_category;
2477 if constexpr (derived_from<_OuterCat, bidirectional_iterator_tag>
2478 && derived_from<_InnerCat, bidirectional_iterator_tag>)
2479 return bidirectional_iterator_tag{};
2480 else if constexpr (derived_from<_OuterCat, forward_iterator_tag>
2481 && derived_from<_InnerCat, forward_iterator_tag>)
2482 return forward_iterator_tag{};
2484 return input_iterator_tag{};
2487 using iterator_category = decltype(_S_iter_cat());
2490 template<
bool _Const>
2493 template<
bool _Const>
2494 struct _Iterator : __iter_cat<_Const>
2497 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
2498 using _Base = join_view::_Base<_Const>;
2500 static constexpr
bool _S_ref_is_glvalue
2501 = join_view::_S_ref_is_glvalue<_Const>;
2506 auto __update_inner = [
this] (range_reference_t<_Base> __x) ->
auto&
2508 if constexpr (_S_ref_is_glvalue)
2511 return (_M_parent->_M_inner = views::all(
std::move(__x)));
2514 for (; _M_outer !=
ranges::end(_M_parent->_M_base); ++_M_outer)
2516 auto& __inner = __update_inner(*_M_outer);
2522 if constexpr (_S_ref_is_glvalue)
2523 _M_inner = _Inner_iter();
2526 static constexpr
auto
2529 if constexpr (_S_ref_is_glvalue
2530 && bidirectional_range<_Base>
2531 && bidirectional_range<range_reference_t<_Base>>)
2532 return bidirectional_iterator_tag{};
2533 else if constexpr (_S_ref_is_glvalue
2534 && forward_range<_Base>
2535 && forward_range<range_reference_t<_Base>>)
2536 return forward_iterator_tag{};
2538 return input_iterator_tag{};
2541 using _Outer_iter = join_view::_Outer_iter<_Const>;
2542 using _Inner_iter = join_view::_Inner_iter<_Const>;
2544 _Outer_iter _M_outer = _Outer_iter();
2545 _Inner_iter _M_inner = _Inner_iter();
2546 _Parent* _M_parent =
nullptr;
2549 using iterator_concept = decltype(_S_iter_concept());
2551 using value_type = range_value_t<range_reference_t<_Base>>;
2552 using difference_type
2553 = common_type_t<range_difference_t<_Base>,
2554 range_difference_t<range_reference_t<_Base>>>;
2556 _Iterator() =
default;
2559 _Iterator(_Parent* __parent, _Outer_iter __outer)
2560 : _M_outer(
std::
move(__outer)),
2565 _Iterator(_Iterator<!_Const> __i)
2567 && convertible_to<iterator_t<_Vp>, _Outer_iter>
2568 && convertible_to<iterator_t<_InnerRange>, _Inner_iter>
2570 _M_parent(__i._M_parent)
2573 constexpr decltype(
auto)
2575 {
return *_M_inner; }
2579 constexpr _Inner_iter
2581 requires __detail::__has_arrow<_Inner_iter>
2582 && copyable<_Inner_iter>
2583 {
return _M_inner; }
2585 constexpr _Iterator&
2588 auto&& __inner_range = [
this] () ->
auto&& {
2589 if constexpr (_S_ref_is_glvalue)
2592 return _M_parent->_M_inner;
2608 requires _S_ref_is_glvalue && forward_range<_Base>
2609 && forward_range<range_reference_t<_Base>>
2616 constexpr _Iterator&
2618 requires _S_ref_is_glvalue && bidirectional_range<_Base>
2619 && bidirectional_range<range_reference_t<_Base>>
2620 && common_range<range_reference_t<_Base>>
2632 requires _S_ref_is_glvalue && bidirectional_range<_Base>
2633 && bidirectional_range<range_reference_t<_Base>>
2634 && common_range<range_reference_t<_Base>>
2641 friend constexpr
bool
2642 operator==(
const _Iterator& __x,
const _Iterator& __y)
2643 requires _S_ref_is_glvalue
2644 && equality_comparable<_Outer_iter>
2645 && equality_comparable<_Inner_iter>
2647 return (__x._M_outer == __y._M_outer
2648 && __x._M_inner == __y._M_inner);
2651 friend constexpr decltype(
auto)
2652 iter_move(const _Iterator& __i)
2653 noexcept(noexcept(ranges::iter_move(__i._M_inner)))
2654 {
return ranges::iter_move(__i._M_inner); }
2656 friend constexpr
void
2657 iter_swap(
const _Iterator& __x,
const _Iterator& __y)
2658 noexcept(noexcept(ranges::iter_swap(__x._M_inner, __y._M_inner)))
2659 requires indirectly_swappable<_Inner_iter>
2660 {
return ranges::iter_swap(__x._M_inner, __y._M_inner); }
2662 friend _Iterator<!_Const>;
2663 template<
bool>
friend struct _Sentinel;
2666 template<
bool _Const>
2670 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
2671 using _Base = join_view::_Base<_Const>;
2673 template<
bool _Const2>
2675 __equal(
const _Iterator<_Const2>& __i)
const
2676 {
return __i._M_outer == _M_end; }
2678 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2681 _Sentinel() =
default;
2684 _Sentinel(_Parent* __parent)
2685 : _M_end(ranges::
end(__parent->_M_base))
2689 _Sentinel(_Sentinel<!_Const> __s)
2690 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2694 template<
bool _Const2>
2695 requires sentinel_for<sentinel_t<_Base>,
2696 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
2697 friend constexpr
bool
2698 operator==(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
2699 {
return __y.__equal(__x); }
2701 friend _Sentinel<!_Const>;
2704 _Vp _M_base = _Vp();
2707 [[no_unique_address]]
2708 __detail::__maybe_present_t<!is_reference_v<_InnerRange>,
2709 views::all_t<_InnerRange>> _M_inner;
2712 join_view() =
default;
2720 base() const& requires copy_constructible<_Vp>
2730 constexpr
bool __use_const
2731 = (__detail::__simple_view<_Vp>
2732 && is_reference_v<range_reference_t<_Vp>>);
2733 return _Iterator<__use_const>{
this,
ranges::begin(_M_base)};
2738 requires input_range<const _Vp>
2739 && is_reference_v<range_reference_t<const _Vp>>
2747 if constexpr (forward_range<_Vp> && is_reference_v<_InnerRange>
2748 && forward_range<_InnerRange>
2749 && common_range<_Vp> && common_range<_InnerRange>)
2750 return _Iterator<__detail::__simple_view<_Vp>>{
this,
2753 return _Sentinel<__detail::__simple_view<_Vp>>{
this};
2758 requires input_range<const _Vp>
2759 && is_reference_v<range_reference_t<const _Vp>>
2761 if constexpr (forward_range<const _Vp>
2762 && is_reference_v<range_reference_t<const _Vp>>
2763 && forward_range<range_reference_t<const _Vp>>
2764 && common_range<const _Vp>
2765 && common_range<range_reference_t<const _Vp>>)
2766 return _Iterator<true>{
this,
ranges::end(_M_base)};
2768 return _Sentinel<true>{
this};
2772 template<
typename _Range>
2773 explicit join_view(_Range&&) -> join_view<views::all_t<_Range>>;
2777 inline constexpr __adaptor::_RangeAdaptorClosure join
2778 = [] <viewable_range _Range> (_Range&& __r)
2782 return join_view<views::all_t<_Range>>{std::forward<_Range>(__r)};
2789 struct __require_constant;
2791 template<
typename _Range>
2792 concept __tiny_range = sized_range<_Range>
2794 {
typename __require_constant<remove_reference_t<_Range>::size()>; }
2795 && (remove_reference_t<_Range>::size() <= 1);
2797 template<
typename _Base>
2798 struct __split_view_outer_iter_cat
2801 template<forward_range _Base>
2802 struct __split_view_outer_iter_cat<_Base>
2803 {
using iterator_category = input_iterator_tag; };
2805 template<
typename _Base>
2806 struct __split_view_inner_iter_cat
2809 template<forward_range _Base>
2810 struct __split_view_inner_iter_cat<_Base>
2813 static constexpr
auto
2816 using _Cat =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
2817 if constexpr (derived_from<_Cat, forward_iterator_tag>)
2818 return forward_iterator_tag{};
2823 using iterator_category = decltype(_S_iter_cat());
2827 template<input_range _Vp, forward_range _Pattern>
2828 requires view<_Vp> && view<_Pattern>
2829 && indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
2831 && (forward_range<_Vp> || __detail::__tiny_range<_Pattern>)
2832 class split_view :
public view_interface<split_view<_Vp, _Pattern>>
2835 template<
bool _Const>
2836 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2838 template<
bool _Const>
2841 template<
bool _Const>
2843 : __detail::__split_view_outer_iter_cat<_Base<_Const>>
2846 using _Parent = __detail::__maybe_const_t<_Const, split_view>;
2847 using _Base = split_view::_Base<_Const>;
2851 {
return __current() ==
ranges::end(_M_parent->_M_base); }
2858 __current() noexcept
2860 if constexpr (forward_range<_Vp>)
2863 return _M_parent->_M_current;
2867 __current() const noexcept
2869 if constexpr (forward_range<_Vp>)
2872 return _M_parent->_M_current;
2875 _Parent* _M_parent =
nullptr;
2878 [[no_unique_address]]
2879 __detail::__maybe_present_t<forward_range<_Vp>,
2880 iterator_t<_Base>> _M_current;
2883 using iterator_concept = conditional_t<forward_range<_Base>,
2884 forward_iterator_tag,
2885 input_iterator_tag>;
2887 using difference_type = range_difference_t<_Base>;
2889 struct value_type : view_interface<value_type>
2892 _OuterIter _M_i = _OuterIter();
2895 value_type() =
default;
2898 value_type(_OuterIter __i)
2902 constexpr _InnerIter<_Const>
2904 {
return _InnerIter<_Const>{_M_i}; }
2906 constexpr default_sentinel_t
2908 {
return default_sentinel; }
2911 _OuterIter() =
default;
2914 _OuterIter(_Parent* __parent) requires (!forward_range<_Base>)
2915 : _M_parent(__parent)
2919 _OuterIter(_Parent* __parent, iterator_t<_Base> __current)
2920 requires forward_range<_Base>
2921 : _M_parent(__parent),
2926 _OuterIter(_OuterIter<!_Const> __i)
2928 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
2929 : _M_parent(__i._M_parent), _M_current(
std::move(__i._M_current))
2932 constexpr value_type
2934 {
return value_type{*
this}; }
2936 constexpr _OuterIter&
2941 const auto __end =
ranges::end(_M_parent->_M_base);
2942 if (__current() == __end)
2944 const auto [__pbegin, __pend] = subrange{_M_parent->_M_pattern};
2945 if (__pbegin == __pend)
2947 else if constexpr (__detail::__tiny_range<_Pattern>)
2949 __current() = __detail::find(
std::move(__current()), __end,
2951 if (__current() != __end)
2958 = __detail::mismatch(__current(), __end, __pbegin, __pend);
2964 }
while (++__current() != __end);
2968 constexpr decltype(
auto)
2971 if constexpr (forward_range<_Base>)
2981 friend constexpr
bool
2982 operator==(
const _OuterIter& __x,
const _OuterIter& __y)
2983 requires forward_range<_Base>
2984 {
return __x._M_current == __y._M_current; }
2986 friend constexpr
bool
2987 operator==(
const _OuterIter& __x, default_sentinel_t)
2988 {
return __x.__at_end(); };
2990 friend _OuterIter<!_Const>;
2991 friend _InnerIter<_Const>;
2994 template<
bool _Const>
2996 : __detail::__split_view_inner_iter_cat<_Base<_Const>>
2999 using _Base = split_view::_Base<_Const>;
3004 auto [__pcur, __pend] = subrange{_M_i._M_parent->_M_pattern};
3005 auto __end =
ranges::end(_M_i._M_parent->_M_base);
3006 if constexpr (__detail::__tiny_range<_Pattern>)
3008 const auto& __cur = _M_i_current();
3011 if (__pcur == __pend)
3012 return _M_incremented;
3013 return *__cur == *__pcur;
3017 auto __cur = _M_i_current();
3020 if (__pcur == __pend)
3021 return _M_incremented;
3024 if (*__cur != *__pcur)
3026 if (++__pcur == __pend)
3028 }
while (++__cur != __end);
3034 _M_i_current() noexcept
3035 {
return _M_i.__current(); }
3038 _M_i_current() const noexcept
3039 {
return _M_i.__current(); }
3041 _OuterIter<_Const> _M_i = _OuterIter<_Const>();
3042 bool _M_incremented =
false;
3045 using iterator_concept
3046 =
typename _OuterIter<_Const>::iterator_concept;
3048 using value_type = range_value_t<_Base>;
3049 using difference_type = range_difference_t<_Base>;
3051 _InnerIter() =
default;
3054 _InnerIter(_OuterIter<_Const> __i)
3058 constexpr
const iterator_t<_Base>&
3059 base() const& noexcept
3060 {
return _M_i_current(); }
3062 constexpr iterator_t<_Base>
3066 constexpr decltype(
auto)
3068 {
return *_M_i_current(); }
3070 constexpr _InnerIter&
3073 _M_incremented =
true;
3074 if constexpr (!forward_range<_Base>)
3075 if constexpr (_Pattern::size() == 0)
3081 constexpr decltype(auto)
3084 if constexpr (forward_range<_Base>)
3094 friend constexpr
bool
3095 operator==(
const _InnerIter& __x,
const _InnerIter& __y)
3096 requires forward_range<_Base>
3097 {
return __x._M_i == __y._M_i; }
3099 friend constexpr
bool
3100 operator==(
const _InnerIter& __x, default_sentinel_t)
3101 {
return __x.__at_end(); }
3103 friend constexpr decltype(
auto)
3104 iter_move(const _InnerIter& __i)
3105 noexcept(noexcept(ranges::iter_move(__i._M_i_current())))
3106 {
return ranges::iter_move(__i._M_i_current()); }
3108 friend constexpr
void
3109 iter_swap(
const _InnerIter& __x,
const _InnerIter& __y)
3110 noexcept(noexcept(ranges::iter_swap(__x._M_i_current(),
3111 __y._M_i_current())))
3112 requires indirectly_swappable<iterator_t<_Base>>
3113 { ranges::iter_swap(__x._M_i_current(), __y._M_i_current()); }
3116 _Vp _M_base = _Vp();
3117 _Pattern _M_pattern = _Pattern();
3120 [[no_unique_address]]
3121 __detail::__maybe_present_t<!forward_range<_Vp>, iterator_t<_Vp>>
3126 split_view() =
default;
3129 split_view(_Vp
__base, _Pattern __pattern)
3133 template<input_range _Range>
3134 requires constructible_from<_Vp, views::all_t<_Range>>
3135 && constructible_from<_Pattern, single_view<range_value_t<_Range>>>
3137 split_view(_Range&& __r, range_value_t<_Range> __e)
3138 : _M_base(views::all(
std::
forward<_Range>(__r))),
3143 base() const& requires copy_constructible<_Vp>
3153 if constexpr (forward_range<_Vp>)
3154 return _OuterIter<__detail::__simple_view<_Vp>>{
3159 return _OuterIter<false>{
this};
3164 begin() const requires forward_range<_Vp> && forward_range<const _Vp>
3170 end() requires forward_range<_Vp> && common_range<_Vp>
3172 return _OuterIter<__detail::__simple_view<_Vp>>{
3179 if constexpr (forward_range<_Vp>
3180 && forward_range<const _Vp>
3181 && common_range<const _Vp>)
3182 return _OuterIter<true>{
this,
ranges::end(_M_base)};
3184 return default_sentinel;
3188 template<
typename _Range,
typename _Pred>
3189 split_view(_Range&&, _Pred&&)
3190 -> split_view<views::all_t<_Range>, views::all_t<_Pred>>;
3192 template<input_range _Range>
3193 split_view(_Range&&, range_value_t<_Range>)
3194 -> split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
3198 inline constexpr __adaptor::_RangeAdaptor split
3199 = [] <viewable_range _Range,
typename _Fp> (_Range&& __r, _Fp&& __f)
3201 return split_view{std::forward<_Range>(__r), std::forward<_Fp>(__f)};
3209 template<input_or_output_iterator _Iter>
3211 operator()(_Iter __i, iter_difference_t<_Iter> __n)
const
3213 if constexpr (random_access_iterator<_Iter>)
3214 return subrange{__i, __i + __n};
3216 return subrange{counted_iterator{
std::move(__i), __n},
3221 inline constexpr _Counted counted{};
3225 requires (!common_range<_Vp>) && copyable<iterator_t<_Vp>>
3226 class common_view :
public view_interface<common_view<_Vp>>
3229 _Vp _M_base = _Vp();
3232 common_view() =
default;
3235 common_view(_Vp __r)
3250 base() const& requires copy_constructible<_Vp>
3260 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3263 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
3268 begin() const requires range<const _Vp>
3270 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
3273 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
3280 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3283 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
3288 end() const requires range<const _Vp>
3290 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
3293 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
3298 size() requires sized_range<_Vp>
3299 {
return ranges::size(_M_base); }
3302 size() const requires sized_range<const _Vp>
3303 {
return ranges::size(_M_base); }
3306 template<
typename _Range>
3307 common_view(_Range&&) -> common_view<views::all_t<_Range>>;
3309 template<
typename _Tp>
3310 inline constexpr
bool enable_borrowed_range<common_view<_Tp>>
3311 = enable_borrowed_range<_Tp>;
3315 inline constexpr __adaptor::_RangeAdaptorClosure common
3316 = [] <viewable_range _Range> (_Range&& __r)
3318 if constexpr (common_range<_Range>
3319 && requires { views::all(std::forward<_Range>(__r)); })
3320 return views::all(std::forward<_Range>(__r));
3322 return common_view{std::forward<_Range>(__r)};
3328 requires bidirectional_range<_Vp>
3329 class reverse_view :
public view_interface<reverse_view<_Vp>>
3332 _Vp _M_base = _Vp();
3334 static constexpr
bool _S_needs_cached_begin
3335 = !common_range<_Vp> && !random_access_range<_Vp>;
3336 [[no_unique_address]]
3337 __detail::__maybe_present_t<_S_needs_cached_begin,
3338 __detail::_CachedPosition<_Vp>>
3342 reverse_view() =
default;
3345 reverse_view(_Vp __r)
3350 base() const& requires copy_constructible<_Vp>
3357 constexpr reverse_iterator<iterator_t<_Vp>>
3360 if constexpr (_S_needs_cached_begin)
3361 if (_M_cached_begin._M_has_value())
3365 if constexpr (_S_needs_cached_begin)
3366 _M_cached_begin._M_set(_M_base, __it);
3371 begin() requires common_range<_Vp>
3375 begin() const requires common_range<const _Vp>
3378 constexpr reverse_iterator<iterator_t<_Vp>>
3383 end() const requires common_range<const _Vp>
3387 size() requires sized_range<_Vp>
3388 {
return ranges::size(_M_base); }
3391 size() const requires sized_range<const _Vp>
3392 {
return ranges::size(_M_base); }
3395 template<
typename _Range>
3396 reverse_view(_Range&&) -> reverse_view<views::all_t<_Range>>;
3398 template<
typename _Tp>
3399 inline constexpr
bool enable_borrowed_range<reverse_view<_Tp>>
3400 = enable_borrowed_range<_Tp>;
3407 inline constexpr
bool __is_reversible_subrange =
false;
3409 template<
typename _Iter, subrange_kind _Kind>
3410 inline constexpr
bool
3411 __is_reversible_subrange<subrange<reverse_iterator<_Iter>,
3412 reverse_iterator<_Iter>,
3416 inline constexpr
bool __is_reverse_view =
false;
3418 template<
typename _Vp>
3419 inline constexpr
bool __is_reverse_view<reverse_view<_Vp>> =
true;
3422 inline constexpr __adaptor::_RangeAdaptorClosure reverse
3423 = [] <viewable_range _Range> (_Range&& __r)
3425 using _Tp = remove_cvref_t<_Range>;
3426 if constexpr (__detail::__is_reverse_view<_Tp>)
3427 return std::forward<_Range>(__r).base();
3428 else if constexpr (__detail::__is_reversible_subrange<_Tp>)
3431 if constexpr (sized_range<_Tp>)
3432 return subrange<_Iter, _Iter, subrange_kind::sized>
3433 (__r.end().base(), __r.begin().base(), __r.size());
3435 return subrange<_Iter, _Iter, subrange_kind::unsized>
3436 (__r.end().base(), __r.begin().base());
3439 return reverse_view{std::forward<_Range>(__r)};
3445 template<
typename _Tp,
size_t _Nm>
3446 concept __has_tuple_element = requires(_Tp __t)
3448 typename tuple_size<_Tp>::type;
3449 requires _Nm < tuple_size_v<_Tp>;
3450 typename tuple_element_t<_Nm, _Tp>;
3451 { std::get<_Nm>(__t) }
3452 -> convertible_to<const tuple_element_t<_Nm, _Tp>&>;
3455 template<
typename _Tp,
size_t _Nm>
3456 concept __returnable_element
3457 = is_reference_v<_Tp> || move_constructible<tuple_element_t<_Nm, _Tp>>;
3460 template<input_range _Vp,
size_t _Nm>
3462 && __detail::__has_tuple_element<range_value_t<_Vp>, _Nm>
3463 && __detail::__has_tuple_element<remove_reference_t<range_reference_t<_Vp>>,
3465 && __detail::__returnable_element<range_reference_t<_Vp>, _Nm>
3466 class elements_view :
public view_interface<elements_view<_Vp, _Nm>>
3469 elements_view() =
default;
3472 elements_view(_Vp base)
3477 base() const& requires copy_constructible<_Vp>
3485 begin() requires (!__detail::__simple_view<_Vp>)
3489 begin() const requires range<const _Vp>
3493 end() requires (!__detail::__simple_view<_Vp> && !common_range<_Vp>)
3494 {
return _Sentinel<false>{
ranges::end(_M_base)}; }
3497 end() requires (!__detail::__simple_view<_Vp> && common_range<_Vp>)
3498 {
return _Iterator<false>{
ranges::end(_M_base)}; }
3501 end() const requires range<const _Vp>
3505 end() const requires common_range<const _Vp>
3509 size() requires sized_range<_Vp>
3510 {
return ranges::size(_M_base); }
3513 size() const requires sized_range<const _Vp>
3514 {
return ranges::size(_M_base); }
3517 template<
bool _Const>
3518 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
3520 template<
bool _Const>
3524 template<
bool _Const>
3525 requires forward_range<_Base<_Const>>
3526 struct __iter_cat<_Const>
3529 static auto _S_iter_cat()
3531 using _Base = elements_view::_Base<_Const>;
3532 using _Cat =
typename iterator_traits<iterator_t<_Base>>::iterator_category;
3533 using _Res = decltype((std::get<_Nm>(*std::declval<iterator_t<_Base>>())));
3534 if constexpr (!is_lvalue_reference_v<_Res>)
3535 return input_iterator_tag{};
3536 else if constexpr (derived_from<_Cat, random_access_iterator_tag>)
3537 return random_access_iterator_tag{};
3542 using iterator_category = decltype(_S_iter_cat());
3545 template<
bool _Const>
3548 template<
bool _Const>
3549 struct _Iterator : __iter_cat<_Const>
3552 using _Base = elements_view::_Base<_Const>;
3554 iterator_t<_Base> _M_current = iterator_t<_Base>();
3556 static constexpr decltype(
auto)
3557 _S_get_element(const iterator_t<_Base>& __i)
3559 if constexpr (is_reference_v<range_reference_t<_Base>>)
3560 return
std::get<_Nm>(*__i);
3563 using _Et = remove_cv_t<tuple_element_t<_Nm, range_reference_t<_Base>>>;
3564 return static_cast<_Et
>(std::get<_Nm>(*__i));
3571 if constexpr (random_access_range<_Base>)
3572 return random_access_iterator_tag{};
3573 else if constexpr (bidirectional_range<_Base>)
3574 return bidirectional_iterator_tag{};
3575 else if constexpr (forward_range<_Base>)
3576 return forward_iterator_tag{};
3578 return input_iterator_tag{};
3581 friend _Iterator<!_Const>;
3584 using iterator_concept = decltype(_S_iter_concept());
3587 = remove_cvref_t<tuple_element_t<_Nm, range_value_t<_Base>>>;
3588 using difference_type = range_difference_t<_Base>;
3590 _Iterator() =
default;
3593 _Iterator(iterator_t<_Base> current)
3594 : _M_current(
std::
move(current))
3598 _Iterator(_Iterator<!_Const> i)
3599 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
3603 constexpr
const iterator_t<_Base>&
3604 base() const& noexcept
3605 {
return _M_current; }
3607 constexpr iterator_t<_Base>
3611 constexpr decltype(
auto)
3613 {
return _S_get_element(_M_current); }
3615 constexpr _Iterator&
3627 operator++(
int) requires forward_range<_Base>
3634 constexpr _Iterator&
3635 operator--() requires bidirectional_range<_Base>
3642 operator--(
int) requires bidirectional_range<_Base>
3649 constexpr _Iterator&
3650 operator+=(difference_type __n)
3651 requires random_access_range<_Base>
3657 constexpr _Iterator&
3658 operator-=(difference_type __n)
3659 requires random_access_range<_Base>
3665 constexpr decltype(
auto)
3666 operator[](difference_type __n) const
3667 requires random_access_range<_Base>
3668 {
return _S_get_element(_M_current + __n); }
3670 friend constexpr
bool
3671 operator==(
const _Iterator& __x,
const _Iterator& __y)
3672 requires equality_comparable<iterator_t<_Base>>
3673 {
return __x._M_current == __y._M_current; }
3675 friend constexpr
bool
3676 operator<(
const _Iterator& __x,
const _Iterator& __y)
3677 requires random_access_range<_Base>
3678 {
return __x._M_current < __y._M_current; }
3680 friend constexpr
bool
3681 operator>(
const _Iterator& __x,
const _Iterator& __y)
3682 requires random_access_range<_Base>
3683 {
return __y._M_current < __x._M_current; }
3685 friend constexpr
bool
3686 operator<=(
const _Iterator& __x,
const _Iterator& __y)
3687 requires random_access_range<_Base>
3688 {
return !(__y._M_current > __x._M_current); }
3690 friend constexpr
bool
3691 operator>=(
const _Iterator& __x,
const _Iterator& __y)
3692 requires random_access_range<_Base>
3693 {
return !(__x._M_current > __y._M_current); }
3695 #ifdef __cpp_lib_three_way_comparison
3696 friend constexpr
auto
3697 operator<=>(
const _Iterator& __x,
const _Iterator& __y)
3698 requires random_access_range<_Base>
3699 && three_way_comparable<iterator_t<_Base>>
3700 {
return __x._M_current <=> __y._M_current; }
3703 friend constexpr _Iterator
3704 operator+(
const _Iterator& __x, difference_type __y)
3705 requires random_access_range<_Base>
3706 {
return _Iterator{__x} += __y; }
3708 friend constexpr _Iterator
3709 operator+(difference_type __x,
const _Iterator& __y)
3710 requires random_access_range<_Base>
3711 {
return __y + __x; }
3713 friend constexpr _Iterator
3714 operator-(
const _Iterator& __x, difference_type __y)
3715 requires random_access_range<_Base>
3716 {
return _Iterator{__x} -= __y; }
3720 friend constexpr difference_type
3721 operator-(
const _Iterator& __x,
const _Iterator& __y)
3722 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
3723 {
return __x._M_current - __y._M_current; }
3725 template <
bool>
friend struct _Sentinel;
3728 template<
bool _Const>
3732 template<
bool _Const2>
3734 _M_equal(
const _Iterator<_Const2>& __x)
const
3735 {
return __x._M_current == _M_end; }
3737 template<
bool _Const2>
3739 _M_distance_from(
const _Iterator<_Const2>& __i)
const
3740 {
return _M_end - __i._M_current; }
3742 using _Base = elements_view::_Base<_Const>;
3743 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
3746 _Sentinel() =
default;
3749 _Sentinel(sentinel_t<_Base> __end)
3754 _Sentinel(_Sentinel<!_Const> __other)
3756 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
3760 constexpr sentinel_t<_Base>
3764 template<
bool _Const2>
3765 requires sentinel_for<sentinel_t<_Base>,
3766 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
3767 friend constexpr
bool
3768 operator==(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
3769 {
return __y._M_equal(__x); }
3771 template<
bool _Const2,
3772 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
3773 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
3774 friend constexpr range_difference_t<_Base2>
3775 operator-(
const _Iterator<_Const2>& __x,
const _Sentinel& __y)
3776 {
return -__y._M_distance_from(__x); }
3778 template<
bool _Const2,
3779 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
3780 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
3781 friend constexpr range_difference_t<_Base2>
3782 operator-(
const _Sentinel& __x,
const _Iterator<_Const2>& __y)
3783 {
return __x._M_distance_from(__y); }
3785 friend _Sentinel<!_Const>;
3788 _Vp _M_base = _Vp();
3791 template<
typename _Tp,
size_t _Nm>
3792 inline constexpr
bool enable_borrowed_range<elements_view<_Tp, _Nm>>
3793 = enable_borrowed_range<_Tp>;
3795 template<
typename _Range>
3796 using keys_view = elements_view<views::all_t<_Range>, 0>;
3798 template<
typename _Range>
3799 using values_view = elements_view<views::all_t<_Range>, 1>;
3803 template<
size_t _Nm>
3804 inline constexpr __adaptor::_RangeAdaptorClosure elements
3805 = [] <viewable_range _Range> (_Range&& __r)
3807 using _El = elements_view<views::all_t<_Range>, _Nm>;
3808 return _El{std::forward<_Range>(__r)};
3811 inline constexpr __adaptor::_RangeAdaptorClosure keys = elements<0>;
3812 inline constexpr __adaptor::_RangeAdaptorClosure values = elements<1>;
3817 namespace views = ranges::views;
3819 template<
typename _Iter,
typename _Sent, ranges::subrange_kind _Kind>
3820 struct tuple_size<ranges::subrange<_Iter, _Sent, _Kind>>
3821 : integral_constant<size_t, 2>
3824 template<
typename _Iter,
typename _Sent, ranges::subrange_kind _Kind>
3825 struct tuple_element<0, ranges::subrange<_Iter, _Sent, _Kind>>
3826 {
using type = _Iter; };
3828 template<
typename _Iter,
typename _Sent, ranges::subrange_kind _Kind>
3829 struct tuple_element<1, ranges::subrange<_Iter, _Sent, _Kind>>
3830 {
using type = _Sent; };
3832 template<
typename _Iter,
typename _Sent, ranges::subrange_kind _Kind>
3833 struct tuple_element<0, const ranges::subrange<_Iter, _Sent, _Kind>>
3834 {
using type = _Iter; };
3836 template<
typename _Iter,
typename _Sent, ranges::subrange_kind _Kind>
3837 struct tuple_element<1, const ranges::subrange<_Iter, _Sent, _Kind>>
3838 {
using type = _Sent; };
3840 _GLIBCXX_END_NAMESPACE_VERSION
constexpr complex< _Tp > operator*(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x times y.
constexpr complex< _Tp > operator-(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x minus y.
constexpr complex< _Tp > operator+(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x plus y.
typename make_unsigned< _Tp >::type make_unsigned_t
Alias template for make_unsigned.
typename remove_const< _Tp >::type remove_const_t
Alias template for remove_const.
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
constexpr __invoke_result< _Callable, _Args... >::type __invoke(_Callable &&__fn, _Args &&... __args) noexcept(__is_nothrow_invocable< _Callable, _Args... >::value)
Invoke a callable object.
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
constexpr _Tp && forward(typename std::remove_reference< _Tp >::type &__t) noexcept
Forward an lvalue.
_Tp * end(valarray< _Tp > &__va) noexcept
Return an iterator pointing to one past the last element of the valarray.
_Tp * begin(valarray< _Tp > &__va) noexcept
Return an iterator pointing to the first element of the valarray.
constexpr const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
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 in_place_t in_place
Tag for in-place construction.
ISO C++ entities toplevel namespace is std.
constexpr iterator_traits< _InputIterator >::difference_type distance(_InputIterator __first, _InputIterator __last)
A generalization of pointer arithmetic.
bitset< _Nb > operator|(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
constexpr void advance(_InputIterator &__i, _Distance __n)
A generalization of pointer arithmetic.
constexpr _Iterator __base(_Iterator __it)