1 // <ranges> -*- C++ -*-
3 // Copyright (C) 2019-2021 Free Software Foundation, Inc.
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
25 /** @file include/ranges
26 * This is a Standard C++ Library header.
30 #ifndef _GLIBCXX_RANGES
31 #define _GLIBCXX_RANGES 1
33 #if __cplusplus > 201703L
35 #pragma GCC system_header
39 #if __cpp_lib_concepts
42 #include <initializer_list>
46 #include <bits/ranges_util.h>
47 #include <bits/refwrap.h>
50 * @defgroup ranges Ranges
52 * Components for dealing with ranges of elements.
55 namespace std _GLIBCXX_VISIBILITY(default)
57 _GLIBCXX_BEGIN_NAMESPACE_VERSION
60 // [range.access] customization point objects
61 // [range.req] range and view concepts
62 // [range.dangling] dangling iterator handling
63 // Defined in <bits/ranges_base.h>
65 // [view.interface] View interface
66 // [range.subrange] Sub-ranges
67 // Defined in <bits/ranges_util.h>
69 // C++20 24.6 [range.factories] Range factories
71 /// A view that contains no elements.
72 template<typename _Tp> requires is_object_v<_Tp>
74 : public view_interface<empty_view<_Tp>>
77 static constexpr _Tp* begin() noexcept { return nullptr; }
78 static constexpr _Tp* end() noexcept { return nullptr; }
79 static constexpr _Tp* data() noexcept { return nullptr; }
80 static constexpr size_t size() noexcept { return 0; }
81 static constexpr bool empty() noexcept { return true; }
84 template<typename _Tp>
85 inline constexpr bool enable_borrowed_range<empty_view<_Tp>> = true;
89 template<typename _Tp>
90 concept __boxable = copy_constructible<_Tp> && is_object_v<_Tp>;
92 template<__boxable _Tp>
93 struct __box : std::optional<_Tp>
95 using std::optional<_Tp>::optional;
99 noexcept(is_nothrow_default_constructible_v<_Tp>)
100 requires default_initializable<_Tp>
101 : std::optional<_Tp>{std::in_place}
104 __box(const __box&) = default;
105 __box(__box&&) = default;
107 using std::optional<_Tp>::operator=;
109 // _GLIBCXX_RESOLVE_LIB_DEFECTS
110 // 3477. Simplify constraints for semiregular-box
112 operator=(const __box& __that)
113 noexcept(is_nothrow_copy_constructible_v<_Tp>)
114 requires (!copyable<_Tp>)
117 this->emplace(*__that);
124 operator=(__box&& __that)
125 noexcept(is_nothrow_move_constructible_v<_Tp>)
126 requires (!movable<_Tp>)
129 this->emplace(std::move(*__that));
136 // For types which are already semiregular, this specialization of the
137 // semiregular wrapper stores the object directly without going through
138 // std::optional. It provides just the subset of the primary template's
139 // API that we currently use.
140 template<__boxable _Tp> requires semiregular<_Tp>
144 [[no_unique_address]] _Tp _M_value = _Tp();
150 __box(const _Tp& __t)
151 noexcept(is_nothrow_copy_constructible_v<_Tp>)
157 noexcept(is_nothrow_move_constructible_v<_Tp>)
158 : _M_value{std::move(__t)}
161 template<typename... _Args>
162 requires constructible_from<_Tp, _Args...>
164 __box(in_place_t, _Args&&... __args)
165 noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
166 : _M_value{std::forward<_Args>(__args)...}
170 has_value() const noexcept
178 operator*() const noexcept
182 operator->() noexcept
183 { return &_M_value; }
186 operator->() const noexcept
187 { return &_M_value; }
189 } // namespace __detail
191 /// A view that contains exactly one element.
192 template<copy_constructible _Tp> requires is_object_v<_Tp>
193 class single_view : public view_interface<single_view<_Tp>>
196 single_view() = default;
199 single_view(const _Tp& __t)
204 single_view(_Tp&& __t)
205 : _M_value(std::move(__t))
208 // _GLIBCXX_RESOLVE_LIB_DEFECTS
209 // 3428. single_view's in place constructor should be explicit
210 template<typename... _Args>
211 requires constructible_from<_Tp, _Args...>
213 single_view(in_place_t, _Args&&... __args)
214 : _M_value{in_place, std::forward<_Args>(__args)...}
222 begin() const noexcept
227 { return data() + 1; }
231 { return data() + 1; }
233 static constexpr size_t
239 { return _M_value.operator->(); }
242 data() const noexcept
243 { return _M_value.operator->(); }
246 [[no_unique_address]] __detail::__box<_Tp> _M_value;
249 template<typename _Tp>
250 single_view(_Tp) -> single_view<_Tp>;
254 template<typename _Wp>
255 constexpr auto __to_signed_like(_Wp __w) noexcept
257 if constexpr (!integral<_Wp>)
258 return iter_difference_t<_Wp>();
259 else if constexpr (sizeof(iter_difference_t<_Wp>) > sizeof(_Wp))
260 return iter_difference_t<_Wp>(__w);
261 else if constexpr (sizeof(ptrdiff_t) > sizeof(_Wp))
262 return ptrdiff_t(__w);
263 else if constexpr (sizeof(long long) > sizeof(_Wp))
264 return (long long)(__w);
265 #ifdef __SIZEOF_INT128__
266 else if constexpr (__SIZEOF_INT128__ > sizeof(_Wp))
267 return __int128(__w);
270 return __max_diff_type(__w);
273 template<typename _Wp>
274 using __iota_diff_t = decltype(__to_signed_like(std::declval<_Wp>()));
276 template<typename _It>
277 concept __decrementable = incrementable<_It>
280 { --__i } -> same_as<_It&>;
281 { __i-- } -> same_as<_It>;
284 template<typename _It>
285 concept __advanceable = __decrementable<_It> && totally_ordered<_It>
286 && requires( _It __i, const _It __j, const __iota_diff_t<_It> __n)
288 { __i += __n } -> same_as<_It&>;
289 { __i -= __n } -> same_as<_It&>;
293 { __j - __j } -> convertible_to<__iota_diff_t<_It>>;
296 template<typename _Winc>
297 struct __iota_view_iter_cat
300 template<incrementable _Winc>
301 struct __iota_view_iter_cat<_Winc>
302 { using iterator_category = input_iterator_tag; };
303 } // namespace __detail
305 template<weakly_incrementable _Winc,
306 semiregular _Bound = unreachable_sentinel_t>
307 requires std::__detail::__weakly_eq_cmp_with<_Winc, _Bound>
308 && semiregular<_Winc>
309 class iota_view : public view_interface<iota_view<_Winc, _Bound>>
314 struct _Iterator : __detail::__iota_view_iter_cat<_Winc>
320 using namespace __detail;
321 if constexpr (__advanceable<_Winc>)
322 return random_access_iterator_tag{};
323 else if constexpr (__decrementable<_Winc>)
324 return bidirectional_iterator_tag{};
325 else if constexpr (incrementable<_Winc>)
326 return forward_iterator_tag{};
328 return input_iterator_tag{};
332 using iterator_concept = decltype(_S_iter_concept());
333 // iterator_category defined in __iota_view_iter_cat
334 using value_type = _Winc;
335 using difference_type = __detail::__iota_diff_t<_Winc>;
337 _Iterator() = default;
340 _Iterator(_Winc __value)
341 : _M_value(__value) { }
344 operator*() const noexcept(is_nothrow_copy_constructible_v<_Winc>)
359 operator++(int) requires incrementable<_Winc>
367 operator--() requires __detail::__decrementable<_Winc>
374 operator--(int) requires __detail::__decrementable<_Winc>
382 operator+=(difference_type __n) requires __detail::__advanceable<_Winc>
384 using __detail::__is_integer_like;
385 using __detail::__is_signed_integer_like;
386 if constexpr (__is_integer_like<_Winc>
387 && !__is_signed_integer_like<_Winc>)
389 if (__n >= difference_type(0))
390 _M_value += static_cast<_Winc>(__n);
392 _M_value -= static_cast<_Winc>(-__n);
400 operator-=(difference_type __n) requires __detail::__advanceable<_Winc>
402 using __detail::__is_integer_like;
403 using __detail::__is_signed_integer_like;
404 if constexpr (__is_integer_like<_Winc>
405 && !__is_signed_integer_like<_Winc>)
407 if (__n >= difference_type(0))
408 _M_value -= static_cast<_Winc>(__n);
410 _M_value += static_cast<_Winc>(-__n);
418 operator[](difference_type __n) const
419 requires __detail::__advanceable<_Winc>
420 { return _Winc(_M_value + __n); }
422 friend constexpr bool
423 operator==(const _Iterator& __x, const _Iterator& __y)
424 requires equality_comparable<_Winc>
425 { return __x._M_value == __y._M_value; }
427 friend constexpr bool
428 operator<(const _Iterator& __x, const _Iterator& __y)
429 requires totally_ordered<_Winc>
430 { return __x._M_value < __y._M_value; }
432 friend constexpr bool
433 operator>(const _Iterator& __x, const _Iterator& __y)
434 requires totally_ordered<_Winc>
435 { return __y < __x; }
437 friend constexpr bool
438 operator<=(const _Iterator& __x, const _Iterator& __y)
439 requires totally_ordered<_Winc>
440 { return !(__y < __x); }
442 friend constexpr bool
443 operator>=(const _Iterator& __x, const _Iterator& __y)
444 requires totally_ordered<_Winc>
445 { return !(__x < __y); }
447 #ifdef __cpp_lib_three_way_comparison
448 friend constexpr auto
449 operator<=>(const _Iterator& __x, const _Iterator& __y)
450 requires totally_ordered<_Winc> && three_way_comparable<_Winc>
451 { return __x._M_value <=> __y._M_value; }
454 friend constexpr _Iterator
455 operator+(_Iterator __i, difference_type __n)
456 requires __detail::__advanceable<_Winc>
457 { return __i += __n; }
459 friend constexpr _Iterator
460 operator+(difference_type __n, _Iterator __i)
461 requires __detail::__advanceable<_Winc>
462 { return __i += __n; }
464 friend constexpr _Iterator
465 operator-(_Iterator __i, difference_type __n)
466 requires __detail::__advanceable<_Winc>
467 { return __i -= __n; }
469 friend constexpr difference_type
470 operator-(const _Iterator& __x, const _Iterator& __y)
471 requires __detail::__advanceable<_Winc>
473 using __detail::__is_integer_like;
474 using __detail::__is_signed_integer_like;
475 using _Dt = difference_type;
476 if constexpr (__is_integer_like<_Winc>)
478 if constexpr (__is_signed_integer_like<_Winc>)
479 return _Dt(_Dt(__x._M_value) - _Dt(__y._M_value));
481 return (__y._M_value > __x._M_value)
482 ? _Dt(-_Dt(__y._M_value - __x._M_value))
483 : _Dt(__x._M_value - __y._M_value);
486 return __x._M_value - __y._M_value;
490 _Winc _M_value = _Winc();
499 _M_equal(const _Iterator& __x) const
500 { return __x._M_value == _M_bound; }
502 _Bound _M_bound = _Bound();
505 _Sentinel() = default;
508 _Sentinel(_Bound __bound)
509 : _M_bound(__bound) { }
511 friend constexpr bool
512 operator==(const _Iterator& __x, const _Sentinel& __y)
513 { return __y._M_equal(__x); }
515 friend constexpr iter_difference_t<_Winc>
516 operator-(const _Iterator& __x, const _Sentinel& __y)
517 requires sized_sentinel_for<_Bound, _Winc>
518 { return __x._M_value - __y._M_bound; }
520 friend constexpr iter_difference_t<_Winc>
521 operator-(const _Sentinel& __x, const _Iterator& __y)
522 requires sized_sentinel_for<_Bound, _Winc>
523 { return -(__y - __x); }
526 _Winc _M_value = _Winc();
527 [[no_unique_address]] _Bound _M_bound = _Bound();
530 iota_view() = default;
533 iota_view(_Winc __value)
538 iota_view(type_identity_t<_Winc> __value,
539 type_identity_t<_Bound> __bound)
540 : _M_value(__value), _M_bound(__bound)
542 if constexpr (totally_ordered_with<_Winc, _Bound>)
543 __glibcxx_assert( bool(__value <= __bound) );
547 begin() const { return _Iterator{_M_value}; }
552 if constexpr (same_as<_Bound, unreachable_sentinel_t>)
553 return unreachable_sentinel;
555 return _Sentinel{_M_bound};
559 end() const requires same_as<_Winc, _Bound>
560 { return _Iterator{_M_bound}; }
564 requires (same_as<_Winc, _Bound> && __detail::__advanceable<_Winc>)
565 || (integral<_Winc> && integral<_Bound>)
566 || sized_sentinel_for<_Bound, _Winc>
568 using __detail::__is_integer_like;
569 using __detail::__to_unsigned_like;
570 if constexpr (integral<_Winc> && integral<_Bound>)
572 using _Up = make_unsigned_t<decltype(_M_bound - _M_value)>;
573 return _Up(_M_bound) - _Up(_M_value);
575 else if constexpr (__is_integer_like<_Winc>)
576 return __to_unsigned_like(_M_bound) - __to_unsigned_like(_M_value);
578 return __to_unsigned_like(_M_bound - _M_value);
582 template<typename _Winc, typename _Bound>
583 requires (!__detail::__is_integer_like<_Winc>
584 || !__detail::__is_integer_like<_Bound>
585 || (__detail::__is_signed_integer_like<_Winc>
586 == __detail::__is_signed_integer_like<_Bound>))
587 iota_view(_Winc, _Bound) -> iota_view<_Winc, _Bound>;
589 template<weakly_incrementable _Winc, semiregular _Bound>
590 inline constexpr bool
591 enable_borrowed_range<iota_view<_Winc, _Bound>> = true;
595 template<typename _Tp>
596 inline constexpr empty_view<_Tp> empty{};
600 template<typename _Tp>
602 operator()(_Tp&& __e) const
603 { return single_view<decay_t<_Tp>>(std::forward<_Tp>(__e)); }
606 inline constexpr _Single single{};
610 template<typename _Tp>
612 operator()(_Tp&& __e) const
613 { return iota_view(std::forward<_Tp>(__e)); }
615 template<typename _Tp, typename _Up>
617 operator()(_Tp&& __e, _Up&& __f) const
618 { return iota_view(std::forward<_Tp>(__e), std::forward<_Up>(__f)); }
621 inline constexpr _Iota iota{};
626 template<typename _Val, typename _CharT, typename _Traits>
627 concept __stream_extractable
628 = requires(basic_istream<_CharT, _Traits>& is, _Val& t) { is >> t; };
629 } // namespace __detail
631 template<movable _Val, typename _CharT, typename _Traits>
632 requires default_initializable<_Val>
633 && __detail::__stream_extractable<_Val, _CharT, _Traits>
634 class basic_istream_view
635 : public view_interface<basic_istream_view<_Val, _CharT, _Traits>>
638 basic_istream_view() = default;
641 basic_istream_view(basic_istream<_CharT, _Traits>& __stream)
642 : _M_stream(std::__addressof(__stream))
648 if (_M_stream != nullptr)
649 *_M_stream >> _M_object;
650 return _Iterator{this};
653 constexpr default_sentinel_t
655 { return default_sentinel; }
658 basic_istream<_CharT, _Traits>* _M_stream = nullptr;
659 _Val _M_object = _Val();
664 using iterator_concept = input_iterator_tag;
665 using difference_type = ptrdiff_t;
666 using value_type = _Val;
668 _Iterator() = default;
671 _Iterator(basic_istream_view* __parent) noexcept
672 : _M_parent(__parent)
675 _Iterator(const _Iterator&) = delete;
676 _Iterator(_Iterator&&) = default;
677 _Iterator& operator=(const _Iterator&) = delete;
678 _Iterator& operator=(_Iterator&&) = default;
683 __glibcxx_assert(_M_parent->_M_stream != nullptr);
684 *_M_parent->_M_stream >> _M_parent->_M_object;
695 __glibcxx_assert(_M_parent->_M_stream != nullptr);
696 return _M_parent->_M_object;
700 operator==(const _Iterator& __x, default_sentinel_t)
701 { return __x._M_at_end(); }
704 basic_istream_view* _M_parent = nullptr;
708 { return _M_parent == nullptr || !*_M_parent->_M_stream; }
714 template<typename _Val, typename _CharT, typename _Traits>
715 basic_istream_view<_Val, _CharT, _Traits>
716 istream_view(basic_istream<_CharT, _Traits>& __s)
717 { return basic_istream_view<_Val, _CharT, _Traits>{__s}; }
719 // C++20 24.7 [range.adaptors] Range adaptors
725 // Alias for a type that is conditionally present
726 // (and is an empty type otherwise).
727 // Data members using this alias should use [[no_unique_address]] so that
728 // they take no space when not needed.
729 template<bool _Present, typename _Tp>
730 using __maybe_present_t = conditional_t<_Present, _Tp, _Empty>;
732 // Alias for a type that is conditionally const.
733 template<bool _Const, typename _Tp>
734 using __maybe_const_t = conditional_t<_Const, const _Tp, _Tp>;
736 } // namespace __detail
738 namespace views::__adaptor
740 // True if the range adaptor _Adaptor can be applied with _Args.
741 template<typename _Adaptor, typename... _Args>
742 concept __adaptor_invocable
743 = requires { std::declval<_Adaptor>()(declval<_Args>()...); };
745 // True if the range adaptor non-closure _Adaptor can be partially applied
747 template<typename _Adaptor, typename... _Args>
748 concept __adaptor_partial_app_viable = (_Adaptor::_S_arity > 1)
749 && (sizeof...(_Args) == _Adaptor::_S_arity - 1)
750 && (constructible_from<decay_t<_Args>, _Args> && ...);
752 template<typename _Adaptor, typename... _Args>
755 template<typename _Lhs, typename _Rhs>
758 // The base class of every range adaptor closure.
759 struct _RangeAdaptorClosure
761 // range | adaptor is equivalent to adaptor(range).
762 template<typename _Self, typename _Range>
763 requires derived_from<remove_cvref_t<_Self>, _RangeAdaptorClosure>
764 && __adaptor_invocable<_Self, _Range>
765 friend constexpr auto
766 operator|(_Range&& __r, _Self&& __self)
767 { return std::forward<_Self>(__self)(std::forward<_Range>(__r)); }
769 // Compose the adaptors __lhs and __rhs into a pipeline, returning
770 // another range adaptor closure object.
771 template<typename _Lhs, typename _Rhs>
772 requires derived_from<_Lhs, _RangeAdaptorClosure>
773 && derived_from<_Rhs, _RangeAdaptorClosure>
774 friend constexpr auto
775 operator|(_Lhs __lhs, _Rhs __rhs)
776 { return _Pipe<_Lhs, _Rhs>{std::move(__lhs), std::move(__rhs)}; }
779 // The base class of every range adaptor non-closure.
781 // The static data member _Derived::_S_arity must contain the total number of
782 // arguments that the adaptor takes, and the class _Derived must introduce
783 // _RangeAdaptor::operator() into the class scope via a using-declaration.
784 template<typename _Derived>
787 // Partially apply the arguments __args to the range adaptor _Derived,
788 // returning a range adaptor closure object.
789 template<typename... _Args>
790 requires __adaptor_partial_app_viable<_Derived, _Args...>
792 operator()(_Args&&... __args) const
794 return _Partial<_Derived, decay_t<_Args>...>{std::forward<_Args>(__args)...};
798 // A range adaptor closure that represents partial application of
799 // the range adaptor _Adaptor with arguments _Args.
800 template<typename _Adaptor, typename... _Args>
801 struct _Partial : _RangeAdaptorClosure
803 tuple<_Args...> _M_args;
806 _Partial(_Args... __args)
807 : _M_args(std::move(__args)...)
810 // Invoke _Adaptor with arguments __r, _M_args... according to the
811 // value category of the range adaptor closure object.
812 template<typename _Range>
813 requires __adaptor_invocable<_Adaptor, _Range, const _Args&...>
815 operator()(_Range&& __r) const &
817 auto __forwarder = [&__r] (const auto&... __args) {
818 return _Adaptor{}(std::forward<_Range>(__r), __args...);
820 return std::apply(__forwarder, _M_args);
823 template<typename _Range>
824 requires __adaptor_invocable<_Adaptor, _Range, _Args...>
826 operator()(_Range&& __r) &&
828 auto __forwarder = [&__r] (auto&... __args) {
829 return _Adaptor{}(std::forward<_Range>(__r), std::move(__args)...);
831 return std::apply(__forwarder, _M_args);
834 template<typename _Range>
836 operator()(_Range&& __r) const && = delete;
839 // A lightweight specialization of the above primary template for
840 // the common case where _Adaptor accepts a single extra argument.
841 template<typename _Adaptor, typename _Arg>
842 struct _Partial<_Adaptor, _Arg> : _RangeAdaptorClosure
848 : _M_arg(std::move(__arg))
851 template<typename _Range>
852 requires __adaptor_invocable<_Adaptor, _Range, const _Arg&>
854 operator()(_Range&& __r) const &
855 { return _Adaptor{}(std::forward<_Range>(__r), _M_arg); }
857 template<typename _Range>
858 requires __adaptor_invocable<_Adaptor, _Range, _Arg>
860 operator()(_Range&& __r) &&
861 { return _Adaptor{}(std::forward<_Range>(__r), std::move(_M_arg)); }
863 template<typename _Range>
865 operator()(_Range&& __r) const && = delete;
868 template<typename _Lhs, typename _Rhs, typename _Range>
869 concept __pipe_invocable
870 = requires { std::declval<_Rhs>()(std::declval<_Lhs>()(std::declval<_Range>())); };
872 // A range adaptor closure that represents composition of the range
873 // adaptor closures _Lhs and _Rhs.
874 template<typename _Lhs, typename _Rhs>
875 struct _Pipe : _RangeAdaptorClosure
877 [[no_unique_address]] _Lhs _M_lhs;
878 [[no_unique_address]] _Rhs _M_rhs;
881 _Pipe(_Lhs __lhs, _Rhs __rhs)
882 : _M_lhs(std::move(__lhs)), _M_rhs(std::move(__rhs))
885 // Invoke _M_rhs(_M_lhs(__r)) according to the value category of this
886 // range adaptor closure object.
887 template<typename _Range>
888 requires __pipe_invocable<const _Lhs&, const _Rhs&, _Range>
890 operator()(_Range&& __r) const &
891 { return _M_rhs(_M_lhs(std::forward<_Range>(__r))); }
893 template<typename _Range>
894 requires __pipe_invocable<_Lhs, _Rhs, _Range>
896 operator()(_Range&& __r) &&
897 { return std::move(_M_rhs)(std::move(_M_lhs)(std::forward<_Range>(__r))); }
899 template<typename _Range>
901 operator()(_Range&& __r) const && = delete;
903 } // namespace views::__adaptor
905 template<range _Range> requires is_object_v<_Range>
906 class ref_view : public view_interface<ref_view<_Range>>
909 _Range* _M_r = nullptr;
911 static void _S_fun(_Range&); // not defined
912 static void _S_fun(_Range&&) = delete;
916 ref_view() noexcept = default;
918 template<__detail::__not_same_as<ref_view> _Tp>
919 requires convertible_to<_Tp, _Range&>
920 && requires { _S_fun(declval<_Tp>()); }
923 : _M_r(std::__addressof(static_cast<_Range&>(std::forward<_Tp>(__t))))
930 constexpr iterator_t<_Range>
932 { return ranges::begin(*_M_r); }
934 constexpr sentinel_t<_Range>
936 { return ranges::end(*_M_r); }
939 empty() const requires requires { ranges::empty(*_M_r); }
940 { return ranges::empty(*_M_r); }
943 size() const requires sized_range<_Range>
944 { return ranges::size(*_M_r); }
947 data() const requires contiguous_range<_Range>
948 { return ranges::data(*_M_r); }
951 template<typename _Range>
952 ref_view(_Range&) -> ref_view<_Range>;
954 template<typename _Tp>
955 inline constexpr bool enable_borrowed_range<ref_view<_Tp>> = true;
961 template<typename _Range>
962 concept __can_ref_view = requires { ref_view{std::declval<_Range>()}; };
964 template<typename _Range>
965 concept __can_subrange = requires { subrange{std::declval<_Range>()}; };
966 } // namespace __detail
968 struct _All : __adaptor::_RangeAdaptorClosure
970 template<viewable_range _Range>
971 requires view<decay_t<_Range>>
972 || __detail::__can_ref_view<_Range>
973 || __detail::__can_subrange<_Range>
975 operator()(_Range&& __r) const
977 if constexpr (view<decay_t<_Range>>)
978 return std::forward<_Range>(__r);
979 else if constexpr (__detail::__can_ref_view<_Range>)
980 return ref_view{std::forward<_Range>(__r)};
982 return subrange{std::forward<_Range>(__r)};
986 inline constexpr _All all;
988 template<viewable_range _Range>
989 using all_t = decltype(all(std::declval<_Range>()));
992 // The following simple algos are transcribed from ranges_algo.h to avoid
993 // having to include that entire header.
996 template<typename _Iter, typename _Sent, typename _Tp>
998 find(_Iter __first, _Sent __last, const _Tp& __value)
1000 while (__first != __last
1001 && !(bool)(*__first == __value))
1006 template<typename _Iter, typename _Sent, typename _Pred>
1008 find_if(_Iter __first, _Sent __last, _Pred __pred)
1010 while (__first != __last
1011 && !(bool)std::__invoke(__pred, *__first))
1016 template<typename _Iter, typename _Sent, typename _Pred>
1018 find_if_not(_Iter __first, _Sent __last, _Pred __pred)
1020 while (__first != __last
1021 && (bool)std::__invoke(__pred, *__first))
1026 template<typename _Iter1, typename _Sent1, typename _Iter2, typename _Sent2>
1027 constexpr pair<_Iter1, _Iter2>
1028 mismatch(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2)
1030 while (__first1 != __last1 && __first2 != __last2
1031 && (bool)ranges::equal_to{}(*__first1, *__first2))
1036 return { std::move(__first1), std::move(__first2) };
1038 } // namespace __detail
1042 template<typename _Tp>
1043 struct __non_propagating_cache
1045 // When _Tp is not an object type (e.g. is a reference type), we make
1046 // __non_propagating_cache<_Tp> empty rather than ill-formed so that
1047 // users can easily conditionally declare data members with this type
1048 // (such as join_view::_M_inner).
1051 template<typename _Tp>
1052 requires is_object_v<_Tp>
1053 struct __non_propagating_cache<_Tp> : protected _Optional_base<_Tp>
1055 __non_propagating_cache() = default;
1058 __non_propagating_cache(const __non_propagating_cache&) noexcept
1062 __non_propagating_cache(__non_propagating_cache&& __other) noexcept
1063 { __other._M_reset(); }
1065 constexpr __non_propagating_cache&
1066 operator=(const __non_propagating_cache& __other) noexcept
1068 if (std::__addressof(__other) != this)
1073 constexpr __non_propagating_cache&
1074 operator=(__non_propagating_cache&& __other) noexcept
1082 operator*() noexcept
1083 { return this->_M_get(); }
1085 constexpr const _Tp&
1086 operator*() const noexcept
1087 { return this->_M_get(); }
1089 template<typename _Iter>
1091 _M_emplace_deref(const _Iter& __i)
1094 // Using _Optional_base::_M_construct to initialize from '*__i'
1095 // would incur an extra move due to the indirection, so we instead
1096 // use placement new directly.
1097 ::new ((void *) std::__addressof(this->_M_payload._M_payload)) _Tp(*__i);
1098 this->_M_payload._M_engaged = true;
1099 return this->_M_get();
1103 template<range _Range>
1104 struct _CachedPosition
1107 _M_has_value() const
1110 constexpr iterator_t<_Range>
1111 _M_get(const _Range&) const
1113 __glibcxx_assert(false);
1118 _M_set(const _Range&, const iterator_t<_Range>&) const
1122 template<forward_range _Range>
1123 struct _CachedPosition<_Range>
1124 : protected __non_propagating_cache<iterator_t<_Range>>
1127 _M_has_value() const
1128 { return this->_M_is_engaged(); }
1130 constexpr iterator_t<_Range>
1131 _M_get(const _Range&) const
1133 __glibcxx_assert(_M_has_value());
1138 _M_set(const _Range&, const iterator_t<_Range>& __it)
1140 __glibcxx_assert(!_M_has_value());
1141 std::construct_at(std::__addressof(this->_M_payload._M_payload),
1143 this->_M_payload._M_engaged = true;
1147 template<random_access_range _Range>
1148 requires (sizeof(range_difference_t<_Range>)
1149 <= sizeof(iterator_t<_Range>))
1150 struct _CachedPosition<_Range>
1153 range_difference_t<_Range> _M_offset = -1;
1156 _CachedPosition() = default;
1159 _CachedPosition(const _CachedPosition&) = default;
1162 _CachedPosition(_CachedPosition&& __other) noexcept
1163 { *this = std::move(__other); }
1165 constexpr _CachedPosition&
1166 operator=(const _CachedPosition&) = default;
1168 constexpr _CachedPosition&
1169 operator=(_CachedPosition&& __other) noexcept
1171 // Propagate the cached offset, but invalidate the source.
1172 _M_offset = __other._M_offset;
1173 __other._M_offset = -1;
1178 _M_has_value() const
1179 { return _M_offset >= 0; }
1181 constexpr iterator_t<_Range>
1182 _M_get(_Range& __r) const
1184 __glibcxx_assert(_M_has_value());
1185 return ranges::begin(__r) + _M_offset;
1189 _M_set(_Range& __r, const iterator_t<_Range>& __it)
1191 __glibcxx_assert(!_M_has_value());
1192 _M_offset = __it - ranges::begin(__r);
1195 } // namespace __detail
1199 template<typename _Base>
1200 struct __filter_view_iter_cat
1203 template<forward_range _Base>
1204 struct __filter_view_iter_cat<_Base>
1210 using _Cat = typename iterator_traits<iterator_t<_Base>>::iterator_category;
1211 if constexpr (derived_from<_Cat, bidirectional_iterator_tag>)
1212 return bidirectional_iterator_tag{};
1213 else if constexpr (derived_from<_Cat, forward_iterator_tag>)
1214 return forward_iterator_tag{};
1219 using iterator_category = decltype(_S_iter_cat());
1221 } // namespace __detail
1223 template<input_range _Vp,
1224 indirect_unary_predicate<iterator_t<_Vp>> _Pred>
1225 requires view<_Vp> && is_object_v<_Pred>
1226 class filter_view : public view_interface<filter_view<_Vp, _Pred>>
1231 struct _Iterator : __detail::__filter_view_iter_cat<_Vp>
1234 static constexpr auto
1237 if constexpr (bidirectional_range<_Vp>)
1238 return bidirectional_iterator_tag{};
1239 else if constexpr (forward_range<_Vp>)
1240 return forward_iterator_tag{};
1242 return input_iterator_tag{};
1247 using _Vp_iter = iterator_t<_Vp>;
1249 _Vp_iter _M_current = _Vp_iter();
1250 filter_view* _M_parent = nullptr;
1253 using iterator_concept = decltype(_S_iter_concept());
1254 // iterator_category defined in __filter_view_iter_cat
1255 using value_type = range_value_t<_Vp>;
1256 using difference_type = range_difference_t<_Vp>;
1258 _Iterator() = default;
1261 _Iterator(filter_view* __parent, _Vp_iter __current)
1262 : _M_current(std::move(__current)),
1268 requires copyable<_Vp_iter>
1269 { return _M_current; }
1273 { return std::move(_M_current); }
1275 constexpr range_reference_t<_Vp>
1277 { return *_M_current; }
1281 requires __detail::__has_arrow<_Vp_iter>
1282 && copyable<_Vp_iter>
1283 { return _M_current; }
1285 constexpr _Iterator&
1288 _M_current = __detail::find_if(std::move(++_M_current),
1289 ranges::end(_M_parent->_M_base),
1290 std::ref(*_M_parent->_M_pred));
1299 operator++(int) requires forward_range<_Vp>
1306 constexpr _Iterator&
1307 operator--() requires bidirectional_range<_Vp>
1311 while (!std::__invoke(*_M_parent->_M_pred, *_M_current));
1316 operator--(int) requires bidirectional_range<_Vp>
1323 friend constexpr bool
1324 operator==(const _Iterator& __x, const _Iterator& __y)
1325 requires equality_comparable<_Vp_iter>
1326 { return __x._M_current == __y._M_current; }
1328 friend constexpr range_rvalue_reference_t<_Vp>
1329 iter_move(const _Iterator& __i)
1330 noexcept(noexcept(ranges::iter_move(__i._M_current)))
1331 { return ranges::iter_move(__i._M_current); }
1333 friend constexpr void
1334 iter_swap(const _Iterator& __x, const _Iterator& __y)
1335 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1336 requires indirectly_swappable<_Vp_iter>
1337 { ranges::iter_swap(__x._M_current, __y._M_current); }
1343 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
1346 __equal(const _Iterator& __i) const
1347 { return __i._M_current == _M_end; }
1350 _Sentinel() = default;
1353 _Sentinel(filter_view* __parent)
1354 : _M_end(ranges::end(__parent->_M_base))
1357 constexpr sentinel_t<_Vp>
1361 friend constexpr bool
1362 operator==(const _Iterator& __x, const _Sentinel& __y)
1363 { return __y.__equal(__x); }
1366 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
1367 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
1368 _Vp _M_base = _Vp();
1371 filter_view() = default;
1374 filter_view(_Vp __base, _Pred __pred)
1375 : _M_pred(std::move(__pred)), _M_base(std::move(__base))
1379 base() const& requires copy_constructible<_Vp>
1384 { return std::move(_M_base); }
1386 constexpr const _Pred&
1388 { return *_M_pred; }
1393 if (_M_cached_begin._M_has_value())
1394 return {this, _M_cached_begin._M_get(_M_base)};
1396 __glibcxx_assert(_M_pred.has_value());
1397 auto __it = __detail::find_if(ranges::begin(_M_base),
1398 ranges::end(_M_base),
1399 std::ref(*_M_pred));
1400 _M_cached_begin._M_set(_M_base, __it);
1401 return {this, std::move(__it)};
1407 if constexpr (common_range<_Vp>)
1408 return _Iterator{this, ranges::end(_M_base)};
1410 return _Sentinel{this};
1414 template<typename _Range, typename _Pred>
1415 filter_view(_Range&&, _Pred) -> filter_view<views::all_t<_Range>, _Pred>;
1421 template<typename _Range, typename _Pred>
1422 concept __can_filter_view
1423 = requires { filter_view(std::declval<_Range>(), std::declval<_Pred>()); };
1424 } // namespace __detail
1426 struct _Filter : __adaptor::_RangeAdaptor<_Filter>
1428 template<viewable_range _Range, typename _Pred>
1429 requires __detail::__can_filter_view<_Range, _Pred>
1431 operator()(_Range&& __r, _Pred&& __p) const
1433 return filter_view(std::forward<_Range>(__r), std::forward<_Pred>(__p));
1436 using _RangeAdaptor<_Filter>::operator();
1437 static constexpr int _S_arity = 2;
1440 inline constexpr _Filter filter;
1441 } // namespace views
1443 template<input_range _Vp, copy_constructible _Fp>
1444 requires view<_Vp> && is_object_v<_Fp>
1445 && regular_invocable<_Fp&, range_reference_t<_Vp>>
1446 && std::__detail::__can_reference<invoke_result_t<_Fp&,
1447 range_reference_t<_Vp>>>
1448 class transform_view : public view_interface<transform_view<_Vp, _Fp>>
1451 template<bool _Const>
1452 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
1454 template<bool _Const>
1458 template<bool _Const>
1459 requires forward_range<_Base<_Const>>
1460 struct __iter_cat<_Const>
1466 using _Base = transform_view::_Base<_Const>;
1467 using _Res = invoke_result_t<_Fp&, range_reference_t<_Base>>;
1468 if constexpr (is_lvalue_reference_v<_Res>)
1471 = typename iterator_traits<iterator_t<_Base>>::iterator_category;
1472 if constexpr (derived_from<_Cat, contiguous_iterator_tag>)
1473 return random_access_iterator_tag{};
1478 return input_iterator_tag{};
1481 using iterator_category = decltype(_S_iter_cat());
1484 template<bool _Const>
1487 template<bool _Const>
1488 struct _Iterator : __iter_cat<_Const>
1491 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
1492 using _Base = transform_view::_Base<_Const>;
1497 if constexpr (random_access_range<_Vp>)
1498 return random_access_iterator_tag{};
1499 else if constexpr (bidirectional_range<_Vp>)
1500 return bidirectional_iterator_tag{};
1501 else if constexpr (forward_range<_Vp>)
1502 return forward_iterator_tag{};
1504 return input_iterator_tag{};
1507 using _Base_iter = iterator_t<_Base>;
1509 _Base_iter _M_current = _Base_iter();
1510 _Parent* _M_parent = nullptr;
1513 using iterator_concept = decltype(_S_iter_concept());
1514 // iterator_category defined in __transform_view_iter_cat
1516 = remove_cvref_t<invoke_result_t<_Fp&, range_reference_t<_Base>>>;
1517 using difference_type = range_difference_t<_Base>;
1519 _Iterator() = default;
1522 _Iterator(_Parent* __parent, _Base_iter __current)
1523 : _M_current(std::move(__current)),
1528 _Iterator(_Iterator<!_Const> __i)
1530 && convertible_to<iterator_t<_Vp>, _Base_iter>
1531 : _M_current(std::move(__i._M_current)), _M_parent(__i._M_parent)
1534 constexpr _Base_iter
1536 requires copyable<_Base_iter>
1537 { return _M_current; }
1539 constexpr _Base_iter
1541 { return std::move(_M_current); }
1543 constexpr decltype(auto)
1545 noexcept(noexcept(std::__invoke(*_M_parent->_M_fun, *_M_current)))
1546 { return std::__invoke(*_M_parent->_M_fun, *_M_current); }
1548 constexpr _Iterator&
1560 operator++(int) requires forward_range<_Base>
1567 constexpr _Iterator&
1568 operator--() requires bidirectional_range<_Base>
1575 operator--(int) requires bidirectional_range<_Base>
1582 constexpr _Iterator&
1583 operator+=(difference_type __n) requires random_access_range<_Base>
1589 constexpr _Iterator&
1590 operator-=(difference_type __n) requires random_access_range<_Base>
1596 constexpr decltype(auto)
1597 operator[](difference_type __n) const
1598 requires random_access_range<_Base>
1599 { return std::__invoke(*_M_parent->_M_fun, _M_current[__n]); }
1601 friend constexpr bool
1602 operator==(const _Iterator& __x, const _Iterator& __y)
1603 requires equality_comparable<_Base_iter>
1604 { return __x._M_current == __y._M_current; }
1606 friend constexpr bool
1607 operator<(const _Iterator& __x, const _Iterator& __y)
1608 requires random_access_range<_Base>
1609 { return __x._M_current < __y._M_current; }
1611 friend constexpr bool
1612 operator>(const _Iterator& __x, const _Iterator& __y)
1613 requires random_access_range<_Base>
1614 { return __y < __x; }
1616 friend constexpr bool
1617 operator<=(const _Iterator& __x, const _Iterator& __y)
1618 requires random_access_range<_Base>
1619 { return !(__y < __x); }
1621 friend constexpr bool
1622 operator>=(const _Iterator& __x, const _Iterator& __y)
1623 requires random_access_range<_Base>
1624 { return !(__x < __y); }
1626 #ifdef __cpp_lib_three_way_comparison
1627 friend constexpr auto
1628 operator<=>(const _Iterator& __x, const _Iterator& __y)
1629 requires random_access_range<_Base>
1630 && three_way_comparable<_Base_iter>
1631 { return __x._M_current <=> __y._M_current; }
1634 friend constexpr _Iterator
1635 operator+(_Iterator __i, difference_type __n)
1636 requires random_access_range<_Base>
1637 { return {__i._M_parent, __i._M_current + __n}; }
1639 friend constexpr _Iterator
1640 operator+(difference_type __n, _Iterator __i)
1641 requires random_access_range<_Base>
1642 { return {__i._M_parent, __i._M_current + __n}; }
1644 friend constexpr _Iterator
1645 operator-(_Iterator __i, difference_type __n)
1646 requires random_access_range<_Base>
1647 { return {__i._M_parent, __i._M_current - __n}; }
1649 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1650 // 3483. transform_view::iterator's difference is overconstrained
1651 friend constexpr difference_type
1652 operator-(const _Iterator& __x, const _Iterator& __y)
1653 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
1654 { return __x._M_current - __y._M_current; }
1656 friend constexpr decltype(auto)
1657 iter_move(const _Iterator& __i) noexcept(noexcept(*__i))
1659 if constexpr (is_lvalue_reference_v<decltype(*__i)>)
1660 return std::move(*__i);
1665 friend _Iterator<!_Const>;
1666 template<bool> friend struct _Sentinel;
1669 template<bool _Const>
1673 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
1674 using _Base = transform_view::_Base<_Const>;
1676 template<bool _Const2>
1678 __distance_from(const _Iterator<_Const2>& __i) const
1679 { return _M_end - __i._M_current; }
1681 template<bool _Const2>
1683 __equal(const _Iterator<_Const2>& __i) const
1684 { return __i._M_current == _M_end; }
1686 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
1689 _Sentinel() = default;
1692 _Sentinel(sentinel_t<_Base> __end)
1697 _Sentinel(_Sentinel<!_Const> __i)
1699 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
1700 : _M_end(std::move(__i._M_end))
1703 constexpr sentinel_t<_Base>
1707 template<bool _Const2>
1708 requires sentinel_for<sentinel_t<_Base>,
1709 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
1710 friend constexpr bool
1711 operator==(const _Iterator<_Const2>& __x, const _Sentinel& __y)
1712 { return __y.__equal(__x); }
1714 template<bool _Const2,
1715 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
1716 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
1717 friend constexpr range_difference_t<_Base2>
1718 operator-(const _Iterator<_Const2>& __x, const _Sentinel& __y)
1719 { return -__y.__distance_from(__x); }
1721 template<bool _Const2,
1722 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
1723 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
1724 friend constexpr range_difference_t<_Base2>
1725 operator-(const _Sentinel& __y, const _Iterator<_Const2>& __x)
1726 { return __y.__distance_from(__x); }
1728 friend _Sentinel<!_Const>;
1731 [[no_unique_address]] __detail::__box<_Fp> _M_fun;
1732 _Vp _M_base = _Vp();
1735 transform_view() = default;
1738 transform_view(_Vp __base, _Fp __fun)
1739 : _M_fun(std::move(__fun)), _M_base(std::move(__base))
1743 base() const& requires copy_constructible<_Vp>
1744 { return _M_base ; }
1748 { return std::move(_M_base); }
1750 constexpr _Iterator<false>
1752 { return _Iterator<false>{this, ranges::begin(_M_base)}; }
1754 constexpr _Iterator<true>
1756 requires range<const _Vp>
1757 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
1758 { return _Iterator<true>{this, ranges::begin(_M_base)}; }
1760 constexpr _Sentinel<false>
1762 { return _Sentinel<false>{ranges::end(_M_base)}; }
1764 constexpr _Iterator<false>
1765 end() requires common_range<_Vp>
1766 { return _Iterator<false>{this, ranges::end(_M_base)}; }
1768 constexpr _Sentinel<true>
1770 requires range<const _Vp>
1771 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
1772 { return _Sentinel<true>{ranges::end(_M_base)}; }
1774 constexpr _Iterator<true>
1776 requires common_range<const _Vp>
1777 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
1778 { return _Iterator<true>{this, ranges::end(_M_base)}; }
1781 size() requires sized_range<_Vp>
1782 { return ranges::size(_M_base); }
1785 size() const requires sized_range<const _Vp>
1786 { return ranges::size(_M_base); }
1789 template<typename _Range, typename _Fp>
1790 transform_view(_Range&&, _Fp) -> transform_view<views::all_t<_Range>, _Fp>;
1796 template<typename _Range, typename _Fp>
1797 concept __can_transform_view
1798 = requires { transform_view(std::declval<_Range>(), std::declval<_Fp>()); };
1799 } // namespace __detail
1801 struct _Transform : __adaptor::_RangeAdaptor<_Transform>
1803 template<viewable_range _Range, typename _Fp>
1804 requires __detail::__can_transform_view<_Range, _Fp>
1806 operator()(_Range&& __r, _Fp&& __f) const
1808 return transform_view(std::forward<_Range>(__r), std::forward<_Fp>(__f));
1811 using _RangeAdaptor<_Transform>::operator();
1812 static constexpr int _S_arity = 2;
1815 inline constexpr _Transform transform;
1816 } // namespace views
1819 class take_view : public view_interface<take_view<_Vp>>
1822 template<bool _Const>
1823 using _CI = counted_iterator<
1824 iterator_t<__detail::__maybe_const_t<_Const, _Vp>>>;
1826 template<bool _Const>
1830 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
1831 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
1834 _Sentinel() = default;
1837 _Sentinel(sentinel_t<_Base> __end)
1842 _Sentinel(_Sentinel<!_Const> __s)
1843 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
1844 : _M_end(std::move(__s._M_end))
1847 constexpr sentinel_t<_Base>
1851 friend constexpr bool
1852 operator==(const _CI<_Const>& __y, const _Sentinel& __x)
1853 { return __y.count() == 0 || __y.base() == __x._M_end; }
1855 template<bool _OtherConst = !_Const,
1856 typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
1857 requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
1858 friend constexpr bool
1859 operator==(const _CI<_OtherConst>& __y, const _Sentinel& __x)
1860 { return __y.count() == 0 || __y.base() == __x._M_end; }
1862 friend _Sentinel<!_Const>;
1865 range_difference_t<_Vp> _M_count = 0;
1866 _Vp _M_base = _Vp();
1869 take_view() = default;
1872 take_view(_Vp base, range_difference_t<_Vp> __count)
1873 : _M_count(std::move(__count)), _M_base(std::move(base))
1877 base() const& requires copy_constructible<_Vp>
1882 { return std::move(_M_base); }
1885 begin() requires (!__detail::__simple_view<_Vp>)
1887 if constexpr (sized_range<_Vp>)
1889 if constexpr (random_access_range<_Vp>)
1890 return ranges::begin(_M_base);
1894 return counted_iterator(ranges::begin(_M_base), __sz);
1898 return counted_iterator(ranges::begin(_M_base), _M_count);
1902 begin() const requires range<const _Vp>
1904 if constexpr (sized_range<const _Vp>)
1906 if constexpr (random_access_range<const _Vp>)
1907 return ranges::begin(_M_base);
1911 return counted_iterator(ranges::begin(_M_base), __sz);
1915 return counted_iterator(ranges::begin(_M_base), _M_count);
1919 end() requires (!__detail::__simple_view<_Vp>)
1921 if constexpr (sized_range<_Vp>)
1923 if constexpr (random_access_range<_Vp>)
1924 return ranges::begin(_M_base) + size();
1926 return default_sentinel;
1929 return _Sentinel<false>{ranges::end(_M_base)};
1933 end() const requires range<const _Vp>
1935 if constexpr (sized_range<const _Vp>)
1937 if constexpr (random_access_range<const _Vp>)
1938 return ranges::begin(_M_base) + size();
1940 return default_sentinel;
1943 return _Sentinel<true>{ranges::end(_M_base)};
1947 size() requires sized_range<_Vp>
1949 auto __n = ranges::size(_M_base);
1950 return std::min(__n, static_cast<decltype(__n)>(_M_count));
1954 size() const requires sized_range<const _Vp>
1956 auto __n = ranges::size(_M_base);
1957 return std::min(__n, static_cast<decltype(__n)>(_M_count));
1961 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1962 // 3447. Deduction guides for take_view and drop_view have different
1964 template<typename _Range>
1965 take_view(_Range&&, range_difference_t<_Range>)
1966 -> take_view<views::all_t<_Range>>;
1968 template<typename _Tp>
1969 inline constexpr bool enable_borrowed_range<take_view<_Tp>>
1970 = enable_borrowed_range<_Tp>;
1976 template<typename _Range, typename _Tp>
1977 concept __can_take_view
1978 = requires { take_view(std::declval<_Range>(), std::declval<_Tp>()); };
1979 } // namespace __detail
1981 struct _Take : __adaptor::_RangeAdaptor<_Take>
1983 template<viewable_range _Range, typename _Tp>
1984 requires __detail::__can_take_view<_Range, _Tp>
1986 operator()(_Range&& __r, _Tp&& __n) const
1988 return take_view(std::forward<_Range>(__r), std::forward<_Tp>(__n));
1991 using _RangeAdaptor<_Take>::operator();
1992 static constexpr int _S_arity = 2;
1995 inline constexpr _Take take;
1996 } // namespace views
1998 template<view _Vp, typename _Pred>
1999 requires input_range<_Vp> && is_object_v<_Pred>
2000 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2001 class take_while_view : public view_interface<take_while_view<_Vp, _Pred>>
2003 template<bool _Const>
2007 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2009 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2010 const _Pred* _M_pred = nullptr;
2013 _Sentinel() = default;
2016 _Sentinel(sentinel_t<_Base> __end, const _Pred* __pred)
2017 : _M_end(__end), _M_pred(__pred)
2021 _Sentinel(_Sentinel<!_Const> __s)
2022 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2023 : _M_end(__s._M_end), _M_pred(__s._M_pred)
2026 constexpr sentinel_t<_Base>
2027 base() const { return _M_end; }
2029 friend constexpr bool
2030 operator==(const iterator_t<_Base>& __x, const _Sentinel& __y)
2031 { return __y._M_end == __x || !std::__invoke(*__y._M_pred, *__x); }
2033 template<bool _OtherConst = !_Const,
2034 typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
2035 requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2036 friend constexpr bool
2037 operator==(const iterator_t<_Base2>& __x, const _Sentinel& __y)
2038 { return __y._M_end == __x || !std::__invoke(*__y._M_pred, *__x); }
2040 friend _Sentinel<!_Const>;
2043 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
2044 _Vp _M_base = _Vp();
2047 take_while_view() = default;
2050 take_while_view(_Vp base, _Pred __pred)
2051 : _M_pred(std::move(__pred)), _M_base(std::move(base))
2055 base() const& requires copy_constructible<_Vp>
2060 { return std::move(_M_base); }
2062 constexpr const _Pred&
2064 { return *_M_pred; }
2067 begin() requires (!__detail::__simple_view<_Vp>)
2068 { return ranges::begin(_M_base); }
2071 begin() const requires range<const _Vp>
2072 && indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
2073 { return ranges::begin(_M_base); }
2076 end() requires (!__detail::__simple_view<_Vp>)
2077 { return _Sentinel<false>(ranges::end(_M_base),
2078 std::__addressof(*_M_pred)); }
2081 end() const requires range<const _Vp>
2082 && indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
2083 { return _Sentinel<true>(ranges::end(_M_base),
2084 std::__addressof(*_M_pred)); }
2087 template<typename _Range, typename _Pred>
2088 take_while_view(_Range&&, _Pred)
2089 -> take_while_view<views::all_t<_Range>, _Pred>;
2095 template<typename _Range, typename _Pred>
2096 concept __can_take_while_view
2097 = requires { take_while_view(std::declval<_Range>(), std::declval<_Pred>()); };
2098 } // namespace __detail
2100 struct _TakeWhile : __adaptor::_RangeAdaptor<_TakeWhile>
2102 template<viewable_range _Range, typename _Pred>
2103 requires __detail::__can_take_while_view<_Range, _Pred>
2105 operator()(_Range&& __r, _Pred&& __p) const
2107 return take_while_view(std::forward<_Range>(__r), std::forward<_Pred>(__p));
2110 using _RangeAdaptor<_TakeWhile>::operator();
2111 static constexpr int _S_arity = 2;
2114 inline constexpr _TakeWhile take_while;
2115 } // namespace views
2118 class drop_view : public view_interface<drop_view<_Vp>>
2121 range_difference_t<_Vp> _M_count = 0;
2122 _Vp _M_base = _Vp();
2124 // ranges::next(begin(base), count, end(base)) is O(1) if _Vp satisfies
2125 // both random_access_range and sized_range. Otherwise, cache its result.
2126 static constexpr bool _S_needs_cached_begin
2127 = !(random_access_range<const _Vp> && sized_range<const _Vp>);
2128 [[no_unique_address]]
2129 __detail::__maybe_present_t<_S_needs_cached_begin,
2130 __detail::_CachedPosition<_Vp>>
2134 drop_view() = default;
2137 drop_view(_Vp __base, range_difference_t<_Vp> __count)
2138 : _M_count(__count), _M_base(std::move(__base))
2139 { __glibcxx_assert(__count >= 0); }
2142 base() const& requires copy_constructible<_Vp>
2147 { return std::move(_M_base); }
2149 // This overload is disabled for simple views with constant-time begin().
2152 requires (!(__detail::__simple_view<_Vp>
2153 && random_access_range<const _Vp>
2154 && sized_range<const _Vp>))
2156 if constexpr (_S_needs_cached_begin)
2157 if (_M_cached_begin._M_has_value())
2158 return _M_cached_begin._M_get(_M_base);
2160 auto __it = ranges::next(ranges::begin(_M_base),
2161 _M_count, ranges::end(_M_base));
2162 if constexpr (_S_needs_cached_begin)
2163 _M_cached_begin._M_set(_M_base, __it);
2167 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2168 // 3482. drop_view's const begin should additionally require sized_range
2171 requires random_access_range<const _Vp> && sized_range<const _Vp>
2173 return ranges::next(ranges::begin(_M_base), _M_count,
2174 ranges::end(_M_base));
2178 end() requires (!__detail::__simple_view<_Vp>)
2179 { return ranges::end(_M_base); }
2182 end() const requires range<const _Vp>
2183 { return ranges::end(_M_base); }
2186 size() requires sized_range<_Vp>
2188 const auto __s = ranges::size(_M_base);
2189 const auto __c = static_cast<decltype(__s)>(_M_count);
2190 return __s < __c ? 0 : __s - __c;
2194 size() const requires sized_range<const _Vp>
2196 const auto __s = ranges::size(_M_base);
2197 const auto __c = static_cast<decltype(__s)>(_M_count);
2198 return __s < __c ? 0 : __s - __c;
2202 template<typename _Range>
2203 drop_view(_Range&&, range_difference_t<_Range>)
2204 -> drop_view<views::all_t<_Range>>;
2206 template<typename _Tp>
2207 inline constexpr bool enable_borrowed_range<drop_view<_Tp>>
2208 = enable_borrowed_range<_Tp>;
2214 template<typename _Range, typename _Tp>
2215 concept __can_drop_view
2216 = requires { drop_view(std::declval<_Range>(), std::declval<_Tp>()); };
2217 } // namespace __detail
2219 struct _Drop : __adaptor::_RangeAdaptor<_Drop>
2221 template<viewable_range _Range, typename _Tp>
2222 requires __detail::__can_drop_view<_Range, _Tp>
2224 operator()(_Range&& __r, _Tp&& __n) const
2226 return drop_view(std::forward<_Range>(__r), std::forward<_Tp>(__n));
2229 using _RangeAdaptor<_Drop>::operator();
2230 static constexpr int _S_arity = 2;
2233 inline constexpr _Drop drop;
2234 } // namespace views
2236 template<view _Vp, typename _Pred>
2237 requires input_range<_Vp> && is_object_v<_Pred>
2238 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2239 class drop_while_view : public view_interface<drop_while_view<_Vp, _Pred>>
2242 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
2243 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
2244 _Vp _M_base = _Vp();
2247 drop_while_view() = default;
2250 drop_while_view(_Vp __base, _Pred __pred)
2251 : _M_pred(std::move(__pred)), _M_base(std::move(__base))
2255 base() const& requires copy_constructible<_Vp>
2260 { return std::move(_M_base); }
2262 constexpr const _Pred&
2264 { return *_M_pred; }
2269 if (_M_cached_begin._M_has_value())
2270 return _M_cached_begin._M_get(_M_base);
2272 auto __it = __detail::find_if_not(ranges::begin(_M_base),
2273 ranges::end(_M_base),
2274 std::cref(*_M_pred));
2275 _M_cached_begin._M_set(_M_base, __it);
2281 { return ranges::end(_M_base); }
2284 template<typename _Range, typename _Pred>
2285 drop_while_view(_Range&&, _Pred)
2286 -> drop_while_view<views::all_t<_Range>, _Pred>;
2288 template<typename _Tp, typename _Pred>
2289 inline constexpr bool enable_borrowed_range<drop_while_view<_Tp, _Pred>>
2290 = enable_borrowed_range<_Tp>;
2296 template<typename _Range, typename _Pred>
2297 concept __can_drop_while_view
2298 = requires { drop_while_view(std::declval<_Range>(), std::declval<_Pred>()); };
2299 } // namespace __detail
2301 struct _DropWhile : __adaptor::_RangeAdaptor<_DropWhile>
2303 template<viewable_range _Range, typename _Pred>
2304 requires __detail::__can_drop_while_view<_Range, _Pred>
2306 operator()(_Range&& __r, _Pred&& __p) const
2308 return drop_while_view(std::forward<_Range>(__r),
2309 std::forward<_Pred>(__p));
2312 using _RangeAdaptor<_DropWhile>::operator();
2313 static constexpr int _S_arity = 2;
2316 inline constexpr _DropWhile drop_while;
2317 } // namespace views
2319 template<input_range _Vp>
2320 requires view<_Vp> && input_range<range_reference_t<_Vp>>
2321 class join_view : public view_interface<join_view<_Vp>>
2324 using _InnerRange = range_reference_t<_Vp>;
2326 template<bool _Const>
2327 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2329 template<bool _Const>
2330 using _Outer_iter = iterator_t<_Base<_Const>>;
2332 template<bool _Const>
2333 using _Inner_iter = iterator_t<range_reference_t<_Base<_Const>>>;
2335 template<bool _Const>
2336 static constexpr bool _S_ref_is_glvalue
2337 = is_reference_v<range_reference_t<_Base<_Const>>>;
2339 template<bool _Const>
2343 template<bool _Const>
2344 requires _S_ref_is_glvalue<_Const>
2345 && forward_range<_Base<_Const>>
2346 && forward_range<range_reference_t<_Base<_Const>>>
2347 struct __iter_cat<_Const>
2350 static constexpr auto
2353 using _Outer_iter = join_view::_Outer_iter<_Const>;
2354 using _Inner_iter = join_view::_Inner_iter<_Const>;
2355 using _OuterCat = typename iterator_traits<_Outer_iter>::iterator_category;
2356 using _InnerCat = typename iterator_traits<_Inner_iter>::iterator_category;
2357 if constexpr (derived_from<_OuterCat, bidirectional_iterator_tag>
2358 && derived_from<_InnerCat, bidirectional_iterator_tag>)
2359 return bidirectional_iterator_tag{};
2360 else if constexpr (derived_from<_OuterCat, forward_iterator_tag>
2361 && derived_from<_InnerCat, forward_iterator_tag>)
2362 return forward_iterator_tag{};
2364 return input_iterator_tag{};
2367 using iterator_category = decltype(_S_iter_cat());
2370 template<bool _Const>
2373 template<bool _Const>
2374 struct _Iterator : __iter_cat<_Const>
2377 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
2378 using _Base = join_view::_Base<_Const>;
2380 static constexpr bool _S_ref_is_glvalue
2381 = join_view::_S_ref_is_glvalue<_Const>;
2386 auto __update_inner = [this] (const iterator_t<_Base>& __x) -> auto&& {
2387 if constexpr (_S_ref_is_glvalue)
2390 return _M_parent->_M_inner._M_emplace_deref(__x);
2393 for (; _M_outer != ranges::end(_M_parent->_M_base); ++_M_outer)
2395 auto&& __inner = __update_inner(_M_outer);
2396 _M_inner = ranges::begin(__inner);
2397 if (_M_inner != ranges::end(__inner))
2401 if constexpr (_S_ref_is_glvalue)
2402 _M_inner = _Inner_iter();
2405 static constexpr auto
2408 if constexpr (_S_ref_is_glvalue
2409 && bidirectional_range<_Base>
2410 && bidirectional_range<range_reference_t<_Base>>)
2411 return bidirectional_iterator_tag{};
2412 else if constexpr (_S_ref_is_glvalue
2413 && forward_range<_Base>
2414 && forward_range<range_reference_t<_Base>>)
2415 return forward_iterator_tag{};
2417 return input_iterator_tag{};
2420 using _Outer_iter = join_view::_Outer_iter<_Const>;
2421 using _Inner_iter = join_view::_Inner_iter<_Const>;
2423 _Outer_iter _M_outer = _Outer_iter();
2424 _Inner_iter _M_inner = _Inner_iter();
2425 _Parent* _M_parent = nullptr;
2428 using iterator_concept = decltype(_S_iter_concept());
2429 // iterator_category defined in __join_view_iter_cat
2430 using value_type = range_value_t<range_reference_t<_Base>>;
2431 using difference_type
2432 = common_type_t<range_difference_t<_Base>,
2433 range_difference_t<range_reference_t<_Base>>>;
2435 _Iterator() = default;
2438 _Iterator(_Parent* __parent, _Outer_iter __outer)
2439 : _M_outer(std::move(__outer)),
2444 _Iterator(_Iterator<!_Const> __i)
2446 && convertible_to<iterator_t<_Vp>, _Outer_iter>
2447 && convertible_to<iterator_t<_InnerRange>, _Inner_iter>
2448 : _M_outer(std::move(__i._M_outer)), _M_inner(__i._M_inner),
2449 _M_parent(__i._M_parent)
2452 constexpr decltype(auto)
2454 { return *_M_inner; }
2456 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2457 // 3500. join_view::iterator::operator->() is bogus
2458 constexpr _Inner_iter
2460 requires __detail::__has_arrow<_Inner_iter>
2461 && copyable<_Inner_iter>
2462 { return _M_inner; }
2464 constexpr _Iterator&
2467 auto&& __inner_range = [this] () -> auto&& {
2468 if constexpr (_S_ref_is_glvalue)
2471 return *_M_parent->_M_inner;
2473 if (++_M_inner == ranges::end(__inner_range))
2487 requires _S_ref_is_glvalue && forward_range<_Base>
2488 && forward_range<range_reference_t<_Base>>
2495 constexpr _Iterator&
2497 requires _S_ref_is_glvalue && bidirectional_range<_Base>
2498 && bidirectional_range<range_reference_t<_Base>>
2499 && common_range<range_reference_t<_Base>>
2501 if (_M_outer == ranges::end(_M_parent->_M_base))
2502 _M_inner = ranges::end(*--_M_outer);
2503 while (_M_inner == ranges::begin(*_M_outer))
2504 _M_inner = ranges::end(*--_M_outer);
2511 requires _S_ref_is_glvalue && bidirectional_range<_Base>
2512 && bidirectional_range<range_reference_t<_Base>>
2513 && common_range<range_reference_t<_Base>>
2520 friend constexpr bool
2521 operator==(const _Iterator& __x, const _Iterator& __y)
2522 requires _S_ref_is_glvalue
2523 && equality_comparable<_Outer_iter>
2524 && equality_comparable<_Inner_iter>
2526 return (__x._M_outer == __y._M_outer
2527 && __x._M_inner == __y._M_inner);
2530 friend constexpr decltype(auto)
2531 iter_move(const _Iterator& __i)
2532 noexcept(noexcept(ranges::iter_move(__i._M_inner)))
2533 { return ranges::iter_move(__i._M_inner); }
2535 friend constexpr void
2536 iter_swap(const _Iterator& __x, const _Iterator& __y)
2537 noexcept(noexcept(ranges::iter_swap(__x._M_inner, __y._M_inner)))
2538 requires indirectly_swappable<_Inner_iter>
2539 { return ranges::iter_swap(__x._M_inner, __y._M_inner); }
2541 friend _Iterator<!_Const>;
2542 template<bool> friend struct _Sentinel;
2545 template<bool _Const>
2549 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
2550 using _Base = join_view::_Base<_Const>;
2552 template<bool _Const2>
2554 __equal(const _Iterator<_Const2>& __i) const
2555 { return __i._M_outer == _M_end; }
2557 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2560 _Sentinel() = default;
2563 _Sentinel(_Parent* __parent)
2564 : _M_end(ranges::end(__parent->_M_base))
2568 _Sentinel(_Sentinel<!_Const> __s)
2569 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2570 : _M_end(std::move(__s._M_end))
2573 template<bool _Const2>
2574 requires sentinel_for<sentinel_t<_Base>,
2575 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
2576 friend constexpr bool
2577 operator==(const _Iterator<_Const2>& __x, const _Sentinel& __y)
2578 { return __y.__equal(__x); }
2580 friend _Sentinel<!_Const>;
2583 [[no_unique_address]]
2584 __detail::__non_propagating_cache<remove_cv_t<_InnerRange>> _M_inner;
2585 _Vp _M_base = _Vp();
2588 join_view() = default;
2591 join_view(_Vp __base)
2592 : _M_base(std::move(__base))
2596 base() const& requires copy_constructible<_Vp>
2601 { return std::move(_M_base); }
2606 constexpr bool __use_const
2607 = (__detail::__simple_view<_Vp>
2608 && is_reference_v<range_reference_t<_Vp>>);
2609 return _Iterator<__use_const>{this, ranges::begin(_M_base)};
2614 requires input_range<const _Vp>
2615 && is_reference_v<range_reference_t<const _Vp>>
2617 return _Iterator<true>{this, ranges::begin(_M_base)};
2623 if constexpr (forward_range<_Vp> && is_reference_v<_InnerRange>
2624 && forward_range<_InnerRange>
2625 && common_range<_Vp> && common_range<_InnerRange>)
2626 return _Iterator<__detail::__simple_view<_Vp>>{this,
2627 ranges::end(_M_base)};
2629 return _Sentinel<__detail::__simple_view<_Vp>>{this};
2634 requires input_range<const _Vp>
2635 && is_reference_v<range_reference_t<const _Vp>>
2637 if constexpr (forward_range<const _Vp>
2638 && is_reference_v<range_reference_t<const _Vp>>
2639 && forward_range<range_reference_t<const _Vp>>
2640 && common_range<const _Vp>
2641 && common_range<range_reference_t<const _Vp>>)
2642 return _Iterator<true>{this, ranges::end(_M_base)};
2644 return _Sentinel<true>{this};
2648 template<typename _Range>
2649 explicit join_view(_Range&&) -> join_view<views::all_t<_Range>>;
2655 template<typename _Range>
2656 concept __can_join_view
2657 = requires { join_view<all_t<_Range>>{std::declval<_Range>()}; };
2658 } // namespace __detail
2660 struct _Join : __adaptor::_RangeAdaptorClosure
2662 template<viewable_range _Range>
2663 requires __detail::__can_join_view<_Range>
2665 operator()(_Range&& __r) const
2667 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2668 // 3474. Nesting join_views is broken because of CTAD
2669 return join_view<all_t<_Range>>{std::forward<_Range>(__r)};
2673 inline constexpr _Join join;
2674 } // namespace views
2679 struct __require_constant;
2681 template<typename _Range>
2682 concept __tiny_range = sized_range<_Range>
2684 { typename __require_constant<remove_reference_t<_Range>::size()>; }
2685 && (remove_reference_t<_Range>::size() <= 1);
2687 template<typename _Base>
2688 struct __split_view_outer_iter_cat
2691 template<forward_range _Base>
2692 struct __split_view_outer_iter_cat<_Base>
2693 { using iterator_category = input_iterator_tag; };
2695 template<typename _Base>
2696 struct __split_view_inner_iter_cat
2699 template<forward_range _Base>
2700 struct __split_view_inner_iter_cat<_Base>
2703 static constexpr auto
2706 using _Cat = typename iterator_traits<iterator_t<_Base>>::iterator_category;
2707 if constexpr (derived_from<_Cat, forward_iterator_tag>)
2708 return forward_iterator_tag{};
2713 using iterator_category = decltype(_S_iter_cat());
2717 template<input_range _Vp, forward_range _Pattern>
2718 requires view<_Vp> && view<_Pattern>
2719 && indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
2721 && (forward_range<_Vp> || __detail::__tiny_range<_Pattern>)
2722 class split_view : public view_interface<split_view<_Vp, _Pattern>>
2725 template<bool _Const>
2726 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2728 template<bool _Const>
2731 template<bool _Const>
2733 : __detail::__split_view_outer_iter_cat<_Base<_Const>>
2736 using _Parent = __detail::__maybe_const_t<_Const, split_view>;
2737 using _Base = split_view::_Base<_Const>;
2741 { return __current() == ranges::end(_M_parent->_M_base); }
2743 // [range.split.outer] p1
2744 // Many of the following specifications refer to the notional member
2745 // current of outer-iterator. current is equivalent to current_ if
2746 // V models forward_range, and parent_->current_ otherwise.
2748 __current() noexcept
2750 if constexpr (forward_range<_Vp>)
2753 return _M_parent->_M_current;
2757 __current() const noexcept
2759 if constexpr (forward_range<_Vp>)
2762 return _M_parent->_M_current;
2765 _Parent* _M_parent = nullptr;
2767 // XXX: _M_current is present only if "V models forward_range"
2768 [[no_unique_address]]
2769 __detail::__maybe_present_t<forward_range<_Vp>,
2770 iterator_t<_Base>> _M_current;
2773 using iterator_concept = conditional_t<forward_range<_Base>,
2774 forward_iterator_tag,
2775 input_iterator_tag>;
2776 // iterator_category defined in __split_view_outer_iter_cat
2777 using difference_type = range_difference_t<_Base>;
2779 struct value_type : view_interface<value_type>
2782 _OuterIter _M_i = _OuterIter();
2785 value_type() = default;
2788 value_type(_OuterIter __i)
2789 : _M_i(std::move(__i))
2792 constexpr _InnerIter<_Const>
2794 requires copyable<_OuterIter>
2795 { return _InnerIter<_Const>{_M_i}; }
2797 constexpr _InnerIter<_Const>
2799 requires (!copyable<_OuterIter>)
2800 { return _InnerIter<_Const>{std::move(_M_i)}; }
2802 constexpr default_sentinel_t
2804 { return default_sentinel; }
2807 _OuterIter() = default;
2810 _OuterIter(_Parent* __parent) requires (!forward_range<_Base>)
2811 : _M_parent(__parent)
2815 _OuterIter(_Parent* __parent, iterator_t<_Base> __current)
2816 requires forward_range<_Base>
2817 : _M_parent(__parent),
2818 _M_current(std::move(__current))
2822 _OuterIter(_OuterIter<!_Const> __i)
2824 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
2825 : _M_parent(__i._M_parent), _M_current(std::move(__i._M_current))
2828 constexpr value_type
2830 { return value_type{*this}; }
2832 constexpr _OuterIter&
2835 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2836 // 3505. split_view::outer-iterator::operator++ misspecified
2837 const auto __end = ranges::end(_M_parent->_M_base);
2838 if (__current() == __end)
2840 const auto [__pbegin, __pend] = subrange{_M_parent->_M_pattern};
2841 if (__pbegin == __pend)
2843 else if constexpr (__detail::__tiny_range<_Pattern>)
2845 __current() = __detail::find(std::move(__current()), __end,
2847 if (__current() != __end)
2854 = __detail::mismatch(__current(), __end, __pbegin, __pend);
2860 } while (++__current() != __end);
2864 constexpr decltype(auto)
2867 if constexpr (forward_range<_Base>)
2877 friend constexpr bool
2878 operator==(const _OuterIter& __x, const _OuterIter& __y)
2879 requires forward_range<_Base>
2880 { return __x._M_current == __y._M_current; }
2882 friend constexpr bool
2883 operator==(const _OuterIter& __x, default_sentinel_t)
2884 { return __x.__at_end(); };
2886 friend _OuterIter<!_Const>;
2887 friend _InnerIter<_Const>;
2890 template<bool _Const>
2892 : __detail::__split_view_inner_iter_cat<_Base<_Const>>
2895 using _Base = split_view::_Base<_Const>;
2900 auto [__pcur, __pend] = subrange{_M_i._M_parent->_M_pattern};
2901 auto __end = ranges::end(_M_i._M_parent->_M_base);
2902 if constexpr (__detail::__tiny_range<_Pattern>)
2904 const auto& __cur = _M_i_current();
2907 if (__pcur == __pend)
2908 return _M_incremented;
2909 return *__cur == *__pcur;
2913 auto __cur = _M_i_current();
2916 if (__pcur == __pend)
2917 return _M_incremented;
2920 if (*__cur != *__pcur)
2922 if (++__pcur == __pend)
2924 } while (++__cur != __end);
2930 _M_i_current() noexcept
2931 { return _M_i.__current(); }
2934 _M_i_current() const noexcept
2935 { return _M_i.__current(); }
2937 _OuterIter<_Const> _M_i = _OuterIter<_Const>();
2938 bool _M_incremented = false;
2941 using iterator_concept
2942 = typename _OuterIter<_Const>::iterator_concept;
2943 // iterator_category defined in __split_view_inner_iter_cat
2944 using value_type = range_value_t<_Base>;
2945 using difference_type = range_difference_t<_Base>;
2947 _InnerIter() = default;
2950 _InnerIter(_OuterIter<_Const> __i)
2951 : _M_i(std::move(__i))
2954 constexpr decltype(auto)
2956 { return *_M_i_current(); }
2958 constexpr _InnerIter&
2961 _M_incremented = true;
2962 if constexpr (!forward_range<_Base>)
2963 if constexpr (_Pattern::size() == 0)
2969 constexpr decltype(auto)
2972 if constexpr (forward_range<_Base>)
2982 friend constexpr bool
2983 operator==(const _InnerIter& __x, const _InnerIter& __y)
2984 requires forward_range<_Base>
2985 { return __x._M_i == __y._M_i; }
2987 friend constexpr bool
2988 operator==(const _InnerIter& __x, default_sentinel_t)
2989 { return __x.__at_end(); }
2991 friend constexpr decltype(auto)
2992 iter_move(const _InnerIter& __i)
2993 noexcept(noexcept(ranges::iter_move(__i._M_i_current())))
2994 { return ranges::iter_move(__i._M_i_current()); }
2996 friend constexpr void
2997 iter_swap(const _InnerIter& __x, const _InnerIter& __y)
2998 noexcept(noexcept(ranges::iter_swap(__x._M_i_current(),
2999 __y._M_i_current())))
3000 requires indirectly_swappable<iterator_t<_Base>>
3001 { ranges::iter_swap(__x._M_i_current(), __y._M_i_current()); }
3004 _Pattern _M_pattern = _Pattern();
3005 // XXX: _M_current is "present only if !forward_range<V>"
3006 [[no_unique_address]]
3007 __detail::__maybe_present_t<!forward_range<_Vp>,
3008 iterator_t<_Vp>> _M_current;
3009 _Vp _M_base = _Vp();
3013 split_view() = default;
3016 split_view(_Vp __base, _Pattern __pattern)
3017 : _M_pattern(std::move(__pattern)), _M_base(std::move(__base))
3020 template<input_range _Range>
3021 requires constructible_from<_Vp, views::all_t<_Range>>
3022 && constructible_from<_Pattern, single_view<range_value_t<_Range>>>
3024 split_view(_Range&& __r, range_value_t<_Range> __e)
3025 : _M_pattern(views::single(std::move(__e))),
3026 _M_base(views::all(std::forward<_Range>(__r)))
3030 base() const& requires copy_constructible<_Vp>
3035 { return std::move(_M_base); }
3040 if constexpr (forward_range<_Vp>)
3041 return _OuterIter<__detail::__simple_view<_Vp>>{
3042 this, ranges::begin(_M_base)};
3045 _M_current = ranges::begin(_M_base);
3046 return _OuterIter<false>{this};
3051 begin() const requires forward_range<_Vp> && forward_range<const _Vp>
3053 return _OuterIter<true>{this, ranges::begin(_M_base)};
3057 end() requires forward_range<_Vp> && common_range<_Vp>
3059 return _OuterIter<__detail::__simple_view<_Vp>>{
3060 this, ranges::end(_M_base)};
3066 if constexpr (forward_range<_Vp>
3067 && forward_range<const _Vp>
3068 && common_range<const _Vp>)
3069 return _OuterIter<true>{this, ranges::end(_M_base)};
3071 return default_sentinel;
3075 template<typename _Range, typename _Pattern>
3076 split_view(_Range&&, _Pattern&&)
3077 -> split_view<views::all_t<_Range>, views::all_t<_Pattern>>;
3079 template<input_range _Range>
3080 split_view(_Range&&, range_value_t<_Range>)
3081 -> split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
3087 template<typename _Range, typename _Pattern>
3088 concept __can_split_view
3089 = requires { split_view(std::declval<_Range>(), std::declval<_Pattern>()); };
3090 } // namespace __detail
3092 struct _Split : __adaptor::_RangeAdaptor<_Split>
3094 template<viewable_range _Range, typename _Pattern>
3095 requires __detail::__can_split_view<_Range, _Pattern>
3097 operator()(_Range&& __r, _Pattern&& __f) const
3099 return split_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
3102 using _RangeAdaptor<_Split>::operator();
3103 static constexpr int _S_arity = 2;
3106 inline constexpr _Split split;
3107 } // namespace views
3113 template<input_or_output_iterator _Iter>
3115 operator()(_Iter __i, iter_difference_t<_Iter> __n) const
3117 if constexpr (random_access_iterator<_Iter>)
3118 return subrange(__i, __i + __n);
3120 return subrange(counted_iterator(std::move(__i), __n),
3125 inline constexpr _Counted counted{};
3126 } // namespace views
3129 requires (!common_range<_Vp>) && copyable<iterator_t<_Vp>>
3130 class common_view : public view_interface<common_view<_Vp>>
3133 _Vp _M_base = _Vp();
3136 common_view() = default;
3139 common_view(_Vp __r)
3140 : _M_base(std::move(__r))
3143 /* XXX: LWG 3280 didn't remove this constructor, but I think it should?
3144 template<viewable_range _Range>
3145 requires (!common_range<_Range>)
3146 && constructible_from<_Vp, views::all_t<_Range>>
3148 common_view(_Range&& __r)
3149 : _M_base(views::all(std::forward<_Range>(__r)))
3154 base() const& requires copy_constructible<_Vp>
3159 { return std::move(_M_base); }
3164 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3165 return ranges::begin(_M_base);
3167 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
3168 (ranges::begin(_M_base));
3172 begin() const requires range<const _Vp>
3174 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
3175 return ranges::begin(_M_base);
3177 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
3178 (ranges::begin(_M_base));
3184 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3185 return ranges::begin(_M_base) + ranges::size(_M_base);
3187 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
3188 (ranges::end(_M_base));
3192 end() const requires range<const _Vp>
3194 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
3195 return ranges::begin(_M_base) + ranges::size(_M_base);
3197 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
3198 (ranges::end(_M_base));
3202 size() requires sized_range<_Vp>
3203 { return ranges::size(_M_base); }
3206 size() const requires sized_range<const _Vp>
3207 { return ranges::size(_M_base); }
3210 template<typename _Range>
3211 common_view(_Range&&) -> common_view<views::all_t<_Range>>;
3213 template<typename _Tp>
3214 inline constexpr bool enable_borrowed_range<common_view<_Tp>>
3215 = enable_borrowed_range<_Tp>;
3221 template<typename _Range>
3222 concept __already_common = common_range<_Range>
3223 && requires { views::all(std::declval<_Range>()); };
3225 template<typename _Range>
3226 concept __can_common_view
3227 = requires { common_view{std::declval<_Range>()}; };
3228 } // namespace __detail
3230 struct _Common : __adaptor::_RangeAdaptorClosure
3232 template<viewable_range _Range>
3233 requires __detail::__already_common<_Range>
3234 || __detail::__can_common_view<_Range>
3236 operator()(_Range&& __r) const
3238 if constexpr (__detail::__already_common<_Range>)
3239 return views::all(std::forward<_Range>(__r));
3241 return common_view{std::forward<_Range>(__r)};
3245 inline constexpr _Common common;
3246 } // namespace views
3249 requires bidirectional_range<_Vp>
3250 class reverse_view : public view_interface<reverse_view<_Vp>>
3253 static constexpr bool _S_needs_cached_begin
3254 = !common_range<_Vp> && !random_access_range<_Vp>;
3256 [[no_unique_address]]
3257 __detail::__maybe_present_t<_S_needs_cached_begin,
3258 __detail::_CachedPosition<_Vp>>
3260 _Vp _M_base = _Vp();
3263 reverse_view() = default;
3266 reverse_view(_Vp __r)
3267 : _M_base(std::move(__r))
3271 base() const& requires copy_constructible<_Vp>
3276 { return std::move(_M_base); }
3278 constexpr reverse_iterator<iterator_t<_Vp>>
3281 if constexpr (_S_needs_cached_begin)
3282 if (_M_cached_begin._M_has_value())
3283 return std::make_reverse_iterator(_M_cached_begin._M_get(_M_base));
3285 auto __it = ranges::next(ranges::begin(_M_base), ranges::end(_M_base));
3286 if constexpr (_S_needs_cached_begin)
3287 _M_cached_begin._M_set(_M_base, __it);
3288 return std::make_reverse_iterator(std::move(__it));
3292 begin() requires common_range<_Vp>
3293 { return std::make_reverse_iterator(ranges::end(_M_base)); }
3296 begin() const requires common_range<const _Vp>
3297 { return std::make_reverse_iterator(ranges::end(_M_base)); }
3299 constexpr reverse_iterator<iterator_t<_Vp>>
3301 { return std::make_reverse_iterator(ranges::begin(_M_base)); }
3304 end() const requires common_range<const _Vp>
3305 { return std::make_reverse_iterator(ranges::begin(_M_base)); }
3308 size() requires sized_range<_Vp>
3309 { return ranges::size(_M_base); }
3312 size() const requires sized_range<const _Vp>
3313 { return ranges::size(_M_base); }
3316 template<typename _Range>
3317 reverse_view(_Range&&) -> reverse_view<views::all_t<_Range>>;
3319 template<typename _Tp>
3320 inline constexpr bool enable_borrowed_range<reverse_view<_Tp>>
3321 = enable_borrowed_range<_Tp>;
3328 inline constexpr bool __is_reversible_subrange = false;
3330 template<typename _Iter, subrange_kind _Kind>
3331 inline constexpr bool
3332 __is_reversible_subrange<subrange<reverse_iterator<_Iter>,
3333 reverse_iterator<_Iter>,
3337 inline constexpr bool __is_reverse_view = false;
3339 template<typename _Vp>
3340 inline constexpr bool __is_reverse_view<reverse_view<_Vp>> = true;
3342 template<typename _Range>
3343 concept __can_reverse_view
3344 = requires { reverse_view{std::declval<_Range>()}; };
3345 } // namespace __detail
3347 struct _Reverse : __adaptor::_RangeAdaptorClosure
3349 template<viewable_range _Range>
3350 requires __detail::__is_reverse_view<remove_cvref_t<_Range>>
3351 || __detail::__is_reversible_subrange<remove_cvref_t<_Range>>
3352 || __detail::__can_reverse_view<_Range>
3354 operator()(_Range&& __r) const
3356 using _Tp = remove_cvref_t<_Range>;
3357 if constexpr (__detail::__is_reverse_view<_Tp>)
3358 return std::forward<_Range>(__r).base();
3359 else if constexpr (__detail::__is_reversible_subrange<_Tp>)
3361 using _Iter = decltype(ranges::begin(__r).base());
3362 if constexpr (sized_range<_Tp>)
3363 return subrange<_Iter, _Iter, subrange_kind::sized>
3364 {__r.end().base(), __r.begin().base(), __r.size()};
3366 return subrange<_Iter, _Iter, subrange_kind::unsized>
3367 {__r.end().base(), __r.begin().base()};
3370 return reverse_view{std::forward<_Range>(__r)};
3374 inline constexpr _Reverse reverse;
3375 } // namespace views
3379 template<typename _Tp, size_t _Nm>
3380 concept __has_tuple_element = requires(_Tp __t)
3382 typename tuple_size<_Tp>::type;
3383 requires _Nm < tuple_size_v<_Tp>;
3384 typename tuple_element_t<_Nm, _Tp>;
3385 { std::get<_Nm>(__t) }
3386 -> convertible_to<const tuple_element_t<_Nm, _Tp>&>;
3389 template<typename _Tp, size_t _Nm>
3390 concept __returnable_element
3391 = is_reference_v<_Tp> || move_constructible<tuple_element_t<_Nm, _Tp>>;
3394 template<input_range _Vp, size_t _Nm>
3396 && __detail::__has_tuple_element<range_value_t<_Vp>, _Nm>
3397 && __detail::__has_tuple_element<remove_reference_t<range_reference_t<_Vp>>,
3399 && __detail::__returnable_element<range_reference_t<_Vp>, _Nm>
3400 class elements_view : public view_interface<elements_view<_Vp, _Nm>>
3403 elements_view() = default;
3406 elements_view(_Vp base)
3407 : _M_base(std::move(base))
3411 base() const& requires copy_constructible<_Vp>
3416 { return std::move(_M_base); }
3419 begin() requires (!__detail::__simple_view<_Vp>)
3420 { return _Iterator<false>(ranges::begin(_M_base)); }
3423 begin() const requires range<const _Vp>
3424 { return _Iterator<true>(ranges::begin(_M_base)); }
3427 end() requires (!__detail::__simple_view<_Vp> && !common_range<_Vp>)
3428 { return _Sentinel<false>{ranges::end(_M_base)}; }
3431 end() requires (!__detail::__simple_view<_Vp> && common_range<_Vp>)
3432 { return _Iterator<false>{ranges::end(_M_base)}; }
3435 end() const requires range<const _Vp>
3436 { return _Sentinel<true>{ranges::end(_M_base)}; }
3439 end() const requires common_range<const _Vp>
3440 { return _Iterator<true>{ranges::end(_M_base)}; }
3443 size() requires sized_range<_Vp>
3444 { return ranges::size(_M_base); }
3447 size() const requires sized_range<const _Vp>
3448 { return ranges::size(_M_base); }
3451 template<bool _Const>
3452 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
3454 template<bool _Const>
3458 template<bool _Const>
3459 requires forward_range<_Base<_Const>>
3460 struct __iter_cat<_Const>
3463 static auto _S_iter_cat()
3465 using _Base = elements_view::_Base<_Const>;
3466 using _Cat = typename iterator_traits<iterator_t<_Base>>::iterator_category;
3467 using _Res = decltype((std::get<_Nm>(*std::declval<iterator_t<_Base>>())));
3468 if constexpr (!is_lvalue_reference_v<_Res>)
3469 return input_iterator_tag{};
3470 else if constexpr (derived_from<_Cat, random_access_iterator_tag>)
3471 return random_access_iterator_tag{};
3476 using iterator_category = decltype(_S_iter_cat());
3479 template<bool _Const>
3482 template<bool _Const>
3483 struct _Iterator : __iter_cat<_Const>
3486 using _Base = elements_view::_Base<_Const>;
3488 iterator_t<_Base> _M_current = iterator_t<_Base>();
3490 static constexpr decltype(auto)
3491 _S_get_element(const iterator_t<_Base>& __i)
3493 if constexpr (is_reference_v<range_reference_t<_Base>>)
3494 return std::get<_Nm>(*__i);
3497 using _Et = remove_cv_t<tuple_element_t<_Nm, range_reference_t<_Base>>>;
3498 return static_cast<_Et>(std::get<_Nm>(*__i));
3505 if constexpr (random_access_range<_Vp>)
3506 return random_access_iterator_tag{};
3507 else if constexpr (bidirectional_range<_Vp>)
3508 return bidirectional_iterator_tag{};
3509 else if constexpr (forward_range<_Vp>)
3510 return forward_iterator_tag{};
3512 return input_iterator_tag{};
3515 friend _Iterator<!_Const>;
3518 using iterator_concept = decltype(_S_iter_concept());
3519 // iterator_category defined in elements_view::__iter_cat
3521 = remove_cvref_t<tuple_element_t<_Nm, range_value_t<_Base>>>;
3522 using difference_type = range_difference_t<_Base>;
3524 _Iterator() = default;
3527 _Iterator(iterator_t<_Base> current)
3528 : _M_current(std::move(current))
3532 _Iterator(_Iterator<!_Const> i)
3533 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
3534 : _M_current(std::move(i._M_current))
3537 constexpr iterator_t<_Base>
3539 requires copyable<iterator_t<_Base>>
3540 { return _M_current; }
3542 constexpr iterator_t<_Base>
3544 { return std::move(_M_current); }
3546 constexpr decltype(auto)
3548 { return _S_get_element(_M_current); }
3550 constexpr _Iterator&
3562 operator++(int) requires forward_range<_Base>
3569 constexpr _Iterator&
3570 operator--() requires bidirectional_range<_Base>
3577 operator--(int) requires bidirectional_range<_Base>
3584 constexpr _Iterator&
3585 operator+=(difference_type __n)
3586 requires random_access_range<_Base>
3592 constexpr _Iterator&
3593 operator-=(difference_type __n)
3594 requires random_access_range<_Base>
3600 constexpr decltype(auto)
3601 operator[](difference_type __n) const
3602 requires random_access_range<_Base>
3603 { return _S_get_element(_M_current + __n); }
3605 friend constexpr bool
3606 operator==(const _Iterator& __x, const _Iterator& __y)
3607 requires equality_comparable<iterator_t<_Base>>
3608 { return __x._M_current == __y._M_current; }
3610 friend constexpr bool
3611 operator<(const _Iterator& __x, const _Iterator& __y)
3612 requires random_access_range<_Base>
3613 { return __x._M_current < __y._M_current; }
3615 friend constexpr bool
3616 operator>(const _Iterator& __x, const _Iterator& __y)
3617 requires random_access_range<_Base>
3618 { return __y._M_current < __x._M_current; }
3620 friend constexpr bool
3621 operator<=(const _Iterator& __x, const _Iterator& __y)
3622 requires random_access_range<_Base>
3623 { return !(__y._M_current > __x._M_current); }
3625 friend constexpr bool
3626 operator>=(const _Iterator& __x, const _Iterator& __y)
3627 requires random_access_range<_Base>
3628 { return !(__x._M_current > __y._M_current); }
3630 #ifdef __cpp_lib_three_way_comparison
3631 friend constexpr auto
3632 operator<=>(const _Iterator& __x, const _Iterator& __y)
3633 requires random_access_range<_Base>
3634 && three_way_comparable<iterator_t<_Base>>
3635 { return __x._M_current <=> __y._M_current; }
3638 friend constexpr _Iterator
3639 operator+(const _Iterator& __x, difference_type __y)
3640 requires random_access_range<_Base>
3641 { return _Iterator{__x} += __y; }
3643 friend constexpr _Iterator
3644 operator+(difference_type __x, const _Iterator& __y)
3645 requires random_access_range<_Base>
3646 { return __y + __x; }
3648 friend constexpr _Iterator
3649 operator-(const _Iterator& __x, difference_type __y)
3650 requires random_access_range<_Base>
3651 { return _Iterator{__x} -= __y; }
3653 // _GLIBCXX_RESOLVE_LIB_DEFECTS
3654 // 3483. transform_view::iterator's difference is overconstrained
3655 friend constexpr difference_type
3656 operator-(const _Iterator& __x, const _Iterator& __y)
3657 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
3658 { return __x._M_current - __y._M_current; }
3660 friend _Sentinel<_Const>;
3663 template<bool _Const>
3668 _M_equal(const _Iterator<_Const>& __x) const
3669 { return __x._M_current == _M_end; }
3671 using _Base = elements_view::_Base<_Const>;
3672 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
3675 _Sentinel() = default;
3678 _Sentinel(sentinel_t<_Base> __end)
3679 : _M_end(std::move(__end))
3683 _Sentinel(_Sentinel<!_Const> __other)
3685 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
3686 : _M_end(std::move(__other._M_end))
3689 constexpr sentinel_t<_Base>
3693 template<bool _Const2>
3694 requires sentinel_for<sentinel_t<_Base>,
3695 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
3696 friend constexpr bool
3697 operator==(const _Iterator<_Const2>& __x, const _Sentinel& __y)
3698 { return __y._M_equal(__x); }
3700 template<bool _Const2,
3701 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
3702 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
3703 friend constexpr range_difference_t<_Base2>
3704 operator-(const _Iterator<_Const2>& __x, const _Sentinel& __y)
3705 { return __x._M_current - __y._M_end; }
3707 template<bool _Const2,
3708 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
3709 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
3710 friend constexpr range_difference_t<_Base>
3711 operator-(const _Sentinel& __x, const _Iterator<_Const2>& __y)
3712 { return __x._M_end - __y._M_current; }
3714 friend _Sentinel<!_Const>;
3717 _Vp _M_base = _Vp();
3720 template<typename _Tp, size_t _Nm>
3721 inline constexpr bool enable_borrowed_range<elements_view<_Tp, _Nm>>
3722 = enable_borrowed_range<_Tp>;
3724 template<typename _Range>
3725 using keys_view = elements_view<views::all_t<_Range>, 0>;
3727 template<typename _Range>
3728 using values_view = elements_view<views::all_t<_Range>, 1>;
3734 template<size_t _Nm, typename _Range>
3735 concept __can_elements_view
3736 = requires { elements_view<all_t<_Range>, _Nm>{std::declval<_Range>()}; };
3737 } // namespace __detail
3739 template<size_t _Nm>
3740 struct _Elements : __adaptor::_RangeAdaptorClosure
3742 template<viewable_range _Range>
3743 requires __detail::__can_elements_view<_Nm, _Range>
3745 operator()(_Range&& __r) const
3747 return elements_view<all_t<_Range>, _Nm>{std::forward<_Range>(__r)};
3751 template<size_t _Nm>
3752 inline constexpr _Elements<_Nm> elements;
3753 inline constexpr auto keys = elements<0>;
3754 inline constexpr auto values = elements<1>;
3755 } // namespace views
3757 } // namespace ranges
3759 namespace views = ranges::views;
3761 _GLIBCXX_END_NAMESPACE_VERSION
3763 #endif // library concepts
3765 #endif /* _GLIBCXX_RANGES */