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>)
116 if (this != std::__addressof(__that))
119 this->emplace(*__that);
127 operator=(__box&& __that)
128 noexcept(is_nothrow_move_constructible_v<_Tp>)
129 requires (!movable<_Tp>)
131 if (this != std::__addressof(__that))
134 this->emplace(std::move(*__that));
142 // For types which are already copyable, this specialization of the
143 // copyable wrapper stores the object directly without going through
144 // std::optional. It provides just the subset of the primary template's
145 // API that we currently use.
146 template<__boxable _Tp>
147 requires copyable<_Tp>
151 [[no_unique_address]] _Tp _M_value = _Tp();
154 __box() requires default_initializable<_Tp> = default;
157 __box(const _Tp& __t)
158 noexcept(is_nothrow_copy_constructible_v<_Tp>)
164 noexcept(is_nothrow_move_constructible_v<_Tp>)
165 : _M_value(std::move(__t))
168 template<typename... _Args>
169 requires constructible_from<_Tp, _Args...>
171 __box(in_place_t, _Args&&... __args)
172 noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
173 : _M_value(std::forward<_Args>(__args)...)
177 has_value() const noexcept
185 operator*() const noexcept
189 operator->() noexcept
190 { return std::__addressof(_M_value); }
193 operator->() const noexcept
194 { return std::__addressof(_M_value); }
196 } // namespace __detail
198 /// A view that contains exactly one element.
199 template<copy_constructible _Tp> requires is_object_v<_Tp>
200 class single_view : public view_interface<single_view<_Tp>>
203 single_view() requires default_initializable<_Tp> = default;
206 single_view(const _Tp& __t)
211 single_view(_Tp&& __t)
212 : _M_value(std::move(__t))
215 // _GLIBCXX_RESOLVE_LIB_DEFECTS
216 // 3428. single_view's in place constructor should be explicit
217 template<typename... _Args>
218 requires constructible_from<_Tp, _Args...>
220 single_view(in_place_t, _Args&&... __args)
221 : _M_value{in_place, std::forward<_Args>(__args)...}
229 begin() const noexcept
234 { return data() + 1; }
238 { return data() + 1; }
240 static constexpr size_t
246 { return _M_value.operator->(); }
249 data() const noexcept
250 { return _M_value.operator->(); }
253 [[no_unique_address]] __detail::__box<_Tp> _M_value;
256 template<typename _Tp>
257 single_view(_Tp) -> single_view<_Tp>;
261 template<typename _Wp>
262 constexpr auto __to_signed_like(_Wp __w) noexcept
264 if constexpr (!integral<_Wp>)
265 return iter_difference_t<_Wp>();
266 else if constexpr (sizeof(iter_difference_t<_Wp>) > sizeof(_Wp))
267 return iter_difference_t<_Wp>(__w);
268 else if constexpr (sizeof(ptrdiff_t) > sizeof(_Wp))
269 return ptrdiff_t(__w);
270 else if constexpr (sizeof(long long) > sizeof(_Wp))
271 return (long long)(__w);
272 #ifdef __SIZEOF_INT128__
273 else if constexpr (__SIZEOF_INT128__ > sizeof(_Wp))
274 return __int128(__w);
277 return __max_diff_type(__w);
280 template<typename _Wp>
281 using __iota_diff_t = decltype(__to_signed_like(std::declval<_Wp>()));
283 template<typename _It>
284 concept __decrementable = incrementable<_It>
287 { --__i } -> same_as<_It&>;
288 { __i-- } -> same_as<_It>;
291 template<typename _It>
292 concept __advanceable = __decrementable<_It> && totally_ordered<_It>
293 && requires( _It __i, const _It __j, const __iota_diff_t<_It> __n)
295 { __i += __n } -> same_as<_It&>;
296 { __i -= __n } -> same_as<_It&>;
300 { __j - __j } -> convertible_to<__iota_diff_t<_It>>;
303 template<typename _Winc>
304 struct __iota_view_iter_cat
307 template<incrementable _Winc>
308 struct __iota_view_iter_cat<_Winc>
309 { using iterator_category = input_iterator_tag; };
310 } // namespace __detail
312 template<weakly_incrementable _Winc,
313 semiregular _Bound = unreachable_sentinel_t>
314 requires std::__detail::__weakly_eq_cmp_with<_Winc, _Bound>
316 class iota_view : public view_interface<iota_view<_Winc, _Bound>>
321 struct _Iterator : __detail::__iota_view_iter_cat<_Winc>
327 using namespace __detail;
328 if constexpr (__advanceable<_Winc>)
329 return random_access_iterator_tag{};
330 else if constexpr (__decrementable<_Winc>)
331 return bidirectional_iterator_tag{};
332 else if constexpr (incrementable<_Winc>)
333 return forward_iterator_tag{};
335 return input_iterator_tag{};
339 using iterator_concept = decltype(_S_iter_concept());
340 // iterator_category defined in __iota_view_iter_cat
341 using value_type = _Winc;
342 using difference_type = __detail::__iota_diff_t<_Winc>;
344 _Iterator() requires default_initializable<_Winc> = default;
347 _Iterator(_Winc __value)
348 : _M_value(__value) { }
351 operator*() const noexcept(is_nothrow_copy_constructible_v<_Winc>)
366 operator++(int) requires incrementable<_Winc>
374 operator--() requires __detail::__decrementable<_Winc>
381 operator--(int) requires __detail::__decrementable<_Winc>
389 operator+=(difference_type __n) requires __detail::__advanceable<_Winc>
391 using __detail::__is_integer_like;
392 using __detail::__is_signed_integer_like;
393 if constexpr (__is_integer_like<_Winc>
394 && !__is_signed_integer_like<_Winc>)
396 if (__n >= difference_type(0))
397 _M_value += static_cast<_Winc>(__n);
399 _M_value -= static_cast<_Winc>(-__n);
407 operator-=(difference_type __n) requires __detail::__advanceable<_Winc>
409 using __detail::__is_integer_like;
410 using __detail::__is_signed_integer_like;
411 if constexpr (__is_integer_like<_Winc>
412 && !__is_signed_integer_like<_Winc>)
414 if (__n >= difference_type(0))
415 _M_value -= static_cast<_Winc>(__n);
417 _M_value += static_cast<_Winc>(-__n);
425 operator[](difference_type __n) const
426 requires __detail::__advanceable<_Winc>
427 { return _Winc(_M_value + __n); }
429 friend constexpr bool
430 operator==(const _Iterator& __x, const _Iterator& __y)
431 requires equality_comparable<_Winc>
432 { return __x._M_value == __y._M_value; }
434 friend constexpr bool
435 operator<(const _Iterator& __x, const _Iterator& __y)
436 requires totally_ordered<_Winc>
437 { return __x._M_value < __y._M_value; }
439 friend constexpr bool
440 operator>(const _Iterator& __x, const _Iterator& __y)
441 requires totally_ordered<_Winc>
442 { return __y < __x; }
444 friend constexpr bool
445 operator<=(const _Iterator& __x, const _Iterator& __y)
446 requires totally_ordered<_Winc>
447 { return !(__y < __x); }
449 friend constexpr bool
450 operator>=(const _Iterator& __x, const _Iterator& __y)
451 requires totally_ordered<_Winc>
452 { return !(__x < __y); }
454 #ifdef __cpp_lib_three_way_comparison
455 friend constexpr auto
456 operator<=>(const _Iterator& __x, const _Iterator& __y)
457 requires totally_ordered<_Winc> && three_way_comparable<_Winc>
458 { return __x._M_value <=> __y._M_value; }
461 friend constexpr _Iterator
462 operator+(_Iterator __i, difference_type __n)
463 requires __detail::__advanceable<_Winc>
469 friend constexpr _Iterator
470 operator+(difference_type __n, _Iterator __i)
471 requires __detail::__advanceable<_Winc>
472 { return __i += __n; }
474 friend constexpr _Iterator
475 operator-(_Iterator __i, difference_type __n)
476 requires __detail::__advanceable<_Winc>
482 friend constexpr difference_type
483 operator-(const _Iterator& __x, const _Iterator& __y)
484 requires __detail::__advanceable<_Winc>
486 using __detail::__is_integer_like;
487 using __detail::__is_signed_integer_like;
488 using _Dt = difference_type;
489 if constexpr (__is_integer_like<_Winc>)
491 if constexpr (__is_signed_integer_like<_Winc>)
492 return _Dt(_Dt(__x._M_value) - _Dt(__y._M_value));
494 return (__y._M_value > __x._M_value)
495 ? _Dt(-_Dt(__y._M_value - __x._M_value))
496 : _Dt(__x._M_value - __y._M_value);
499 return __x._M_value - __y._M_value;
503 _Winc _M_value = _Winc();
513 _M_equal(const _Iterator& __x) const
514 { return __x._M_value == _M_bound; }
517 _M_distance_from(const _Iterator& __x) const
518 { return _M_bound - __x._M_value; }
520 _Bound _M_bound = _Bound();
523 _Sentinel() = default;
526 _Sentinel(_Bound __bound)
527 : _M_bound(__bound) { }
529 friend constexpr bool
530 operator==(const _Iterator& __x, const _Sentinel& __y)
531 { return __y._M_equal(__x); }
533 friend constexpr iter_difference_t<_Winc>
534 operator-(const _Iterator& __x, const _Sentinel& __y)
535 requires sized_sentinel_for<_Bound, _Winc>
536 { return -__y._M_distance_from(__x); }
538 friend constexpr iter_difference_t<_Winc>
539 operator-(const _Sentinel& __x, const _Iterator& __y)
540 requires sized_sentinel_for<_Bound, _Winc>
541 { return __x._M_distance_from(__y); }
546 _Winc _M_value = _Winc();
547 [[no_unique_address]] _Bound _M_bound = _Bound();
550 iota_view() requires default_initializable<_Winc> = default;
553 iota_view(_Winc __value)
558 iota_view(type_identity_t<_Winc> __value,
559 type_identity_t<_Bound> __bound)
560 : _M_value(__value), _M_bound(__bound)
562 if constexpr (totally_ordered_with<_Winc, _Bound>)
563 __glibcxx_assert( bool(__value <= __bound) );
567 iota_view(_Iterator __first, _Iterator __last)
568 requires same_as<_Winc, _Bound>
569 : iota_view(__first._M_value, __last._M_value)
573 iota_view(_Iterator __first, unreachable_sentinel_t __last)
574 requires same_as<_Bound, unreachable_sentinel_t>
575 : iota_view(__first._M_value, __last)
579 iota_view(_Iterator __first, _Sentinel __last)
580 requires (!same_as<_Winc, _Bound>) && (!same_as<_Bound, unreachable_sentinel_t>)
581 : iota_view(__first._M_value, __last._M_bound)
585 begin() const { return _Iterator{_M_value}; }
590 if constexpr (same_as<_Bound, unreachable_sentinel_t>)
591 return unreachable_sentinel;
593 return _Sentinel{_M_bound};
597 end() const requires same_as<_Winc, _Bound>
598 { return _Iterator{_M_bound}; }
602 requires (same_as<_Winc, _Bound> && __detail::__advanceable<_Winc>)
603 || (integral<_Winc> && integral<_Bound>)
604 || sized_sentinel_for<_Bound, _Winc>
606 using __detail::__is_integer_like;
607 using __detail::__to_unsigned_like;
608 if constexpr (integral<_Winc> && integral<_Bound>)
610 using _Up = make_unsigned_t<decltype(_M_bound - _M_value)>;
611 return _Up(_M_bound) - _Up(_M_value);
613 else if constexpr (__is_integer_like<_Winc>)
614 return __to_unsigned_like(_M_bound) - __to_unsigned_like(_M_value);
616 return __to_unsigned_like(_M_bound - _M_value);
620 template<typename _Winc, typename _Bound>
621 requires (!__detail::__is_integer_like<_Winc>
622 || !__detail::__is_integer_like<_Bound>
623 || (__detail::__is_signed_integer_like<_Winc>
624 == __detail::__is_signed_integer_like<_Bound>))
625 iota_view(_Winc, _Bound) -> iota_view<_Winc, _Bound>;
627 template<weakly_incrementable _Winc, semiregular _Bound>
628 inline constexpr bool
629 enable_borrowed_range<iota_view<_Winc, _Bound>> = true;
633 template<typename _Tp>
634 inline constexpr empty_view<_Tp> empty{};
638 template<typename _Tp>
640 operator()(_Tp&& __e) const
641 { return single_view<decay_t<_Tp>>(std::forward<_Tp>(__e)); }
644 inline constexpr _Single single{};
648 template<typename _Tp>
650 operator()(_Tp&& __e) const
651 { return iota_view(std::forward<_Tp>(__e)); }
653 template<typename _Tp, typename _Up>
655 operator()(_Tp&& __e, _Up&& __f) const
656 { return iota_view(std::forward<_Tp>(__e), std::forward<_Up>(__f)); }
659 inline constexpr _Iota iota{};
664 template<typename _Val, typename _CharT, typename _Traits>
665 concept __stream_extractable
666 = requires(basic_istream<_CharT, _Traits>& is, _Val& t) { is >> t; };
667 } // namespace __detail
669 template<movable _Val, typename _CharT,
670 typename _Traits = char_traits<_CharT>>
671 requires default_initializable<_Val>
672 && __detail::__stream_extractable<_Val, _CharT, _Traits>
673 class basic_istream_view
674 : public view_interface<basic_istream_view<_Val, _CharT, _Traits>>
677 basic_istream_view() = default;
680 basic_istream_view(basic_istream<_CharT, _Traits>& __stream)
681 : _M_stream(std::__addressof(__stream))
687 if (_M_stream != nullptr)
688 *_M_stream >> _M_object;
689 return _Iterator{this};
692 constexpr default_sentinel_t
694 { return default_sentinel; }
697 basic_istream<_CharT, _Traits>* _M_stream = nullptr;
698 _Val _M_object = _Val();
703 using iterator_concept = input_iterator_tag;
704 using difference_type = ptrdiff_t;
705 using value_type = _Val;
707 _Iterator() = default;
710 _Iterator(basic_istream_view* __parent) noexcept
711 : _M_parent(__parent)
714 _Iterator(const _Iterator&) = delete;
715 _Iterator(_Iterator&&) = default;
716 _Iterator& operator=(const _Iterator&) = delete;
717 _Iterator& operator=(_Iterator&&) = default;
722 __glibcxx_assert(_M_parent->_M_stream != nullptr);
723 *_M_parent->_M_stream >> _M_parent->_M_object;
734 __glibcxx_assert(_M_parent->_M_stream != nullptr);
735 return _M_parent->_M_object;
739 operator==(const _Iterator& __x, default_sentinel_t)
740 { return __x._M_at_end(); }
743 basic_istream_view* _M_parent = nullptr;
747 { return _M_parent == nullptr || !*_M_parent->_M_stream; }
753 template<typename _Val, typename _CharT, typename _Traits>
754 basic_istream_view<_Val, _CharT, _Traits>
755 istream_view(basic_istream<_CharT, _Traits>& __s)
756 { return basic_istream_view<_Val, _CharT, _Traits>{__s}; }
758 // C++20 24.7 [range.adaptors] Range adaptors
764 // Alias for a type that is conditionally present
765 // (and is an empty type otherwise).
766 // Data members using this alias should use [[no_unique_address]] so that
767 // they take no space when not needed.
768 template<bool _Present, typename _Tp>
769 using __maybe_present_t = conditional_t<_Present, _Tp, _Empty>;
771 // Alias for a type that is conditionally const.
772 template<bool _Const, typename _Tp>
773 using __maybe_const_t = conditional_t<_Const, const _Tp, _Tp>;
775 } // namespace __detail
777 namespace views::__adaptor
779 // True if the range adaptor _Adaptor can be applied with _Args.
780 template<typename _Adaptor, typename... _Args>
781 concept __adaptor_invocable
782 = requires { std::declval<_Adaptor>()(declval<_Args>()...); };
784 // True if the range adaptor non-closure _Adaptor can be partially applied
786 template<typename _Adaptor, typename... _Args>
787 concept __adaptor_partial_app_viable = (_Adaptor::_S_arity > 1)
788 && (sizeof...(_Args) == _Adaptor::_S_arity - 1)
789 && (constructible_from<decay_t<_Args>, _Args> && ...);
791 template<typename _Adaptor, typename... _Args>
794 template<typename _Lhs, typename _Rhs>
797 // The base class of every range adaptor closure.
799 // The derived class should define the optional static data member
800 // _S_has_simple_call_op to true if the behavior of this adaptor is
801 // independent of the constness/value category of the adaptor object.
802 struct _RangeAdaptorClosure
804 // range | adaptor is equivalent to adaptor(range).
805 template<typename _Self, typename _Range>
806 requires derived_from<remove_cvref_t<_Self>, _RangeAdaptorClosure>
807 && __adaptor_invocable<_Self, _Range>
808 friend constexpr auto
809 operator|(_Range&& __r, _Self&& __self)
810 { return std::forward<_Self>(__self)(std::forward<_Range>(__r)); }
812 // Compose the adaptors __lhs and __rhs into a pipeline, returning
813 // another range adaptor closure object.
814 template<typename _Lhs, typename _Rhs>
815 requires derived_from<_Lhs, _RangeAdaptorClosure>
816 && derived_from<_Rhs, _RangeAdaptorClosure>
817 friend constexpr auto
818 operator|(_Lhs __lhs, _Rhs __rhs)
819 { return _Pipe<_Lhs, _Rhs>{std::move(__lhs), std::move(__rhs)}; }
822 // The base class of every range adaptor non-closure.
824 // The static data member _Derived::_S_arity must contain the total number of
825 // arguments that the adaptor takes, and the class _Derived must introduce
826 // _RangeAdaptor::operator() into the class scope via a using-declaration.
828 // The optional static data member _Derived::_S_has_simple_extra_args should
829 // be defined to true if the behavior of this adaptor is independent of the
830 // constness/value category of the extra arguments. This data member could
831 // also be defined as a variable template parameterized by the types of the
833 template<typename _Derived>
836 // Partially apply the arguments __args to the range adaptor _Derived,
837 // returning a range adaptor closure object.
838 template<typename... _Args>
839 requires __adaptor_partial_app_viable<_Derived, _Args...>
841 operator()(_Args&&... __args) const
843 return _Partial<_Derived, decay_t<_Args>...>{std::forward<_Args>(__args)...};
847 // True if the range adaptor closure _Adaptor has a simple operator(), i.e.
848 // one that's not overloaded according to constness or value category of the
850 template<typename _Adaptor>
851 concept __closure_has_simple_call_op = _Adaptor::_S_has_simple_call_op;
853 // True if the behavior of the range adaptor non-closure _Adaptor is
854 // independent of the value category of its extra arguments _Args.
855 template<typename _Adaptor, typename... _Args>
856 concept __adaptor_has_simple_extra_args = _Adaptor::_S_has_simple_extra_args
857 || _Adaptor::template _S_has_simple_extra_args<_Args...>;
859 // A range adaptor closure that represents partial application of
860 // the range adaptor _Adaptor with arguments _Args.
861 template<typename _Adaptor, typename... _Args>
862 struct _Partial : _RangeAdaptorClosure
864 tuple<_Args...> _M_args;
867 _Partial(_Args... __args)
868 : _M_args(std::move(__args)...)
871 // Invoke _Adaptor with arguments __r, _M_args... according to the
872 // value category of this _Partial object.
873 template<typename _Range>
874 requires __adaptor_invocable<_Adaptor, _Range, const _Args&...>
876 operator()(_Range&& __r) const &
878 auto __forwarder = [&__r] (const auto&... __args) {
879 return _Adaptor{}(std::forward<_Range>(__r), __args...);
881 return std::apply(__forwarder, _M_args);
884 template<typename _Range>
885 requires __adaptor_invocable<_Adaptor, _Range, _Args...>
887 operator()(_Range&& __r) &&
889 auto __forwarder = [&__r] (auto&... __args) {
890 return _Adaptor{}(std::forward<_Range>(__r), std::move(__args)...);
892 return std::apply(__forwarder, _M_args);
895 template<typename _Range>
897 operator()(_Range&& __r) const && = delete;
900 // A lightweight specialization of the above primary template for
901 // the common case where _Adaptor accepts a single extra argument.
902 template<typename _Adaptor, typename _Arg>
903 struct _Partial<_Adaptor, _Arg> : _RangeAdaptorClosure
909 : _M_arg(std::move(__arg))
912 template<typename _Range>
913 requires __adaptor_invocable<_Adaptor, _Range, const _Arg&>
915 operator()(_Range&& __r) const &
916 { return _Adaptor{}(std::forward<_Range>(__r), _M_arg); }
918 template<typename _Range>
919 requires __adaptor_invocable<_Adaptor, _Range, _Arg>
921 operator()(_Range&& __r) &&
922 { return _Adaptor{}(std::forward<_Range>(__r), std::move(_M_arg)); }
924 template<typename _Range>
926 operator()(_Range&& __r) const && = delete;
929 // Partial specialization of the primary template for the case where the extra
930 // arguments of the adaptor can always be safely and efficiently forwarded by
931 // const reference. This lets us get away with a single operator() overload,
932 // which makes overload resolution failure diagnostics more concise.
933 template<typename _Adaptor, typename... _Args>
934 requires __adaptor_has_simple_extra_args<_Adaptor, _Args...>
935 && (is_trivially_copyable_v<_Args> && ...)
936 struct _Partial<_Adaptor, _Args...> : _RangeAdaptorClosure
938 tuple<_Args...> _M_args;
941 _Partial(_Args... __args)
942 : _M_args(std::move(__args)...)
945 // Invoke _Adaptor with arguments __r, const _M_args&... regardless
946 // of the value category of this _Partial object.
947 template<typename _Range>
948 requires __adaptor_invocable<_Adaptor, _Range, const _Args&...>
950 operator()(_Range&& __r) const
952 auto __forwarder = [&__r] (const auto&... __args) {
953 return _Adaptor{}(std::forward<_Range>(__r), __args...);
955 return std::apply(__forwarder, _M_args);
958 static constexpr bool _S_has_simple_call_op = true;
961 // A lightweight specialization of the above template for the common case
962 // where _Adaptor accepts a single extra argument.
963 template<typename _Adaptor, typename _Arg>
964 requires __adaptor_has_simple_extra_args<_Adaptor, _Arg>
965 && is_trivially_copyable_v<_Arg>
966 struct _Partial<_Adaptor, _Arg> : _RangeAdaptorClosure
972 : _M_arg(std::move(__arg))
975 template<typename _Range>
976 requires __adaptor_invocable<_Adaptor, _Range, const _Arg&>
978 operator()(_Range&& __r) const
979 { return _Adaptor{}(std::forward<_Range>(__r), _M_arg); }
981 static constexpr bool _S_has_simple_call_op = true;
984 template<typename _Lhs, typename _Rhs, typename _Range>
985 concept __pipe_invocable
986 = requires { std::declval<_Rhs>()(std::declval<_Lhs>()(std::declval<_Range>())); };
988 // A range adaptor closure that represents composition of the range
989 // adaptor closures _Lhs and _Rhs.
990 template<typename _Lhs, typename _Rhs>
991 struct _Pipe : _RangeAdaptorClosure
993 [[no_unique_address]] _Lhs _M_lhs;
994 [[no_unique_address]] _Rhs _M_rhs;
997 _Pipe(_Lhs __lhs, _Rhs __rhs)
998 : _M_lhs(std::move(__lhs)), _M_rhs(std::move(__rhs))
1001 // Invoke _M_rhs(_M_lhs(__r)) according to the value category of this
1002 // range adaptor closure object.
1003 template<typename _Range>
1004 requires __pipe_invocable<const _Lhs&, const _Rhs&, _Range>
1006 operator()(_Range&& __r) const &
1007 { return _M_rhs(_M_lhs(std::forward<_Range>(__r))); }
1009 template<typename _Range>
1010 requires __pipe_invocable<_Lhs, _Rhs, _Range>
1012 operator()(_Range&& __r) &&
1013 { return std::move(_M_rhs)(std::move(_M_lhs)(std::forward<_Range>(__r))); }
1015 template<typename _Range>
1017 operator()(_Range&& __r) const && = delete;
1020 // A partial specialization of the above primary template for the case where
1021 // both adaptor operands have a simple operator(). This in turn lets us
1022 // implement composition using a single simple operator(), which makes
1023 // overload resolution failure diagnostics more concise.
1024 template<typename _Lhs, typename _Rhs>
1025 requires __closure_has_simple_call_op<_Lhs>
1026 && __closure_has_simple_call_op<_Rhs>
1027 struct _Pipe<_Lhs, _Rhs> : _RangeAdaptorClosure
1029 [[no_unique_address]] _Lhs _M_lhs;
1030 [[no_unique_address]] _Rhs _M_rhs;
1033 _Pipe(_Lhs __lhs, _Rhs __rhs)
1034 : _M_lhs(std::move(__lhs)), _M_rhs(std::move(__rhs))
1037 template<typename _Range>
1038 requires __pipe_invocable<const _Lhs&, const _Rhs&, _Range>
1040 operator()(_Range&& __r) const
1041 { return _M_rhs(_M_lhs(std::forward<_Range>(__r))); }
1043 static constexpr bool _S_has_simple_call_op = true;
1045 } // namespace views::__adaptor
1047 template<range _Range> requires is_object_v<_Range>
1048 class ref_view : public view_interface<ref_view<_Range>>
1051 _Range* _M_r = nullptr;
1053 static void _S_fun(_Range&); // not defined
1054 static void _S_fun(_Range&&) = delete;
1058 ref_view() noexcept = default;
1060 template<__detail::__not_same_as<ref_view> _Tp>
1061 requires convertible_to<_Tp, _Range&>
1062 && requires { _S_fun(declval<_Tp>()); }
1065 : _M_r(std::__addressof(static_cast<_Range&>(std::forward<_Tp>(__t))))
1072 constexpr iterator_t<_Range>
1074 { return ranges::begin(*_M_r); }
1076 constexpr sentinel_t<_Range>
1078 { return ranges::end(*_M_r); }
1081 empty() const requires requires { ranges::empty(*_M_r); }
1082 { return ranges::empty(*_M_r); }
1085 size() const requires sized_range<_Range>
1086 { return ranges::size(*_M_r); }
1089 data() const requires contiguous_range<_Range>
1090 { return ranges::data(*_M_r); }
1093 template<typename _Range>
1094 ref_view(_Range&) -> ref_view<_Range>;
1096 template<typename _Tp>
1097 inline constexpr bool enable_borrowed_range<ref_view<_Tp>> = true;
1103 template<typename _Range>
1104 concept __can_ref_view = requires { ref_view{std::declval<_Range>()}; };
1106 template<typename _Range>
1107 concept __can_subrange = requires { subrange{std::declval<_Range>()}; };
1108 } // namespace __detail
1110 struct _All : __adaptor::_RangeAdaptorClosure
1112 template<viewable_range _Range>
1113 requires view<decay_t<_Range>>
1114 || __detail::__can_ref_view<_Range>
1115 || __detail::__can_subrange<_Range>
1117 operator()(_Range&& __r) const
1119 if constexpr (view<decay_t<_Range>>)
1120 return std::forward<_Range>(__r);
1121 else if constexpr (__detail::__can_ref_view<_Range>)
1122 return ref_view{std::forward<_Range>(__r)};
1124 return subrange{std::forward<_Range>(__r)};
1127 static constexpr bool _S_has_simple_call_op = true;
1130 inline constexpr _All all;
1132 template<viewable_range _Range>
1133 using all_t = decltype(all(std::declval<_Range>()));
1134 } // namespace views
1138 template<typename _Tp>
1139 struct __non_propagating_cache
1141 // When _Tp is not an object type (e.g. is a reference type), we make
1142 // __non_propagating_cache<_Tp> empty rather than ill-formed so that
1143 // users can easily conditionally declare data members with this type
1144 // (such as join_view::_M_inner).
1147 template<typename _Tp>
1148 requires is_object_v<_Tp>
1149 struct __non_propagating_cache<_Tp> : protected _Optional_base<_Tp>
1151 __non_propagating_cache() = default;
1154 __non_propagating_cache(const __non_propagating_cache&) noexcept
1158 __non_propagating_cache(__non_propagating_cache&& __other) noexcept
1159 { __other._M_reset(); }
1161 constexpr __non_propagating_cache&
1162 operator=(const __non_propagating_cache& __other) noexcept
1164 if (std::__addressof(__other) != this)
1169 constexpr __non_propagating_cache&
1170 operator=(__non_propagating_cache&& __other) noexcept
1178 operator*() noexcept
1179 { return this->_M_get(); }
1181 constexpr const _Tp&
1182 operator*() const noexcept
1183 { return this->_M_get(); }
1185 template<typename _Iter>
1187 _M_emplace_deref(const _Iter& __i)
1190 // Using _Optional_base::_M_construct to initialize from '*__i'
1191 // would incur an extra move due to the indirection, so we instead
1192 // use placement new directly.
1193 ::new ((void *) std::__addressof(this->_M_payload._M_payload)) _Tp(*__i);
1194 this->_M_payload._M_engaged = true;
1195 return this->_M_get();
1199 template<range _Range>
1200 struct _CachedPosition
1203 _M_has_value() const
1206 constexpr iterator_t<_Range>
1207 _M_get(const _Range&) const
1209 __glibcxx_assert(false);
1210 __builtin_unreachable();
1214 _M_set(const _Range&, const iterator_t<_Range>&) const
1218 template<forward_range _Range>
1219 struct _CachedPosition<_Range>
1220 : protected __non_propagating_cache<iterator_t<_Range>>
1223 _M_has_value() const
1224 { return this->_M_is_engaged(); }
1226 constexpr iterator_t<_Range>
1227 _M_get(const _Range&) const
1229 __glibcxx_assert(_M_has_value());
1234 _M_set(const _Range&, const iterator_t<_Range>& __it)
1236 __glibcxx_assert(!_M_has_value());
1237 std::construct_at(std::__addressof(this->_M_payload._M_payload),
1239 this->_M_payload._M_engaged = true;
1243 template<random_access_range _Range>
1244 requires (sizeof(range_difference_t<_Range>)
1245 <= sizeof(iterator_t<_Range>))
1246 struct _CachedPosition<_Range>
1249 range_difference_t<_Range> _M_offset = -1;
1252 _CachedPosition() = default;
1255 _CachedPosition(const _CachedPosition&) = default;
1258 _CachedPosition(_CachedPosition&& __other) noexcept
1259 { *this = std::move(__other); }
1261 constexpr _CachedPosition&
1262 operator=(const _CachedPosition&) = default;
1264 constexpr _CachedPosition&
1265 operator=(_CachedPosition&& __other) noexcept
1267 // Propagate the cached offset, but invalidate the source.
1268 _M_offset = __other._M_offset;
1269 __other._M_offset = -1;
1274 _M_has_value() const
1275 { return _M_offset >= 0; }
1277 constexpr iterator_t<_Range>
1278 _M_get(_Range& __r) const
1280 __glibcxx_assert(_M_has_value());
1281 return ranges::begin(__r) + _M_offset;
1285 _M_set(_Range& __r, const iterator_t<_Range>& __it)
1287 __glibcxx_assert(!_M_has_value());
1288 _M_offset = __it - ranges::begin(__r);
1291 } // namespace __detail
1295 template<typename _Base>
1296 struct __filter_view_iter_cat
1299 template<forward_range _Base>
1300 struct __filter_view_iter_cat<_Base>
1306 using _Cat = typename iterator_traits<iterator_t<_Base>>::iterator_category;
1307 if constexpr (derived_from<_Cat, bidirectional_iterator_tag>)
1308 return bidirectional_iterator_tag{};
1309 else if constexpr (derived_from<_Cat, forward_iterator_tag>)
1310 return forward_iterator_tag{};
1315 using iterator_category = decltype(_S_iter_cat());
1317 } // namespace __detail
1319 template<input_range _Vp,
1320 indirect_unary_predicate<iterator_t<_Vp>> _Pred>
1321 requires view<_Vp> && is_object_v<_Pred>
1322 class filter_view : public view_interface<filter_view<_Vp, _Pred>>
1327 struct _Iterator : __detail::__filter_view_iter_cat<_Vp>
1330 static constexpr auto
1333 if constexpr (bidirectional_range<_Vp>)
1334 return bidirectional_iterator_tag{};
1335 else if constexpr (forward_range<_Vp>)
1336 return forward_iterator_tag{};
1338 return input_iterator_tag{};
1343 using _Vp_iter = iterator_t<_Vp>;
1345 _Vp_iter _M_current = _Vp_iter();
1346 filter_view* _M_parent = nullptr;
1349 using iterator_concept = decltype(_S_iter_concept());
1350 // iterator_category defined in __filter_view_iter_cat
1351 using value_type = range_value_t<_Vp>;
1352 using difference_type = range_difference_t<_Vp>;
1354 _Iterator() requires default_initializable<_Vp_iter> = default;
1357 _Iterator(filter_view* __parent, _Vp_iter __current)
1358 : _M_current(std::move(__current)),
1362 constexpr const _Vp_iter&
1363 base() const & noexcept
1364 { return _M_current; }
1368 { return std::move(_M_current); }
1370 constexpr range_reference_t<_Vp>
1372 { return *_M_current; }
1376 requires __detail::__has_arrow<_Vp_iter>
1377 && copyable<_Vp_iter>
1378 { return _M_current; }
1380 constexpr _Iterator&
1383 _M_current = ranges::find_if(std::move(++_M_current),
1384 ranges::end(_M_parent->_M_base),
1385 std::ref(*_M_parent->_M_pred));
1394 operator++(int) requires forward_range<_Vp>
1401 constexpr _Iterator&
1402 operator--() requires bidirectional_range<_Vp>
1406 while (!std::__invoke(*_M_parent->_M_pred, *_M_current));
1411 operator--(int) requires bidirectional_range<_Vp>
1418 friend constexpr bool
1419 operator==(const _Iterator& __x, const _Iterator& __y)
1420 requires equality_comparable<_Vp_iter>
1421 { return __x._M_current == __y._M_current; }
1423 friend constexpr range_rvalue_reference_t<_Vp>
1424 iter_move(const _Iterator& __i)
1425 noexcept(noexcept(ranges::iter_move(__i._M_current)))
1426 { return ranges::iter_move(__i._M_current); }
1428 friend constexpr void
1429 iter_swap(const _Iterator& __x, const _Iterator& __y)
1430 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1431 requires indirectly_swappable<_Vp_iter>
1432 { ranges::iter_swap(__x._M_current, __y._M_current); }
1438 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
1441 __equal(const _Iterator& __i) const
1442 { return __i._M_current == _M_end; }
1445 _Sentinel() = default;
1448 _Sentinel(filter_view* __parent)
1449 : _M_end(ranges::end(__parent->_M_base))
1452 constexpr sentinel_t<_Vp>
1456 friend constexpr bool
1457 operator==(const _Iterator& __x, const _Sentinel& __y)
1458 { return __y.__equal(__x); }
1461 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
1462 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
1463 _Vp _M_base = _Vp();
1466 filter_view() requires (default_initializable<_Vp>
1467 && default_initializable<_Pred>)
1471 filter_view(_Vp __base, _Pred __pred)
1472 : _M_pred(std::move(__pred)), _M_base(std::move(__base))
1476 base() const& requires copy_constructible<_Vp>
1481 { return std::move(_M_base); }
1483 constexpr const _Pred&
1485 { return *_M_pred; }
1490 if (_M_cached_begin._M_has_value())
1491 return {this, _M_cached_begin._M_get(_M_base)};
1493 __glibcxx_assert(_M_pred.has_value());
1494 auto __it = ranges::find_if(ranges::begin(_M_base),
1495 ranges::end(_M_base),
1496 std::ref(*_M_pred));
1497 _M_cached_begin._M_set(_M_base, __it);
1498 return {this, std::move(__it)};
1504 if constexpr (common_range<_Vp>)
1505 return _Iterator{this, ranges::end(_M_base)};
1507 return _Sentinel{this};
1511 template<typename _Range, typename _Pred>
1512 filter_view(_Range&&, _Pred) -> filter_view<views::all_t<_Range>, _Pred>;
1518 template<typename _Range, typename _Pred>
1519 concept __can_filter_view
1520 = requires { filter_view(std::declval<_Range>(), std::declval<_Pred>()); };
1521 } // namespace __detail
1523 struct _Filter : __adaptor::_RangeAdaptor<_Filter>
1525 template<viewable_range _Range, typename _Pred>
1526 requires __detail::__can_filter_view<_Range, _Pred>
1528 operator()(_Range&& __r, _Pred&& __p) const
1530 return filter_view(std::forward<_Range>(__r), std::forward<_Pred>(__p));
1533 using _RangeAdaptor<_Filter>::operator();
1534 static constexpr int _S_arity = 2;
1535 static constexpr bool _S_has_simple_extra_args = true;
1538 inline constexpr _Filter filter;
1539 } // namespace views
1541 template<input_range _Vp, copy_constructible _Fp>
1542 requires view<_Vp> && is_object_v<_Fp>
1543 && regular_invocable<_Fp&, range_reference_t<_Vp>>
1544 && std::__detail::__can_reference<invoke_result_t<_Fp&,
1545 range_reference_t<_Vp>>>
1546 class transform_view : public view_interface<transform_view<_Vp, _Fp>>
1549 template<bool _Const>
1550 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
1552 template<bool _Const>
1556 template<bool _Const>
1557 requires forward_range<_Base<_Const>>
1558 struct __iter_cat<_Const>
1564 using _Base = transform_view::_Base<_Const>;
1565 using _Res = invoke_result_t<_Fp&, range_reference_t<_Base>>;
1566 if constexpr (is_lvalue_reference_v<_Res>)
1569 = typename iterator_traits<iterator_t<_Base>>::iterator_category;
1570 if constexpr (derived_from<_Cat, contiguous_iterator_tag>)
1571 return random_access_iterator_tag{};
1576 return input_iterator_tag{};
1579 using iterator_category = decltype(_S_iter_cat());
1582 template<bool _Const>
1585 template<bool _Const>
1586 struct _Iterator : __iter_cat<_Const>
1589 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
1590 using _Base = transform_view::_Base<_Const>;
1595 if constexpr (random_access_range<_Base>)
1596 return random_access_iterator_tag{};
1597 else if constexpr (bidirectional_range<_Base>)
1598 return bidirectional_iterator_tag{};
1599 else if constexpr (forward_range<_Base>)
1600 return forward_iterator_tag{};
1602 return input_iterator_tag{};
1605 using _Base_iter = iterator_t<_Base>;
1607 _Base_iter _M_current = _Base_iter();
1608 _Parent* _M_parent = nullptr;
1611 using iterator_concept = decltype(_S_iter_concept());
1612 // iterator_category defined in __transform_view_iter_cat
1614 = remove_cvref_t<invoke_result_t<_Fp&, range_reference_t<_Base>>>;
1615 using difference_type = range_difference_t<_Base>;
1617 _Iterator() requires default_initializable<_Base_iter> = default;
1620 _Iterator(_Parent* __parent, _Base_iter __current)
1621 : _M_current(std::move(__current)),
1626 _Iterator(_Iterator<!_Const> __i)
1628 && convertible_to<iterator_t<_Vp>, _Base_iter>
1629 : _M_current(std::move(__i._M_current)), _M_parent(__i._M_parent)
1632 constexpr const _Base_iter&
1633 base() const & noexcept
1634 { return _M_current; }
1636 constexpr _Base_iter
1638 { return std::move(_M_current); }
1640 constexpr decltype(auto)
1642 noexcept(noexcept(std::__invoke(*_M_parent->_M_fun, *_M_current)))
1643 { return std::__invoke(*_M_parent->_M_fun, *_M_current); }
1645 constexpr _Iterator&
1657 operator++(int) requires forward_range<_Base>
1664 constexpr _Iterator&
1665 operator--() requires bidirectional_range<_Base>
1672 operator--(int) requires bidirectional_range<_Base>
1679 constexpr _Iterator&
1680 operator+=(difference_type __n) requires random_access_range<_Base>
1686 constexpr _Iterator&
1687 operator-=(difference_type __n) requires random_access_range<_Base>
1693 constexpr decltype(auto)
1694 operator[](difference_type __n) const
1695 requires random_access_range<_Base>
1696 { return std::__invoke(*_M_parent->_M_fun, _M_current[__n]); }
1698 friend constexpr bool
1699 operator==(const _Iterator& __x, const _Iterator& __y)
1700 requires equality_comparable<_Base_iter>
1701 { return __x._M_current == __y._M_current; }
1703 friend constexpr bool
1704 operator<(const _Iterator& __x, const _Iterator& __y)
1705 requires random_access_range<_Base>
1706 { return __x._M_current < __y._M_current; }
1708 friend constexpr bool
1709 operator>(const _Iterator& __x, const _Iterator& __y)
1710 requires random_access_range<_Base>
1711 { return __y < __x; }
1713 friend constexpr bool
1714 operator<=(const _Iterator& __x, const _Iterator& __y)
1715 requires random_access_range<_Base>
1716 { return !(__y < __x); }
1718 friend constexpr bool
1719 operator>=(const _Iterator& __x, const _Iterator& __y)
1720 requires random_access_range<_Base>
1721 { return !(__x < __y); }
1723 #ifdef __cpp_lib_three_way_comparison
1724 friend constexpr auto
1725 operator<=>(const _Iterator& __x, const _Iterator& __y)
1726 requires random_access_range<_Base>
1727 && three_way_comparable<_Base_iter>
1728 { return __x._M_current <=> __y._M_current; }
1731 friend constexpr _Iterator
1732 operator+(_Iterator __i, difference_type __n)
1733 requires random_access_range<_Base>
1734 { return {__i._M_parent, __i._M_current + __n}; }
1736 friend constexpr _Iterator
1737 operator+(difference_type __n, _Iterator __i)
1738 requires random_access_range<_Base>
1739 { return {__i._M_parent, __i._M_current + __n}; }
1741 friend constexpr _Iterator
1742 operator-(_Iterator __i, difference_type __n)
1743 requires random_access_range<_Base>
1744 { return {__i._M_parent, __i._M_current - __n}; }
1746 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1747 // 3483. transform_view::iterator's difference is overconstrained
1748 friend constexpr difference_type
1749 operator-(const _Iterator& __x, const _Iterator& __y)
1750 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
1751 { return __x._M_current - __y._M_current; }
1753 friend constexpr decltype(auto)
1754 iter_move(const _Iterator& __i) noexcept(noexcept(*__i))
1756 if constexpr (is_lvalue_reference_v<decltype(*__i)>)
1757 return std::move(*__i);
1762 friend _Iterator<!_Const>;
1763 template<bool> friend struct _Sentinel;
1766 template<bool _Const>
1770 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
1771 using _Base = transform_view::_Base<_Const>;
1773 template<bool _Const2>
1775 __distance_from(const _Iterator<_Const2>& __i) const
1776 { return _M_end - __i._M_current; }
1778 template<bool _Const2>
1780 __equal(const _Iterator<_Const2>& __i) const
1781 { return __i._M_current == _M_end; }
1783 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
1786 _Sentinel() = default;
1789 _Sentinel(sentinel_t<_Base> __end)
1794 _Sentinel(_Sentinel<!_Const> __i)
1796 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
1797 : _M_end(std::move(__i._M_end))
1800 constexpr sentinel_t<_Base>
1804 template<bool _Const2>
1805 requires sentinel_for<sentinel_t<_Base>,
1806 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
1807 friend constexpr bool
1808 operator==(const _Iterator<_Const2>& __x, const _Sentinel& __y)
1809 { return __y.__equal(__x); }
1811 template<bool _Const2,
1812 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
1813 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
1814 friend constexpr range_difference_t<_Base2>
1815 operator-(const _Iterator<_Const2>& __x, const _Sentinel& __y)
1816 { return -__y.__distance_from(__x); }
1818 template<bool _Const2,
1819 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
1820 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
1821 friend constexpr range_difference_t<_Base2>
1822 operator-(const _Sentinel& __y, const _Iterator<_Const2>& __x)
1823 { return __y.__distance_from(__x); }
1825 friend _Sentinel<!_Const>;
1828 [[no_unique_address]] __detail::__box<_Fp> _M_fun;
1829 _Vp _M_base = _Vp();
1832 transform_view() requires (default_initializable<_Vp>
1833 && default_initializable<_Fp>)
1837 transform_view(_Vp __base, _Fp __fun)
1838 : _M_fun(std::move(__fun)), _M_base(std::move(__base))
1842 base() const& requires copy_constructible<_Vp>
1843 { return _M_base ; }
1847 { return std::move(_M_base); }
1849 constexpr _Iterator<false>
1851 { return _Iterator<false>{this, ranges::begin(_M_base)}; }
1853 constexpr _Iterator<true>
1855 requires range<const _Vp>
1856 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
1857 { return _Iterator<true>{this, ranges::begin(_M_base)}; }
1859 constexpr _Sentinel<false>
1861 { return _Sentinel<false>{ranges::end(_M_base)}; }
1863 constexpr _Iterator<false>
1864 end() requires common_range<_Vp>
1865 { return _Iterator<false>{this, ranges::end(_M_base)}; }
1867 constexpr _Sentinel<true>
1869 requires range<const _Vp>
1870 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
1871 { return _Sentinel<true>{ranges::end(_M_base)}; }
1873 constexpr _Iterator<true>
1875 requires common_range<const _Vp>
1876 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
1877 { return _Iterator<true>{this, ranges::end(_M_base)}; }
1880 size() requires sized_range<_Vp>
1881 { return ranges::size(_M_base); }
1884 size() const requires sized_range<const _Vp>
1885 { return ranges::size(_M_base); }
1888 template<typename _Range, typename _Fp>
1889 transform_view(_Range&&, _Fp) -> transform_view<views::all_t<_Range>, _Fp>;
1895 template<typename _Range, typename _Fp>
1896 concept __can_transform_view
1897 = requires { transform_view(std::declval<_Range>(), std::declval<_Fp>()); };
1898 } // namespace __detail
1900 struct _Transform : __adaptor::_RangeAdaptor<_Transform>
1902 template<viewable_range _Range, typename _Fp>
1903 requires __detail::__can_transform_view<_Range, _Fp>
1905 operator()(_Range&& __r, _Fp&& __f) const
1907 return transform_view(std::forward<_Range>(__r), std::forward<_Fp>(__f));
1910 using _RangeAdaptor<_Transform>::operator();
1911 static constexpr int _S_arity = 2;
1912 static constexpr bool _S_has_simple_extra_args = true;
1915 inline constexpr _Transform transform;
1916 } // namespace views
1919 class take_view : public view_interface<take_view<_Vp>>
1922 template<bool _Const>
1923 using _CI = counted_iterator<
1924 iterator_t<__detail::__maybe_const_t<_Const, _Vp>>>;
1926 template<bool _Const>
1930 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
1931 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
1934 _Sentinel() = default;
1937 _Sentinel(sentinel_t<_Base> __end)
1942 _Sentinel(_Sentinel<!_Const> __s)
1943 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
1944 : _M_end(std::move(__s._M_end))
1947 constexpr sentinel_t<_Base>
1951 friend constexpr bool
1952 operator==(const _CI<_Const>& __y, const _Sentinel& __x)
1953 { return __y.count() == 0 || __y.base() == __x._M_end; }
1955 template<bool _OtherConst = !_Const,
1956 typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
1957 requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
1958 friend constexpr bool
1959 operator==(const _CI<_OtherConst>& __y, const _Sentinel& __x)
1960 { return __y.count() == 0 || __y.base() == __x._M_end; }
1962 friend _Sentinel<!_Const>;
1965 range_difference_t<_Vp> _M_count = 0;
1966 _Vp _M_base = _Vp();
1969 take_view() requires default_initializable<_Vp> = default;
1972 take_view(_Vp base, range_difference_t<_Vp> __count)
1973 : _M_count(std::move(__count)), _M_base(std::move(base))
1977 base() const& requires copy_constructible<_Vp>
1982 { return std::move(_M_base); }
1985 begin() requires (!__detail::__simple_view<_Vp>)
1987 if constexpr (sized_range<_Vp>)
1989 if constexpr (random_access_range<_Vp>)
1990 return ranges::begin(_M_base);
1994 return counted_iterator(ranges::begin(_M_base), __sz);
1998 return counted_iterator(ranges::begin(_M_base), _M_count);
2002 begin() const requires range<const _Vp>
2004 if constexpr (sized_range<const _Vp>)
2006 if constexpr (random_access_range<const _Vp>)
2007 return ranges::begin(_M_base);
2011 return counted_iterator(ranges::begin(_M_base), __sz);
2015 return counted_iterator(ranges::begin(_M_base), _M_count);
2019 end() requires (!__detail::__simple_view<_Vp>)
2021 if constexpr (sized_range<_Vp>)
2023 if constexpr (random_access_range<_Vp>)
2024 return ranges::begin(_M_base) + size();
2026 return default_sentinel;
2029 return _Sentinel<false>{ranges::end(_M_base)};
2033 end() const requires range<const _Vp>
2035 if constexpr (sized_range<const _Vp>)
2037 if constexpr (random_access_range<const _Vp>)
2038 return ranges::begin(_M_base) + size();
2040 return default_sentinel;
2043 return _Sentinel<true>{ranges::end(_M_base)};
2047 size() requires sized_range<_Vp>
2049 auto __n = ranges::size(_M_base);
2050 return std::min(__n, static_cast<decltype(__n)>(_M_count));
2054 size() const requires sized_range<const _Vp>
2056 auto __n = ranges::size(_M_base);
2057 return std::min(__n, static_cast<decltype(__n)>(_M_count));
2061 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2062 // 3447. Deduction guides for take_view and drop_view have different
2064 template<typename _Range>
2065 take_view(_Range&&, range_difference_t<_Range>)
2066 -> take_view<views::all_t<_Range>>;
2068 template<typename _Tp>
2069 inline constexpr bool enable_borrowed_range<take_view<_Tp>>
2070 = enable_borrowed_range<_Tp>;
2076 template<typename _Range, typename _Tp>
2077 concept __can_take_view
2078 = requires { take_view(std::declval<_Range>(), std::declval<_Tp>()); };
2079 } // namespace __detail
2081 struct _Take : __adaptor::_RangeAdaptor<_Take>
2083 template<viewable_range _Range, typename _Tp>
2084 requires __detail::__can_take_view<_Range, _Tp>
2086 operator()(_Range&& __r, _Tp&& __n) const
2088 return take_view(std::forward<_Range>(__r), std::forward<_Tp>(__n));
2091 using _RangeAdaptor<_Take>::operator();
2092 static constexpr int _S_arity = 2;
2093 // The count argument of views::take is not always simple -- it can be
2094 // e.g. a move-only class that's implicitly convertible to the difference
2095 // type. But an integer-like count argument is surely simple.
2096 template<typename _Tp>
2097 static constexpr bool _S_has_simple_extra_args
2098 = ranges::__detail::__is_integer_like<_Tp>;
2101 inline constexpr _Take take;
2102 } // namespace views
2104 template<view _Vp, typename _Pred>
2105 requires input_range<_Vp> && is_object_v<_Pred>
2106 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2107 class take_while_view : public view_interface<take_while_view<_Vp, _Pred>>
2109 template<bool _Const>
2113 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2115 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2116 const _Pred* _M_pred = nullptr;
2119 _Sentinel() = default;
2122 _Sentinel(sentinel_t<_Base> __end, const _Pred* __pred)
2123 : _M_end(__end), _M_pred(__pred)
2127 _Sentinel(_Sentinel<!_Const> __s)
2128 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2129 : _M_end(__s._M_end), _M_pred(__s._M_pred)
2132 constexpr sentinel_t<_Base>
2133 base() const { return _M_end; }
2135 friend constexpr bool
2136 operator==(const iterator_t<_Base>& __x, const _Sentinel& __y)
2137 { return __y._M_end == __x || !std::__invoke(*__y._M_pred, *__x); }
2139 template<bool _OtherConst = !_Const,
2140 typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
2141 requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2142 friend constexpr bool
2143 operator==(const iterator_t<_Base2>& __x, const _Sentinel& __y)
2144 { return __y._M_end == __x || !std::__invoke(*__y._M_pred, *__x); }
2146 friend _Sentinel<!_Const>;
2149 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
2150 _Vp _M_base = _Vp();
2153 take_while_view() requires (default_initializable<_Vp>
2154 && default_initializable<_Pred>)
2158 take_while_view(_Vp base, _Pred __pred)
2159 : _M_pred(std::move(__pred)), _M_base(std::move(base))
2163 base() const& requires copy_constructible<_Vp>
2168 { return std::move(_M_base); }
2170 constexpr const _Pred&
2172 { return *_M_pred; }
2175 begin() requires (!__detail::__simple_view<_Vp>)
2176 { return ranges::begin(_M_base); }
2179 begin() const requires range<const _Vp>
2180 && indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
2181 { return ranges::begin(_M_base); }
2184 end() requires (!__detail::__simple_view<_Vp>)
2185 { return _Sentinel<false>(ranges::end(_M_base),
2186 std::__addressof(*_M_pred)); }
2189 end() const requires range<const _Vp>
2190 && indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
2191 { return _Sentinel<true>(ranges::end(_M_base),
2192 std::__addressof(*_M_pred)); }
2195 template<typename _Range, typename _Pred>
2196 take_while_view(_Range&&, _Pred)
2197 -> take_while_view<views::all_t<_Range>, _Pred>;
2203 template<typename _Range, typename _Pred>
2204 concept __can_take_while_view
2205 = requires { take_while_view(std::declval<_Range>(), std::declval<_Pred>()); };
2206 } // namespace __detail
2208 struct _TakeWhile : __adaptor::_RangeAdaptor<_TakeWhile>
2210 template<viewable_range _Range, typename _Pred>
2211 requires __detail::__can_take_while_view<_Range, _Pred>
2213 operator()(_Range&& __r, _Pred&& __p) const
2215 return take_while_view(std::forward<_Range>(__r), std::forward<_Pred>(__p));
2218 using _RangeAdaptor<_TakeWhile>::operator();
2219 static constexpr int _S_arity = 2;
2220 static constexpr bool _S_has_simple_extra_args = true;
2223 inline constexpr _TakeWhile take_while;
2224 } // namespace views
2227 class drop_view : public view_interface<drop_view<_Vp>>
2230 range_difference_t<_Vp> _M_count = 0;
2231 _Vp _M_base = _Vp();
2233 // ranges::next(begin(base), count, end(base)) is O(1) if _Vp satisfies
2234 // both random_access_range and sized_range. Otherwise, cache its result.
2235 static constexpr bool _S_needs_cached_begin
2236 = !(random_access_range<const _Vp> && sized_range<const _Vp>);
2237 [[no_unique_address]]
2238 __detail::__maybe_present_t<_S_needs_cached_begin,
2239 __detail::_CachedPosition<_Vp>>
2243 drop_view() requires default_initializable<_Vp> = default;
2246 drop_view(_Vp __base, range_difference_t<_Vp> __count)
2247 : _M_count(__count), _M_base(std::move(__base))
2248 { __glibcxx_assert(__count >= 0); }
2251 base() const& requires copy_constructible<_Vp>
2256 { return std::move(_M_base); }
2258 // This overload is disabled for simple views with constant-time begin().
2261 requires (!(__detail::__simple_view<_Vp>
2262 && random_access_range<const _Vp>
2263 && sized_range<const _Vp>))
2265 if constexpr (_S_needs_cached_begin)
2266 if (_M_cached_begin._M_has_value())
2267 return _M_cached_begin._M_get(_M_base);
2269 auto __it = ranges::next(ranges::begin(_M_base),
2270 _M_count, ranges::end(_M_base));
2271 if constexpr (_S_needs_cached_begin)
2272 _M_cached_begin._M_set(_M_base, __it);
2276 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2277 // 3482. drop_view's const begin should additionally require sized_range
2280 requires random_access_range<const _Vp> && sized_range<const _Vp>
2282 return ranges::next(ranges::begin(_M_base), _M_count,
2283 ranges::end(_M_base));
2287 end() requires (!__detail::__simple_view<_Vp>)
2288 { return ranges::end(_M_base); }
2291 end() const requires range<const _Vp>
2292 { return ranges::end(_M_base); }
2295 size() requires sized_range<_Vp>
2297 const auto __s = ranges::size(_M_base);
2298 const auto __c = static_cast<decltype(__s)>(_M_count);
2299 return __s < __c ? 0 : __s - __c;
2303 size() const requires sized_range<const _Vp>
2305 const auto __s = ranges::size(_M_base);
2306 const auto __c = static_cast<decltype(__s)>(_M_count);
2307 return __s < __c ? 0 : __s - __c;
2311 template<typename _Range>
2312 drop_view(_Range&&, range_difference_t<_Range>)
2313 -> drop_view<views::all_t<_Range>>;
2315 template<typename _Tp>
2316 inline constexpr bool enable_borrowed_range<drop_view<_Tp>>
2317 = enable_borrowed_range<_Tp>;
2323 template<typename _Range, typename _Tp>
2324 concept __can_drop_view
2325 = requires { drop_view(std::declval<_Range>(), std::declval<_Tp>()); };
2326 } // namespace __detail
2328 struct _Drop : __adaptor::_RangeAdaptor<_Drop>
2330 template<viewable_range _Range, typename _Tp>
2331 requires __detail::__can_drop_view<_Range, _Tp>
2333 operator()(_Range&& __r, _Tp&& __n) const
2335 return drop_view(std::forward<_Range>(__r), std::forward<_Tp>(__n));
2338 using _RangeAdaptor<_Drop>::operator();
2339 static constexpr int _S_arity = 2;
2340 template<typename _Tp>
2341 static constexpr bool _S_has_simple_extra_args
2342 = _Take::_S_has_simple_extra_args<_Tp>;
2345 inline constexpr _Drop drop;
2346 } // namespace views
2348 template<view _Vp, typename _Pred>
2349 requires input_range<_Vp> && is_object_v<_Pred>
2350 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2351 class drop_while_view : public view_interface<drop_while_view<_Vp, _Pred>>
2354 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
2355 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
2356 _Vp _M_base = _Vp();
2359 drop_while_view() requires (default_initializable<_Vp>
2360 && default_initializable<_Pred>)
2364 drop_while_view(_Vp __base, _Pred __pred)
2365 : _M_pred(std::move(__pred)), _M_base(std::move(__base))
2369 base() const& requires copy_constructible<_Vp>
2374 { return std::move(_M_base); }
2376 constexpr const _Pred&
2378 { return *_M_pred; }
2383 if (_M_cached_begin._M_has_value())
2384 return _M_cached_begin._M_get(_M_base);
2386 __glibcxx_assert(_M_pred.has_value());
2387 auto __it = ranges::find_if_not(ranges::begin(_M_base),
2388 ranges::end(_M_base),
2389 std::cref(*_M_pred));
2390 _M_cached_begin._M_set(_M_base, __it);
2396 { return ranges::end(_M_base); }
2399 template<typename _Range, typename _Pred>
2400 drop_while_view(_Range&&, _Pred)
2401 -> drop_while_view<views::all_t<_Range>, _Pred>;
2403 template<typename _Tp, typename _Pred>
2404 inline constexpr bool enable_borrowed_range<drop_while_view<_Tp, _Pred>>
2405 = enable_borrowed_range<_Tp>;
2411 template<typename _Range, typename _Pred>
2412 concept __can_drop_while_view
2413 = requires { drop_while_view(std::declval<_Range>(), std::declval<_Pred>()); };
2414 } // namespace __detail
2416 struct _DropWhile : __adaptor::_RangeAdaptor<_DropWhile>
2418 template<viewable_range _Range, typename _Pred>
2419 requires __detail::__can_drop_while_view<_Range, _Pred>
2421 operator()(_Range&& __r, _Pred&& __p) const
2423 return drop_while_view(std::forward<_Range>(__r),
2424 std::forward<_Pred>(__p));
2427 using _RangeAdaptor<_DropWhile>::operator();
2428 static constexpr int _S_arity = 2;
2429 static constexpr bool _S_has_simple_extra_args = true;
2432 inline constexpr _DropWhile drop_while;
2433 } // namespace views
2435 template<input_range _Vp>
2436 requires view<_Vp> && input_range<range_reference_t<_Vp>>
2437 class join_view : public view_interface<join_view<_Vp>>
2440 using _InnerRange = range_reference_t<_Vp>;
2442 template<bool _Const>
2443 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2445 template<bool _Const>
2446 using _Outer_iter = iterator_t<_Base<_Const>>;
2448 template<bool _Const>
2449 using _Inner_iter = iterator_t<range_reference_t<_Base<_Const>>>;
2451 template<bool _Const>
2452 static constexpr bool _S_ref_is_glvalue
2453 = is_reference_v<range_reference_t<_Base<_Const>>>;
2455 template<bool _Const>
2459 template<bool _Const>
2460 requires _S_ref_is_glvalue<_Const>
2461 && forward_range<_Base<_Const>>
2462 && forward_range<range_reference_t<_Base<_Const>>>
2463 struct __iter_cat<_Const>
2466 static constexpr auto
2469 using _Outer_iter = join_view::_Outer_iter<_Const>;
2470 using _Inner_iter = join_view::_Inner_iter<_Const>;
2471 using _OuterCat = typename iterator_traits<_Outer_iter>::iterator_category;
2472 using _InnerCat = typename iterator_traits<_Inner_iter>::iterator_category;
2473 if constexpr (derived_from<_OuterCat, bidirectional_iterator_tag>
2474 && derived_from<_InnerCat, bidirectional_iterator_tag>
2475 && common_range<range_reference_t<_Base<_Const>>>)
2476 return bidirectional_iterator_tag{};
2477 else if constexpr (derived_from<_OuterCat, forward_iterator_tag>
2478 && derived_from<_InnerCat, forward_iterator_tag>)
2479 return forward_iterator_tag{};
2481 return input_iterator_tag{};
2484 using iterator_category = decltype(_S_iter_cat());
2487 template<bool _Const>
2490 template<bool _Const>
2491 struct _Iterator : __iter_cat<_Const>
2494 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
2495 using _Base = join_view::_Base<_Const>;
2497 static constexpr bool _S_ref_is_glvalue
2498 = join_view::_S_ref_is_glvalue<_Const>;
2503 auto __update_inner = [this] (const iterator_t<_Base>& __x) -> auto&& {
2504 if constexpr (_S_ref_is_glvalue)
2507 return _M_parent->_M_inner._M_emplace_deref(__x);
2510 for (; _M_outer != ranges::end(_M_parent->_M_base); ++_M_outer)
2512 auto&& __inner = __update_inner(_M_outer);
2513 _M_inner = ranges::begin(__inner);
2514 if (_M_inner != ranges::end(__inner))
2518 if constexpr (_S_ref_is_glvalue)
2519 _M_inner = _Inner_iter();
2522 static constexpr auto
2525 if constexpr (_S_ref_is_glvalue
2526 && bidirectional_range<_Base>
2527 && bidirectional_range<range_reference_t<_Base>>
2528 && common_range<range_reference_t<_Base>>)
2529 return bidirectional_iterator_tag{};
2530 else if constexpr (_S_ref_is_glvalue
2531 && forward_range<_Base>
2532 && forward_range<range_reference_t<_Base>>)
2533 return forward_iterator_tag{};
2535 return input_iterator_tag{};
2538 using _Outer_iter = join_view::_Outer_iter<_Const>;
2539 using _Inner_iter = join_view::_Inner_iter<_Const>;
2541 _Outer_iter _M_outer = _Outer_iter();
2542 _Inner_iter _M_inner = _Inner_iter();
2543 _Parent* _M_parent = nullptr;
2546 using iterator_concept = decltype(_S_iter_concept());
2547 // iterator_category defined in __join_view_iter_cat
2548 using value_type = range_value_t<range_reference_t<_Base>>;
2549 using difference_type
2550 = common_type_t<range_difference_t<_Base>,
2551 range_difference_t<range_reference_t<_Base>>>;
2553 _Iterator() requires (default_initializable<_Outer_iter>
2554 && default_initializable<_Inner_iter>)
2558 _Iterator(_Parent* __parent, _Outer_iter __outer)
2559 : _M_outer(std::move(__outer)),
2564 _Iterator(_Iterator<!_Const> __i)
2566 && convertible_to<iterator_t<_Vp>, _Outer_iter>
2567 && convertible_to<iterator_t<_InnerRange>, _Inner_iter>
2568 : _M_outer(std::move(__i._M_outer)), _M_inner(std::move(__i._M_inner)),
2569 _M_parent(__i._M_parent)
2572 constexpr decltype(auto)
2574 { return *_M_inner; }
2576 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2577 // 3500. join_view::iterator::operator->() is bogus
2578 constexpr _Inner_iter
2580 requires __detail::__has_arrow<_Inner_iter>
2581 && copyable<_Inner_iter>
2582 { return _M_inner; }
2584 constexpr _Iterator&
2587 auto&& __inner_range = [this] () -> auto&& {
2588 if constexpr (_S_ref_is_glvalue)
2591 return *_M_parent->_M_inner;
2593 if (++_M_inner == ranges::end(__inner_range))
2607 requires _S_ref_is_glvalue && forward_range<_Base>
2608 && forward_range<range_reference_t<_Base>>
2615 constexpr _Iterator&
2617 requires _S_ref_is_glvalue && bidirectional_range<_Base>
2618 && bidirectional_range<range_reference_t<_Base>>
2619 && common_range<range_reference_t<_Base>>
2621 if (_M_outer == ranges::end(_M_parent->_M_base))
2622 _M_inner = ranges::end(*--_M_outer);
2623 while (_M_inner == ranges::begin(*_M_outer))
2624 _M_inner = ranges::end(*--_M_outer);
2631 requires _S_ref_is_glvalue && bidirectional_range<_Base>
2632 && bidirectional_range<range_reference_t<_Base>>
2633 && common_range<range_reference_t<_Base>>
2640 friend constexpr bool
2641 operator==(const _Iterator& __x, const _Iterator& __y)
2642 requires _S_ref_is_glvalue
2643 && equality_comparable<_Outer_iter>
2644 && equality_comparable<_Inner_iter>
2646 return (__x._M_outer == __y._M_outer
2647 && __x._M_inner == __y._M_inner);
2650 friend constexpr decltype(auto)
2651 iter_move(const _Iterator& __i)
2652 noexcept(noexcept(ranges::iter_move(__i._M_inner)))
2653 { return ranges::iter_move(__i._M_inner); }
2655 friend constexpr void
2656 iter_swap(const _Iterator& __x, const _Iterator& __y)
2657 noexcept(noexcept(ranges::iter_swap(__x._M_inner, __y._M_inner)))
2658 requires indirectly_swappable<_Inner_iter>
2659 { return ranges::iter_swap(__x._M_inner, __y._M_inner); }
2661 friend _Iterator<!_Const>;
2662 template<bool> friend struct _Sentinel;
2665 template<bool _Const>
2669 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
2670 using _Base = join_view::_Base<_Const>;
2672 template<bool _Const2>
2674 __equal(const _Iterator<_Const2>& __i) const
2675 { return __i._M_outer == _M_end; }
2677 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2680 _Sentinel() = default;
2683 _Sentinel(_Parent* __parent)
2684 : _M_end(ranges::end(__parent->_M_base))
2688 _Sentinel(_Sentinel<!_Const> __s)
2689 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2690 : _M_end(std::move(__s._M_end))
2693 template<bool _Const2>
2694 requires sentinel_for<sentinel_t<_Base>,
2695 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
2696 friend constexpr bool
2697 operator==(const _Iterator<_Const2>& __x, const _Sentinel& __y)
2698 { return __y.__equal(__x); }
2700 friend _Sentinel<!_Const>;
2703 [[no_unique_address]]
2704 __detail::__non_propagating_cache<remove_cv_t<_InnerRange>> _M_inner;
2705 _Vp _M_base = _Vp();
2708 join_view() requires default_initializable<_Vp> = default;
2711 join_view(_Vp __base)
2712 : _M_base(std::move(__base))
2716 base() const& requires copy_constructible<_Vp>
2721 { return std::move(_M_base); }
2726 constexpr bool __use_const
2727 = (__detail::__simple_view<_Vp>
2728 && is_reference_v<range_reference_t<_Vp>>);
2729 return _Iterator<__use_const>{this, ranges::begin(_M_base)};
2734 requires input_range<const _Vp>
2735 && is_reference_v<range_reference_t<const _Vp>>
2737 return _Iterator<true>{this, ranges::begin(_M_base)};
2743 if constexpr (forward_range<_Vp> && is_reference_v<_InnerRange>
2744 && forward_range<_InnerRange>
2745 && common_range<_Vp> && common_range<_InnerRange>)
2746 return _Iterator<__detail::__simple_view<_Vp>>{this,
2747 ranges::end(_M_base)};
2749 return _Sentinel<__detail::__simple_view<_Vp>>{this};
2754 requires input_range<const _Vp>
2755 && is_reference_v<range_reference_t<const _Vp>>
2757 if constexpr (forward_range<const _Vp>
2758 && is_reference_v<range_reference_t<const _Vp>>
2759 && forward_range<range_reference_t<const _Vp>>
2760 && common_range<const _Vp>
2761 && common_range<range_reference_t<const _Vp>>)
2762 return _Iterator<true>{this, ranges::end(_M_base)};
2764 return _Sentinel<true>{this};
2768 template<typename _Range>
2769 explicit join_view(_Range&&) -> join_view<views::all_t<_Range>>;
2775 template<typename _Range>
2776 concept __can_join_view
2777 = requires { join_view<all_t<_Range>>{std::declval<_Range>()}; };
2778 } // namespace __detail
2780 struct _Join : __adaptor::_RangeAdaptorClosure
2782 template<viewable_range _Range>
2783 requires __detail::__can_join_view<_Range>
2785 operator()(_Range&& __r) const
2787 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2788 // 3474. Nesting join_views is broken because of CTAD
2789 return join_view<all_t<_Range>>{std::forward<_Range>(__r)};
2792 static constexpr bool _S_has_simple_call_op = true;
2795 inline constexpr _Join join;
2796 } // namespace views
2801 struct __require_constant;
2803 template<typename _Range>
2804 concept __tiny_range = sized_range<_Range>
2806 { typename __require_constant<remove_reference_t<_Range>::size()>; }
2807 && (remove_reference_t<_Range>::size() <= 1);
2809 template<typename _Base>
2810 struct __split_view_outer_iter_cat
2813 template<forward_range _Base>
2814 struct __split_view_outer_iter_cat<_Base>
2815 { using iterator_category = input_iterator_tag; };
2817 template<typename _Base>
2818 struct __split_view_inner_iter_cat
2821 template<forward_range _Base>
2822 struct __split_view_inner_iter_cat<_Base>
2825 static constexpr auto
2828 using _Cat = typename iterator_traits<iterator_t<_Base>>::iterator_category;
2829 if constexpr (derived_from<_Cat, forward_iterator_tag>)
2830 return forward_iterator_tag{};
2835 using iterator_category = decltype(_S_iter_cat());
2839 template<input_range _Vp, forward_range _Pattern>
2840 requires view<_Vp> && view<_Pattern>
2841 && indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
2843 && (forward_range<_Vp> || __detail::__tiny_range<_Pattern>)
2844 class split_view : public view_interface<split_view<_Vp, _Pattern>>
2847 template<bool _Const>
2848 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2850 template<bool _Const>
2853 template<bool _Const>
2855 : __detail::__split_view_outer_iter_cat<_Base<_Const>>
2858 using _Parent = __detail::__maybe_const_t<_Const, split_view>;
2859 using _Base = split_view::_Base<_Const>;
2863 { return __current() == ranges::end(_M_parent->_M_base); }
2865 // [range.split.outer] p1
2866 // Many of the following specifications refer to the notional member
2867 // current of outer-iterator. current is equivalent to current_ if
2868 // V models forward_range, and parent_->current_ otherwise.
2870 __current() noexcept
2872 if constexpr (forward_range<_Vp>)
2875 return _M_parent->_M_current;
2879 __current() const noexcept
2881 if constexpr (forward_range<_Vp>)
2884 return _M_parent->_M_current;
2887 _Parent* _M_parent = nullptr;
2889 // XXX: _M_current is present only if "V models forward_range"
2890 [[no_unique_address]]
2891 __detail::__maybe_present_t<forward_range<_Vp>,
2892 iterator_t<_Base>> _M_current;
2895 using iterator_concept = conditional_t<forward_range<_Base>,
2896 forward_iterator_tag,
2897 input_iterator_tag>;
2898 // iterator_category defined in __split_view_outer_iter_cat
2899 using difference_type = range_difference_t<_Base>;
2901 struct value_type : view_interface<value_type>
2904 _OuterIter _M_i = _OuterIter();
2907 value_type() = default;
2910 value_type(_OuterIter __i)
2911 : _M_i(std::move(__i))
2914 constexpr _InnerIter<_Const>
2916 { return _InnerIter<_Const>{_M_i}; }
2918 constexpr default_sentinel_t
2919 end() const noexcept
2920 { return default_sentinel; }
2923 _OuterIter() = default;
2926 _OuterIter(_Parent* __parent) requires (!forward_range<_Base>)
2927 : _M_parent(__parent)
2931 _OuterIter(_Parent* __parent, iterator_t<_Base> __current)
2932 requires forward_range<_Base>
2933 : _M_parent(__parent),
2934 _M_current(std::move(__current))
2938 _OuterIter(_OuterIter<!_Const> __i)
2940 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
2941 : _M_parent(__i._M_parent), _M_current(std::move(__i._M_current))
2944 constexpr value_type
2946 { return value_type{*this}; }
2948 constexpr _OuterIter&
2951 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2952 // 3505. split_view::outer-iterator::operator++ misspecified
2953 const auto __end = ranges::end(_M_parent->_M_base);
2954 if (__current() == __end)
2956 const auto [__pbegin, __pend] = subrange{_M_parent->_M_pattern};
2957 if (__pbegin == __pend)
2959 else if constexpr (__detail::__tiny_range<_Pattern>)
2961 __current() = ranges::find(std::move(__current()), __end,
2963 if (__current() != __end)
2970 = ranges::mismatch(__current(), __end, __pbegin, __pend);
2976 } while (++__current() != __end);
2980 constexpr decltype(auto)
2983 if constexpr (forward_range<_Base>)
2993 friend constexpr bool
2994 operator==(const _OuterIter& __x, const _OuterIter& __y)
2995 requires forward_range<_Base>
2996 { return __x._M_current == __y._M_current; }
2998 friend constexpr bool
2999 operator==(const _OuterIter& __x, default_sentinel_t)
3000 { return __x.__at_end(); };
3002 friend _OuterIter<!_Const>;
3003 friend _InnerIter<_Const>;
3006 template<bool _Const>
3008 : __detail::__split_view_inner_iter_cat<_Base<_Const>>
3011 using _Base = split_view::_Base<_Const>;
3016 auto [__pcur, __pend] = subrange{_M_i._M_parent->_M_pattern};
3017 auto __end = ranges::end(_M_i._M_parent->_M_base);
3018 if constexpr (__detail::__tiny_range<_Pattern>)
3020 const auto& __cur = _M_i_current();
3023 if (__pcur == __pend)
3024 return _M_incremented;
3025 return *__cur == *__pcur;
3029 auto __cur = _M_i_current();
3032 if (__pcur == __pend)
3033 return _M_incremented;
3036 if (*__cur != *__pcur)
3038 if (++__pcur == __pend)
3040 } while (++__cur != __end);
3046 _M_i_current() noexcept
3047 { return _M_i.__current(); }
3050 _M_i_current() const noexcept
3051 { return _M_i.__current(); }
3053 _OuterIter<_Const> _M_i = _OuterIter<_Const>();
3054 bool _M_incremented = false;
3057 using iterator_concept
3058 = typename _OuterIter<_Const>::iterator_concept;
3059 // iterator_category defined in __split_view_inner_iter_cat
3060 using value_type = range_value_t<_Base>;
3061 using difference_type = range_difference_t<_Base>;
3063 _InnerIter() = default;
3066 _InnerIter(_OuterIter<_Const> __i)
3067 : _M_i(std::move(__i))
3070 constexpr const iterator_t<_Base>&
3071 base() const& noexcept
3072 { return _M_i_current(); }
3074 constexpr iterator_t<_Base>
3075 base() && requires forward_range<_Vp>
3076 { return std::move(_M_i_current()); }
3078 constexpr decltype(auto)
3080 { return *_M_i_current(); }
3082 constexpr _InnerIter&
3085 _M_incremented = true;
3086 if constexpr (!forward_range<_Base>)
3087 if constexpr (_Pattern::size() == 0)
3093 constexpr decltype(auto)
3096 if constexpr (forward_range<_Base>)
3106 friend constexpr bool
3107 operator==(const _InnerIter& __x, const _InnerIter& __y)
3108 requires forward_range<_Base>
3109 { return __x._M_i == __y._M_i; }
3111 friend constexpr bool
3112 operator==(const _InnerIter& __x, default_sentinel_t)
3113 { return __x.__at_end(); }
3115 friend constexpr decltype(auto)
3116 iter_move(const _InnerIter& __i)
3117 noexcept(noexcept(ranges::iter_move(__i._M_i_current())))
3118 { return ranges::iter_move(__i._M_i_current()); }
3120 friend constexpr void
3121 iter_swap(const _InnerIter& __x, const _InnerIter& __y)
3122 noexcept(noexcept(ranges::iter_swap(__x._M_i_current(),
3123 __y._M_i_current())))
3124 requires indirectly_swappable<iterator_t<_Base>>
3125 { ranges::iter_swap(__x._M_i_current(), __y._M_i_current()); }
3128 _Pattern _M_pattern = _Pattern();
3129 // XXX: _M_current is "present only if !forward_range<V>"
3130 [[no_unique_address]]
3131 __detail::__maybe_present_t<!forward_range<_Vp>,
3132 iterator_t<_Vp>> _M_current;
3133 _Vp _M_base = _Vp();
3137 split_view() requires (default_initializable<_Vp>
3138 && default_initializable<_Pattern>
3139 && (forward_range<_Vp>
3140 || default_initializable<iterator_t<_Vp>>))
3144 split_view(_Vp __base, _Pattern __pattern)
3145 : _M_pattern(std::move(__pattern)), _M_base(std::move(__base))
3148 template<input_range _Range>
3149 requires constructible_from<_Vp, views::all_t<_Range>>
3150 && constructible_from<_Pattern, single_view<range_value_t<_Range>>>
3152 split_view(_Range&& __r, range_value_t<_Range> __e)
3153 : _M_pattern(views::single(std::move(__e))),
3154 _M_base(views::all(std::forward<_Range>(__r)))
3158 base() const& requires copy_constructible<_Vp>
3163 { return std::move(_M_base); }
3168 if constexpr (forward_range<_Vp>)
3170 constexpr bool __simple
3171 = __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
3172 return _OuterIter<__simple>{this, ranges::begin(_M_base)};
3176 _M_current = ranges::begin(_M_base);
3177 return _OuterIter<false>{this};
3182 begin() const requires forward_range<_Vp> && forward_range<const _Vp>
3184 return _OuterIter<true>{this, ranges::begin(_M_base)};
3188 end() requires forward_range<_Vp> && common_range<_Vp>
3190 constexpr bool __simple
3191 = __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
3192 return _OuterIter<__simple>{this, ranges::end(_M_base)};
3198 if constexpr (forward_range<_Vp>
3199 && forward_range<const _Vp>
3200 && common_range<const _Vp>)
3201 return _OuterIter<true>{this, ranges::end(_M_base)};
3203 return default_sentinel;
3207 template<typename _Range, typename _Pattern>
3208 split_view(_Range&&, _Pattern&&)
3209 -> split_view<views::all_t<_Range>, views::all_t<_Pattern>>;
3211 template<input_range _Range>
3212 split_view(_Range&&, range_value_t<_Range>)
3213 -> split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
3219 template<typename _Range, typename _Pattern>
3220 concept __can_split_view
3221 = requires { split_view(std::declval<_Range>(), std::declval<_Pattern>()); };
3222 } // namespace __detail
3224 struct _Split : __adaptor::_RangeAdaptor<_Split>
3226 template<viewable_range _Range, typename _Pattern>
3227 requires __detail::__can_split_view<_Range, _Pattern>
3229 operator()(_Range&& __r, _Pattern&& __f) const
3231 return split_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
3234 using _RangeAdaptor<_Split>::operator();
3235 static constexpr int _S_arity = 2;
3236 // The pattern argument of views::split is not always simple -- it can be
3237 // a non-view range, the value category of which affects whether the call
3238 // is well-formed. But a scalar or a view pattern argument is surely
3240 template<typename _Pattern>
3241 static constexpr bool _S_has_simple_extra_args
3242 = is_scalar_v<_Pattern> || (view<_Pattern>
3243 && copy_constructible<_Pattern>);
3246 inline constexpr _Split split;
3247 } // namespace views
3253 template<input_or_output_iterator _Iter>
3255 operator()(_Iter __i, iter_difference_t<_Iter> __n) const
3257 if constexpr (random_access_iterator<_Iter>)
3258 return subrange(__i, __i + __n);
3260 return subrange(counted_iterator(std::move(__i), __n),
3265 inline constexpr _Counted counted{};
3266 } // namespace views
3269 requires (!common_range<_Vp>) && copyable<iterator_t<_Vp>>
3270 class common_view : public view_interface<common_view<_Vp>>
3273 _Vp _M_base = _Vp();
3276 common_view() requires default_initializable<_Vp> = default;
3279 common_view(_Vp __r)
3280 : _M_base(std::move(__r))
3283 /* XXX: LWG 3280 didn't remove this constructor, but I think it should?
3284 template<viewable_range _Range>
3285 requires (!common_range<_Range>)
3286 && constructible_from<_Vp, views::all_t<_Range>>
3288 common_view(_Range&& __r)
3289 : _M_base(views::all(std::forward<_Range>(__r)))
3294 base() const& requires copy_constructible<_Vp>
3299 { return std::move(_M_base); }
3304 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3305 return ranges::begin(_M_base);
3307 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
3308 (ranges::begin(_M_base));
3312 begin() const requires range<const _Vp>
3314 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
3315 return ranges::begin(_M_base);
3317 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
3318 (ranges::begin(_M_base));
3324 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3325 return ranges::begin(_M_base) + ranges::size(_M_base);
3327 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
3328 (ranges::end(_M_base));
3332 end() const requires range<const _Vp>
3334 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
3335 return ranges::begin(_M_base) + ranges::size(_M_base);
3337 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
3338 (ranges::end(_M_base));
3342 size() requires sized_range<_Vp>
3343 { return ranges::size(_M_base); }
3346 size() const requires sized_range<const _Vp>
3347 { return ranges::size(_M_base); }
3350 template<typename _Range>
3351 common_view(_Range&&) -> common_view<views::all_t<_Range>>;
3353 template<typename _Tp>
3354 inline constexpr bool enable_borrowed_range<common_view<_Tp>>
3355 = enable_borrowed_range<_Tp>;
3361 template<typename _Range>
3362 concept __already_common = common_range<_Range>
3363 && requires { views::all(std::declval<_Range>()); };
3365 template<typename _Range>
3366 concept __can_common_view
3367 = requires { common_view{std::declval<_Range>()}; };
3368 } // namespace __detail
3370 struct _Common : __adaptor::_RangeAdaptorClosure
3372 template<viewable_range _Range>
3373 requires __detail::__already_common<_Range>
3374 || __detail::__can_common_view<_Range>
3376 operator()(_Range&& __r) const
3378 if constexpr (__detail::__already_common<_Range>)
3379 return views::all(std::forward<_Range>(__r));
3381 return common_view{std::forward<_Range>(__r)};
3384 static constexpr bool _S_has_simple_call_op = true;
3387 inline constexpr _Common common;
3388 } // namespace views
3391 requires bidirectional_range<_Vp>
3392 class reverse_view : public view_interface<reverse_view<_Vp>>
3395 static constexpr bool _S_needs_cached_begin
3396 = !common_range<_Vp> && !random_access_range<_Vp>;
3398 [[no_unique_address]]
3399 __detail::__maybe_present_t<_S_needs_cached_begin,
3400 __detail::_CachedPosition<_Vp>>
3402 _Vp _M_base = _Vp();
3405 reverse_view() requires default_initializable<_Vp> = default;
3408 reverse_view(_Vp __r)
3409 : _M_base(std::move(__r))
3413 base() const& requires copy_constructible<_Vp>
3418 { return std::move(_M_base); }
3420 constexpr reverse_iterator<iterator_t<_Vp>>
3423 if constexpr (_S_needs_cached_begin)
3424 if (_M_cached_begin._M_has_value())
3425 return std::make_reverse_iterator(_M_cached_begin._M_get(_M_base));
3427 auto __it = ranges::next(ranges::begin(_M_base), ranges::end(_M_base));
3428 if constexpr (_S_needs_cached_begin)
3429 _M_cached_begin._M_set(_M_base, __it);
3430 return std::make_reverse_iterator(std::move(__it));
3434 begin() requires common_range<_Vp>
3435 { return std::make_reverse_iterator(ranges::end(_M_base)); }
3438 begin() const requires common_range<const _Vp>
3439 { return std::make_reverse_iterator(ranges::end(_M_base)); }
3441 constexpr reverse_iterator<iterator_t<_Vp>>
3443 { return std::make_reverse_iterator(ranges::begin(_M_base)); }
3446 end() const requires common_range<const _Vp>
3447 { return std::make_reverse_iterator(ranges::begin(_M_base)); }
3450 size() requires sized_range<_Vp>
3451 { return ranges::size(_M_base); }
3454 size() const requires sized_range<const _Vp>
3455 { return ranges::size(_M_base); }
3458 template<typename _Range>
3459 reverse_view(_Range&&) -> reverse_view<views::all_t<_Range>>;
3461 template<typename _Tp>
3462 inline constexpr bool enable_borrowed_range<reverse_view<_Tp>>
3463 = enable_borrowed_range<_Tp>;
3470 inline constexpr bool __is_reversible_subrange = false;
3472 template<typename _Iter, subrange_kind _Kind>
3473 inline constexpr bool
3474 __is_reversible_subrange<subrange<reverse_iterator<_Iter>,
3475 reverse_iterator<_Iter>,
3479 inline constexpr bool __is_reverse_view = false;
3481 template<typename _Vp>
3482 inline constexpr bool __is_reverse_view<reverse_view<_Vp>> = true;
3484 template<typename _Range>
3485 concept __can_reverse_view
3486 = requires { reverse_view{std::declval<_Range>()}; };
3487 } // namespace __detail
3489 struct _Reverse : __adaptor::_RangeAdaptorClosure
3491 template<viewable_range _Range>
3492 requires __detail::__is_reverse_view<remove_cvref_t<_Range>>
3493 || __detail::__is_reversible_subrange<remove_cvref_t<_Range>>
3494 || __detail::__can_reverse_view<_Range>
3496 operator()(_Range&& __r) const
3498 using _Tp = remove_cvref_t<_Range>;
3499 if constexpr (__detail::__is_reverse_view<_Tp>)
3500 return std::forward<_Range>(__r).base();
3501 else if constexpr (__detail::__is_reversible_subrange<_Tp>)
3503 using _Iter = decltype(ranges::begin(__r).base());
3504 if constexpr (sized_range<_Tp>)
3505 return subrange<_Iter, _Iter, subrange_kind::sized>
3506 {__r.end().base(), __r.begin().base(), __r.size()};
3508 return subrange<_Iter, _Iter, subrange_kind::unsized>
3509 {__r.end().base(), __r.begin().base()};
3512 return reverse_view{std::forward<_Range>(__r)};
3515 static constexpr bool _S_has_simple_call_op = true;
3518 inline constexpr _Reverse reverse;
3519 } // namespace views
3523 template<typename _Tp, size_t _Nm>
3524 concept __has_tuple_element = requires(_Tp __t)
3526 typename tuple_size<_Tp>::type;
3527 requires _Nm < tuple_size_v<_Tp>;
3528 typename tuple_element_t<_Nm, _Tp>;
3529 { std::get<_Nm>(__t) }
3530 -> convertible_to<const tuple_element_t<_Nm, _Tp>&>;
3533 template<typename _Tp, size_t _Nm>
3534 concept __returnable_element
3535 = is_reference_v<_Tp> || move_constructible<tuple_element_t<_Nm, _Tp>>;
3538 template<input_range _Vp, size_t _Nm>
3540 && __detail::__has_tuple_element<range_value_t<_Vp>, _Nm>
3541 && __detail::__has_tuple_element<remove_reference_t<range_reference_t<_Vp>>,
3543 && __detail::__returnable_element<range_reference_t<_Vp>, _Nm>
3544 class elements_view : public view_interface<elements_view<_Vp, _Nm>>
3547 elements_view() requires default_initializable<_Vp> = default;
3550 elements_view(_Vp base)
3551 : _M_base(std::move(base))
3555 base() const& requires copy_constructible<_Vp>
3560 { return std::move(_M_base); }
3563 begin() requires (!__detail::__simple_view<_Vp>)
3564 { return _Iterator<false>(ranges::begin(_M_base)); }
3567 begin() const requires range<const _Vp>
3568 { return _Iterator<true>(ranges::begin(_M_base)); }
3571 end() requires (!__detail::__simple_view<_Vp> && !common_range<_Vp>)
3572 { return _Sentinel<false>{ranges::end(_M_base)}; }
3575 end() requires (!__detail::__simple_view<_Vp> && common_range<_Vp>)
3576 { return _Iterator<false>{ranges::end(_M_base)}; }
3579 end() const requires range<const _Vp>
3580 { return _Sentinel<true>{ranges::end(_M_base)}; }
3583 end() const requires common_range<const _Vp>
3584 { return _Iterator<true>{ranges::end(_M_base)}; }
3587 size() requires sized_range<_Vp>
3588 { return ranges::size(_M_base); }
3591 size() const requires sized_range<const _Vp>
3592 { return ranges::size(_M_base); }
3595 template<bool _Const>
3596 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
3598 template<bool _Const>
3602 template<bool _Const>
3603 requires forward_range<_Base<_Const>>
3604 struct __iter_cat<_Const>
3607 static auto _S_iter_cat()
3609 using _Base = elements_view::_Base<_Const>;
3610 using _Cat = typename iterator_traits<iterator_t<_Base>>::iterator_category;
3611 using _Res = decltype((std::get<_Nm>(*std::declval<iterator_t<_Base>>())));
3612 if constexpr (!is_lvalue_reference_v<_Res>)
3613 return input_iterator_tag{};
3614 else if constexpr (derived_from<_Cat, random_access_iterator_tag>)
3615 return random_access_iterator_tag{};
3620 using iterator_category = decltype(_S_iter_cat());
3623 template<bool _Const>
3626 template<bool _Const>
3627 struct _Iterator : __iter_cat<_Const>
3630 using _Base = elements_view::_Base<_Const>;
3632 iterator_t<_Base> _M_current = iterator_t<_Base>();
3634 static constexpr decltype(auto)
3635 _S_get_element(const iterator_t<_Base>& __i)
3637 if constexpr (is_reference_v<range_reference_t<_Base>>)
3638 return std::get<_Nm>(*__i);
3641 using _Et = remove_cv_t<tuple_element_t<_Nm, range_reference_t<_Base>>>;
3642 return static_cast<_Et>(std::get<_Nm>(*__i));
3649 if constexpr (random_access_range<_Base>)
3650 return random_access_iterator_tag{};
3651 else if constexpr (bidirectional_range<_Base>)
3652 return bidirectional_iterator_tag{};
3653 else if constexpr (forward_range<_Base>)
3654 return forward_iterator_tag{};
3656 return input_iterator_tag{};
3659 friend _Iterator<!_Const>;
3662 using iterator_concept = decltype(_S_iter_concept());
3663 // iterator_category defined in elements_view::__iter_cat
3665 = remove_cvref_t<tuple_element_t<_Nm, range_value_t<_Base>>>;
3666 using difference_type = range_difference_t<_Base>;
3668 _Iterator() requires default_initializable<iterator_t<_Base>> = default;
3671 _Iterator(iterator_t<_Base> current)
3672 : _M_current(std::move(current))
3676 _Iterator(_Iterator<!_Const> i)
3677 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
3678 : _M_current(std::move(i._M_current))
3681 constexpr const iterator_t<_Base>&
3682 base() const& noexcept
3683 { return _M_current; }
3685 constexpr iterator_t<_Base>
3687 { return std::move(_M_current); }
3689 constexpr decltype(auto)
3691 { return _S_get_element(_M_current); }
3693 constexpr _Iterator&
3705 operator++(int) requires forward_range<_Base>
3712 constexpr _Iterator&
3713 operator--() requires bidirectional_range<_Base>
3720 operator--(int) requires bidirectional_range<_Base>
3727 constexpr _Iterator&
3728 operator+=(difference_type __n)
3729 requires random_access_range<_Base>
3735 constexpr _Iterator&
3736 operator-=(difference_type __n)
3737 requires random_access_range<_Base>
3743 constexpr decltype(auto)
3744 operator[](difference_type __n) const
3745 requires random_access_range<_Base>
3746 { return _S_get_element(_M_current + __n); }
3748 friend constexpr bool
3749 operator==(const _Iterator& __x, const _Iterator& __y)
3750 requires equality_comparable<iterator_t<_Base>>
3751 { return __x._M_current == __y._M_current; }
3753 friend constexpr bool
3754 operator<(const _Iterator& __x, const _Iterator& __y)
3755 requires random_access_range<_Base>
3756 { return __x._M_current < __y._M_current; }
3758 friend constexpr bool
3759 operator>(const _Iterator& __x, const _Iterator& __y)
3760 requires random_access_range<_Base>
3761 { return __y._M_current < __x._M_current; }
3763 friend constexpr bool
3764 operator<=(const _Iterator& __x, const _Iterator& __y)
3765 requires random_access_range<_Base>
3766 { return !(__y._M_current > __x._M_current); }
3768 friend constexpr bool
3769 operator>=(const _Iterator& __x, const _Iterator& __y)
3770 requires random_access_range<_Base>
3771 { return !(__x._M_current > __y._M_current); }
3773 #ifdef __cpp_lib_three_way_comparison
3774 friend constexpr auto
3775 operator<=>(const _Iterator& __x, const _Iterator& __y)
3776 requires random_access_range<_Base>
3777 && three_way_comparable<iterator_t<_Base>>
3778 { return __x._M_current <=> __y._M_current; }
3781 friend constexpr _Iterator
3782 operator+(const _Iterator& __x, difference_type __y)
3783 requires random_access_range<_Base>
3784 { return _Iterator{__x} += __y; }
3786 friend constexpr _Iterator
3787 operator+(difference_type __x, const _Iterator& __y)
3788 requires random_access_range<_Base>
3789 { return __y + __x; }
3791 friend constexpr _Iterator
3792 operator-(const _Iterator& __x, difference_type __y)
3793 requires random_access_range<_Base>
3794 { return _Iterator{__x} -= __y; }
3796 // _GLIBCXX_RESOLVE_LIB_DEFECTS
3797 // 3483. transform_view::iterator's difference is overconstrained
3798 friend constexpr difference_type
3799 operator-(const _Iterator& __x, const _Iterator& __y)
3800 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
3801 { return __x._M_current - __y._M_current; }
3803 template <bool> friend struct _Sentinel;
3806 template<bool _Const>
3810 template<bool _Const2>
3812 _M_equal(const _Iterator<_Const2>& __x) const
3813 { return __x._M_current == _M_end; }
3815 template<bool _Const2>
3817 _M_distance_from(const _Iterator<_Const2>& __i) const
3818 { return _M_end - __i._M_current; }
3820 using _Base = elements_view::_Base<_Const>;
3821 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
3824 _Sentinel() = default;
3827 _Sentinel(sentinel_t<_Base> __end)
3828 : _M_end(std::move(__end))
3832 _Sentinel(_Sentinel<!_Const> __other)
3834 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
3835 : _M_end(std::move(__other._M_end))
3838 constexpr sentinel_t<_Base>
3842 template<bool _Const2>
3843 requires sentinel_for<sentinel_t<_Base>,
3844 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
3845 friend constexpr bool
3846 operator==(const _Iterator<_Const2>& __x, const _Sentinel& __y)
3847 { return __y._M_equal(__x); }
3849 template<bool _Const2,
3850 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
3851 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
3852 friend constexpr range_difference_t<_Base2>
3853 operator-(const _Iterator<_Const2>& __x, const _Sentinel& __y)
3854 { return -__y._M_distance_from(__x); }
3856 template<bool _Const2,
3857 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
3858 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
3859 friend constexpr range_difference_t<_Base2>
3860 operator-(const _Sentinel& __x, const _Iterator<_Const2>& __y)
3861 { return __x._M_distance_from(__y); }
3863 friend _Sentinel<!_Const>;
3866 _Vp _M_base = _Vp();
3869 template<typename _Tp, size_t _Nm>
3870 inline constexpr bool enable_borrowed_range<elements_view<_Tp, _Nm>>
3871 = enable_borrowed_range<_Tp>;
3873 template<typename _Range>
3874 using keys_view = elements_view<views::all_t<_Range>, 0>;
3876 template<typename _Range>
3877 using values_view = elements_view<views::all_t<_Range>, 1>;
3883 template<size_t _Nm, typename _Range>
3884 concept __can_elements_view
3885 = requires { elements_view<all_t<_Range>, _Nm>{std::declval<_Range>()}; };
3886 } // namespace __detail
3888 template<size_t _Nm>
3889 struct _Elements : __adaptor::_RangeAdaptorClosure
3891 template<viewable_range _Range>
3892 requires __detail::__can_elements_view<_Nm, _Range>
3894 operator()(_Range&& __r) const
3896 return elements_view<all_t<_Range>, _Nm>{std::forward<_Range>(__r)};
3899 static constexpr bool _S_has_simple_call_op = true;
3902 template<size_t _Nm>
3903 inline constexpr _Elements<_Nm> elements;
3904 inline constexpr auto keys = elements<0>;
3905 inline constexpr auto values = elements<1>;
3906 } // namespace views
3908 } // namespace ranges
3910 namespace views = ranges::views;
3912 _GLIBCXX_END_NAMESPACE_VERSION
3914 #endif // library concepts
3916 #endif /* _GLIBCXX_RANGES */