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>
464 { return __i += __n; }
466 friend constexpr _Iterator
467 operator+(difference_type __n, _Iterator __i)
468 requires __detail::__advanceable<_Winc>
469 { return __i += __n; }
471 friend constexpr _Iterator
472 operator-(_Iterator __i, difference_type __n)
473 requires __detail::__advanceable<_Winc>
474 { return __i -= __n; }
476 friend constexpr difference_type
477 operator-(const _Iterator& __x, const _Iterator& __y)
478 requires __detail::__advanceable<_Winc>
480 using __detail::__is_integer_like;
481 using __detail::__is_signed_integer_like;
482 using _Dt = difference_type;
483 if constexpr (__is_integer_like<_Winc>)
485 if constexpr (__is_signed_integer_like<_Winc>)
486 return _Dt(_Dt(__x._M_value) - _Dt(__y._M_value));
488 return (__y._M_value > __x._M_value)
489 ? _Dt(-_Dt(__y._M_value - __x._M_value))
490 : _Dt(__x._M_value - __y._M_value);
493 return __x._M_value - __y._M_value;
497 _Winc _M_value = _Winc();
506 _M_equal(const _Iterator& __x) const
507 { return __x._M_value == _M_bound; }
510 _M_distance_from(const _Iterator& __x) const
511 { return _M_bound - __x._M_value; }
513 _Bound _M_bound = _Bound();
516 _Sentinel() = default;
519 _Sentinel(_Bound __bound)
520 : _M_bound(__bound) { }
522 friend constexpr bool
523 operator==(const _Iterator& __x, const _Sentinel& __y)
524 { return __y._M_equal(__x); }
526 friend constexpr iter_difference_t<_Winc>
527 operator-(const _Iterator& __x, const _Sentinel& __y)
528 requires sized_sentinel_for<_Bound, _Winc>
529 { return -__y._M_distance_from(__x); }
531 friend constexpr iter_difference_t<_Winc>
532 operator-(const _Sentinel& __x, const _Iterator& __y)
533 requires sized_sentinel_for<_Bound, _Winc>
534 { return __x._M_distance_from(__y); }
537 _Winc _M_value = _Winc();
538 [[no_unique_address]] _Bound _M_bound = _Bound();
541 iota_view() requires default_initializable<_Winc> = default;
544 iota_view(_Winc __value)
549 iota_view(type_identity_t<_Winc> __value,
550 type_identity_t<_Bound> __bound)
551 : _M_value(__value), _M_bound(__bound)
553 if constexpr (totally_ordered_with<_Winc, _Bound>)
554 __glibcxx_assert( bool(__value <= __bound) );
558 begin() const { return _Iterator{_M_value}; }
563 if constexpr (same_as<_Bound, unreachable_sentinel_t>)
564 return unreachable_sentinel;
566 return _Sentinel{_M_bound};
570 end() const requires same_as<_Winc, _Bound>
571 { return _Iterator{_M_bound}; }
575 requires (same_as<_Winc, _Bound> && __detail::__advanceable<_Winc>)
576 || (integral<_Winc> && integral<_Bound>)
577 || sized_sentinel_for<_Bound, _Winc>
579 using __detail::__is_integer_like;
580 using __detail::__to_unsigned_like;
581 if constexpr (integral<_Winc> && integral<_Bound>)
583 using _Up = make_unsigned_t<decltype(_M_bound - _M_value)>;
584 return _Up(_M_bound) - _Up(_M_value);
586 else if constexpr (__is_integer_like<_Winc>)
587 return __to_unsigned_like(_M_bound) - __to_unsigned_like(_M_value);
589 return __to_unsigned_like(_M_bound - _M_value);
593 template<typename _Winc, typename _Bound>
594 requires (!__detail::__is_integer_like<_Winc>
595 || !__detail::__is_integer_like<_Bound>
596 || (__detail::__is_signed_integer_like<_Winc>
597 == __detail::__is_signed_integer_like<_Bound>))
598 iota_view(_Winc, _Bound) -> iota_view<_Winc, _Bound>;
600 template<weakly_incrementable _Winc, semiregular _Bound>
601 inline constexpr bool
602 enable_borrowed_range<iota_view<_Winc, _Bound>> = true;
606 template<typename _Tp>
607 inline constexpr empty_view<_Tp> empty{};
611 template<typename _Tp>
613 operator()(_Tp&& __e) const
614 { return single_view<decay_t<_Tp>>(std::forward<_Tp>(__e)); }
617 inline constexpr _Single single{};
621 template<typename _Tp>
623 operator()(_Tp&& __e) const
624 { return iota_view(std::forward<_Tp>(__e)); }
626 template<typename _Tp, typename _Up>
628 operator()(_Tp&& __e, _Up&& __f) const
629 { return iota_view(std::forward<_Tp>(__e), std::forward<_Up>(__f)); }
632 inline constexpr _Iota iota{};
637 template<typename _Val, typename _CharT, typename _Traits>
638 concept __stream_extractable
639 = requires(basic_istream<_CharT, _Traits>& is, _Val& t) { is >> t; };
640 } // namespace __detail
642 template<movable _Val, typename _CharT,
643 typename _Traits = char_traits<_CharT>>
644 requires default_initializable<_Val>
645 && __detail::__stream_extractable<_Val, _CharT, _Traits>
646 class basic_istream_view
647 : public view_interface<basic_istream_view<_Val, _CharT, _Traits>>
650 basic_istream_view() = default;
653 basic_istream_view(basic_istream<_CharT, _Traits>& __stream)
654 : _M_stream(std::__addressof(__stream))
660 if (_M_stream != nullptr)
661 *_M_stream >> _M_object;
662 return _Iterator{this};
665 constexpr default_sentinel_t
667 { return default_sentinel; }
670 basic_istream<_CharT, _Traits>* _M_stream = nullptr;
671 _Val _M_object = _Val();
676 using iterator_concept = input_iterator_tag;
677 using difference_type = ptrdiff_t;
678 using value_type = _Val;
680 _Iterator() = default;
683 _Iterator(basic_istream_view* __parent) noexcept
684 : _M_parent(__parent)
687 _Iterator(const _Iterator&) = delete;
688 _Iterator(_Iterator&&) = default;
689 _Iterator& operator=(const _Iterator&) = delete;
690 _Iterator& operator=(_Iterator&&) = default;
695 __glibcxx_assert(_M_parent->_M_stream != nullptr);
696 *_M_parent->_M_stream >> _M_parent->_M_object;
707 __glibcxx_assert(_M_parent->_M_stream != nullptr);
708 return _M_parent->_M_object;
712 operator==(const _Iterator& __x, default_sentinel_t)
713 { return __x._M_at_end(); }
716 basic_istream_view* _M_parent = nullptr;
720 { return _M_parent == nullptr || !*_M_parent->_M_stream; }
726 template<typename _Val, typename _CharT, typename _Traits>
727 basic_istream_view<_Val, _CharT, _Traits>
728 istream_view(basic_istream<_CharT, _Traits>& __s)
729 { return basic_istream_view<_Val, _CharT, _Traits>{__s}; }
731 // C++20 24.7 [range.adaptors] Range adaptors
737 // Alias for a type that is conditionally present
738 // (and is an empty type otherwise).
739 // Data members using this alias should use [[no_unique_address]] so that
740 // they take no space when not needed.
741 template<bool _Present, typename _Tp>
742 using __maybe_present_t = conditional_t<_Present, _Tp, _Empty>;
744 // Alias for a type that is conditionally const.
745 template<bool _Const, typename _Tp>
746 using __maybe_const_t = conditional_t<_Const, const _Tp, _Tp>;
748 } // namespace __detail
750 namespace views::__adaptor
752 // True if the range adaptor _Adaptor can be applied with _Args.
753 template<typename _Adaptor, typename... _Args>
754 concept __adaptor_invocable
755 = requires { std::declval<_Adaptor>()(declval<_Args>()...); };
757 // True if the range adaptor non-closure _Adaptor can be partially applied
759 template<typename _Adaptor, typename... _Args>
760 concept __adaptor_partial_app_viable = (_Adaptor::_S_arity > 1)
761 && (sizeof...(_Args) == _Adaptor::_S_arity - 1)
762 && (constructible_from<decay_t<_Args>, _Args> && ...);
764 template<typename _Adaptor, typename... _Args>
767 template<typename _Lhs, typename _Rhs>
770 // The base class of every range adaptor closure.
772 // The derived class should define the optional static data member
773 // _S_has_simple_call_op to true if the behavior of this adaptor is
774 // independent of the constness/value category of the adaptor object.
775 struct _RangeAdaptorClosure
777 // range | adaptor is equivalent to adaptor(range).
778 template<typename _Self, typename _Range>
779 requires derived_from<remove_cvref_t<_Self>, _RangeAdaptorClosure>
780 && __adaptor_invocable<_Self, _Range>
781 friend constexpr auto
782 operator|(_Range&& __r, _Self&& __self)
783 { return std::forward<_Self>(__self)(std::forward<_Range>(__r)); }
785 // Compose the adaptors __lhs and __rhs into a pipeline, returning
786 // another range adaptor closure object.
787 template<typename _Lhs, typename _Rhs>
788 requires derived_from<_Lhs, _RangeAdaptorClosure>
789 && derived_from<_Rhs, _RangeAdaptorClosure>
790 friend constexpr auto
791 operator|(_Lhs __lhs, _Rhs __rhs)
792 { return _Pipe<_Lhs, _Rhs>{std::move(__lhs), std::move(__rhs)}; }
795 // The base class of every range adaptor non-closure.
797 // The static data member _Derived::_S_arity must contain the total number of
798 // arguments that the adaptor takes, and the class _Derived must introduce
799 // _RangeAdaptor::operator() into the class scope via a using-declaration.
801 // The optional static data member _Derived::_S_has_simple_extra_args should
802 // be defined to true if the behavior of this adaptor is independent of the
803 // constness/value category of the extra arguments. This data member could
804 // also be defined as a variable template parameterized by the types of the
806 template<typename _Derived>
809 // Partially apply the arguments __args to the range adaptor _Derived,
810 // returning a range adaptor closure object.
811 template<typename... _Args>
812 requires __adaptor_partial_app_viable<_Derived, _Args...>
814 operator()(_Args&&... __args) const
816 return _Partial<_Derived, decay_t<_Args>...>{std::forward<_Args>(__args)...};
820 // True if the range adaptor closure _Adaptor has a simple operator(), i.e.
821 // one that's not overloaded according to constness or value category of the
823 template<typename _Adaptor>
824 concept __closure_has_simple_call_op = _Adaptor::_S_has_simple_call_op;
826 // True if the behavior of the range adaptor non-closure _Adaptor is
827 // independent of the value category of its extra arguments _Args.
828 template<typename _Adaptor, typename... _Args>
829 concept __adaptor_has_simple_extra_args = _Adaptor::_S_has_simple_extra_args
830 || _Adaptor::template _S_has_simple_extra_args<_Args...>;
832 // A range adaptor closure that represents partial application of
833 // the range adaptor _Adaptor with arguments _Args.
834 template<typename _Adaptor, typename... _Args>
835 struct _Partial : _RangeAdaptorClosure
837 tuple<_Args...> _M_args;
840 _Partial(_Args... __args)
841 : _M_args(std::move(__args)...)
844 // Invoke _Adaptor with arguments __r, _M_args... according to the
845 // value category of this _Partial object.
846 template<typename _Range>
847 requires __adaptor_invocable<_Adaptor, _Range, const _Args&...>
849 operator()(_Range&& __r) const &
851 auto __forwarder = [&__r] (const auto&... __args) {
852 return _Adaptor{}(std::forward<_Range>(__r), __args...);
854 return std::apply(__forwarder, _M_args);
857 template<typename _Range>
858 requires __adaptor_invocable<_Adaptor, _Range, _Args...>
860 operator()(_Range&& __r) &&
862 auto __forwarder = [&__r] (auto&... __args) {
863 return _Adaptor{}(std::forward<_Range>(__r), std::move(__args)...);
865 return std::apply(__forwarder, _M_args);
868 template<typename _Range>
870 operator()(_Range&& __r) const && = delete;
873 // A lightweight specialization of the above primary template for
874 // the common case where _Adaptor accepts a single extra argument.
875 template<typename _Adaptor, typename _Arg>
876 struct _Partial<_Adaptor, _Arg> : _RangeAdaptorClosure
882 : _M_arg(std::move(__arg))
885 template<typename _Range>
886 requires __adaptor_invocable<_Adaptor, _Range, const _Arg&>
888 operator()(_Range&& __r) const &
889 { return _Adaptor{}(std::forward<_Range>(__r), _M_arg); }
891 template<typename _Range>
892 requires __adaptor_invocable<_Adaptor, _Range, _Arg>
894 operator()(_Range&& __r) &&
895 { return _Adaptor{}(std::forward<_Range>(__r), std::move(_M_arg)); }
897 template<typename _Range>
899 operator()(_Range&& __r) const && = delete;
902 // Partial specialization of the primary template for the case where the extra
903 // arguments of the adaptor can always be safely and efficiently forwarded by
904 // const reference. This lets us get away with a single operator() overload,
905 // which makes overload resolution failure diagnostics more concise.
906 template<typename _Adaptor, typename... _Args>
907 requires __adaptor_has_simple_extra_args<_Adaptor, _Args...>
908 && (is_trivially_copyable_v<_Args> && ...)
909 struct _Partial<_Adaptor, _Args...> : _RangeAdaptorClosure
911 tuple<_Args...> _M_args;
914 _Partial(_Args... __args)
915 : _M_args(std::move(__args)...)
918 // Invoke _Adaptor with arguments __r, const _M_args&... regardless
919 // of the value category of this _Partial object.
920 template<typename _Range>
921 requires __adaptor_invocable<_Adaptor, _Range, const _Args&...>
923 operator()(_Range&& __r) const
925 auto __forwarder = [&__r] (const auto&... __args) {
926 return _Adaptor{}(std::forward<_Range>(__r), __args...);
928 return std::apply(__forwarder, _M_args);
931 static constexpr bool _S_has_simple_call_op = true;
934 // A lightweight specialization of the above template for the common case
935 // where _Adaptor accepts a single extra argument.
936 template<typename _Adaptor, typename _Arg>
937 requires __adaptor_has_simple_extra_args<_Adaptor, _Arg>
938 && is_trivially_copyable_v<_Arg>
939 struct _Partial<_Adaptor, _Arg> : _RangeAdaptorClosure
945 : _M_arg(std::move(__arg))
948 template<typename _Range>
949 requires __adaptor_invocable<_Adaptor, _Range, const _Arg&>
951 operator()(_Range&& __r) const
952 { return _Adaptor{}(std::forward<_Range>(__r), _M_arg); }
954 static constexpr bool _S_has_simple_call_op = true;
957 template<typename _Lhs, typename _Rhs, typename _Range>
958 concept __pipe_invocable
959 = requires { std::declval<_Rhs>()(std::declval<_Lhs>()(std::declval<_Range>())); };
961 // A range adaptor closure that represents composition of the range
962 // adaptor closures _Lhs and _Rhs.
963 template<typename _Lhs, typename _Rhs>
964 struct _Pipe : _RangeAdaptorClosure
966 [[no_unique_address]] _Lhs _M_lhs;
967 [[no_unique_address]] _Rhs _M_rhs;
970 _Pipe(_Lhs __lhs, _Rhs __rhs)
971 : _M_lhs(std::move(__lhs)), _M_rhs(std::move(__rhs))
974 // Invoke _M_rhs(_M_lhs(__r)) according to the value category of this
975 // range adaptor closure object.
976 template<typename _Range>
977 requires __pipe_invocable<const _Lhs&, const _Rhs&, _Range>
979 operator()(_Range&& __r) const &
980 { return _M_rhs(_M_lhs(std::forward<_Range>(__r))); }
982 template<typename _Range>
983 requires __pipe_invocable<_Lhs, _Rhs, _Range>
985 operator()(_Range&& __r) &&
986 { return std::move(_M_rhs)(std::move(_M_lhs)(std::forward<_Range>(__r))); }
988 template<typename _Range>
990 operator()(_Range&& __r) const && = delete;
993 // A partial specialization of the above primary template for the case where
994 // both adaptor operands have a simple operator(). This in turn lets us
995 // implement composition using a single simple operator(), which makes
996 // overload resolution failure diagnostics more concise.
997 template<typename _Lhs, typename _Rhs>
998 requires __closure_has_simple_call_op<_Lhs>
999 && __closure_has_simple_call_op<_Rhs>
1000 struct _Pipe<_Lhs, _Rhs> : _RangeAdaptorClosure
1002 [[no_unique_address]] _Lhs _M_lhs;
1003 [[no_unique_address]] _Rhs _M_rhs;
1006 _Pipe(_Lhs __lhs, _Rhs __rhs)
1007 : _M_lhs(std::move(__lhs)), _M_rhs(std::move(__rhs))
1010 template<typename _Range>
1011 requires __pipe_invocable<const _Lhs&, const _Rhs&, _Range>
1013 operator()(_Range&& __r) const
1014 { return _M_rhs(_M_lhs(std::forward<_Range>(__r))); }
1016 static constexpr bool _S_has_simple_call_op = true;
1018 } // namespace views::__adaptor
1020 template<range _Range> requires is_object_v<_Range>
1021 class ref_view : public view_interface<ref_view<_Range>>
1024 _Range* _M_r = nullptr;
1026 static void _S_fun(_Range&); // not defined
1027 static void _S_fun(_Range&&) = delete;
1031 ref_view() noexcept = default;
1033 template<__detail::__not_same_as<ref_view> _Tp>
1034 requires convertible_to<_Tp, _Range&>
1035 && requires { _S_fun(declval<_Tp>()); }
1038 : _M_r(std::__addressof(static_cast<_Range&>(std::forward<_Tp>(__t))))
1045 constexpr iterator_t<_Range>
1047 { return ranges::begin(*_M_r); }
1049 constexpr sentinel_t<_Range>
1051 { return ranges::end(*_M_r); }
1054 empty() const requires requires { ranges::empty(*_M_r); }
1055 { return ranges::empty(*_M_r); }
1058 size() const requires sized_range<_Range>
1059 { return ranges::size(*_M_r); }
1062 data() const requires contiguous_range<_Range>
1063 { return ranges::data(*_M_r); }
1066 template<typename _Range>
1067 ref_view(_Range&) -> ref_view<_Range>;
1069 template<typename _Tp>
1070 inline constexpr bool enable_borrowed_range<ref_view<_Tp>> = true;
1076 template<typename _Range>
1077 concept __can_ref_view = requires { ref_view{std::declval<_Range>()}; };
1079 template<typename _Range>
1080 concept __can_subrange = requires { subrange{std::declval<_Range>()}; };
1081 } // namespace __detail
1083 struct _All : __adaptor::_RangeAdaptorClosure
1085 template<viewable_range _Range>
1086 requires view<decay_t<_Range>>
1087 || __detail::__can_ref_view<_Range>
1088 || __detail::__can_subrange<_Range>
1090 operator()(_Range&& __r) const
1092 if constexpr (view<decay_t<_Range>>)
1093 return std::forward<_Range>(__r);
1094 else if constexpr (__detail::__can_ref_view<_Range>)
1095 return ref_view{std::forward<_Range>(__r)};
1097 return subrange{std::forward<_Range>(__r)};
1100 static constexpr bool _S_has_simple_call_op = true;
1103 inline constexpr _All all;
1105 template<viewable_range _Range>
1106 using all_t = decltype(all(std::declval<_Range>()));
1107 } // namespace views
1111 template<typename _Tp>
1112 struct __non_propagating_cache
1114 // When _Tp is not an object type (e.g. is a reference type), we make
1115 // __non_propagating_cache<_Tp> empty rather than ill-formed so that
1116 // users can easily conditionally declare data members with this type
1117 // (such as join_view::_M_inner).
1120 template<typename _Tp>
1121 requires is_object_v<_Tp>
1122 struct __non_propagating_cache<_Tp> : protected _Optional_base<_Tp>
1124 __non_propagating_cache() = default;
1127 __non_propagating_cache(const __non_propagating_cache&) noexcept
1131 __non_propagating_cache(__non_propagating_cache&& __other) noexcept
1132 { __other._M_reset(); }
1134 constexpr __non_propagating_cache&
1135 operator=(const __non_propagating_cache& __other) noexcept
1137 if (std::__addressof(__other) != this)
1142 constexpr __non_propagating_cache&
1143 operator=(__non_propagating_cache&& __other) noexcept
1151 operator*() noexcept
1152 { return this->_M_get(); }
1154 constexpr const _Tp&
1155 operator*() const noexcept
1156 { return this->_M_get(); }
1158 template<typename _Iter>
1160 _M_emplace_deref(const _Iter& __i)
1163 // Using _Optional_base::_M_construct to initialize from '*__i'
1164 // would incur an extra move due to the indirection, so we instead
1165 // use placement new directly.
1166 ::new ((void *) std::__addressof(this->_M_payload._M_payload)) _Tp(*__i);
1167 this->_M_payload._M_engaged = true;
1168 return this->_M_get();
1172 template<range _Range>
1173 struct _CachedPosition
1176 _M_has_value() const
1179 constexpr iterator_t<_Range>
1180 _M_get(const _Range&) const
1182 __glibcxx_assert(false);
1183 __builtin_unreachable();
1187 _M_set(const _Range&, const iterator_t<_Range>&) const
1191 template<forward_range _Range>
1192 struct _CachedPosition<_Range>
1193 : protected __non_propagating_cache<iterator_t<_Range>>
1196 _M_has_value() const
1197 { return this->_M_is_engaged(); }
1199 constexpr iterator_t<_Range>
1200 _M_get(const _Range&) const
1202 __glibcxx_assert(_M_has_value());
1207 _M_set(const _Range&, const iterator_t<_Range>& __it)
1209 __glibcxx_assert(!_M_has_value());
1210 std::construct_at(std::__addressof(this->_M_payload._M_payload),
1212 this->_M_payload._M_engaged = true;
1216 template<random_access_range _Range>
1217 requires (sizeof(range_difference_t<_Range>)
1218 <= sizeof(iterator_t<_Range>))
1219 struct _CachedPosition<_Range>
1222 range_difference_t<_Range> _M_offset = -1;
1225 _CachedPosition() = default;
1228 _CachedPosition(const _CachedPosition&) = default;
1231 _CachedPosition(_CachedPosition&& __other) noexcept
1232 { *this = std::move(__other); }
1234 constexpr _CachedPosition&
1235 operator=(const _CachedPosition&) = default;
1237 constexpr _CachedPosition&
1238 operator=(_CachedPosition&& __other) noexcept
1240 // Propagate the cached offset, but invalidate the source.
1241 _M_offset = __other._M_offset;
1242 __other._M_offset = -1;
1247 _M_has_value() const
1248 { return _M_offset >= 0; }
1250 constexpr iterator_t<_Range>
1251 _M_get(_Range& __r) const
1253 __glibcxx_assert(_M_has_value());
1254 return ranges::begin(__r) + _M_offset;
1258 _M_set(_Range& __r, const iterator_t<_Range>& __it)
1260 __glibcxx_assert(!_M_has_value());
1261 _M_offset = __it - ranges::begin(__r);
1264 } // namespace __detail
1268 template<typename _Base>
1269 struct __filter_view_iter_cat
1272 template<forward_range _Base>
1273 struct __filter_view_iter_cat<_Base>
1279 using _Cat = typename iterator_traits<iterator_t<_Base>>::iterator_category;
1280 if constexpr (derived_from<_Cat, bidirectional_iterator_tag>)
1281 return bidirectional_iterator_tag{};
1282 else if constexpr (derived_from<_Cat, forward_iterator_tag>)
1283 return forward_iterator_tag{};
1288 using iterator_category = decltype(_S_iter_cat());
1290 } // namespace __detail
1292 template<input_range _Vp,
1293 indirect_unary_predicate<iterator_t<_Vp>> _Pred>
1294 requires view<_Vp> && is_object_v<_Pred>
1295 class filter_view : public view_interface<filter_view<_Vp, _Pred>>
1300 struct _Iterator : __detail::__filter_view_iter_cat<_Vp>
1303 static constexpr auto
1306 if constexpr (bidirectional_range<_Vp>)
1307 return bidirectional_iterator_tag{};
1308 else if constexpr (forward_range<_Vp>)
1309 return forward_iterator_tag{};
1311 return input_iterator_tag{};
1316 using _Vp_iter = iterator_t<_Vp>;
1318 _Vp_iter _M_current = _Vp_iter();
1319 filter_view* _M_parent = nullptr;
1322 using iterator_concept = decltype(_S_iter_concept());
1323 // iterator_category defined in __filter_view_iter_cat
1324 using value_type = range_value_t<_Vp>;
1325 using difference_type = range_difference_t<_Vp>;
1327 _Iterator() requires default_initializable<_Vp_iter> = default;
1330 _Iterator(filter_view* __parent, _Vp_iter __current)
1331 : _M_current(std::move(__current)),
1335 constexpr const _Vp_iter&
1336 base() const & noexcept
1337 { return _M_current; }
1341 { return std::move(_M_current); }
1343 constexpr range_reference_t<_Vp>
1345 { return *_M_current; }
1349 requires __detail::__has_arrow<_Vp_iter>
1350 && copyable<_Vp_iter>
1351 { return _M_current; }
1353 constexpr _Iterator&
1356 _M_current = ranges::find_if(std::move(++_M_current),
1357 ranges::end(_M_parent->_M_base),
1358 std::ref(*_M_parent->_M_pred));
1367 operator++(int) requires forward_range<_Vp>
1374 constexpr _Iterator&
1375 operator--() requires bidirectional_range<_Vp>
1379 while (!std::__invoke(*_M_parent->_M_pred, *_M_current));
1384 operator--(int) requires bidirectional_range<_Vp>
1391 friend constexpr bool
1392 operator==(const _Iterator& __x, const _Iterator& __y)
1393 requires equality_comparable<_Vp_iter>
1394 { return __x._M_current == __y._M_current; }
1396 friend constexpr range_rvalue_reference_t<_Vp>
1397 iter_move(const _Iterator& __i)
1398 noexcept(noexcept(ranges::iter_move(__i._M_current)))
1399 { return ranges::iter_move(__i._M_current); }
1401 friend constexpr void
1402 iter_swap(const _Iterator& __x, const _Iterator& __y)
1403 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1404 requires indirectly_swappable<_Vp_iter>
1405 { ranges::iter_swap(__x._M_current, __y._M_current); }
1411 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
1414 __equal(const _Iterator& __i) const
1415 { return __i._M_current == _M_end; }
1418 _Sentinel() = default;
1421 _Sentinel(filter_view* __parent)
1422 : _M_end(ranges::end(__parent->_M_base))
1425 constexpr sentinel_t<_Vp>
1429 friend constexpr bool
1430 operator==(const _Iterator& __x, const _Sentinel& __y)
1431 { return __y.__equal(__x); }
1434 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
1435 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
1436 _Vp _M_base = _Vp();
1439 filter_view() requires (default_initializable<_Vp>
1440 && default_initializable<_Pred>)
1444 filter_view(_Vp __base, _Pred __pred)
1445 : _M_pred(std::move(__pred)), _M_base(std::move(__base))
1449 base() const& requires copy_constructible<_Vp>
1454 { return std::move(_M_base); }
1456 constexpr const _Pred&
1458 { return *_M_pred; }
1463 if (_M_cached_begin._M_has_value())
1464 return {this, _M_cached_begin._M_get(_M_base)};
1466 __glibcxx_assert(_M_pred.has_value());
1467 auto __it = ranges::find_if(ranges::begin(_M_base),
1468 ranges::end(_M_base),
1469 std::ref(*_M_pred));
1470 _M_cached_begin._M_set(_M_base, __it);
1471 return {this, std::move(__it)};
1477 if constexpr (common_range<_Vp>)
1478 return _Iterator{this, ranges::end(_M_base)};
1480 return _Sentinel{this};
1484 template<typename _Range, typename _Pred>
1485 filter_view(_Range&&, _Pred) -> filter_view<views::all_t<_Range>, _Pred>;
1491 template<typename _Range, typename _Pred>
1492 concept __can_filter_view
1493 = requires { filter_view(std::declval<_Range>(), std::declval<_Pred>()); };
1494 } // namespace __detail
1496 struct _Filter : __adaptor::_RangeAdaptor<_Filter>
1498 template<viewable_range _Range, typename _Pred>
1499 requires __detail::__can_filter_view<_Range, _Pred>
1501 operator()(_Range&& __r, _Pred&& __p) const
1503 return filter_view(std::forward<_Range>(__r), std::forward<_Pred>(__p));
1506 using _RangeAdaptor<_Filter>::operator();
1507 static constexpr int _S_arity = 2;
1508 static constexpr bool _S_has_simple_extra_args = true;
1511 inline constexpr _Filter filter;
1512 } // namespace views
1514 template<input_range _Vp, copy_constructible _Fp>
1515 requires view<_Vp> && is_object_v<_Fp>
1516 && regular_invocable<_Fp&, range_reference_t<_Vp>>
1517 && std::__detail::__can_reference<invoke_result_t<_Fp&,
1518 range_reference_t<_Vp>>>
1519 class transform_view : public view_interface<transform_view<_Vp, _Fp>>
1522 template<bool _Const>
1523 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
1525 template<bool _Const>
1529 template<bool _Const>
1530 requires forward_range<_Base<_Const>>
1531 struct __iter_cat<_Const>
1537 using _Base = transform_view::_Base<_Const>;
1538 using _Res = invoke_result_t<_Fp&, range_reference_t<_Base>>;
1539 if constexpr (is_lvalue_reference_v<_Res>)
1542 = typename iterator_traits<iterator_t<_Base>>::iterator_category;
1543 if constexpr (derived_from<_Cat, contiguous_iterator_tag>)
1544 return random_access_iterator_tag{};
1549 return input_iterator_tag{};
1552 using iterator_category = decltype(_S_iter_cat());
1555 template<bool _Const>
1558 template<bool _Const>
1559 struct _Iterator : __iter_cat<_Const>
1562 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
1563 using _Base = transform_view::_Base<_Const>;
1568 if constexpr (random_access_range<_Base>)
1569 return random_access_iterator_tag{};
1570 else if constexpr (bidirectional_range<_Base>)
1571 return bidirectional_iterator_tag{};
1572 else if constexpr (forward_range<_Base>)
1573 return forward_iterator_tag{};
1575 return input_iterator_tag{};
1578 using _Base_iter = iterator_t<_Base>;
1580 _Base_iter _M_current = _Base_iter();
1581 _Parent* _M_parent = nullptr;
1584 using iterator_concept = decltype(_S_iter_concept());
1585 // iterator_category defined in __transform_view_iter_cat
1587 = remove_cvref_t<invoke_result_t<_Fp&, range_reference_t<_Base>>>;
1588 using difference_type = range_difference_t<_Base>;
1590 _Iterator() requires default_initializable<_Base_iter> = default;
1593 _Iterator(_Parent* __parent, _Base_iter __current)
1594 : _M_current(std::move(__current)),
1599 _Iterator(_Iterator<!_Const> __i)
1601 && convertible_to<iterator_t<_Vp>, _Base_iter>
1602 : _M_current(std::move(__i._M_current)), _M_parent(__i._M_parent)
1605 constexpr const _Base_iter&
1606 base() const & noexcept
1607 { return _M_current; }
1609 constexpr _Base_iter
1611 { return std::move(_M_current); }
1613 constexpr decltype(auto)
1615 noexcept(noexcept(std::__invoke(*_M_parent->_M_fun, *_M_current)))
1616 { return std::__invoke(*_M_parent->_M_fun, *_M_current); }
1618 constexpr _Iterator&
1630 operator++(int) requires forward_range<_Base>
1637 constexpr _Iterator&
1638 operator--() requires bidirectional_range<_Base>
1645 operator--(int) requires bidirectional_range<_Base>
1652 constexpr _Iterator&
1653 operator+=(difference_type __n) requires random_access_range<_Base>
1659 constexpr _Iterator&
1660 operator-=(difference_type __n) requires random_access_range<_Base>
1666 constexpr decltype(auto)
1667 operator[](difference_type __n) const
1668 requires random_access_range<_Base>
1669 { return std::__invoke(*_M_parent->_M_fun, _M_current[__n]); }
1671 friend constexpr bool
1672 operator==(const _Iterator& __x, const _Iterator& __y)
1673 requires equality_comparable<_Base_iter>
1674 { return __x._M_current == __y._M_current; }
1676 friend constexpr bool
1677 operator<(const _Iterator& __x, const _Iterator& __y)
1678 requires random_access_range<_Base>
1679 { return __x._M_current < __y._M_current; }
1681 friend constexpr bool
1682 operator>(const _Iterator& __x, const _Iterator& __y)
1683 requires random_access_range<_Base>
1684 { return __y < __x; }
1686 friend constexpr bool
1687 operator<=(const _Iterator& __x, const _Iterator& __y)
1688 requires random_access_range<_Base>
1689 { return !(__y < __x); }
1691 friend constexpr bool
1692 operator>=(const _Iterator& __x, const _Iterator& __y)
1693 requires random_access_range<_Base>
1694 { return !(__x < __y); }
1696 #ifdef __cpp_lib_three_way_comparison
1697 friend constexpr auto
1698 operator<=>(const _Iterator& __x, const _Iterator& __y)
1699 requires random_access_range<_Base>
1700 && three_way_comparable<_Base_iter>
1701 { return __x._M_current <=> __y._M_current; }
1704 friend constexpr _Iterator
1705 operator+(_Iterator __i, difference_type __n)
1706 requires random_access_range<_Base>
1707 { return {__i._M_parent, __i._M_current + __n}; }
1709 friend constexpr _Iterator
1710 operator+(difference_type __n, _Iterator __i)
1711 requires random_access_range<_Base>
1712 { return {__i._M_parent, __i._M_current + __n}; }
1714 friend constexpr _Iterator
1715 operator-(_Iterator __i, difference_type __n)
1716 requires random_access_range<_Base>
1717 { return {__i._M_parent, __i._M_current - __n}; }
1719 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1720 // 3483. transform_view::iterator's difference is overconstrained
1721 friend constexpr difference_type
1722 operator-(const _Iterator& __x, const _Iterator& __y)
1723 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
1724 { return __x._M_current - __y._M_current; }
1726 friend constexpr decltype(auto)
1727 iter_move(const _Iterator& __i) noexcept(noexcept(*__i))
1729 if constexpr (is_lvalue_reference_v<decltype(*__i)>)
1730 return std::move(*__i);
1735 friend _Iterator<!_Const>;
1736 template<bool> friend struct _Sentinel;
1739 template<bool _Const>
1743 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
1744 using _Base = transform_view::_Base<_Const>;
1746 template<bool _Const2>
1748 __distance_from(const _Iterator<_Const2>& __i) const
1749 { return _M_end - __i._M_current; }
1751 template<bool _Const2>
1753 __equal(const _Iterator<_Const2>& __i) const
1754 { return __i._M_current == _M_end; }
1756 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
1759 _Sentinel() = default;
1762 _Sentinel(sentinel_t<_Base> __end)
1767 _Sentinel(_Sentinel<!_Const> __i)
1769 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
1770 : _M_end(std::move(__i._M_end))
1773 constexpr sentinel_t<_Base>
1777 template<bool _Const2>
1778 requires sentinel_for<sentinel_t<_Base>,
1779 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
1780 friend constexpr bool
1781 operator==(const _Iterator<_Const2>& __x, const _Sentinel& __y)
1782 { return __y.__equal(__x); }
1784 template<bool _Const2,
1785 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
1786 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
1787 friend constexpr range_difference_t<_Base2>
1788 operator-(const _Iterator<_Const2>& __x, const _Sentinel& __y)
1789 { return -__y.__distance_from(__x); }
1791 template<bool _Const2,
1792 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
1793 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
1794 friend constexpr range_difference_t<_Base2>
1795 operator-(const _Sentinel& __y, const _Iterator<_Const2>& __x)
1796 { return __y.__distance_from(__x); }
1798 friend _Sentinel<!_Const>;
1801 [[no_unique_address]] __detail::__box<_Fp> _M_fun;
1802 _Vp _M_base = _Vp();
1805 transform_view() requires (default_initializable<_Vp>
1806 && default_initializable<_Fp>)
1810 transform_view(_Vp __base, _Fp __fun)
1811 : _M_fun(std::move(__fun)), _M_base(std::move(__base))
1815 base() const& requires copy_constructible<_Vp>
1816 { return _M_base ; }
1820 { return std::move(_M_base); }
1822 constexpr _Iterator<false>
1824 { return _Iterator<false>{this, ranges::begin(_M_base)}; }
1826 constexpr _Iterator<true>
1828 requires range<const _Vp>
1829 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
1830 { return _Iterator<true>{this, ranges::begin(_M_base)}; }
1832 constexpr _Sentinel<false>
1834 { return _Sentinel<false>{ranges::end(_M_base)}; }
1836 constexpr _Iterator<false>
1837 end() requires common_range<_Vp>
1838 { return _Iterator<false>{this, ranges::end(_M_base)}; }
1840 constexpr _Sentinel<true>
1842 requires range<const _Vp>
1843 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
1844 { return _Sentinel<true>{ranges::end(_M_base)}; }
1846 constexpr _Iterator<true>
1848 requires common_range<const _Vp>
1849 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
1850 { return _Iterator<true>{this, ranges::end(_M_base)}; }
1853 size() requires sized_range<_Vp>
1854 { return ranges::size(_M_base); }
1857 size() const requires sized_range<const _Vp>
1858 { return ranges::size(_M_base); }
1861 template<typename _Range, typename _Fp>
1862 transform_view(_Range&&, _Fp) -> transform_view<views::all_t<_Range>, _Fp>;
1868 template<typename _Range, typename _Fp>
1869 concept __can_transform_view
1870 = requires { transform_view(std::declval<_Range>(), std::declval<_Fp>()); };
1871 } // namespace __detail
1873 struct _Transform : __adaptor::_RangeAdaptor<_Transform>
1875 template<viewable_range _Range, typename _Fp>
1876 requires __detail::__can_transform_view<_Range, _Fp>
1878 operator()(_Range&& __r, _Fp&& __f) const
1880 return transform_view(std::forward<_Range>(__r), std::forward<_Fp>(__f));
1883 using _RangeAdaptor<_Transform>::operator();
1884 static constexpr int _S_arity = 2;
1885 static constexpr bool _S_has_simple_extra_args = true;
1888 inline constexpr _Transform transform;
1889 } // namespace views
1892 class take_view : public view_interface<take_view<_Vp>>
1895 template<bool _Const>
1896 using _CI = counted_iterator<
1897 iterator_t<__detail::__maybe_const_t<_Const, _Vp>>>;
1899 template<bool _Const>
1903 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
1904 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
1907 _Sentinel() = default;
1910 _Sentinel(sentinel_t<_Base> __end)
1915 _Sentinel(_Sentinel<!_Const> __s)
1916 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
1917 : _M_end(std::move(__s._M_end))
1920 constexpr sentinel_t<_Base>
1924 friend constexpr bool
1925 operator==(const _CI<_Const>& __y, const _Sentinel& __x)
1926 { return __y.count() == 0 || __y.base() == __x._M_end; }
1928 template<bool _OtherConst = !_Const,
1929 typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
1930 requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
1931 friend constexpr bool
1932 operator==(const _CI<_OtherConst>& __y, const _Sentinel& __x)
1933 { return __y.count() == 0 || __y.base() == __x._M_end; }
1935 friend _Sentinel<!_Const>;
1938 range_difference_t<_Vp> _M_count = 0;
1939 _Vp _M_base = _Vp();
1942 take_view() requires default_initializable<_Vp> = default;
1945 take_view(_Vp base, range_difference_t<_Vp> __count)
1946 : _M_count(std::move(__count)), _M_base(std::move(base))
1950 base() const& requires copy_constructible<_Vp>
1955 { return std::move(_M_base); }
1958 begin() requires (!__detail::__simple_view<_Vp>)
1960 if constexpr (sized_range<_Vp>)
1962 if constexpr (random_access_range<_Vp>)
1963 return ranges::begin(_M_base);
1967 return counted_iterator(ranges::begin(_M_base), __sz);
1971 return counted_iterator(ranges::begin(_M_base), _M_count);
1975 begin() const requires range<const _Vp>
1977 if constexpr (sized_range<const _Vp>)
1979 if constexpr (random_access_range<const _Vp>)
1980 return ranges::begin(_M_base);
1984 return counted_iterator(ranges::begin(_M_base), __sz);
1988 return counted_iterator(ranges::begin(_M_base), _M_count);
1992 end() requires (!__detail::__simple_view<_Vp>)
1994 if constexpr (sized_range<_Vp>)
1996 if constexpr (random_access_range<_Vp>)
1997 return ranges::begin(_M_base) + size();
1999 return default_sentinel;
2002 return _Sentinel<false>{ranges::end(_M_base)};
2006 end() const requires range<const _Vp>
2008 if constexpr (sized_range<const _Vp>)
2010 if constexpr (random_access_range<const _Vp>)
2011 return ranges::begin(_M_base) + size();
2013 return default_sentinel;
2016 return _Sentinel<true>{ranges::end(_M_base)};
2020 size() requires sized_range<_Vp>
2022 auto __n = ranges::size(_M_base);
2023 return std::min(__n, static_cast<decltype(__n)>(_M_count));
2027 size() const requires sized_range<const _Vp>
2029 auto __n = ranges::size(_M_base);
2030 return std::min(__n, static_cast<decltype(__n)>(_M_count));
2034 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2035 // 3447. Deduction guides for take_view and drop_view have different
2037 template<typename _Range>
2038 take_view(_Range&&, range_difference_t<_Range>)
2039 -> take_view<views::all_t<_Range>>;
2041 template<typename _Tp>
2042 inline constexpr bool enable_borrowed_range<take_view<_Tp>>
2043 = enable_borrowed_range<_Tp>;
2049 template<typename _Range, typename _Tp>
2050 concept __can_take_view
2051 = requires { take_view(std::declval<_Range>(), std::declval<_Tp>()); };
2052 } // namespace __detail
2054 struct _Take : __adaptor::_RangeAdaptor<_Take>
2056 template<viewable_range _Range, typename _Tp>
2057 requires __detail::__can_take_view<_Range, _Tp>
2059 operator()(_Range&& __r, _Tp&& __n) const
2061 return take_view(std::forward<_Range>(__r), std::forward<_Tp>(__n));
2064 using _RangeAdaptor<_Take>::operator();
2065 static constexpr int _S_arity = 2;
2066 // The count argument of views::take is not always simple -- it can be
2067 // e.g. a move-only class that's implicitly convertible to the difference
2068 // type. But an integer-like count argument is surely simple.
2069 template<typename _Tp>
2070 static constexpr bool _S_has_simple_extra_args
2071 = ranges::__detail::__is_integer_like<_Tp>;
2074 inline constexpr _Take take;
2075 } // namespace views
2077 template<view _Vp, typename _Pred>
2078 requires input_range<_Vp> && is_object_v<_Pred>
2079 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2080 class take_while_view : public view_interface<take_while_view<_Vp, _Pred>>
2082 template<bool _Const>
2086 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2088 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2089 const _Pred* _M_pred = nullptr;
2092 _Sentinel() = default;
2095 _Sentinel(sentinel_t<_Base> __end, const _Pred* __pred)
2096 : _M_end(__end), _M_pred(__pred)
2100 _Sentinel(_Sentinel<!_Const> __s)
2101 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2102 : _M_end(__s._M_end), _M_pred(__s._M_pred)
2105 constexpr sentinel_t<_Base>
2106 base() const { return _M_end; }
2108 friend constexpr bool
2109 operator==(const iterator_t<_Base>& __x, const _Sentinel& __y)
2110 { return __y._M_end == __x || !std::__invoke(*__y._M_pred, *__x); }
2112 template<bool _OtherConst = !_Const,
2113 typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
2114 requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2115 friend constexpr bool
2116 operator==(const iterator_t<_Base2>& __x, const _Sentinel& __y)
2117 { return __y._M_end == __x || !std::__invoke(*__y._M_pred, *__x); }
2119 friend _Sentinel<!_Const>;
2122 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
2123 _Vp _M_base = _Vp();
2126 take_while_view() requires (default_initializable<_Vp>
2127 && default_initializable<_Pred>)
2131 take_while_view(_Vp base, _Pred __pred)
2132 : _M_pred(std::move(__pred)), _M_base(std::move(base))
2136 base() const& requires copy_constructible<_Vp>
2141 { return std::move(_M_base); }
2143 constexpr const _Pred&
2145 { return *_M_pred; }
2148 begin() requires (!__detail::__simple_view<_Vp>)
2149 { return ranges::begin(_M_base); }
2152 begin() const requires range<const _Vp>
2153 && indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
2154 { return ranges::begin(_M_base); }
2157 end() requires (!__detail::__simple_view<_Vp>)
2158 { return _Sentinel<false>(ranges::end(_M_base),
2159 std::__addressof(*_M_pred)); }
2162 end() const requires range<const _Vp>
2163 && indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
2164 { return _Sentinel<true>(ranges::end(_M_base),
2165 std::__addressof(*_M_pred)); }
2168 template<typename _Range, typename _Pred>
2169 take_while_view(_Range&&, _Pred)
2170 -> take_while_view<views::all_t<_Range>, _Pred>;
2176 template<typename _Range, typename _Pred>
2177 concept __can_take_while_view
2178 = requires { take_while_view(std::declval<_Range>(), std::declval<_Pred>()); };
2179 } // namespace __detail
2181 struct _TakeWhile : __adaptor::_RangeAdaptor<_TakeWhile>
2183 template<viewable_range _Range, typename _Pred>
2184 requires __detail::__can_take_while_view<_Range, _Pred>
2186 operator()(_Range&& __r, _Pred&& __p) const
2188 return take_while_view(std::forward<_Range>(__r), std::forward<_Pred>(__p));
2191 using _RangeAdaptor<_TakeWhile>::operator();
2192 static constexpr int _S_arity = 2;
2193 static constexpr bool _S_has_simple_extra_args = true;
2196 inline constexpr _TakeWhile take_while;
2197 } // namespace views
2200 class drop_view : public view_interface<drop_view<_Vp>>
2203 range_difference_t<_Vp> _M_count = 0;
2204 _Vp _M_base = _Vp();
2206 // ranges::next(begin(base), count, end(base)) is O(1) if _Vp satisfies
2207 // both random_access_range and sized_range. Otherwise, cache its result.
2208 static constexpr bool _S_needs_cached_begin
2209 = !(random_access_range<const _Vp> && sized_range<const _Vp>);
2210 [[no_unique_address]]
2211 __detail::__maybe_present_t<_S_needs_cached_begin,
2212 __detail::_CachedPosition<_Vp>>
2216 drop_view() requires default_initializable<_Vp> = default;
2219 drop_view(_Vp __base, range_difference_t<_Vp> __count)
2220 : _M_count(__count), _M_base(std::move(__base))
2221 { __glibcxx_assert(__count >= 0); }
2224 base() const& requires copy_constructible<_Vp>
2229 { return std::move(_M_base); }
2231 // This overload is disabled for simple views with constant-time begin().
2234 requires (!(__detail::__simple_view<_Vp>
2235 && random_access_range<const _Vp>
2236 && sized_range<const _Vp>))
2238 if constexpr (_S_needs_cached_begin)
2239 if (_M_cached_begin._M_has_value())
2240 return _M_cached_begin._M_get(_M_base);
2242 auto __it = ranges::next(ranges::begin(_M_base),
2243 _M_count, ranges::end(_M_base));
2244 if constexpr (_S_needs_cached_begin)
2245 _M_cached_begin._M_set(_M_base, __it);
2249 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2250 // 3482. drop_view's const begin should additionally require sized_range
2253 requires random_access_range<const _Vp> && sized_range<const _Vp>
2255 return ranges::next(ranges::begin(_M_base), _M_count,
2256 ranges::end(_M_base));
2260 end() requires (!__detail::__simple_view<_Vp>)
2261 { return ranges::end(_M_base); }
2264 end() const requires range<const _Vp>
2265 { return ranges::end(_M_base); }
2268 size() requires sized_range<_Vp>
2270 const auto __s = ranges::size(_M_base);
2271 const auto __c = static_cast<decltype(__s)>(_M_count);
2272 return __s < __c ? 0 : __s - __c;
2276 size() const requires sized_range<const _Vp>
2278 const auto __s = ranges::size(_M_base);
2279 const auto __c = static_cast<decltype(__s)>(_M_count);
2280 return __s < __c ? 0 : __s - __c;
2284 template<typename _Range>
2285 drop_view(_Range&&, range_difference_t<_Range>)
2286 -> drop_view<views::all_t<_Range>>;
2288 template<typename _Tp>
2289 inline constexpr bool enable_borrowed_range<drop_view<_Tp>>
2290 = enable_borrowed_range<_Tp>;
2296 template<typename _Range, typename _Tp>
2297 concept __can_drop_view
2298 = requires { drop_view(std::declval<_Range>(), std::declval<_Tp>()); };
2299 } // namespace __detail
2301 struct _Drop : __adaptor::_RangeAdaptor<_Drop>
2303 template<viewable_range _Range, typename _Tp>
2304 requires __detail::__can_drop_view<_Range, _Tp>
2306 operator()(_Range&& __r, _Tp&& __n) const
2308 return drop_view(std::forward<_Range>(__r), std::forward<_Tp>(__n));
2311 using _RangeAdaptor<_Drop>::operator();
2312 static constexpr int _S_arity = 2;
2313 template<typename _Tp>
2314 static constexpr bool _S_has_simple_extra_args
2315 = _Take::_S_has_simple_extra_args<_Tp>;
2318 inline constexpr _Drop drop;
2319 } // namespace views
2321 template<view _Vp, typename _Pred>
2322 requires input_range<_Vp> && is_object_v<_Pred>
2323 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2324 class drop_while_view : public view_interface<drop_while_view<_Vp, _Pred>>
2327 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
2328 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
2329 _Vp _M_base = _Vp();
2332 drop_while_view() requires (default_initializable<_Vp>
2333 && default_initializable<_Pred>)
2337 drop_while_view(_Vp __base, _Pred __pred)
2338 : _M_pred(std::move(__pred)), _M_base(std::move(__base))
2342 base() const& requires copy_constructible<_Vp>
2347 { return std::move(_M_base); }
2349 constexpr const _Pred&
2351 { return *_M_pred; }
2356 if (_M_cached_begin._M_has_value())
2357 return _M_cached_begin._M_get(_M_base);
2359 __glibcxx_assert(_M_pred.has_value());
2360 auto __it = ranges::find_if_not(ranges::begin(_M_base),
2361 ranges::end(_M_base),
2362 std::cref(*_M_pred));
2363 _M_cached_begin._M_set(_M_base, __it);
2369 { return ranges::end(_M_base); }
2372 template<typename _Range, typename _Pred>
2373 drop_while_view(_Range&&, _Pred)
2374 -> drop_while_view<views::all_t<_Range>, _Pred>;
2376 template<typename _Tp, typename _Pred>
2377 inline constexpr bool enable_borrowed_range<drop_while_view<_Tp, _Pred>>
2378 = enable_borrowed_range<_Tp>;
2384 template<typename _Range, typename _Pred>
2385 concept __can_drop_while_view
2386 = requires { drop_while_view(std::declval<_Range>(), std::declval<_Pred>()); };
2387 } // namespace __detail
2389 struct _DropWhile : __adaptor::_RangeAdaptor<_DropWhile>
2391 template<viewable_range _Range, typename _Pred>
2392 requires __detail::__can_drop_while_view<_Range, _Pred>
2394 operator()(_Range&& __r, _Pred&& __p) const
2396 return drop_while_view(std::forward<_Range>(__r),
2397 std::forward<_Pred>(__p));
2400 using _RangeAdaptor<_DropWhile>::operator();
2401 static constexpr int _S_arity = 2;
2402 static constexpr bool _S_has_simple_extra_args = true;
2405 inline constexpr _DropWhile drop_while;
2406 } // namespace views
2408 template<input_range _Vp>
2409 requires view<_Vp> && input_range<range_reference_t<_Vp>>
2410 class join_view : public view_interface<join_view<_Vp>>
2413 using _InnerRange = range_reference_t<_Vp>;
2415 template<bool _Const>
2416 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2418 template<bool _Const>
2419 using _Outer_iter = iterator_t<_Base<_Const>>;
2421 template<bool _Const>
2422 using _Inner_iter = iterator_t<range_reference_t<_Base<_Const>>>;
2424 template<bool _Const>
2425 static constexpr bool _S_ref_is_glvalue
2426 = is_reference_v<range_reference_t<_Base<_Const>>>;
2428 template<bool _Const>
2432 template<bool _Const>
2433 requires _S_ref_is_glvalue<_Const>
2434 && forward_range<_Base<_Const>>
2435 && forward_range<range_reference_t<_Base<_Const>>>
2436 struct __iter_cat<_Const>
2439 static constexpr auto
2442 using _Outer_iter = join_view::_Outer_iter<_Const>;
2443 using _Inner_iter = join_view::_Inner_iter<_Const>;
2444 using _OuterCat = typename iterator_traits<_Outer_iter>::iterator_category;
2445 using _InnerCat = typename iterator_traits<_Inner_iter>::iterator_category;
2446 if constexpr (derived_from<_OuterCat, bidirectional_iterator_tag>
2447 && derived_from<_InnerCat, bidirectional_iterator_tag>)
2448 return bidirectional_iterator_tag{};
2449 else if constexpr (derived_from<_OuterCat, forward_iterator_tag>
2450 && derived_from<_InnerCat, forward_iterator_tag>)
2451 return forward_iterator_tag{};
2453 return input_iterator_tag{};
2456 using iterator_category = decltype(_S_iter_cat());
2459 template<bool _Const>
2462 template<bool _Const>
2463 struct _Iterator : __iter_cat<_Const>
2466 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
2467 using _Base = join_view::_Base<_Const>;
2469 static constexpr bool _S_ref_is_glvalue
2470 = join_view::_S_ref_is_glvalue<_Const>;
2475 auto __update_inner = [this] (const iterator_t<_Base>& __x) -> auto&& {
2476 if constexpr (_S_ref_is_glvalue)
2479 return _M_parent->_M_inner._M_emplace_deref(__x);
2482 for (; _M_outer != ranges::end(_M_parent->_M_base); ++_M_outer)
2484 auto&& __inner = __update_inner(_M_outer);
2485 _M_inner = ranges::begin(__inner);
2486 if (_M_inner != ranges::end(__inner))
2490 if constexpr (_S_ref_is_glvalue)
2491 _M_inner = _Inner_iter();
2494 static constexpr auto
2497 if constexpr (_S_ref_is_glvalue
2498 && bidirectional_range<_Base>
2499 && bidirectional_range<range_reference_t<_Base>>)
2500 return bidirectional_iterator_tag{};
2501 else if constexpr (_S_ref_is_glvalue
2502 && forward_range<_Base>
2503 && forward_range<range_reference_t<_Base>>)
2504 return forward_iterator_tag{};
2506 return input_iterator_tag{};
2509 using _Outer_iter = join_view::_Outer_iter<_Const>;
2510 using _Inner_iter = join_view::_Inner_iter<_Const>;
2512 _Outer_iter _M_outer = _Outer_iter();
2513 _Inner_iter _M_inner = _Inner_iter();
2514 _Parent* _M_parent = nullptr;
2517 using iterator_concept = decltype(_S_iter_concept());
2518 // iterator_category defined in __join_view_iter_cat
2519 using value_type = range_value_t<range_reference_t<_Base>>;
2520 using difference_type
2521 = common_type_t<range_difference_t<_Base>,
2522 range_difference_t<range_reference_t<_Base>>>;
2524 _Iterator() requires (default_initializable<_Outer_iter>
2525 && default_initializable<_Inner_iter>)
2529 _Iterator(_Parent* __parent, _Outer_iter __outer)
2530 : _M_outer(std::move(__outer)),
2535 _Iterator(_Iterator<!_Const> __i)
2537 && convertible_to<iterator_t<_Vp>, _Outer_iter>
2538 && convertible_to<iterator_t<_InnerRange>, _Inner_iter>
2539 : _M_outer(std::move(__i._M_outer)), _M_inner(std::move(__i._M_inner)),
2540 _M_parent(__i._M_parent)
2543 constexpr decltype(auto)
2545 { return *_M_inner; }
2547 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2548 // 3500. join_view::iterator::operator->() is bogus
2549 constexpr _Inner_iter
2551 requires __detail::__has_arrow<_Inner_iter>
2552 && copyable<_Inner_iter>
2553 { return _M_inner; }
2555 constexpr _Iterator&
2558 auto&& __inner_range = [this] () -> auto&& {
2559 if constexpr (_S_ref_is_glvalue)
2562 return *_M_parent->_M_inner;
2564 if (++_M_inner == ranges::end(__inner_range))
2578 requires _S_ref_is_glvalue && forward_range<_Base>
2579 && forward_range<range_reference_t<_Base>>
2586 constexpr _Iterator&
2588 requires _S_ref_is_glvalue && bidirectional_range<_Base>
2589 && bidirectional_range<range_reference_t<_Base>>
2590 && common_range<range_reference_t<_Base>>
2592 if (_M_outer == ranges::end(_M_parent->_M_base))
2593 _M_inner = ranges::end(*--_M_outer);
2594 while (_M_inner == ranges::begin(*_M_outer))
2595 _M_inner = ranges::end(*--_M_outer);
2602 requires _S_ref_is_glvalue && bidirectional_range<_Base>
2603 && bidirectional_range<range_reference_t<_Base>>
2604 && common_range<range_reference_t<_Base>>
2611 friend constexpr bool
2612 operator==(const _Iterator& __x, const _Iterator& __y)
2613 requires _S_ref_is_glvalue
2614 && equality_comparable<_Outer_iter>
2615 && equality_comparable<_Inner_iter>
2617 return (__x._M_outer == __y._M_outer
2618 && __x._M_inner == __y._M_inner);
2621 friend constexpr decltype(auto)
2622 iter_move(const _Iterator& __i)
2623 noexcept(noexcept(ranges::iter_move(__i._M_inner)))
2624 { return ranges::iter_move(__i._M_inner); }
2626 friend constexpr void
2627 iter_swap(const _Iterator& __x, const _Iterator& __y)
2628 noexcept(noexcept(ranges::iter_swap(__x._M_inner, __y._M_inner)))
2629 requires indirectly_swappable<_Inner_iter>
2630 { return ranges::iter_swap(__x._M_inner, __y._M_inner); }
2632 friend _Iterator<!_Const>;
2633 template<bool> friend struct _Sentinel;
2636 template<bool _Const>
2640 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
2641 using _Base = join_view::_Base<_Const>;
2643 template<bool _Const2>
2645 __equal(const _Iterator<_Const2>& __i) const
2646 { return __i._M_outer == _M_end; }
2648 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2651 _Sentinel() = default;
2654 _Sentinel(_Parent* __parent)
2655 : _M_end(ranges::end(__parent->_M_base))
2659 _Sentinel(_Sentinel<!_Const> __s)
2660 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2661 : _M_end(std::move(__s._M_end))
2664 template<bool _Const2>
2665 requires sentinel_for<sentinel_t<_Base>,
2666 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
2667 friend constexpr bool
2668 operator==(const _Iterator<_Const2>& __x, const _Sentinel& __y)
2669 { return __y.__equal(__x); }
2671 friend _Sentinel<!_Const>;
2674 [[no_unique_address]]
2675 __detail::__non_propagating_cache<remove_cv_t<_InnerRange>> _M_inner;
2676 _Vp _M_base = _Vp();
2679 join_view() requires default_initializable<_Vp> = default;
2682 join_view(_Vp __base)
2683 : _M_base(std::move(__base))
2687 base() const& requires copy_constructible<_Vp>
2692 { return std::move(_M_base); }
2697 constexpr bool __use_const
2698 = (__detail::__simple_view<_Vp>
2699 && is_reference_v<range_reference_t<_Vp>>);
2700 return _Iterator<__use_const>{this, ranges::begin(_M_base)};
2705 requires input_range<const _Vp>
2706 && is_reference_v<range_reference_t<const _Vp>>
2708 return _Iterator<true>{this, ranges::begin(_M_base)};
2714 if constexpr (forward_range<_Vp> && is_reference_v<_InnerRange>
2715 && forward_range<_InnerRange>
2716 && common_range<_Vp> && common_range<_InnerRange>)
2717 return _Iterator<__detail::__simple_view<_Vp>>{this,
2718 ranges::end(_M_base)};
2720 return _Sentinel<__detail::__simple_view<_Vp>>{this};
2725 requires input_range<const _Vp>
2726 && is_reference_v<range_reference_t<const _Vp>>
2728 if constexpr (forward_range<const _Vp>
2729 && is_reference_v<range_reference_t<const _Vp>>
2730 && forward_range<range_reference_t<const _Vp>>
2731 && common_range<const _Vp>
2732 && common_range<range_reference_t<const _Vp>>)
2733 return _Iterator<true>{this, ranges::end(_M_base)};
2735 return _Sentinel<true>{this};
2739 template<typename _Range>
2740 explicit join_view(_Range&&) -> join_view<views::all_t<_Range>>;
2746 template<typename _Range>
2747 concept __can_join_view
2748 = requires { join_view<all_t<_Range>>{std::declval<_Range>()}; };
2749 } // namespace __detail
2751 struct _Join : __adaptor::_RangeAdaptorClosure
2753 template<viewable_range _Range>
2754 requires __detail::__can_join_view<_Range>
2756 operator()(_Range&& __r) const
2758 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2759 // 3474. Nesting join_views is broken because of CTAD
2760 return join_view<all_t<_Range>>{std::forward<_Range>(__r)};
2763 static constexpr bool _S_has_simple_call_op = true;
2766 inline constexpr _Join join;
2767 } // namespace views
2772 struct __require_constant;
2774 template<typename _Range>
2775 concept __tiny_range = sized_range<_Range>
2777 { typename __require_constant<remove_reference_t<_Range>::size()>; }
2778 && (remove_reference_t<_Range>::size() <= 1);
2780 template<typename _Base>
2781 struct __split_view_outer_iter_cat
2784 template<forward_range _Base>
2785 struct __split_view_outer_iter_cat<_Base>
2786 { using iterator_category = input_iterator_tag; };
2788 template<typename _Base>
2789 struct __split_view_inner_iter_cat
2792 template<forward_range _Base>
2793 struct __split_view_inner_iter_cat<_Base>
2796 static constexpr auto
2799 using _Cat = typename iterator_traits<iterator_t<_Base>>::iterator_category;
2800 if constexpr (derived_from<_Cat, forward_iterator_tag>)
2801 return forward_iterator_tag{};
2806 using iterator_category = decltype(_S_iter_cat());
2810 template<input_range _Vp, forward_range _Pattern>
2811 requires view<_Vp> && view<_Pattern>
2812 && indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
2814 && (forward_range<_Vp> || __detail::__tiny_range<_Pattern>)
2815 class split_view : public view_interface<split_view<_Vp, _Pattern>>
2818 template<bool _Const>
2819 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2821 template<bool _Const>
2824 template<bool _Const>
2826 : __detail::__split_view_outer_iter_cat<_Base<_Const>>
2829 using _Parent = __detail::__maybe_const_t<_Const, split_view>;
2830 using _Base = split_view::_Base<_Const>;
2834 { return __current() == ranges::end(_M_parent->_M_base); }
2836 // [range.split.outer] p1
2837 // Many of the following specifications refer to the notional member
2838 // current of outer-iterator. current is equivalent to current_ if
2839 // V models forward_range, and parent_->current_ otherwise.
2841 __current() noexcept
2843 if constexpr (forward_range<_Vp>)
2846 return _M_parent->_M_current;
2850 __current() const noexcept
2852 if constexpr (forward_range<_Vp>)
2855 return _M_parent->_M_current;
2858 _Parent* _M_parent = nullptr;
2860 // XXX: _M_current is present only if "V models forward_range"
2861 [[no_unique_address]]
2862 __detail::__maybe_present_t<forward_range<_Vp>,
2863 iterator_t<_Base>> _M_current;
2866 using iterator_concept = conditional_t<forward_range<_Base>,
2867 forward_iterator_tag,
2868 input_iterator_tag>;
2869 // iterator_category defined in __split_view_outer_iter_cat
2870 using difference_type = range_difference_t<_Base>;
2872 struct value_type : view_interface<value_type>
2875 _OuterIter _M_i = _OuterIter();
2878 value_type() = default;
2881 value_type(_OuterIter __i)
2882 : _M_i(std::move(__i))
2885 constexpr _InnerIter<_Const>
2887 { return _InnerIter<_Const>{_M_i}; }
2889 constexpr default_sentinel_t
2891 { return default_sentinel; }
2894 _OuterIter() = default;
2897 _OuterIter(_Parent* __parent) requires (!forward_range<_Base>)
2898 : _M_parent(__parent)
2902 _OuterIter(_Parent* __parent, iterator_t<_Base> __current)
2903 requires forward_range<_Base>
2904 : _M_parent(__parent),
2905 _M_current(std::move(__current))
2909 _OuterIter(_OuterIter<!_Const> __i)
2911 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
2912 : _M_parent(__i._M_parent), _M_current(std::move(__i._M_current))
2915 constexpr value_type
2917 { return value_type{*this}; }
2919 constexpr _OuterIter&
2922 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2923 // 3505. split_view::outer-iterator::operator++ misspecified
2924 const auto __end = ranges::end(_M_parent->_M_base);
2925 if (__current() == __end)
2927 const auto [__pbegin, __pend] = subrange{_M_parent->_M_pattern};
2928 if (__pbegin == __pend)
2930 else if constexpr (__detail::__tiny_range<_Pattern>)
2932 __current() = ranges::find(std::move(__current()), __end,
2934 if (__current() != __end)
2941 = ranges::mismatch(__current(), __end, __pbegin, __pend);
2947 } while (++__current() != __end);
2951 constexpr decltype(auto)
2954 if constexpr (forward_range<_Base>)
2964 friend constexpr bool
2965 operator==(const _OuterIter& __x, const _OuterIter& __y)
2966 requires forward_range<_Base>
2967 { return __x._M_current == __y._M_current; }
2969 friend constexpr bool
2970 operator==(const _OuterIter& __x, default_sentinel_t)
2971 { return __x.__at_end(); };
2973 friend _OuterIter<!_Const>;
2974 friend _InnerIter<_Const>;
2977 template<bool _Const>
2979 : __detail::__split_view_inner_iter_cat<_Base<_Const>>
2982 using _Base = split_view::_Base<_Const>;
2987 auto [__pcur, __pend] = subrange{_M_i._M_parent->_M_pattern};
2988 auto __end = ranges::end(_M_i._M_parent->_M_base);
2989 if constexpr (__detail::__tiny_range<_Pattern>)
2991 const auto& __cur = _M_i_current();
2994 if (__pcur == __pend)
2995 return _M_incremented;
2996 return *__cur == *__pcur;
3000 auto __cur = _M_i_current();
3003 if (__pcur == __pend)
3004 return _M_incremented;
3007 if (*__cur != *__pcur)
3009 if (++__pcur == __pend)
3011 } while (++__cur != __end);
3017 _M_i_current() noexcept
3018 { return _M_i.__current(); }
3021 _M_i_current() const noexcept
3022 { return _M_i.__current(); }
3024 _OuterIter<_Const> _M_i = _OuterIter<_Const>();
3025 bool _M_incremented = false;
3028 using iterator_concept
3029 = typename _OuterIter<_Const>::iterator_concept;
3030 // iterator_category defined in __split_view_inner_iter_cat
3031 using value_type = range_value_t<_Base>;
3032 using difference_type = range_difference_t<_Base>;
3034 _InnerIter() = default;
3037 _InnerIter(_OuterIter<_Const> __i)
3038 : _M_i(std::move(__i))
3041 constexpr const iterator_t<_Base>&
3042 base() const& noexcept
3043 { return _M_i_current(); }
3045 constexpr iterator_t<_Base>
3047 { return std::move(_M_i_current()); }
3049 constexpr decltype(auto)
3051 { return *_M_i_current(); }
3053 constexpr _InnerIter&
3056 _M_incremented = true;
3057 if constexpr (!forward_range<_Base>)
3058 if constexpr (_Pattern::size() == 0)
3064 constexpr decltype(auto)
3067 if constexpr (forward_range<_Base>)
3077 friend constexpr bool
3078 operator==(const _InnerIter& __x, const _InnerIter& __y)
3079 requires forward_range<_Base>
3080 { return __x._M_i == __y._M_i; }
3082 friend constexpr bool
3083 operator==(const _InnerIter& __x, default_sentinel_t)
3084 { return __x.__at_end(); }
3086 friend constexpr decltype(auto)
3087 iter_move(const _InnerIter& __i)
3088 noexcept(noexcept(ranges::iter_move(__i._M_i_current())))
3089 { return ranges::iter_move(__i._M_i_current()); }
3091 friend constexpr void
3092 iter_swap(const _InnerIter& __x, const _InnerIter& __y)
3093 noexcept(noexcept(ranges::iter_swap(__x._M_i_current(),
3094 __y._M_i_current())))
3095 requires indirectly_swappable<iterator_t<_Base>>
3096 { ranges::iter_swap(__x._M_i_current(), __y._M_i_current()); }
3099 _Pattern _M_pattern = _Pattern();
3100 // XXX: _M_current is "present only if !forward_range<V>"
3101 [[no_unique_address]]
3102 __detail::__maybe_present_t<!forward_range<_Vp>,
3103 iterator_t<_Vp>> _M_current;
3104 _Vp _M_base = _Vp();
3108 split_view() requires (default_initializable<_Vp>
3109 && default_initializable<_Pattern>
3110 && (forward_range<_Vp>
3111 || default_initializable<iterator_t<_Vp>>))
3115 split_view(_Vp __base, _Pattern __pattern)
3116 : _M_pattern(std::move(__pattern)), _M_base(std::move(__base))
3119 template<input_range _Range>
3120 requires constructible_from<_Vp, views::all_t<_Range>>
3121 && constructible_from<_Pattern, single_view<range_value_t<_Range>>>
3123 split_view(_Range&& __r, range_value_t<_Range> __e)
3124 : _M_pattern(views::single(std::move(__e))),
3125 _M_base(views::all(std::forward<_Range>(__r)))
3129 base() const& requires copy_constructible<_Vp>
3134 { return std::move(_M_base); }
3139 if constexpr (forward_range<_Vp>)
3140 return _OuterIter<__detail::__simple_view<_Vp>>{
3141 this, ranges::begin(_M_base)};
3144 _M_current = ranges::begin(_M_base);
3145 return _OuterIter<false>{this};
3150 begin() const requires forward_range<_Vp> && forward_range<const _Vp>
3152 return _OuterIter<true>{this, ranges::begin(_M_base)};
3156 end() requires forward_range<_Vp> && common_range<_Vp>
3158 return _OuterIter<__detail::__simple_view<_Vp>>{
3159 this, ranges::end(_M_base)};
3165 if constexpr (forward_range<_Vp>
3166 && forward_range<const _Vp>
3167 && common_range<const _Vp>)
3168 return _OuterIter<true>{this, ranges::end(_M_base)};
3170 return default_sentinel;
3174 template<typename _Range, typename _Pattern>
3175 split_view(_Range&&, _Pattern&&)
3176 -> split_view<views::all_t<_Range>, views::all_t<_Pattern>>;
3178 template<input_range _Range>
3179 split_view(_Range&&, range_value_t<_Range>)
3180 -> split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
3186 template<typename _Range, typename _Pattern>
3187 concept __can_split_view
3188 = requires { split_view(std::declval<_Range>(), std::declval<_Pattern>()); };
3189 } // namespace __detail
3191 struct _Split : __adaptor::_RangeAdaptor<_Split>
3193 template<viewable_range _Range, typename _Pattern>
3194 requires __detail::__can_split_view<_Range, _Pattern>
3196 operator()(_Range&& __r, _Pattern&& __f) const
3198 return split_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
3201 using _RangeAdaptor<_Split>::operator();
3202 static constexpr int _S_arity = 2;
3203 // The pattern argument of views::split is not always simple -- it can be
3204 // a non-view range, the value category of which affects whether the call
3205 // is well-formed. But a scalar or a view pattern argument is surely
3207 template<typename _Pattern>
3208 static constexpr bool _S_has_simple_extra_args
3209 = is_scalar_v<_Pattern> || (view<_Pattern>
3210 && copy_constructible<_Pattern>);
3213 inline constexpr _Split split;
3214 } // namespace views
3220 template<input_or_output_iterator _Iter>
3222 operator()(_Iter __i, iter_difference_t<_Iter> __n) const
3224 if constexpr (random_access_iterator<_Iter>)
3225 return subrange(__i, __i + __n);
3227 return subrange(counted_iterator(std::move(__i), __n),
3232 inline constexpr _Counted counted{};
3233 } // namespace views
3236 requires (!common_range<_Vp>) && copyable<iterator_t<_Vp>>
3237 class common_view : public view_interface<common_view<_Vp>>
3240 _Vp _M_base = _Vp();
3243 common_view() requires default_initializable<_Vp> = default;
3246 common_view(_Vp __r)
3247 : _M_base(std::move(__r))
3250 /* XXX: LWG 3280 didn't remove this constructor, but I think it should?
3251 template<viewable_range _Range>
3252 requires (!common_range<_Range>)
3253 && constructible_from<_Vp, views::all_t<_Range>>
3255 common_view(_Range&& __r)
3256 : _M_base(views::all(std::forward<_Range>(__r)))
3261 base() const& requires copy_constructible<_Vp>
3266 { return std::move(_M_base); }
3271 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3272 return ranges::begin(_M_base);
3274 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
3275 (ranges::begin(_M_base));
3279 begin() const requires range<const _Vp>
3281 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
3282 return ranges::begin(_M_base);
3284 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
3285 (ranges::begin(_M_base));
3291 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3292 return ranges::begin(_M_base) + ranges::size(_M_base);
3294 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
3295 (ranges::end(_M_base));
3299 end() const requires range<const _Vp>
3301 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
3302 return ranges::begin(_M_base) + ranges::size(_M_base);
3304 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
3305 (ranges::end(_M_base));
3309 size() requires sized_range<_Vp>
3310 { return ranges::size(_M_base); }
3313 size() const requires sized_range<const _Vp>
3314 { return ranges::size(_M_base); }
3317 template<typename _Range>
3318 common_view(_Range&&) -> common_view<views::all_t<_Range>>;
3320 template<typename _Tp>
3321 inline constexpr bool enable_borrowed_range<common_view<_Tp>>
3322 = enable_borrowed_range<_Tp>;
3328 template<typename _Range>
3329 concept __already_common = common_range<_Range>
3330 && requires { views::all(std::declval<_Range>()); };
3332 template<typename _Range>
3333 concept __can_common_view
3334 = requires { common_view{std::declval<_Range>()}; };
3335 } // namespace __detail
3337 struct _Common : __adaptor::_RangeAdaptorClosure
3339 template<viewable_range _Range>
3340 requires __detail::__already_common<_Range>
3341 || __detail::__can_common_view<_Range>
3343 operator()(_Range&& __r) const
3345 if constexpr (__detail::__already_common<_Range>)
3346 return views::all(std::forward<_Range>(__r));
3348 return common_view{std::forward<_Range>(__r)};
3351 static constexpr bool _S_has_simple_call_op = true;
3354 inline constexpr _Common common;
3355 } // namespace views
3358 requires bidirectional_range<_Vp>
3359 class reverse_view : public view_interface<reverse_view<_Vp>>
3362 static constexpr bool _S_needs_cached_begin
3363 = !common_range<_Vp> && !random_access_range<_Vp>;
3365 [[no_unique_address]]
3366 __detail::__maybe_present_t<_S_needs_cached_begin,
3367 __detail::_CachedPosition<_Vp>>
3369 _Vp _M_base = _Vp();
3372 reverse_view() requires default_initializable<_Vp> = default;
3375 reverse_view(_Vp __r)
3376 : _M_base(std::move(__r))
3380 base() const& requires copy_constructible<_Vp>
3385 { return std::move(_M_base); }
3387 constexpr reverse_iterator<iterator_t<_Vp>>
3390 if constexpr (_S_needs_cached_begin)
3391 if (_M_cached_begin._M_has_value())
3392 return std::make_reverse_iterator(_M_cached_begin._M_get(_M_base));
3394 auto __it = ranges::next(ranges::begin(_M_base), ranges::end(_M_base));
3395 if constexpr (_S_needs_cached_begin)
3396 _M_cached_begin._M_set(_M_base, __it);
3397 return std::make_reverse_iterator(std::move(__it));
3401 begin() requires common_range<_Vp>
3402 { return std::make_reverse_iterator(ranges::end(_M_base)); }
3405 begin() const requires common_range<const _Vp>
3406 { return std::make_reverse_iterator(ranges::end(_M_base)); }
3408 constexpr reverse_iterator<iterator_t<_Vp>>
3410 { return std::make_reverse_iterator(ranges::begin(_M_base)); }
3413 end() const requires common_range<const _Vp>
3414 { return std::make_reverse_iterator(ranges::begin(_M_base)); }
3417 size() requires sized_range<_Vp>
3418 { return ranges::size(_M_base); }
3421 size() const requires sized_range<const _Vp>
3422 { return ranges::size(_M_base); }
3425 template<typename _Range>
3426 reverse_view(_Range&&) -> reverse_view<views::all_t<_Range>>;
3428 template<typename _Tp>
3429 inline constexpr bool enable_borrowed_range<reverse_view<_Tp>>
3430 = enable_borrowed_range<_Tp>;
3437 inline constexpr bool __is_reversible_subrange = false;
3439 template<typename _Iter, subrange_kind _Kind>
3440 inline constexpr bool
3441 __is_reversible_subrange<subrange<reverse_iterator<_Iter>,
3442 reverse_iterator<_Iter>,
3446 inline constexpr bool __is_reverse_view = false;
3448 template<typename _Vp>
3449 inline constexpr bool __is_reverse_view<reverse_view<_Vp>> = true;
3451 template<typename _Range>
3452 concept __can_reverse_view
3453 = requires { reverse_view{std::declval<_Range>()}; };
3454 } // namespace __detail
3456 struct _Reverse : __adaptor::_RangeAdaptorClosure
3458 template<viewable_range _Range>
3459 requires __detail::__is_reverse_view<remove_cvref_t<_Range>>
3460 || __detail::__is_reversible_subrange<remove_cvref_t<_Range>>
3461 || __detail::__can_reverse_view<_Range>
3463 operator()(_Range&& __r) const
3465 using _Tp = remove_cvref_t<_Range>;
3466 if constexpr (__detail::__is_reverse_view<_Tp>)
3467 return std::forward<_Range>(__r).base();
3468 else if constexpr (__detail::__is_reversible_subrange<_Tp>)
3470 using _Iter = decltype(ranges::begin(__r).base());
3471 if constexpr (sized_range<_Tp>)
3472 return subrange<_Iter, _Iter, subrange_kind::sized>
3473 {__r.end().base(), __r.begin().base(), __r.size()};
3475 return subrange<_Iter, _Iter, subrange_kind::unsized>
3476 {__r.end().base(), __r.begin().base()};
3479 return reverse_view{std::forward<_Range>(__r)};
3482 static constexpr bool _S_has_simple_call_op = true;
3485 inline constexpr _Reverse reverse;
3486 } // namespace views
3490 template<typename _Tp, size_t _Nm>
3491 concept __has_tuple_element = requires(_Tp __t)
3493 typename tuple_size<_Tp>::type;
3494 requires _Nm < tuple_size_v<_Tp>;
3495 typename tuple_element_t<_Nm, _Tp>;
3496 { std::get<_Nm>(__t) }
3497 -> convertible_to<const tuple_element_t<_Nm, _Tp>&>;
3500 template<typename _Tp, size_t _Nm>
3501 concept __returnable_element
3502 = is_reference_v<_Tp> || move_constructible<tuple_element_t<_Nm, _Tp>>;
3505 template<input_range _Vp, size_t _Nm>
3507 && __detail::__has_tuple_element<range_value_t<_Vp>, _Nm>
3508 && __detail::__has_tuple_element<remove_reference_t<range_reference_t<_Vp>>,
3510 && __detail::__returnable_element<range_reference_t<_Vp>, _Nm>
3511 class elements_view : public view_interface<elements_view<_Vp, _Nm>>
3514 elements_view() requires default_initializable<_Vp> = default;
3517 elements_view(_Vp base)
3518 : _M_base(std::move(base))
3522 base() const& requires copy_constructible<_Vp>
3527 { return std::move(_M_base); }
3530 begin() requires (!__detail::__simple_view<_Vp>)
3531 { return _Iterator<false>(ranges::begin(_M_base)); }
3534 begin() const requires range<const _Vp>
3535 { return _Iterator<true>(ranges::begin(_M_base)); }
3538 end() requires (!__detail::__simple_view<_Vp> && !common_range<_Vp>)
3539 { return _Sentinel<false>{ranges::end(_M_base)}; }
3542 end() requires (!__detail::__simple_view<_Vp> && common_range<_Vp>)
3543 { return _Iterator<false>{ranges::end(_M_base)}; }
3546 end() const requires range<const _Vp>
3547 { return _Sentinel<true>{ranges::end(_M_base)}; }
3550 end() const requires common_range<const _Vp>
3551 { return _Iterator<true>{ranges::end(_M_base)}; }
3554 size() requires sized_range<_Vp>
3555 { return ranges::size(_M_base); }
3558 size() const requires sized_range<const _Vp>
3559 { return ranges::size(_M_base); }
3562 template<bool _Const>
3563 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
3565 template<bool _Const>
3569 template<bool _Const>
3570 requires forward_range<_Base<_Const>>
3571 struct __iter_cat<_Const>
3574 static auto _S_iter_cat()
3576 using _Base = elements_view::_Base<_Const>;
3577 using _Cat = typename iterator_traits<iterator_t<_Base>>::iterator_category;
3578 using _Res = decltype((std::get<_Nm>(*std::declval<iterator_t<_Base>>())));
3579 if constexpr (!is_lvalue_reference_v<_Res>)
3580 return input_iterator_tag{};
3581 else if constexpr (derived_from<_Cat, random_access_iterator_tag>)
3582 return random_access_iterator_tag{};
3587 using iterator_category = decltype(_S_iter_cat());
3590 template<bool _Const>
3593 template<bool _Const>
3594 struct _Iterator : __iter_cat<_Const>
3597 using _Base = elements_view::_Base<_Const>;
3599 iterator_t<_Base> _M_current = iterator_t<_Base>();
3601 static constexpr decltype(auto)
3602 _S_get_element(const iterator_t<_Base>& __i)
3604 if constexpr (is_reference_v<range_reference_t<_Base>>)
3605 return std::get<_Nm>(*__i);
3608 using _Et = remove_cv_t<tuple_element_t<_Nm, range_reference_t<_Base>>>;
3609 return static_cast<_Et>(std::get<_Nm>(*__i));
3616 if constexpr (random_access_range<_Base>)
3617 return random_access_iterator_tag{};
3618 else if constexpr (bidirectional_range<_Base>)
3619 return bidirectional_iterator_tag{};
3620 else if constexpr (forward_range<_Base>)
3621 return forward_iterator_tag{};
3623 return input_iterator_tag{};
3626 friend _Iterator<!_Const>;
3629 using iterator_concept = decltype(_S_iter_concept());
3630 // iterator_category defined in elements_view::__iter_cat
3632 = remove_cvref_t<tuple_element_t<_Nm, range_value_t<_Base>>>;
3633 using difference_type = range_difference_t<_Base>;
3635 _Iterator() requires default_initializable<iterator_t<_Base>> = default;
3638 _Iterator(iterator_t<_Base> current)
3639 : _M_current(std::move(current))
3643 _Iterator(_Iterator<!_Const> i)
3644 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
3645 : _M_current(std::move(i._M_current))
3648 constexpr const iterator_t<_Base>&
3649 base() const& noexcept
3650 { return _M_current; }
3652 constexpr iterator_t<_Base>
3654 { return std::move(_M_current); }
3656 constexpr decltype(auto)
3658 { return _S_get_element(_M_current); }
3660 constexpr _Iterator&
3672 operator++(int) requires forward_range<_Base>
3679 constexpr _Iterator&
3680 operator--() requires bidirectional_range<_Base>
3687 operator--(int) requires bidirectional_range<_Base>
3694 constexpr _Iterator&
3695 operator+=(difference_type __n)
3696 requires random_access_range<_Base>
3702 constexpr _Iterator&
3703 operator-=(difference_type __n)
3704 requires random_access_range<_Base>
3710 constexpr decltype(auto)
3711 operator[](difference_type __n) const
3712 requires random_access_range<_Base>
3713 { return _S_get_element(_M_current + __n); }
3715 friend constexpr bool
3716 operator==(const _Iterator& __x, const _Iterator& __y)
3717 requires equality_comparable<iterator_t<_Base>>
3718 { return __x._M_current == __y._M_current; }
3720 friend constexpr bool
3721 operator<(const _Iterator& __x, const _Iterator& __y)
3722 requires random_access_range<_Base>
3723 { return __x._M_current < __y._M_current; }
3725 friend constexpr bool
3726 operator>(const _Iterator& __x, const _Iterator& __y)
3727 requires random_access_range<_Base>
3728 { return __y._M_current < __x._M_current; }
3730 friend constexpr bool
3731 operator<=(const _Iterator& __x, const _Iterator& __y)
3732 requires random_access_range<_Base>
3733 { return !(__y._M_current > __x._M_current); }
3735 friend constexpr bool
3736 operator>=(const _Iterator& __x, const _Iterator& __y)
3737 requires random_access_range<_Base>
3738 { return !(__x._M_current > __y._M_current); }
3740 #ifdef __cpp_lib_three_way_comparison
3741 friend constexpr auto
3742 operator<=>(const _Iterator& __x, const _Iterator& __y)
3743 requires random_access_range<_Base>
3744 && three_way_comparable<iterator_t<_Base>>
3745 { return __x._M_current <=> __y._M_current; }
3748 friend constexpr _Iterator
3749 operator+(const _Iterator& __x, difference_type __y)
3750 requires random_access_range<_Base>
3751 { return _Iterator{__x} += __y; }
3753 friend constexpr _Iterator
3754 operator+(difference_type __x, const _Iterator& __y)
3755 requires random_access_range<_Base>
3756 { return __y + __x; }
3758 friend constexpr _Iterator
3759 operator-(const _Iterator& __x, difference_type __y)
3760 requires random_access_range<_Base>
3761 { return _Iterator{__x} -= __y; }
3763 // _GLIBCXX_RESOLVE_LIB_DEFECTS
3764 // 3483. transform_view::iterator's difference is overconstrained
3765 friend constexpr difference_type
3766 operator-(const _Iterator& __x, const _Iterator& __y)
3767 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
3768 { return __x._M_current - __y._M_current; }
3770 template <bool> friend struct _Sentinel;
3773 template<bool _Const>
3777 template<bool _Const2>
3779 _M_equal(const _Iterator<_Const2>& __x) const
3780 { return __x._M_current == _M_end; }
3782 template<bool _Const2>
3784 _M_distance_from(const _Iterator<_Const2>& __i) const
3785 { return _M_end - __i._M_current; }
3787 using _Base = elements_view::_Base<_Const>;
3788 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
3791 _Sentinel() = default;
3794 _Sentinel(sentinel_t<_Base> __end)
3795 : _M_end(std::move(__end))
3799 _Sentinel(_Sentinel<!_Const> __other)
3801 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
3802 : _M_end(std::move(__other._M_end))
3805 constexpr sentinel_t<_Base>
3809 template<bool _Const2>
3810 requires sentinel_for<sentinel_t<_Base>,
3811 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
3812 friend constexpr bool
3813 operator==(const _Iterator<_Const2>& __x, const _Sentinel& __y)
3814 { return __y._M_equal(__x); }
3816 template<bool _Const2,
3817 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
3818 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
3819 friend constexpr range_difference_t<_Base2>
3820 operator-(const _Iterator<_Const2>& __x, const _Sentinel& __y)
3821 { return -__y._M_distance_from(__x); }
3823 template<bool _Const2,
3824 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
3825 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
3826 friend constexpr range_difference_t<_Base2>
3827 operator-(const _Sentinel& __x, const _Iterator<_Const2>& __y)
3828 { return __x._M_distance_from(__y); }
3830 friend _Sentinel<!_Const>;
3833 _Vp _M_base = _Vp();
3836 template<typename _Tp, size_t _Nm>
3837 inline constexpr bool enable_borrowed_range<elements_view<_Tp, _Nm>>
3838 = enable_borrowed_range<_Tp>;
3840 template<typename _Range>
3841 using keys_view = elements_view<views::all_t<_Range>, 0>;
3843 template<typename _Range>
3844 using values_view = elements_view<views::all_t<_Range>, 1>;
3850 template<size_t _Nm, typename _Range>
3851 concept __can_elements_view
3852 = requires { elements_view<all_t<_Range>, _Nm>{std::declval<_Range>()}; };
3853 } // namespace __detail
3855 template<size_t _Nm>
3856 struct _Elements : __adaptor::_RangeAdaptorClosure
3858 template<viewable_range _Range>
3859 requires __detail::__can_elements_view<_Nm, _Range>
3861 operator()(_Range&& __r) const
3863 return elements_view<all_t<_Range>, _Nm>{std::forward<_Range>(__r)};
3866 static constexpr bool _S_has_simple_call_op = true;
3869 template<size_t _Nm>
3870 inline constexpr _Elements<_Nm> elements;
3871 inline constexpr auto keys = elements<0>;
3872 inline constexpr auto values = elements<1>;
3873 } // namespace views
3875 } // namespace ranges
3877 namespace views = ranges::views;
3879 _GLIBCXX_END_NAMESPACE_VERSION
3881 #endif // library concepts
3883 #endif /* _GLIBCXX_RANGES */