3// Copyright (C) 2019-2024 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
42#include <initializer_list>
48#if __cplusplus > 202002L
51#include <bits/ranges_util.h>
52#include <bits/refwrap.h>
54#define __glibcxx_want_ranges
55#define __glibcxx_want_ranges_as_const
56#define __glibcxx_want_ranges_as_rvalue
57#define __glibcxx_want_ranges_cartesian_product
58#define __glibcxx_want_ranges_chunk
59#define __glibcxx_want_ranges_chunk_by
60#define __glibcxx_want_ranges_enumerate
61#define __glibcxx_want_ranges_iota
62#define __glibcxx_want_ranges_join_with
63#define __glibcxx_want_ranges_repeat
64#define __glibcxx_want_ranges_slide
65#define __glibcxx_want_ranges_stride
66#define __glibcxx_want_ranges_to_container
67#define __glibcxx_want_ranges_zip
68#include <bits/version.h>
70#ifdef __glibcxx_generator // C++ >= 23 && __glibcxx_coroutine
71# include <bits/elements_of.h>
75 * @defgroup ranges Ranges
77 * Components for dealing with ranges of elements.
80namespace std _GLIBCXX_VISIBILITY(default)
82_GLIBCXX_BEGIN_NAMESPACE_VERSION
85 // [range.access] customization point objects
86 // [range.req] range and view concepts
87 // [range.dangling] dangling iterator handling
88 // Defined in <bits/ranges_base.h>
90 // [view.interface] View interface
91 // [range.subrange] Sub-ranges
92 // Defined in <bits/ranges_util.h>
94 // C++20 24.6 [range.factories] Range factories
96 /// A view that contains no elements.
97 template<typename _Tp> requires is_object_v<_Tp>
99 : public view_interface<empty_view<_Tp>>
102 static constexpr _Tp* begin() noexcept { return nullptr; }
103 static constexpr _Tp* end() noexcept { return nullptr; }
104 static constexpr _Tp* data() noexcept { return nullptr; }
105 static constexpr size_t size() noexcept { return 0; }
106 static constexpr bool empty() noexcept { return true; }
109 template<typename _Tp>
110 inline constexpr bool enable_borrowed_range<empty_view<_Tp>> = true;
114#if __cpp_lib_ranges >= 202207L // C++ >= 23
115 // P2494R2 Relaxing range adaptors to allow for move only types
116 template<typename _Tp>
117 concept __boxable = move_constructible<_Tp> && is_object_v<_Tp>;
119 template<typename _Tp>
120 concept __boxable = copy_constructible<_Tp> && is_object_v<_Tp>;
123 template<__boxable _Tp>
124 struct __box : std::optional<_Tp>
126 using std::optional<_Tp>::optional;
130 noexcept(is_nothrow_default_constructible_v<_Tp>)
131 requires default_initializable<_Tp>
132 : std::optional<_Tp>{std::in_place}
135 __box(const __box&) = default;
136 __box(__box&&) = default;
138 using std::optional<_Tp>::operator=;
140 // _GLIBCXX_RESOLVE_LIB_DEFECTS
141 // 3477. Simplify constraints for semiregular-box
142 // 3572. copyable-box should be fully constexpr
144 operator=(const __box& __that)
145 noexcept(is_nothrow_copy_constructible_v<_Tp>)
146 requires (!copyable<_Tp>) && copy_constructible<_Tp>
148 if (this != std::__addressof(__that))
151 this->emplace(*__that);
159 operator=(__box&& __that)
160 noexcept(is_nothrow_move_constructible_v<_Tp>)
161 requires (!movable<_Tp>)
163 if (this != std::__addressof(__that))
166 this->emplace(std::move(*__that));
174 template<typename _Tp>
175 concept __boxable_copyable
176 = copy_constructible<_Tp>
177 && (copyable<_Tp> || (is_nothrow_move_constructible_v<_Tp>
178 && is_nothrow_copy_constructible_v<_Tp>));
179 template<typename _Tp>
180 concept __boxable_movable
181 = (!copy_constructible<_Tp>)
182 && (movable<_Tp> || is_nothrow_move_constructible_v<_Tp>);
184 // For types which are already copyable (or since C++23, movable)
185 // this specialization of the box wrapper stores the object directly
186 // without going through std::optional. It provides just the subset of
187 // the primary template's API that we currently use.
188 template<__boxable _Tp>
189 requires __boxable_copyable<_Tp> || __boxable_movable<_Tp>
193 [[no_unique_address]] _Tp _M_value = _Tp();
196 __box() requires default_initializable<_Tp> = default;
199 __box(const _Tp& __t)
200 noexcept(is_nothrow_copy_constructible_v<_Tp>)
201 requires copy_constructible<_Tp>
207 noexcept(is_nothrow_move_constructible_v<_Tp>)
208 : _M_value(std::move(__t))
211 template<typename... _Args>
212 requires constructible_from<_Tp, _Args...>
214 __box(in_place_t, _Args&&... __args)
215 noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
216 : _M_value(std::forward<_Args>(__args)...)
219 __box(const __box&) = default;
220 __box(__box&&) = default;
221 __box& operator=(const __box&) requires copyable<_Tp> = default;
222 __box& operator=(__box&&) requires movable<_Tp> = default;
224 // When _Tp is nothrow_copy_constructible but not copy_assignable,
225 // copy assignment is implemented via destroy-then-copy-construct.
227 operator=(const __box& __that) noexcept
228 requires (!copyable<_Tp>) && copy_constructible<_Tp>
230 static_assert(is_nothrow_copy_constructible_v<_Tp>);
231 if (this != std::__addressof(__that))
234 std::construct_at(std::__addressof(_M_value), *__that);
239 // Likewise for move assignment.
241 operator=(__box&& __that) noexcept
242 requires (!movable<_Tp>)
244 static_assert(is_nothrow_move_constructible_v<_Tp>);
245 if (this != std::__addressof(__that))
248 std::construct_at(std::__addressof(_M_value), std::move(*__that));
254 has_value() const noexcept
258 operator*() & noexcept
262 operator*() const & noexcept
266 operator*() && noexcept
267 { return std::move(_M_value); }
269 constexpr const _Tp&&
270 operator*() const && noexcept
271 { return std::move(_M_value); }
274 operator->() noexcept
275 { return std::__addressof(_M_value); }
278 operator->() const noexcept
279 { return std::__addressof(_M_value); }
281 } // namespace __detail
283 /// A view that contains exactly one element.
284#if __cpp_lib_ranges >= 202207L // C++ >= 23
285 template<move_constructible _Tp>
287 template<copy_constructible _Tp>
289 requires is_object_v<_Tp>
290 class single_view : public view_interface<single_view<_Tp>>
293 single_view() requires default_initializable<_Tp> = default;
296 single_view(const _Tp& __t)
297 noexcept(is_nothrow_copy_constructible_v<_Tp>)
298 requires copy_constructible<_Tp>
303 single_view(_Tp&& __t)
304 noexcept(is_nothrow_move_constructible_v<_Tp>)
305 : _M_value(std::move(__t))
308 // _GLIBCXX_RESOLVE_LIB_DEFECTS
309 // 3428. single_view's in place constructor should be explicit
310 template<typename... _Args>
311 requires constructible_from<_Tp, _Args...>
313 single_view(in_place_t, _Args&&... __args)
314 noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
315 : _M_value{in_place, std::forward<_Args>(__args)...}
323 begin() const noexcept
328 { return data() + 1; }
332 { return data() + 1; }
334 // _GLIBCXX_RESOLVE_LIB_DEFECTS
335 // 4035. single_view should provide empty
336 static constexpr bool
340 static constexpr size_t
346 { return _M_value.operator->(); }
349 data() const noexcept
350 { return _M_value.operator->(); }
353 [[no_unique_address]] __detail::__box<_Tp> _M_value;
356 template<typename _Tp>
357 single_view(_Tp) -> single_view<_Tp>;
361 template<typename _Wp>
362 constexpr auto __to_signed_like(_Wp __w) noexcept
364 if constexpr (!integral<_Wp>)
365 return iter_difference_t<_Wp>();
366 else if constexpr (sizeof(iter_difference_t<_Wp>) > sizeof(_Wp))
367 return iter_difference_t<_Wp>(__w);
368 else if constexpr (sizeof(ptrdiff_t) > sizeof(_Wp))
369 return ptrdiff_t(__w);
370 else if constexpr (sizeof(long long) > sizeof(_Wp))
371 return (long long)(__w);
372#ifdef __SIZEOF_INT128__
373 else if constexpr (__SIZEOF_INT128__ > sizeof(_Wp))
374 return __int128(__w);
377 return __max_diff_type(__w);
380 template<typename _Wp>
381 using __iota_diff_t = decltype(__to_signed_like(std::declval<_Wp>()));
383 template<typename _It>
384 concept __decrementable = incrementable<_It>
387 { --__i } -> same_as<_It&>;
388 { __i-- } -> same_as<_It>;
391 template<typename _It>
392 concept __advanceable = __decrementable<_It> && totally_ordered<_It>
393 && requires( _It __i, const _It __j, const __iota_diff_t<_It> __n)
395 { __i += __n } -> same_as<_It&>;
396 { __i -= __n } -> same_as<_It&>;
400 { __j - __j } -> convertible_to<__iota_diff_t<_It>>;
403 template<typename _Winc>
404 struct __iota_view_iter_cat
407 template<incrementable _Winc>
408 struct __iota_view_iter_cat<_Winc>
409 { using iterator_category = input_iterator_tag; };
410 } // namespace __detail
412 template<weakly_incrementable _Winc,
413 semiregular _Bound = unreachable_sentinel_t>
414 requires std::__detail::__weakly_eq_cmp_with<_Winc, _Bound>
416 class iota_view : public view_interface<iota_view<_Winc, _Bound>>
421 struct _Iterator : __detail::__iota_view_iter_cat<_Winc>
427 using namespace __detail;
428 if constexpr (__advanceable<_Winc>)
429 return random_access_iterator_tag{};
430 else if constexpr (__decrementable<_Winc>)
431 return bidirectional_iterator_tag{};
432 else if constexpr (incrementable<_Winc>)
433 return forward_iterator_tag{};
435 return input_iterator_tag{};
439 using iterator_concept = decltype(_S_iter_concept());
440 // iterator_category defined in __iota_view_iter_cat
441 using value_type = _Winc;
442 using difference_type = __detail::__iota_diff_t<_Winc>;
444 _Iterator() requires default_initializable<_Winc> = default;
447 _Iterator(_Winc __value)
448 : _M_value(__value) { }
451 operator*() const noexcept(is_nothrow_copy_constructible_v<_Winc>)
466 operator++(int) requires incrementable<_Winc>
474 operator--() requires __detail::__decrementable<_Winc>
481 operator--(int) requires __detail::__decrementable<_Winc>
489 operator+=(difference_type __n) requires __detail::__advanceable<_Winc>
491 using __detail::__is_integer_like;
492 using __detail::__is_signed_integer_like;
493 if constexpr (__is_integer_like<_Winc>
494 && !__is_signed_integer_like<_Winc>)
496 if (__n >= difference_type(0))
497 _M_value += static_cast<_Winc>(__n);
499 _M_value -= static_cast<_Winc>(-__n);
507 operator-=(difference_type __n) requires __detail::__advanceable<_Winc>
509 using __detail::__is_integer_like;
510 using __detail::__is_signed_integer_like;
511 if constexpr (__is_integer_like<_Winc>
512 && !__is_signed_integer_like<_Winc>)
514 if (__n >= difference_type(0))
515 _M_value -= static_cast<_Winc>(__n);
517 _M_value += static_cast<_Winc>(-__n);
525 operator[](difference_type __n) const
526 requires __detail::__advanceable<_Winc>
527 { return _Winc(_M_value + __n); }
529 friend constexpr bool
530 operator==(const _Iterator& __x, const _Iterator& __y)
531 requires equality_comparable<_Winc>
532 { return __x._M_value == __y._M_value; }
534 friend constexpr bool
535 operator<(const _Iterator& __x, const _Iterator& __y)
536 requires totally_ordered<_Winc>
537 { return __x._M_value < __y._M_value; }
539 friend constexpr bool
540 operator>(const _Iterator& __x, const _Iterator& __y)
541 requires totally_ordered<_Winc>
542 { return __y < __x; }
544 friend constexpr bool
545 operator<=(const _Iterator& __x, const _Iterator& __y)
546 requires totally_ordered<_Winc>
547 { return !(__y < __x); }
549 friend constexpr bool
550 operator>=(const _Iterator& __x, const _Iterator& __y)
551 requires totally_ordered<_Winc>
552 { return !(__x < __y); }
554#ifdef __cpp_lib_three_way_comparison
555 friend constexpr auto
556 operator<=>(const _Iterator& __x, const _Iterator& __y)
557 requires totally_ordered<_Winc> && three_way_comparable<_Winc>
558 { return __x._M_value <=> __y._M_value; }
561 friend constexpr _Iterator
562 operator+(_Iterator __i, difference_type __n)
563 requires __detail::__advanceable<_Winc>
569 friend constexpr _Iterator
570 operator+(difference_type __n, _Iterator __i)
571 requires __detail::__advanceable<_Winc>
572 { return __i += __n; }
574 friend constexpr _Iterator
575 operator-(_Iterator __i, difference_type __n)
576 requires __detail::__advanceable<_Winc>
582 friend constexpr difference_type
583 operator-(const _Iterator& __x, const _Iterator& __y)
584 requires __detail::__advanceable<_Winc>
586 using __detail::__is_integer_like;
587 using __detail::__is_signed_integer_like;
588 using _Dt = difference_type;
589 if constexpr (__is_integer_like<_Winc>)
591 if constexpr (__is_signed_integer_like<_Winc>)
592 return _Dt(_Dt(__x._M_value) - _Dt(__y._M_value));
594 return (__y._M_value > __x._M_value)
595 ? _Dt(-_Dt(__y._M_value - __x._M_value))
596 : _Dt(__x._M_value - __y._M_value);
599 return __x._M_value - __y._M_value;
603 _Winc _M_value = _Winc();
613 _M_equal(const _Iterator& __x) const
614 { return __x._M_value == _M_bound; }
617 _M_distance_from(const _Iterator& __x) const
618 { return _M_bound - __x._M_value; }
620 _Bound _M_bound = _Bound();
623 _Sentinel() = default;
626 _Sentinel(_Bound __bound)
627 : _M_bound(__bound) { }
629 friend constexpr bool
630 operator==(const _Iterator& __x, const _Sentinel& __y)
631 { return __y._M_equal(__x); }
633 friend constexpr iter_difference_t<_Winc>
634 operator-(const _Iterator& __x, const _Sentinel& __y)
635 requires sized_sentinel_for<_Bound, _Winc>
636 { return -__y._M_distance_from(__x); }
638 friend constexpr iter_difference_t<_Winc>
639 operator-(const _Sentinel& __x, const _Iterator& __y)
640 requires sized_sentinel_for<_Bound, _Winc>
641 { return __x._M_distance_from(__y); }
646 _Winc _M_value = _Winc();
647 [[no_unique_address]] _Bound _M_bound = _Bound();
650 iota_view() requires default_initializable<_Winc> = default;
653 iota_view(_Winc __value)
658 iota_view(type_identity_t<_Winc> __value,
659 type_identity_t<_Bound> __bound)
660 : _M_value(__value), _M_bound(__bound)
662 if constexpr (totally_ordered_with<_Winc, _Bound>)
663 __glibcxx_assert( bool(__value <= __bound) );
667 iota_view(_Iterator __first, _Iterator __last)
668 requires same_as<_Winc, _Bound>
669 : iota_view(__first._M_value, __last._M_value)
673 iota_view(_Iterator __first, unreachable_sentinel_t __last)
674 requires same_as<_Bound, unreachable_sentinel_t>
675 : iota_view(__first._M_value, __last)
679 iota_view(_Iterator __first, _Sentinel __last)
680 requires (!same_as<_Winc, _Bound>) && (!same_as<_Bound, unreachable_sentinel_t>)
681 : iota_view(__first._M_value, __last._M_bound)
685 begin() const { return _Iterator{_M_value}; }
690 if constexpr (same_as<_Bound, unreachable_sentinel_t>)
691 return unreachable_sentinel;
693 return _Sentinel{_M_bound};
697 end() const requires same_as<_Winc, _Bound>
698 { return _Iterator{_M_bound}; }
700 // _GLIBCXX_RESOLVE_LIB_DEFECTS
701 // 4001. iota_view should provide empty
704 { return _M_value == _M_bound; }
708 requires (same_as<_Winc, _Bound> && __detail::__advanceable<_Winc>)
709 || (integral<_Winc> && integral<_Bound>)
710 || sized_sentinel_for<_Bound, _Winc>
712 using __detail::__is_integer_like;
713 using __detail::__to_unsigned_like;
714 if constexpr (integral<_Winc> && integral<_Bound>)
716 using _Up = make_unsigned_t<decltype(_M_bound - _M_value)>;
717 return _Up(_M_bound) - _Up(_M_value);
719 else if constexpr (__is_integer_like<_Winc>)
720 return __to_unsigned_like(_M_bound) - __to_unsigned_like(_M_value);
722 return __to_unsigned_like(_M_bound - _M_value);
726 template<typename _Winc, typename _Bound>
727 requires (!__detail::__is_integer_like<_Winc>
728 || !__detail::__is_integer_like<_Bound>
729 || (__detail::__is_signed_integer_like<_Winc>
730 == __detail::__is_signed_integer_like<_Bound>))
731 iota_view(_Winc, _Bound) -> iota_view<_Winc, _Bound>;
733 template<typename _Winc, typename _Bound>
734 inline constexpr bool
735 enable_borrowed_range<iota_view<_Winc, _Bound>> = true;
739 template<typename _Tp>
740 inline constexpr empty_view<_Tp> empty{};
744 template<typename _Tp>
745 concept __can_single_view
746 = requires { single_view<decay_t<_Tp>>(std::declval<_Tp>()); };
747 } // namespace __detail
751 template<__detail::__can_single_view _Tp>
753 operator() [[nodiscard]] (_Tp&& __e) const
754 noexcept(noexcept(single_view<decay_t<_Tp>>(std::forward<_Tp>(__e))))
755 { return single_view<decay_t<_Tp>>(std::forward<_Tp>(__e)); }
758 inline constexpr _Single single{};
762 template<typename... _Args>
763 concept __can_iota_view = requires { iota_view(std::declval<_Args>()...); };
764 } // namespace __detail
768 template<__detail::__can_iota_view _Tp>
770 operator() [[nodiscard]] (_Tp&& __e) const
771 { return iota_view(std::forward<_Tp>(__e)); }
773 template<typename _Tp, typename _Up>
774 requires __detail::__can_iota_view<_Tp, _Up>
776 operator() [[nodiscard]] (_Tp&& __e, _Up&& __f) const
777 { return iota_view(std::forward<_Tp>(__e), std::forward<_Up>(__f)); }
780 inline constexpr _Iota iota{};
786 template<typename _Val, typename _CharT, typename _Traits>
787 concept __stream_extractable
788 = requires(basic_istream<_CharT, _Traits>& is, _Val& t) { is >> t; };
789 } // namespace __detail
791 template<movable _Val, typename _CharT,
792 typename _Traits = char_traits<_CharT>>
793 requires default_initializable<_Val>
794 && __detail::__stream_extractable<_Val, _CharT, _Traits>
795 class basic_istream_view
796 : public view_interface<basic_istream_view<_Val, _CharT, _Traits>>
800 basic_istream_view(basic_istream<_CharT, _Traits>& __stream)
801 : _M_stream(std::__addressof(__stream))
807 *_M_stream >> _M_object;
808 return _Iterator{this};
811 constexpr default_sentinel_t
813 { return default_sentinel; }
816 basic_istream<_CharT, _Traits>* _M_stream;
817 _Val _M_object = _Val();
822 using iterator_concept = input_iterator_tag;
823 using difference_type = ptrdiff_t;
824 using value_type = _Val;
827 _Iterator(basic_istream_view* __parent) noexcept
828 : _M_parent(__parent)
831 _Iterator(const _Iterator&) = delete;
832 _Iterator(_Iterator&&) = default;
833 _Iterator& operator=(const _Iterator&) = delete;
834 _Iterator& operator=(_Iterator&&) = default;
839 *_M_parent->_M_stream >> _M_parent->_M_object;
849 { return _M_parent->_M_object; }
852 operator==(const _Iterator& __x, default_sentinel_t)
853 { return __x._M_at_end(); }
856 basic_istream_view* _M_parent;
860 { return !*_M_parent->_M_stream; }
866 template<typename _Val>
867 using istream_view = basic_istream_view<_Val, char>;
869 template<typename _Val>
870 using wistream_view = basic_istream_view<_Val, wchar_t>;
876 template<typename _Tp, typename _Up>
877 concept __can_istream_view = requires (_Up __e) {
878 basic_istream_view<_Tp, typename _Up::char_type, typename _Up::traits_type>(__e);
880 } // namespace __detail
882 template<typename _Tp>
885 template<typename _CharT, typename _Traits>
887 operator() [[nodiscard]] (basic_istream<_CharT, _Traits>& __e) const
888 requires __detail::__can_istream_view<_Tp, remove_reference_t<decltype(__e)>>
889 { return basic_istream_view<_Tp, _CharT, _Traits>(__e); }
892 template<typename _Tp>
893 inline constexpr _Istream<_Tp> istream;
897 // C++20 24.7 [range.adaptors] Range adaptors
901 template<typename _Tp, int _Disc>
904 // Alias for a type that is conditionally present
905 // (and is an empty type otherwise).
906 // Data members using this alias should use [[no_unique_address]] so that
907 // they take no space when not needed.
908 // The optional template parameter _Disc is for discriminating two otherwise
909 // equivalent absent types so that even they can overlap.
910 template<bool _Present, typename _Tp, int _Disc = 0>
911 using __maybe_present_t = __conditional_t<_Present, _Tp, _Absent<_Tp, _Disc>>;
913 // Alias for a type that is conditionally const.
914 template<bool _Const, typename _Tp>
915 using __maybe_const_t = __conditional_t<_Const, const _Tp, _Tp>;
917} // namespace __detail
919// Shorthand for __detail::__maybe_const_t.
920using __detail::__maybe_const_t;
922namespace views::__adaptor
924 // True if the range adaptor _Adaptor can be applied with _Args.
925 template<typename _Adaptor, typename... _Args>
926 concept __adaptor_invocable
927 = requires { std::declval<_Adaptor>()(declval<_Args>()...); };
929 // True if the range adaptor non-closure _Adaptor can be partially applied
931 template<typename _Adaptor, typename... _Args>
932 concept __adaptor_partial_app_viable = (_Adaptor::_S_arity > 1)
933 && (sizeof...(_Args) == _Adaptor::_S_arity - 1)
934 && (constructible_from<decay_t<_Args>, _Args> && ...);
936 template<typename _Adaptor, typename... _Args>
939 template<typename _Lhs, typename _Rhs>
942 // The base class of every range adaptor closure.
944 // The derived class should define the optional static data member
945 // _S_has_simple_call_op to true if the behavior of this adaptor is
946 // independent of the constness/value category of the adaptor object.
947 template<typename _Derived>
948 struct _RangeAdaptorClosure
951 template<typename _Tp, typename _Up>
952 requires (!same_as<_Tp, _RangeAdaptorClosure<_Up>>)
953 void __is_range_adaptor_closure_fn
954 (const _Tp&, const _RangeAdaptorClosure<_Up>&); // not defined
956 template<typename _Tp>
957 concept __is_range_adaptor_closure
958 = requires (_Tp __t) { __adaptor::__is_range_adaptor_closure_fn(__t, __t); };
960#pragma GCC diagnostic push
961#pragma GCC diagnostic ignored "-Wdangling-reference"
962 // range | adaptor is equivalent to adaptor(range).
963 template<typename _Self, typename _Range>
964 requires __is_range_adaptor_closure<_Self>
965 && __adaptor_invocable<_Self, _Range>
967 operator|(_Range&& __r, _Self&& __self)
968 { return std::forward<_Self>(__self)(std::forward<_Range>(__r)); }
970 // Compose the adaptors __lhs and __rhs into a pipeline, returning
971 // another range adaptor closure object.
972 template<typename _Lhs, typename _Rhs>
973 requires __is_range_adaptor_closure<_Lhs>
974 && __is_range_adaptor_closure<_Rhs>
976 operator|(_Lhs&& __lhs, _Rhs&& __rhs)
978 return _Pipe<decay_t<_Lhs>, decay_t<_Rhs>>{std::forward<_Lhs>(__lhs),
979 std::forward<_Rhs>(__rhs)};
981#pragma GCC diagnostic pop
983 // The base class of every range adaptor non-closure.
985 // The static data member _Derived::_S_arity must contain the total number of
986 // arguments that the adaptor takes, and the class _Derived must introduce
987 // _RangeAdaptor::operator() into the class scope via a using-declaration.
989 // The optional static data member _Derived::_S_has_simple_extra_args should
990 // be defined to true if the behavior of this adaptor is independent of the
991 // constness/value category of the extra arguments. This data member could
992 // also be defined as a variable template parameterized by the types of the
994 template<typename _Derived>
997 // Partially apply the arguments __args to the range adaptor _Derived,
998 // returning a range adaptor closure object.
999 template<typename... _Args>
1000 requires __adaptor_partial_app_viable<_Derived, _Args...>
1002 operator()(_Args&&... __args) const
1004 return _Partial<_Derived, decay_t<_Args>...>{0, std::forward<_Args>(__args)...};
1008 // True if the range adaptor closure _Adaptor has a simple operator(), i.e.
1009 // one that's not overloaded according to constness or value category of the
1011 template<typename _Adaptor>
1012 concept __closure_has_simple_call_op = _Adaptor::_S_has_simple_call_op;
1014 // True if the behavior of the range adaptor non-closure _Adaptor is
1015 // independent of the value category of its extra arguments _Args.
1016 template<typename _Adaptor, typename... _Args>
1017 concept __adaptor_has_simple_extra_args = _Adaptor::_S_has_simple_extra_args
1018 || _Adaptor::template _S_has_simple_extra_args<_Args...>;
1020 // A range adaptor closure that represents partial application of
1021 // the range adaptor _Adaptor with arguments _Args.
1022 template<typename _Adaptor, typename... _Args>
1023 struct _Partial : _RangeAdaptorClosure<_Partial<_Adaptor, _Args...>>
1025 tuple<_Args...> _M_args;
1027 // First parameter is to ensure this constructor is never used
1028 // instead of the copy/move constructor.
1029 template<typename... _Ts>
1031 _Partial(int, _Ts&&... __args)
1032 : _M_args(std::forward<_Ts>(__args)...)
1035 // Invoke _Adaptor with arguments __r, _M_args... according to the
1036 // value category of this _Partial object.
1037#if __cpp_explicit_this_parameter
1038 template<typename _Self, typename _Range>
1039 requires __adaptor_invocable<_Adaptor, _Range, __like_t<_Self, _Args>...>
1041 operator()(this _Self&& __self, _Range&& __r)
1043 auto __forwarder = [&__r] (auto&&... __args) {
1044 return _Adaptor{}(std::forward<_Range>(__r),
1045 std::forward<decltype(__args)>(__args)...);
1047 return std::apply(__forwarder, __like_t<_Self, _Partial>(__self)._M_args);
1050 template<typename _Range>
1051 requires __adaptor_invocable<_Adaptor, _Range, const _Args&...>
1053 operator()(_Range&& __r) const &
1055 auto __forwarder = [&__r] (const auto&... __args) {
1056 return _Adaptor{}(std::forward<_Range>(__r), __args...);
1058 return std::apply(__forwarder, _M_args);
1061 template<typename _Range>
1062 requires __adaptor_invocable<_Adaptor, _Range, _Args...>
1064 operator()(_Range&& __r) &&
1066 auto __forwarder = [&__r] (auto&... __args) {
1067 return _Adaptor{}(std::forward<_Range>(__r), std::move(__args)...);
1069 return std::apply(__forwarder, _M_args);
1072 template<typename _Range>
1074 operator()(_Range&& __r) const && = delete;
1078 // A lightweight specialization of the above primary template for
1079 // the common case where _Adaptor accepts a single extra argument.
1080 template<typename _Adaptor, typename _Arg>
1081 struct _Partial<_Adaptor, _Arg> : _RangeAdaptorClosure<_Partial<_Adaptor, _Arg>>
1085 template<typename _Tp>
1087 _Partial(int, _Tp&& __arg)
1088 : _M_arg(std::forward<_Tp>(__arg))
1091#if __cpp_explicit_this_parameter
1092 template<typename _Self, typename _Range>
1093 requires __adaptor_invocable<_Adaptor, _Range, __like_t<_Self, _Arg>>
1095 operator()(this _Self&& __self, _Range&& __r)
1097 return _Adaptor{}(std::forward<_Range>(__r),
1098 __like_t<_Self, _Partial>(__self)._M_arg);
1101 template<typename _Range>
1102 requires __adaptor_invocable<_Adaptor, _Range, const _Arg&>
1104 operator()(_Range&& __r) const &
1105 { return _Adaptor{}(std::forward<_Range>(__r), _M_arg); }
1107 template<typename _Range>
1108 requires __adaptor_invocable<_Adaptor, _Range, _Arg>
1110 operator()(_Range&& __r) &&
1111 { return _Adaptor{}(std::forward<_Range>(__r), std::move(_M_arg)); }
1113 template<typename _Range>
1115 operator()(_Range&& __r) const && = delete;
1119 // Partial specialization of the primary template for the case where the extra
1120 // arguments of the adaptor can always be safely and efficiently forwarded by
1121 // const reference. This lets us get away with a single operator() overload,
1122 // which makes overload resolution failure diagnostics more concise.
1123 template<typename _Adaptor, typename... _Args>
1124 requires __adaptor_has_simple_extra_args<_Adaptor, _Args...>
1125 && (is_trivially_copyable_v<_Args> && ...)
1126 struct _Partial<_Adaptor, _Args...> : _RangeAdaptorClosure<_Partial<_Adaptor, _Args...>>
1128 tuple<_Args...> _M_args;
1130 template<typename... _Ts>
1132 _Partial(int, _Ts&&... __args)
1133 : _M_args(std::forward<_Ts>(__args)...)
1136 // Invoke _Adaptor with arguments __r, const _M_args&... regardless
1137 // of the value category of this _Partial object.
1138 template<typename _Range>
1139 requires __adaptor_invocable<_Adaptor, _Range, const _Args&...>
1141 operator()(_Range&& __r) const
1143 auto __forwarder = [&__r] (const auto&... __args) {
1144 return _Adaptor{}(std::forward<_Range>(__r), __args...);
1146 return std::apply(__forwarder, _M_args);
1149 static constexpr bool _S_has_simple_call_op = true;
1152 // A lightweight specialization of the above template for the common case
1153 // where _Adaptor accepts a single extra argument.
1154 template<typename _Adaptor, typename _Arg>
1155 requires __adaptor_has_simple_extra_args<_Adaptor, _Arg>
1156 && is_trivially_copyable_v<_Arg>
1157 struct _Partial<_Adaptor, _Arg> : _RangeAdaptorClosure<_Partial<_Adaptor, _Arg>>
1161 template<typename _Tp>
1163 _Partial(int, _Tp&& __arg)
1164 : _M_arg(std::forward<_Tp>(__arg))
1167 template<typename _Range>
1168 requires __adaptor_invocable<_Adaptor, _Range, const _Arg&>
1170 operator()(_Range&& __r) const
1171 { return _Adaptor{}(std::forward<_Range>(__r), _M_arg); }
1173 static constexpr bool _S_has_simple_call_op = true;
1176 template<typename _Lhs, typename _Rhs, typename _Range>
1177 concept __pipe_invocable
1178 = requires { std::declval<_Rhs>()(std::declval<_Lhs>()(std::declval<_Range>())); };
1180 // A range adaptor closure that represents composition of the range
1181 // adaptor closures _Lhs and _Rhs.
1182 template<typename _Lhs, typename _Rhs>
1183 struct _Pipe : _RangeAdaptorClosure<_Pipe<_Lhs, _Rhs>>
1185 [[no_unique_address]] _Lhs _M_lhs;
1186 [[no_unique_address]] _Rhs _M_rhs;
1188 template<typename _Tp, typename _Up>
1190 _Pipe(_Tp&& __lhs, _Up&& __rhs)
1191 : _M_lhs(std::forward<_Tp>(__lhs)), _M_rhs(std::forward<_Up>(__rhs))
1194 // Invoke _M_rhs(_M_lhs(__r)) according to the value category of this
1195 // range adaptor closure object.
1196#if __cpp_explicit_this_parameter
1197 template<typename _Self, typename _Range>
1198 requires __pipe_invocable<__like_t<_Self, _Lhs>, __like_t<_Self, _Rhs>, _Range>
1200 operator()(this _Self&& __self, _Range&& __r)
1202 return (__like_t<_Self, _Pipe>(__self)._M_rhs
1203 (__like_t<_Self, _Pipe>(__self)._M_lhs
1204 (std::forward<_Range>(__r))));
1207 template<typename _Range>
1208 requires __pipe_invocable<const _Lhs&, const _Rhs&, _Range>
1210 operator()(_Range&& __r) const &
1211 { return _M_rhs(_M_lhs(std::forward<_Range>(__r))); }
1213 template<typename _Range>
1214 requires __pipe_invocable<_Lhs, _Rhs, _Range>
1216 operator()(_Range&& __r) &&
1217 { return std::move(_M_rhs)(std::move(_M_lhs)(std::forward<_Range>(__r))); }
1219 template<typename _Range>
1221 operator()(_Range&& __r) const && = delete;
1225 // A partial specialization of the above primary template for the case where
1226 // both adaptor operands have a simple operator(). This in turn lets us
1227 // implement composition using a single simple operator(), which makes
1228 // overload resolution failure diagnostics more concise.
1229 template<typename _Lhs, typename _Rhs>
1230 requires __closure_has_simple_call_op<_Lhs>
1231 && __closure_has_simple_call_op<_Rhs>
1232 struct _Pipe<_Lhs, _Rhs> : _RangeAdaptorClosure<_Pipe<_Lhs, _Rhs>>
1234 [[no_unique_address]] _Lhs _M_lhs;
1235 [[no_unique_address]] _Rhs _M_rhs;
1237 template<typename _Tp, typename _Up>
1239 _Pipe(_Tp&& __lhs, _Up&& __rhs)
1240 : _M_lhs(std::forward<_Tp>(__lhs)), _M_rhs(std::forward<_Up>(__rhs))
1243 template<typename _Range>
1244 requires __pipe_invocable<const _Lhs&, const _Rhs&, _Range>
1246 operator()(_Range&& __r) const
1247 { return _M_rhs(_M_lhs(std::forward<_Range>(__r))); }
1249 static constexpr bool _S_has_simple_call_op = true;
1251} // namespace views::__adaptor
1253#if __cpp_lib_ranges >= 202202L
1254 // P2387R3 Pipe support for user-defined range adaptors
1255 template<typename _Derived>
1256 requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
1257 class range_adaptor_closure
1258 : public views::__adaptor::_RangeAdaptorClosure<_Derived>
1262 template<range _Range> requires is_object_v<_Range>
1263 class ref_view : public view_interface<ref_view<_Range>>
1268 static void _S_fun(_Range&); // not defined
1269 static void _S_fun(_Range&&) = delete;
1272 template<__detail::__different_from<ref_view> _Tp>
1273 requires convertible_to<_Tp, _Range&>
1274 && requires { _S_fun(declval<_Tp>()); }
1277 noexcept(noexcept(static_cast<_Range&>(std::declval<_Tp>())))
1278 : _M_r(std::__addressof(static_cast<_Range&>(std::forward<_Tp>(__t))))
1285 constexpr iterator_t<_Range>
1287 { return ranges::begin(*_M_r); }
1289 constexpr sentinel_t<_Range>
1291 { return ranges::end(*_M_r); }
1294 empty() const requires requires { ranges::empty(*_M_r); }
1295 { return ranges::empty(*_M_r); }
1298 size() const requires sized_range<_Range>
1299 { return ranges::size(*_M_r); }
1302 data() const requires contiguous_range<_Range>
1303 { return ranges::data(*_M_r); }
1306 template<typename _Range>
1307 ref_view(_Range&) -> ref_view<_Range>;
1309 template<typename _Tp>
1310 inline constexpr bool enable_borrowed_range<ref_view<_Tp>> = true;
1312 template<range _Range>
1313 requires movable<_Range>
1314 && (!__detail::__is_initializer_list<remove_cv_t<_Range>>)
1315 class owning_view : public view_interface<owning_view<_Range>>
1318 _Range _M_r = _Range();
1321 owning_view() requires default_initializable<_Range> = default;
1324 owning_view(_Range&& __t)
1325 noexcept(is_nothrow_move_constructible_v<_Range>)
1326 : _M_r(std::move(__t))
1329 owning_view(owning_view&&) = default;
1330 owning_view& operator=(owning_view&&) = default;
1336 constexpr const _Range&
1337 base() const& noexcept
1342 { return std::move(_M_r); }
1344 constexpr const _Range&&
1345 base() const&& noexcept
1346 { return std::move(_M_r); }
1348 constexpr iterator_t<_Range>
1350 { return ranges::begin(_M_r); }
1352 constexpr sentinel_t<_Range>
1354 { return ranges::end(_M_r); }
1357 begin() const requires range<const _Range>
1358 { return ranges::begin(_M_r); }
1361 end() const requires range<const _Range>
1362 { return ranges::end(_M_r); }
1365 empty() requires requires { ranges::empty(_M_r); }
1366 { return ranges::empty(_M_r); }
1369 empty() const requires requires { ranges::empty(_M_r); }
1370 { return ranges::empty(_M_r); }
1373 size() requires sized_range<_Range>
1374 { return ranges::size(_M_r); }
1377 size() const requires sized_range<const _Range>
1378 { return ranges::size(_M_r); }
1381 data() requires contiguous_range<_Range>
1382 { return ranges::data(_M_r); }
1385 data() const requires contiguous_range<const _Range>
1386 { return ranges::data(_M_r); }
1389 template<typename _Tp>
1390 inline constexpr bool enable_borrowed_range<owning_view<_Tp>>
1391 = enable_borrowed_range<_Tp>;
1397 template<typename _Range>
1398 concept __can_ref_view = requires { ref_view{std::declval<_Range>()}; };
1400 template<typename _Range>
1401 concept __can_owning_view = requires { owning_view{std::declval<_Range>()}; };
1402 } // namespace __detail
1404 struct _All : __adaptor::_RangeAdaptorClosure<_All>
1406 template<typename _Range>
1407 static constexpr bool
1410 if constexpr (view<decay_t<_Range>>)
1411 return is_nothrow_constructible_v<decay_t<_Range>, _Range>;
1412 else if constexpr (__detail::__can_ref_view<_Range>)
1415 return noexcept(owning_view{std::declval<_Range>()});
1418 template<viewable_range _Range>
1419 requires view<decay_t<_Range>>
1420 || __detail::__can_ref_view<_Range>
1421 || __detail::__can_owning_view<_Range>
1423 operator() [[nodiscard]] (_Range&& __r) const
1424 noexcept(_S_noexcept<_Range>())
1426 if constexpr (view<decay_t<_Range>>)
1427 return std::forward<_Range>(__r);
1428 else if constexpr (__detail::__can_ref_view<_Range>)
1429 return ref_view{std::forward<_Range>(__r)};
1431 return owning_view{std::forward<_Range>(__r)};
1434 static constexpr bool _S_has_simple_call_op = true;
1437 inline constexpr _All all;
1439 template<viewable_range _Range>
1440 using all_t = decltype(all(std::declval<_Range>()));
1441 } // namespace views
1445 template<typename _Tp>
1446 struct __non_propagating_cache
1448 // When _Tp is not an object type (e.g. is a reference type), we make
1449 // __non_propagating_cache<_Tp> empty rather than ill-formed so that
1450 // users can easily conditionally declare data members with this type
1451 // (such as join_view::_M_inner).
1454 template<typename _Tp>
1455 requires is_object_v<_Tp>
1456 struct __non_propagating_cache<_Tp>
1457 : protected _Optional_base<_Tp>
1459 __non_propagating_cache() = default;
1462 __non_propagating_cache(const __non_propagating_cache&) noexcept
1466 __non_propagating_cache(__non_propagating_cache&& __other) noexcept
1467 { __other._M_reset(); }
1469 constexpr __non_propagating_cache&
1470 operator=(const __non_propagating_cache& __other) noexcept
1472 if (std::__addressof(__other) != this)
1477 constexpr __non_propagating_cache&
1478 operator=(__non_propagating_cache&& __other) noexcept
1485 constexpr __non_propagating_cache&
1486 operator=(_Tp __val)
1489 this->_M_payload._M_construct(std::move(__val));
1494 operator bool() const noexcept
1495 { return this->_M_is_engaged(); }
1498 operator*() noexcept
1499 { return this->_M_get(); }
1501 constexpr const _Tp&
1502 operator*() const noexcept
1503 { return this->_M_get(); }
1505 template<typename _Iter>
1507 _M_emplace_deref(const _Iter& __i)
1510 auto __f = [] (auto& __x) { return *__x; };
1511 this->_M_payload._M_apply(_Optional_func{__f}, __i);
1512 return this->_M_get();
1516 template<range _Range>
1517 struct _CachedPosition
1520 _M_has_value() const
1523 constexpr iterator_t<_Range>
1524 _M_get(const _Range&) const
1526 __glibcxx_assert(false);
1527 __builtin_unreachable();
1531 _M_set(const _Range&, const iterator_t<_Range>&) const
1535 template<forward_range _Range>
1536 struct _CachedPosition<_Range>
1537 : protected __non_propagating_cache<iterator_t<_Range>>
1540 _M_has_value() const
1541 { return this->_M_is_engaged(); }
1543 constexpr iterator_t<_Range>
1544 _M_get(const _Range&) const
1546 __glibcxx_assert(_M_has_value());
1551 _M_set(const _Range&, const iterator_t<_Range>& __it)
1553 __glibcxx_assert(!_M_has_value());
1554 std::construct_at(std::__addressof(this->_M_payload._M_payload),
1556 this->_M_payload._M_engaged = true;
1560 template<random_access_range _Range>
1561 requires (sizeof(range_difference_t<_Range>)
1562 <= sizeof(iterator_t<_Range>))
1563 struct _CachedPosition<_Range>
1566 range_difference_t<_Range> _M_offset = -1;
1569 _CachedPosition() = default;
1572 _CachedPosition(const _CachedPosition&) = default;
1575 _CachedPosition(_CachedPosition&& __other) noexcept
1576 { *this = std::move(__other); }
1578 constexpr _CachedPosition&
1579 operator=(const _CachedPosition&) = default;
1581 constexpr _CachedPosition&
1582 operator=(_CachedPosition&& __other) noexcept
1584 // Propagate the cached offset, but invalidate the source.
1585 _M_offset = __other._M_offset;
1586 __other._M_offset = -1;
1591 _M_has_value() const
1592 { return _M_offset >= 0; }
1594 constexpr iterator_t<_Range>
1595 _M_get(_Range& __r) const
1597 __glibcxx_assert(_M_has_value());
1598 return ranges::begin(__r) + _M_offset;
1602 _M_set(_Range& __r, const iterator_t<_Range>& __it)
1604 __glibcxx_assert(!_M_has_value());
1605 _M_offset = __it - ranges::begin(__r);
1608 } // namespace __detail
1612 template<typename _Base>
1613 struct __filter_view_iter_cat
1616 template<forward_range _Base>
1617 struct __filter_view_iter_cat<_Base>
1623 using _Cat = typename iterator_traits<iterator_t<_Base>>::iterator_category;
1624 if constexpr (derived_from<_Cat, bidirectional_iterator_tag>)
1625 return bidirectional_iterator_tag{};
1626 else if constexpr (derived_from<_Cat, forward_iterator_tag>)
1627 return forward_iterator_tag{};
1632 using iterator_category = decltype(_S_iter_cat());
1634 } // namespace __detail
1636 template<input_range _Vp,
1637 indirect_unary_predicate<iterator_t<_Vp>> _Pred>
1638 requires view<_Vp> && is_object_v<_Pred>
1639 class filter_view : public view_interface<filter_view<_Vp, _Pred>>
1644 struct _Iterator : __detail::__filter_view_iter_cat<_Vp>
1647 static constexpr auto
1650 if constexpr (bidirectional_range<_Vp>)
1651 return bidirectional_iterator_tag{};
1652 else if constexpr (forward_range<_Vp>)
1653 return forward_iterator_tag{};
1655 return input_iterator_tag{};
1660 using _Vp_iter = iterator_t<_Vp>;
1662 _Vp_iter _M_current = _Vp_iter();
1663 filter_view* _M_parent = nullptr;
1666 using iterator_concept = decltype(_S_iter_concept());
1667 // iterator_category defined in __filter_view_iter_cat
1668 using value_type = range_value_t<_Vp>;
1669 using difference_type = range_difference_t<_Vp>;
1671 _Iterator() requires default_initializable<_Vp_iter> = default;
1674 _Iterator(filter_view* __parent, _Vp_iter __current)
1675 : _M_current(std::move(__current)),
1679 constexpr const _Vp_iter&
1680 base() const & noexcept
1681 { return _M_current; }
1685 { return std::move(_M_current); }
1687 constexpr range_reference_t<_Vp>
1689 { return *_M_current; }
1693 requires __detail::__has_arrow<_Vp_iter>
1694 && copyable<_Vp_iter>
1695 { return _M_current; }
1697 constexpr _Iterator&
1700 _M_current = ranges::find_if(std::move(++_M_current),
1701 ranges::end(_M_parent->_M_base),
1702 std::ref(*_M_parent->_M_pred));
1711 operator++(int) requires forward_range<_Vp>
1718 constexpr _Iterator&
1719 operator--() requires bidirectional_range<_Vp>
1723 while (!std::__invoke(*_M_parent->_M_pred, *_M_current));
1728 operator--(int) requires bidirectional_range<_Vp>
1735 friend constexpr bool
1736 operator==(const _Iterator& __x, const _Iterator& __y)
1737 requires equality_comparable<_Vp_iter>
1738 { return __x._M_current == __y._M_current; }
1740 friend constexpr range_rvalue_reference_t<_Vp>
1741 iter_move(const _Iterator& __i)
1742 noexcept(noexcept(ranges::iter_move(__i._M_current)))
1743 { return ranges::iter_move(__i._M_current); }
1745 friend constexpr void
1746 iter_swap(const _Iterator& __x, const _Iterator& __y)
1747 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1748 requires indirectly_swappable<_Vp_iter>
1749 { ranges::iter_swap(__x._M_current, __y._M_current); }
1755 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
1758 __equal(const _Iterator& __i) const
1759 { return __i._M_current == _M_end; }
1762 _Sentinel() = default;
1765 _Sentinel(filter_view* __parent)
1766 : _M_end(ranges::end(__parent->_M_base))
1769 constexpr sentinel_t<_Vp>
1773 friend constexpr bool
1774 operator==(const _Iterator& __x, const _Sentinel& __y)
1775 { return __y.__equal(__x); }
1778 _Vp _M_base = _Vp();
1779 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
1780 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
1783 filter_view() requires (default_initializable<_Vp>
1784 && default_initializable<_Pred>)
1788 filter_view(_Vp __base, _Pred __pred)
1789 : _M_base(std::move(__base)), _M_pred(std::move(__pred))
1793 base() const& requires copy_constructible<_Vp>
1798 { return std::move(_M_base); }
1800 constexpr const _Pred&
1802 { return *_M_pred; }
1807 if (_M_cached_begin._M_has_value())
1808 return {this, _M_cached_begin._M_get(_M_base)};
1810 __glibcxx_assert(_M_pred.has_value());
1811 auto __it = ranges::find_if(ranges::begin(_M_base),
1812 ranges::end(_M_base),
1813 std::ref(*_M_pred));
1814 _M_cached_begin._M_set(_M_base, __it);
1815 return {this, std::move(__it)};
1821 if constexpr (common_range<_Vp>)
1822 return _Iterator{this, ranges::end(_M_base)};
1824 return _Sentinel{this};
1828 template<typename _Range, typename _Pred>
1829 filter_view(_Range&&, _Pred) -> filter_view<views::all_t<_Range>, _Pred>;
1835 template<typename _Range, typename _Pred>
1836 concept __can_filter_view
1837 = requires { filter_view(std::declval<_Range>(), std::declval<_Pred>()); };
1838 } // namespace __detail
1840 struct _Filter : __adaptor::_RangeAdaptor<_Filter>
1842 template<viewable_range _Range, typename _Pred>
1843 requires __detail::__can_filter_view<_Range, _Pred>
1845 operator() [[nodiscard]] (_Range&& __r, _Pred&& __p) const
1847 return filter_view(std::forward<_Range>(__r), std::forward<_Pred>(__p));
1850 using _RangeAdaptor<_Filter>::operator();
1851 static constexpr int _S_arity = 2;
1852 static constexpr bool _S_has_simple_extra_args = true;
1855 inline constexpr _Filter filter;
1856 } // namespace views
1858#if __cpp_lib_ranges >= 202207L // C++ >= 23
1859 template<input_range _Vp, move_constructible _Fp>
1861 template<input_range _Vp, copy_constructible _Fp>
1863 requires view<_Vp> && is_object_v<_Fp>
1864 && regular_invocable<_Fp&, range_reference_t<_Vp>>
1865 && std::__detail::__can_reference<invoke_result_t<_Fp&,
1866 range_reference_t<_Vp>>>
1867 class transform_view : public view_interface<transform_view<_Vp, _Fp>>
1870 template<bool _Const>
1871 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
1873 template<bool _Const>
1877 template<bool _Const>
1878 requires forward_range<_Base<_Const>>
1879 struct __iter_cat<_Const>
1885 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1886 // 3564. transform_view::iterator<true>::value_type and
1887 // iterator_category should use const F&
1888 using _Base = transform_view::_Base<_Const>;
1889 using _Res = invoke_result_t<__maybe_const_t<_Const, _Fp>&,
1890 range_reference_t<_Base>>;
1891 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1892 // 3798. Rvalue reference and iterator_category
1893 if constexpr (is_reference_v<_Res>)
1896 = typename iterator_traits<iterator_t<_Base>>::iterator_category;
1897 if constexpr (derived_from<_Cat, contiguous_iterator_tag>)
1898 return random_access_iterator_tag{};
1903 return input_iterator_tag{};
1906 using iterator_category = decltype(_S_iter_cat());
1909 template<bool _Const>
1912 template<bool _Const>
1913 struct _Iterator : __iter_cat<_Const>
1916 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
1917 using _Base = transform_view::_Base<_Const>;
1922 if constexpr (random_access_range<_Base>)
1923 return random_access_iterator_tag{};
1924 else if constexpr (bidirectional_range<_Base>)
1925 return bidirectional_iterator_tag{};
1926 else if constexpr (forward_range<_Base>)
1927 return forward_iterator_tag{};
1929 return input_iterator_tag{};
1932 using _Base_iter = iterator_t<_Base>;
1934 _Base_iter _M_current = _Base_iter();
1935 _Parent* _M_parent = nullptr;
1938 using iterator_concept = decltype(_S_iter_concept());
1939 // iterator_category defined in __transform_view_iter_cat
1941 = remove_cvref_t<invoke_result_t<__maybe_const_t<_Const, _Fp>&,
1942 range_reference_t<_Base>>>;
1943 using difference_type = range_difference_t<_Base>;
1945 _Iterator() requires default_initializable<_Base_iter> = default;
1948 _Iterator(_Parent* __parent, _Base_iter __current)
1949 : _M_current(std::move(__current)),
1954 _Iterator(_Iterator<!_Const> __i)
1956 && convertible_to<iterator_t<_Vp>, _Base_iter>
1957 : _M_current(std::move(__i._M_current)), _M_parent(__i._M_parent)
1960 constexpr const _Base_iter&
1961 base() const & noexcept
1962 { return _M_current; }
1964 constexpr _Base_iter
1966 { return std::move(_M_current); }
1968 constexpr decltype(auto)
1970 noexcept(noexcept(std::__invoke(*_M_parent->_M_fun, *_M_current)))
1971 { return std::__invoke(*_M_parent->_M_fun, *_M_current); }
1973 constexpr _Iterator&
1985 operator++(int) requires forward_range<_Base>
1992 constexpr _Iterator&
1993 operator--() requires bidirectional_range<_Base>
2000 operator--(int) requires bidirectional_range<_Base>
2007 constexpr _Iterator&
2008 operator+=(difference_type __n) requires random_access_range<_Base>
2014 constexpr _Iterator&
2015 operator-=(difference_type __n) requires random_access_range<_Base>
2021 constexpr decltype(auto)
2022 operator[](difference_type __n) const
2023 requires random_access_range<_Base>
2024 { return std::__invoke(*_M_parent->_M_fun, _M_current[__n]); }
2026 friend constexpr bool
2027 operator==(const _Iterator& __x, const _Iterator& __y)
2028 requires equality_comparable<_Base_iter>
2029 { return __x._M_current == __y._M_current; }
2031 friend constexpr bool
2032 operator<(const _Iterator& __x, const _Iterator& __y)
2033 requires random_access_range<_Base>
2034 { return __x._M_current < __y._M_current; }
2036 friend constexpr bool
2037 operator>(const _Iterator& __x, const _Iterator& __y)
2038 requires random_access_range<_Base>
2039 { return __y < __x; }
2041 friend constexpr bool
2042 operator<=(const _Iterator& __x, const _Iterator& __y)
2043 requires random_access_range<_Base>
2044 { return !(__y < __x); }
2046 friend constexpr bool
2047 operator>=(const _Iterator& __x, const _Iterator& __y)
2048 requires random_access_range<_Base>
2049 { return !(__x < __y); }
2051#ifdef __cpp_lib_three_way_comparison
2052 friend constexpr auto
2053 operator<=>(const _Iterator& __x, const _Iterator& __y)
2054 requires random_access_range<_Base>
2055 && three_way_comparable<_Base_iter>
2056 { return __x._M_current <=> __y._M_current; }
2059 friend constexpr _Iterator
2060 operator+(_Iterator __i, difference_type __n)
2061 requires random_access_range<_Base>
2062 { return {__i._M_parent, __i._M_current + __n}; }
2064 friend constexpr _Iterator
2065 operator+(difference_type __n, _Iterator __i)
2066 requires random_access_range<_Base>
2067 { return {__i._M_parent, __i._M_current + __n}; }
2069 friend constexpr _Iterator
2070 operator-(_Iterator __i, difference_type __n)
2071 requires random_access_range<_Base>
2072 { return {__i._M_parent, __i._M_current - __n}; }
2074 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2075 // 3483. transform_view::iterator's difference is overconstrained
2076 friend constexpr difference_type
2077 operator-(const _Iterator& __x, const _Iterator& __y)
2078 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
2079 { return __x._M_current - __y._M_current; }
2081 friend constexpr decltype(auto)
2082 iter_move(const _Iterator& __i) noexcept(noexcept(*__i))
2084 if constexpr (is_lvalue_reference_v<decltype(*__i)>)
2085 return std::move(*__i);
2090 friend _Iterator<!_Const>;
2091 template<bool> friend struct _Sentinel;
2094 template<bool _Const>
2098 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
2099 using _Base = transform_view::_Base<_Const>;
2101 template<bool _Const2>
2103 __distance_from(const _Iterator<_Const2>& __i) const
2104 { return _M_end - __i._M_current; }
2106 template<bool _Const2>
2108 __equal(const _Iterator<_Const2>& __i) const
2109 { return __i._M_current == _M_end; }
2111 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2114 _Sentinel() = default;
2117 _Sentinel(sentinel_t<_Base> __end)
2122 _Sentinel(_Sentinel<!_Const> __i)
2124 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2125 : _M_end(std::move(__i._M_end))
2128 constexpr sentinel_t<_Base>
2132 template<bool _Const2>
2133 requires sentinel_for<sentinel_t<_Base>,
2134 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
2135 friend constexpr bool
2136 operator==(const _Iterator<_Const2>& __x, const _Sentinel& __y)
2137 { return __y.__equal(__x); }
2139 template<bool _Const2,
2140 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
2141 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2142 friend constexpr range_difference_t<_Base2>
2143 operator-(const _Iterator<_Const2>& __x, const _Sentinel& __y)
2144 { return -__y.__distance_from(__x); }
2146 template<bool _Const2,
2147 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
2148 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2149 friend constexpr range_difference_t<_Base2>
2150 operator-(const _Sentinel& __y, const _Iterator<_Const2>& __x)
2151 { return __y.__distance_from(__x); }
2153 friend _Sentinel<!_Const>;
2156 _Vp _M_base = _Vp();
2157 [[no_unique_address]] __detail::__box<_Fp> _M_fun;
2160 transform_view() requires (default_initializable<_Vp>
2161 && default_initializable<_Fp>)
2165 transform_view(_Vp __base, _Fp __fun)
2166 : _M_base(std::move(__base)), _M_fun(std::move(__fun))
2170 base() const& requires copy_constructible<_Vp>
2171 { return _M_base ; }
2175 { return std::move(_M_base); }
2177 constexpr _Iterator<false>
2179 { return _Iterator<false>{this, ranges::begin(_M_base)}; }
2181 constexpr _Iterator<true>
2183 requires range<const _Vp>
2184 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
2185 { return _Iterator<true>{this, ranges::begin(_M_base)}; }
2187 constexpr _Sentinel<false>
2189 { return _Sentinel<false>{ranges::end(_M_base)}; }
2191 constexpr _Iterator<false>
2192 end() requires common_range<_Vp>
2193 { return _Iterator<false>{this, ranges::end(_M_base)}; }
2195 constexpr _Sentinel<true>
2197 requires range<const _Vp>
2198 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
2199 { return _Sentinel<true>{ranges::end(_M_base)}; }
2201 constexpr _Iterator<true>
2203 requires common_range<const _Vp>
2204 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
2205 { return _Iterator<true>{this, ranges::end(_M_base)}; }
2208 size() requires sized_range<_Vp>
2209 { return ranges::size(_M_base); }
2212 size() const requires sized_range<const _Vp>
2213 { return ranges::size(_M_base); }
2216 template<typename _Range, typename _Fp>
2217 transform_view(_Range&&, _Fp) -> transform_view<views::all_t<_Range>, _Fp>;
2223 template<typename _Range, typename _Fp>
2224 concept __can_transform_view
2225 = requires { transform_view(std::declval<_Range>(), std::declval<_Fp>()); };
2226 } // namespace __detail
2228 struct _Transform : __adaptor::_RangeAdaptor<_Transform>
2230 template<viewable_range _Range, typename _Fp>
2231 requires __detail::__can_transform_view<_Range, _Fp>
2233 operator() [[nodiscard]] (_Range&& __r, _Fp&& __f) const
2235 return transform_view(std::forward<_Range>(__r), std::forward<_Fp>(__f));
2238 using _RangeAdaptor<_Transform>::operator();
2239 static constexpr int _S_arity = 2;
2240 static constexpr bool _S_has_simple_extra_args = true;
2243 inline constexpr _Transform transform;
2244 } // namespace views
2247 class take_view : public view_interface<take_view<_Vp>>
2250 template<bool _Const>
2251 using _CI = counted_iterator<
2252 iterator_t<__detail::__maybe_const_t<_Const, _Vp>>>;
2254 template<bool _Const>
2258 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2259 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2262 _Sentinel() = default;
2265 _Sentinel(sentinel_t<_Base> __end)
2270 _Sentinel(_Sentinel<!_Const> __s)
2271 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2272 : _M_end(std::move(__s._M_end))
2275 constexpr sentinel_t<_Base>
2279 friend constexpr bool
2280 operator==(const _CI<_Const>& __y, const _Sentinel& __x)
2281 { return __y.count() == 0 || __y.base() == __x._M_end; }
2283 template<bool _OtherConst = !_Const,
2284 typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
2285 requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2286 friend constexpr bool
2287 operator==(const _CI<_OtherConst>& __y, const _Sentinel& __x)
2288 { return __y.count() == 0 || __y.base() == __x._M_end; }
2290 friend _Sentinel<!_Const>;
2293 _Vp _M_base = _Vp();
2294 range_difference_t<_Vp> _M_count = 0;
2297 take_view() requires default_initializable<_Vp> = default;
2300 take_view(_Vp __base, range_difference_t<_Vp> __count)
2301 : _M_base(std::move(__base)), _M_count(std::move(__count))
2305 base() const& requires copy_constructible<_Vp>
2310 { return std::move(_M_base); }
2313 begin() requires (!__detail::__simple_view<_Vp>)
2315 if constexpr (sized_range<_Vp>)
2317 if constexpr (random_access_range<_Vp>)
2318 return ranges::begin(_M_base);
2322 return counted_iterator(ranges::begin(_M_base), __sz);
2326 return counted_iterator(ranges::begin(_M_base), _M_count);
2330 begin() const requires range<const _Vp>
2332 if constexpr (sized_range<const _Vp>)
2334 if constexpr (random_access_range<const _Vp>)
2335 return ranges::begin(_M_base);
2339 return counted_iterator(ranges::begin(_M_base), __sz);
2343 return counted_iterator(ranges::begin(_M_base), _M_count);
2347 end() requires (!__detail::__simple_view<_Vp>)
2349 if constexpr (sized_range<_Vp>)
2351 if constexpr (random_access_range<_Vp>)
2352 return ranges::begin(_M_base) + size();
2354 return default_sentinel;
2357 return _Sentinel<false>{ranges::end(_M_base)};
2361 end() const requires range<const _Vp>
2363 if constexpr (sized_range<const _Vp>)
2365 if constexpr (random_access_range<const _Vp>)
2366 return ranges::begin(_M_base) + size();
2368 return default_sentinel;
2371 return _Sentinel<true>{ranges::end(_M_base)};
2375 size() requires sized_range<_Vp>
2377 auto __n = ranges::size(_M_base);
2378 return std::min(__n, static_cast<decltype(__n)>(_M_count));
2382 size() const requires sized_range<const _Vp>
2384 auto __n = ranges::size(_M_base);
2385 return std::min(__n, static_cast<decltype(__n)>(_M_count));
2389 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2390 // 3447. Deduction guides for take_view and drop_view have different
2392 template<typename _Range>
2393 take_view(_Range&&, range_difference_t<_Range>)
2394 -> take_view<views::all_t<_Range>>;
2396 template<typename _Tp>
2397 inline constexpr bool enable_borrowed_range<take_view<_Tp>>
2398 = enable_borrowed_range<_Tp>;
2404 template<typename _Range>
2405 inline constexpr bool __is_empty_view = false;
2407 template<typename _Tp>
2408 inline constexpr bool __is_empty_view<empty_view<_Tp>> = true;
2410 template<typename _Range>
2411 inline constexpr bool __is_basic_string_view = false;
2413 template<typename _CharT, typename _Traits>
2414 inline constexpr bool __is_basic_string_view<basic_string_view<_CharT, _Traits>>
2417 using ranges::__detail::__is_subrange;
2419 template<typename _Range>
2420 inline constexpr bool __is_iota_view = false;
2422 template<typename _Winc, typename _Bound>
2423 inline constexpr bool __is_iota_view<iota_view<_Winc, _Bound>> = true;
2425 template<typename _Range>
2426 inline constexpr bool __is_repeat_view = false;
2428 template<typename _Range>
2430 __take_of_repeat_view(_Range&&, range_difference_t<_Range>); // defined later
2432 template<typename _Range, typename _Dp>
2433 concept __can_take_view
2434 = requires { take_view(std::declval<_Range>(), std::declval<_Dp>()); };
2435 } // namespace __detail
2437 struct _Take : __adaptor::_RangeAdaptor<_Take>
2439 template<viewable_range _Range, typename _Dp = range_difference_t<_Range>>
2440 requires __detail::__can_take_view<_Range, _Dp>
2442 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n) const
2444 using _Tp = remove_cvref_t<_Range>;
2445 if constexpr (__detail::__is_empty_view<_Tp>)
2447 else if constexpr (random_access_range<_Tp>
2449 && (std::__detail::__is_span<_Tp>
2450 || __detail::__is_basic_string_view<_Tp>
2451 || __detail::__is_subrange<_Tp>
2452 || __detail::__is_iota_view<_Tp>))
2454 __n = std::min<_Dp>(ranges::distance(__r), __n);
2455 auto __begin = ranges::begin(__r);
2456 auto __end = __begin + __n;
2457 if constexpr (std::__detail::__is_span<_Tp>)
2458 return span<typename _Tp::element_type>(__begin, __end);
2459 else if constexpr (__detail::__is_basic_string_view<_Tp>)
2460 return _Tp(__begin, __end);
2461 else if constexpr (__detail::__is_subrange<_Tp>)
2462 return subrange<iterator_t<_Tp>>(__begin, __end);
2464 return iota_view(*__begin, *__end);
2466 else if constexpr (__detail::__is_repeat_view<_Tp>)
2467 return __detail::__take_of_repeat_view(std::forward<_Range>(__r), __n);
2469 return take_view(std::forward<_Range>(__r), __n);
2472 using _RangeAdaptor<_Take>::operator();
2473 static constexpr int _S_arity = 2;
2474 // The count argument of views::take is not always simple -- it can be
2475 // e.g. a move-only class that's implicitly convertible to the difference
2476 // type. But an integer-like count argument is surely simple.
2477 template<typename _Tp>
2478 static constexpr bool _S_has_simple_extra_args
2479 = ranges::__detail::__is_integer_like<_Tp>;
2482 inline constexpr _Take take;
2483 } // namespace views
2485 template<view _Vp, typename _Pred>
2486 requires input_range<_Vp> && is_object_v<_Pred>
2487 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2488 class take_while_view : public view_interface<take_while_view<_Vp, _Pred>>
2490 template<bool _Const>
2494 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2496 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2497 const _Pred* _M_pred = nullptr;
2500 _Sentinel() = default;
2503 _Sentinel(sentinel_t<_Base> __end, const _Pred* __pred)
2504 : _M_end(__end), _M_pred(__pred)
2508 _Sentinel(_Sentinel<!_Const> __s)
2509 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2510 : _M_end(__s._M_end), _M_pred(__s._M_pred)
2513 constexpr sentinel_t<_Base>
2514 base() const { return _M_end; }
2516 friend constexpr bool
2517 operator==(const iterator_t<_Base>& __x, const _Sentinel& __y)
2518 { return __y._M_end == __x || !std::__invoke(*__y._M_pred, *__x); }
2520 template<bool _OtherConst = !_Const,
2521 typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
2522 requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2523 friend constexpr bool
2524 operator==(const iterator_t<_Base2>& __x, const _Sentinel& __y)
2525 { return __y._M_end == __x || !std::__invoke(*__y._M_pred, *__x); }
2527 friend _Sentinel<!_Const>;
2530 _Vp _M_base = _Vp();
2531 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
2534 take_while_view() requires (default_initializable<_Vp>
2535 && default_initializable<_Pred>)
2539 take_while_view(_Vp __base, _Pred __pred)
2540 : _M_base(std::move(__base)), _M_pred(std::move(__pred))
2544 base() const& requires copy_constructible<_Vp>
2549 { return std::move(_M_base); }
2551 constexpr const _Pred&
2553 { return *_M_pred; }
2556 begin() requires (!__detail::__simple_view<_Vp>)
2557 { return ranges::begin(_M_base); }
2560 begin() const requires range<const _Vp>
2561 && indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
2562 { return ranges::begin(_M_base); }
2565 end() requires (!__detail::__simple_view<_Vp>)
2566 { return _Sentinel<false>(ranges::end(_M_base),
2567 std::__addressof(*_M_pred)); }
2570 end() const requires range<const _Vp>
2571 && indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
2572 { return _Sentinel<true>(ranges::end(_M_base),
2573 std::__addressof(*_M_pred)); }
2576 template<typename _Range, typename _Pred>
2577 take_while_view(_Range&&, _Pred)
2578 -> take_while_view<views::all_t<_Range>, _Pred>;
2584 template<typename _Range, typename _Pred>
2585 concept __can_take_while_view
2586 = requires { take_while_view(std::declval<_Range>(), std::declval<_Pred>()); };
2587 } // namespace __detail
2589 struct _TakeWhile : __adaptor::_RangeAdaptor<_TakeWhile>
2591 template<viewable_range _Range, typename _Pred>
2592 requires __detail::__can_take_while_view<_Range, _Pred>
2594 operator() [[nodiscard]] (_Range&& __r, _Pred&& __p) const
2596 return take_while_view(std::forward<_Range>(__r), std::forward<_Pred>(__p));
2599 using _RangeAdaptor<_TakeWhile>::operator();
2600 static constexpr int _S_arity = 2;
2601 static constexpr bool _S_has_simple_extra_args = true;
2604 inline constexpr _TakeWhile take_while;
2605 } // namespace views
2608 class drop_view : public view_interface<drop_view<_Vp>>
2611 _Vp _M_base = _Vp();
2612 range_difference_t<_Vp> _M_count = 0;
2614 // ranges::next(begin(base), count, end(base)) is O(1) if _Vp satisfies
2615 // both random_access_range and sized_range. Otherwise, cache its result.
2616 static constexpr bool _S_needs_cached_begin
2617 = !(random_access_range<const _Vp> && sized_range<const _Vp>);
2618 [[no_unique_address]]
2619 __detail::__maybe_present_t<_S_needs_cached_begin,
2620 __detail::_CachedPosition<_Vp>>
2624 drop_view() requires default_initializable<_Vp> = default;
2627 drop_view(_Vp __base, range_difference_t<_Vp> __count)
2628 : _M_base(std::move(__base)), _M_count(__count)
2629 { __glibcxx_assert(__count >= 0); }
2632 base() const& requires copy_constructible<_Vp>
2637 { return std::move(_M_base); }
2639 // This overload is disabled for simple views with constant-time begin().
2642 requires (!(__detail::__simple_view<_Vp>
2643 && random_access_range<const _Vp>
2644 && sized_range<const _Vp>))
2646 if constexpr (_S_needs_cached_begin)
2647 if (_M_cached_begin._M_has_value())
2648 return _M_cached_begin._M_get(_M_base);
2650 auto __it = ranges::next(ranges::begin(_M_base),
2651 _M_count, ranges::end(_M_base));
2652 if constexpr (_S_needs_cached_begin)
2653 _M_cached_begin._M_set(_M_base, __it);
2657 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2658 // 3482. drop_view's const begin should additionally require sized_range
2661 requires random_access_range<const _Vp> && sized_range<const _Vp>
2663 return ranges::begin(_M_base) + ranges::min(ranges::distance(_M_base),
2668 end() requires (!__detail::__simple_view<_Vp>)
2669 { return ranges::end(_M_base); }
2672 end() const requires range<const _Vp>
2673 { return ranges::end(_M_base); }
2676 size() requires sized_range<_Vp>
2678 const auto __s = ranges::size(_M_base);
2679 const auto __c = static_cast<decltype(__s)>(_M_count);
2680 return __s < __c ? 0 : __s - __c;
2684 size() const requires sized_range<const _Vp>
2686 const auto __s = ranges::size(_M_base);
2687 const auto __c = static_cast<decltype(__s)>(_M_count);
2688 return __s < __c ? 0 : __s - __c;
2692 template<typename _Range>
2693 drop_view(_Range&&, range_difference_t<_Range>)
2694 -> drop_view<views::all_t<_Range>>;
2696 template<typename _Tp>
2697 inline constexpr bool enable_borrowed_range<drop_view<_Tp>>
2698 = enable_borrowed_range<_Tp>;
2704 template<typename _Range>
2706 __drop_of_repeat_view(_Range&&, range_difference_t<_Range>); // defined later
2708 template<typename _Range, typename _Dp>
2709 concept __can_drop_view
2710 = requires { drop_view(std::declval<_Range>(), std::declval<_Dp>()); };
2711 } // namespace __detail
2713 struct _Drop : __adaptor::_RangeAdaptor<_Drop>
2715 template<viewable_range _Range, typename _Dp = range_difference_t<_Range>>
2716 requires __detail::__can_drop_view<_Range, _Dp>
2718 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n) const
2720 using _Tp = remove_cvref_t<_Range>;
2721 if constexpr (__detail::__is_empty_view<_Tp>)
2723 else if constexpr (random_access_range<_Tp>
2725 && (std::__detail::__is_span<_Tp>
2726 || __detail::__is_basic_string_view<_Tp>
2727 || __detail::__is_iota_view<_Tp>
2728 || __detail::__is_subrange<_Tp>))
2730 __n = std::min<_Dp>(ranges::distance(__r), __n);
2731 auto __begin = ranges::begin(__r) + __n;
2732 auto __end = ranges::end(__r);
2733 if constexpr (std::__detail::__is_span<_Tp>)
2734 return span<typename _Tp::element_type>(__begin, __end);
2735 else if constexpr (__detail::__is_subrange<_Tp>)
2737 if constexpr (_Tp::_S_store_size)
2739 using ranges::__detail::__to_unsigned_like;
2740 auto __m = ranges::distance(__r) - __n;
2741 return _Tp(__begin, __end, __to_unsigned_like(__m));
2744 return _Tp(__begin, __end);
2747 return _Tp(__begin, __end);
2749 else if constexpr (__detail::__is_repeat_view<_Tp>)
2750 return __detail::__drop_of_repeat_view(std::forward<_Range>(__r), __n);
2752 return drop_view(std::forward<_Range>(__r), __n);
2755 using _RangeAdaptor<_Drop>::operator();
2756 static constexpr int _S_arity = 2;
2757 template<typename _Tp>
2758 static constexpr bool _S_has_simple_extra_args
2759 = _Take::_S_has_simple_extra_args<_Tp>;
2762 inline constexpr _Drop drop;
2763 } // namespace views
2765 template<view _Vp, typename _Pred>
2766 requires input_range<_Vp> && is_object_v<_Pred>
2767 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2768 class drop_while_view : public view_interface<drop_while_view<_Vp, _Pred>>
2771 _Vp _M_base = _Vp();
2772 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
2773 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
2776 drop_while_view() requires (default_initializable<_Vp>
2777 && default_initializable<_Pred>)
2781 drop_while_view(_Vp __base, _Pred __pred)
2782 : _M_base(std::move(__base)), _M_pred(std::move(__pred))
2786 base() const& requires copy_constructible<_Vp>
2791 { return std::move(_M_base); }
2793 constexpr const _Pred&
2795 { return *_M_pred; }
2800 if (_M_cached_begin._M_has_value())
2801 return _M_cached_begin._M_get(_M_base);
2803 __glibcxx_assert(_M_pred.has_value());
2804 auto __it = ranges::find_if_not(ranges::begin(_M_base),
2805 ranges::end(_M_base),
2806 std::cref(*_M_pred));
2807 _M_cached_begin._M_set(_M_base, __it);
2813 { return ranges::end(_M_base); }
2816 template<typename _Range, typename _Pred>
2817 drop_while_view(_Range&&, _Pred)
2818 -> drop_while_view<views::all_t<_Range>, _Pred>;
2820 template<typename _Tp, typename _Pred>
2821 inline constexpr bool enable_borrowed_range<drop_while_view<_Tp, _Pred>>
2822 = enable_borrowed_range<_Tp>;
2828 template<typename _Range, typename _Pred>
2829 concept __can_drop_while_view
2830 = requires { drop_while_view(std::declval<_Range>(), std::declval<_Pred>()); };
2831 } // namespace __detail
2833 struct _DropWhile : __adaptor::_RangeAdaptor<_DropWhile>
2835 template<viewable_range _Range, typename _Pred>
2836 requires __detail::__can_drop_while_view<_Range, _Pred>
2838 operator() [[nodiscard]] (_Range&& __r, _Pred&& __p) const
2840 return drop_while_view(std::forward<_Range>(__r),
2841 std::forward<_Pred>(__p));
2844 using _RangeAdaptor<_DropWhile>::operator();
2845 static constexpr int _S_arity = 2;
2846 static constexpr bool _S_has_simple_extra_args = true;
2849 inline constexpr _DropWhile drop_while;
2850 } // namespace views
2854 template<typename _Tp>
2856 __as_lvalue(_Tp&& __t)
2857 { return static_cast<_Tp&>(__t); }
2858 } // namespace __detail
2860 template<input_range _Vp>
2861 requires view<_Vp> && input_range<range_reference_t<_Vp>>
2862 class join_view : public view_interface<join_view<_Vp>>
2865 using _InnerRange = range_reference_t<_Vp>;
2867 template<bool _Const>
2868 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2870 template<bool _Const>
2871 using _Outer_iter = iterator_t<_Base<_Const>>;
2873 template<bool _Const>
2874 using _Inner_iter = iterator_t<range_reference_t<_Base<_Const>>>;
2876 template<bool _Const>
2877 static constexpr bool _S_ref_is_glvalue
2878 = is_reference_v<range_reference_t<_Base<_Const>>>;
2880 template<bool _Const>
2884 template<bool _Const>
2885 requires _S_ref_is_glvalue<_Const>
2886 && forward_range<_Base<_Const>>
2887 && forward_range<range_reference_t<_Base<_Const>>>
2888 struct __iter_cat<_Const>
2891 static constexpr auto
2894 using _Outer_iter = join_view::_Outer_iter<_Const>;
2895 using _Inner_iter = join_view::_Inner_iter<_Const>;
2896 using _OuterCat = typename iterator_traits<_Outer_iter>::iterator_category;
2897 using _InnerCat = typename iterator_traits<_Inner_iter>::iterator_category;
2898 if constexpr (derived_from<_OuterCat, bidirectional_iterator_tag>
2899 && derived_from<_InnerCat, bidirectional_iterator_tag>
2900 && common_range<range_reference_t<_Base<_Const>>>)
2901 return bidirectional_iterator_tag{};
2902 else if constexpr (derived_from<_OuterCat, forward_iterator_tag>
2903 && derived_from<_InnerCat, forward_iterator_tag>)
2904 return forward_iterator_tag{};
2906 return input_iterator_tag{};
2909 using iterator_category = decltype(_S_iter_cat());
2912 template<bool _Const>
2915 template<bool _Const>
2916 struct _Iterator : __iter_cat<_Const>
2919 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
2920 using _Base = join_view::_Base<_Const>;
2924 static constexpr bool _S_ref_is_glvalue
2925 = join_view::_S_ref_is_glvalue<_Const>;
2930 auto __update_inner = [this] (const iterator_t<_Base>& __x) -> auto&& {
2931 if constexpr (_S_ref_is_glvalue)
2934 return _M_parent->_M_inner._M_emplace_deref(__x);
2937 _Outer_iter& __outer = _M_get_outer();
2938 for (; __outer != ranges::end(_M_parent->_M_base); ++__outer)
2940 auto&& __inner = __update_inner(__outer);
2941 _M_inner = ranges::begin(__inner);
2942 if (_M_inner != ranges::end(__inner))
2946 if constexpr (_S_ref_is_glvalue)
2950 static constexpr auto
2953 if constexpr (_S_ref_is_glvalue
2954 && bidirectional_range<_Base>
2955 && bidirectional_range<range_reference_t<_Base>>
2956 && common_range<range_reference_t<_Base>>)
2957 return bidirectional_iterator_tag{};
2958 else if constexpr (_S_ref_is_glvalue
2959 && forward_range<_Base>
2960 && forward_range<range_reference_t<_Base>>)
2961 return forward_iterator_tag{};
2963 return input_iterator_tag{};
2966 using _Outer_iter = join_view::_Outer_iter<_Const>;
2967 using _Inner_iter = join_view::_Inner_iter<_Const>;
2969 constexpr _Outer_iter&
2972 if constexpr (forward_range<_Base>)
2975 return *_M_parent->_M_outer;
2978 constexpr const _Outer_iter&
2979 _M_get_outer() const
2981 if constexpr (forward_range<_Base>)
2984 return *_M_parent->_M_outer;
2988 _Iterator(_Parent* __parent, _Outer_iter __outer) requires forward_range<_Base>
2989 : _M_outer(std::move(__outer)), _M_parent(__parent)
2993 _Iterator(_Parent* __parent) requires (!forward_range<_Base>)
2994 : _M_parent(__parent)
2997 [[no_unique_address]]
2998 __detail::__maybe_present_t<forward_range<_Base>, _Outer_iter> _M_outer;
2999 optional<_Inner_iter> _M_inner;
3000 _Parent* _M_parent = nullptr;
3003 using iterator_concept = decltype(_S_iter_concept());
3004 // iterator_category defined in __join_view_iter_cat
3005 using value_type = range_value_t<range_reference_t<_Base>>;
3006 using difference_type
3007 = common_type_t<range_difference_t<_Base>,
3008 range_difference_t<range_reference_t<_Base>>>;
3010 _Iterator() = default;
3013 _Iterator(_Iterator<!_Const> __i)
3015 && convertible_to<iterator_t<_Vp>, _Outer_iter>
3016 && convertible_to<iterator_t<_InnerRange>, _Inner_iter>
3017 : _M_outer(std::move(__i._M_outer)), _M_inner(std::move(__i._M_inner)),
3018 _M_parent(__i._M_parent)
3021 constexpr decltype(auto)
3023 { return **_M_inner; }
3025 // _GLIBCXX_RESOLVE_LIB_DEFECTS
3026 // 3500. join_view::iterator::operator->() is bogus
3027 constexpr _Inner_iter
3029 requires __detail::__has_arrow<_Inner_iter>
3030 && copyable<_Inner_iter>
3031 { return *_M_inner; }
3033 constexpr _Iterator&
3036 auto&& __inner_range = [this] () -> auto&& {
3037 if constexpr (_S_ref_is_glvalue)
3038 return *_M_get_outer();
3040 return *_M_parent->_M_inner;
3042 if (++*_M_inner == ranges::end(__inner_range))
3056 requires _S_ref_is_glvalue && forward_range<_Base>
3057 && forward_range<range_reference_t<_Base>>
3064 constexpr _Iterator&
3066 requires _S_ref_is_glvalue && bidirectional_range<_Base>
3067 && bidirectional_range<range_reference_t<_Base>>
3068 && common_range<range_reference_t<_Base>>
3070 if (_M_outer == ranges::end(_M_parent->_M_base))
3071 _M_inner = ranges::end(__detail::__as_lvalue(*--_M_outer));
3072 while (*_M_inner == ranges::begin(__detail::__as_lvalue(*_M_outer)))
3073 *_M_inner = ranges::end(__detail::__as_lvalue(*--_M_outer));
3080 requires _S_ref_is_glvalue && bidirectional_range<_Base>
3081 && bidirectional_range<range_reference_t<_Base>>
3082 && common_range<range_reference_t<_Base>>
3089 friend constexpr bool
3090 operator==(const _Iterator& __x, const _Iterator& __y)
3091 requires _S_ref_is_glvalue
3092 && forward_range<_Base>
3093 && equality_comparable<_Inner_iter>
3095 return (__x._M_outer == __y._M_outer
3096 && __x._M_inner == __y._M_inner);
3099 friend constexpr decltype(auto)
3100 iter_move(const _Iterator& __i)
3101 noexcept(noexcept(ranges::iter_move(*__i._M_inner)))
3102 { return ranges::iter_move(*__i._M_inner); }
3104 friend constexpr void
3105 iter_swap(const _Iterator& __x, const _Iterator& __y)
3106 noexcept(noexcept(ranges::iter_swap(*__x._M_inner, *__y._M_inner)))
3107 requires indirectly_swappable<_Inner_iter>
3108 { return ranges::iter_swap(*__x._M_inner, *__y._M_inner); }
3110 friend _Iterator<!_Const>;
3111 template<bool> friend struct _Sentinel;
3114 template<bool _Const>
3118 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
3119 using _Base = join_view::_Base<_Const>;
3121 template<bool _Const2>
3123 __equal(const _Iterator<_Const2>& __i) const
3124 { return __i._M_get_outer() == _M_end; }
3126 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
3129 _Sentinel() = default;
3132 _Sentinel(_Parent* __parent)
3133 : _M_end(ranges::end(__parent->_M_base))
3137 _Sentinel(_Sentinel<!_Const> __s)
3138 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
3139 : _M_end(std::move(__s._M_end))
3142 template<bool _Const2>
3143 requires sentinel_for<sentinel_t<_Base>,
3144 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
3145 friend constexpr bool
3146 operator==(const _Iterator<_Const2>& __x, const _Sentinel& __y)
3147 { return __y.__equal(__x); }
3149 friend _Sentinel<!_Const>;
3152 _Vp _M_base = _Vp();
3153 [[no_unique_address]]
3154 __detail::__maybe_present_t<!forward_range<_Vp>,
3155 __detail::__non_propagating_cache<iterator_t<_Vp>>> _M_outer;
3156 [[no_unique_address]]
3157 __detail::__non_propagating_cache<remove_cv_t<_InnerRange>> _M_inner;
3160 join_view() requires default_initializable<_Vp> = default;
3163 join_view(_Vp __base)
3164 : _M_base(std::move(__base))
3168 base() const& requires copy_constructible<_Vp>
3173 { return std::move(_M_base); }
3178 if constexpr (forward_range<_Vp>)
3180 constexpr bool __use_const
3181 = (__detail::__simple_view<_Vp>
3182 && is_reference_v<range_reference_t<_Vp>>);
3183 return _Iterator<__use_const>{this, ranges::begin(_M_base)};
3187 _M_outer = ranges::begin(_M_base);
3188 return _Iterator<false>{this};
3194 requires forward_range<const _Vp>
3195 && is_reference_v<range_reference_t<const _Vp>>
3196 && input_range<range_reference_t<const _Vp>>
3198 return _Iterator<true>{this, ranges::begin(_M_base)};
3204 if constexpr (forward_range<_Vp> && is_reference_v<_InnerRange>
3205 && forward_range<_InnerRange>
3206 && common_range<_Vp> && common_range<_InnerRange>)
3207 return _Iterator<__detail::__simple_view<_Vp>>{this,
3208 ranges::end(_M_base)};
3210 return _Sentinel<__detail::__simple_view<_Vp>>{this};
3215 requires forward_range<const _Vp>
3216 && is_reference_v<range_reference_t<const _Vp>>
3217 && input_range<range_reference_t<const _Vp>>
3219 if constexpr (is_reference_v<range_reference_t<const _Vp>>
3220 && forward_range<range_reference_t<const _Vp>>
3221 && common_range<const _Vp>
3222 && common_range<range_reference_t<const _Vp>>)
3223 return _Iterator<true>{this, ranges::end(_M_base)};
3225 return _Sentinel<true>{this};
3229 template<typename _Range>
3230 explicit join_view(_Range&&) -> join_view<views::all_t<_Range>>;
3236 template<typename _Range>
3237 concept __can_join_view
3238 = requires { join_view<all_t<_Range>>{std::declval<_Range>()}; };
3239 } // namespace __detail
3241 struct _Join : __adaptor::_RangeAdaptorClosure<_Join>
3243 template<viewable_range _Range>
3244 requires __detail::__can_join_view<_Range>
3246 operator() [[nodiscard]] (_Range&& __r) const
3248 // _GLIBCXX_RESOLVE_LIB_DEFECTS
3249 // 3474. Nesting join_views is broken because of CTAD
3250 return join_view<all_t<_Range>>{std::forward<_Range>(__r)};
3253 static constexpr bool _S_has_simple_call_op = true;
3256 inline constexpr _Join join;
3257 } // namespace views
3262 struct __require_constant;
3264 template<typename _Range>
3265 concept __tiny_range = sized_range<_Range>
3267 { typename __require_constant<remove_reference_t<_Range>::size()>; }
3268 && (remove_reference_t<_Range>::size() <= 1);
3270 template<typename _Base>
3271 struct __lazy_split_view_outer_iter_cat
3274 template<forward_range _Base>
3275 struct __lazy_split_view_outer_iter_cat<_Base>
3276 { using iterator_category = input_iterator_tag; };
3278 template<typename _Base>
3279 struct __lazy_split_view_inner_iter_cat
3282 template<forward_range _Base>
3283 struct __lazy_split_view_inner_iter_cat<_Base>
3286 static constexpr auto
3289 using _Cat = typename iterator_traits<iterator_t<_Base>>::iterator_category;
3290 if constexpr (derived_from<_Cat, forward_iterator_tag>)
3291 return forward_iterator_tag{};
3296 using iterator_category = decltype(_S_iter_cat());
3300 template<input_range _Vp, forward_range _Pattern>
3301 requires view<_Vp> && view<_Pattern>
3302 && indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
3304 && (forward_range<_Vp> || __detail::__tiny_range<_Pattern>)
3305 class lazy_split_view : public view_interface<lazy_split_view<_Vp, _Pattern>>
3308 template<bool _Const>
3309 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
3311 template<bool _Const>
3314 template<bool _Const>
3316 : __detail::__lazy_split_view_outer_iter_cat<_Base<_Const>>
3319 using _Parent = __detail::__maybe_const_t<_Const, lazy_split_view>;
3320 using _Base = lazy_split_view::_Base<_Const>;
3324 { return __current() == ranges::end(_M_parent->_M_base) && !_M_trailing_empty; }
3326 // [range.lazy.split.outer] p1
3327 // Many of the following specifications refer to the notional member
3328 // current of outer-iterator. current is equivalent to current_ if
3329 // V models forward_range, and parent_->current_ otherwise.
3331 __current() noexcept
3333 if constexpr (forward_range<_Vp>)
3336 return *_M_parent->_M_current;
3340 __current() const noexcept
3342 if constexpr (forward_range<_Vp>)
3345 return *_M_parent->_M_current;
3348 _Parent* _M_parent = nullptr;
3350 [[no_unique_address]]
3351 __detail::__maybe_present_t<forward_range<_Vp>,
3352 iterator_t<_Base>> _M_current;
3353 bool _M_trailing_empty = false;
3356 using iterator_concept = __conditional_t<forward_range<_Base>,
3357 forward_iterator_tag,
3358 input_iterator_tag>;
3359 // iterator_category defined in __lazy_split_view_outer_iter_cat
3360 using difference_type = range_difference_t<_Base>;
3362 struct value_type : view_interface<value_type>
3365 _OuterIter _M_i = _OuterIter();
3367 // _GLIBCXX_RESOLVE_LIB_DEFECTS
3368 // 4013. lazy_split_view::outer-iterator::value_type should not
3369 // provide default constructor
3371 value_type(_OuterIter __i)
3372 : _M_i(std::move(__i))
3378 constexpr _InnerIter<_Const>
3380 { return _InnerIter<_Const>{_M_i}; }
3382 constexpr default_sentinel_t
3383 end() const noexcept
3384 { return default_sentinel; }
3387 _OuterIter() = default;
3390 _OuterIter(_Parent* __parent) requires (!forward_range<_Base>)
3391 : _M_parent(__parent)
3395 _OuterIter(_Parent* __parent, iterator_t<_Base> __current)
3396 requires forward_range<_Base>
3397 : _M_parent(__parent),
3398 _M_current(std::move(__current))
3402 _OuterIter(_OuterIter<!_Const> __i)
3404 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
3405 : _M_parent(__i._M_parent), _M_current(std::move(__i._M_current)),
3406 _M_trailing_empty(__i._M_trailing_empty)
3409 constexpr value_type
3411 { return value_type{*this}; }
3413 constexpr _OuterIter&
3416 // _GLIBCXX_RESOLVE_LIB_DEFECTS
3417 // 3505. lazy_split_view::outer-iterator::operator++ misspecified
3418 const auto __end = ranges::end(_M_parent->_M_base);
3419 if (__current() == __end)
3421 _M_trailing_empty = false;
3424 const auto [__pbegin, __pend] = subrange{_M_parent->_M_pattern};
3425 if (__pbegin == __pend)
3427 else if constexpr (__detail::__tiny_range<_Pattern>)
3429 __current() = ranges::find(std::move(__current()), __end,
3431 if (__current() != __end)
3434 if (__current() == __end)
3435 _M_trailing_empty = true;
3442 = ranges::mismatch(__current(), __end, __pbegin, __pend);
3446 if (__current() == __end)
3447 _M_trailing_empty = true;
3450 } while (++__current() != __end);
3454 constexpr decltype(auto)
3457 if constexpr (forward_range<_Base>)
3467 friend constexpr bool
3468 operator==(const _OuterIter& __x, const _OuterIter& __y)
3469 requires forward_range<_Base>
3471 return __x._M_current == __y._M_current
3472 && __x._M_trailing_empty == __y._M_trailing_empty;
3475 friend constexpr bool
3476 operator==(const _OuterIter& __x, default_sentinel_t)
3477 { return __x.__at_end(); };
3479 friend _OuterIter<!_Const>;
3480 friend _InnerIter<_Const>;
3483 template<bool _Const>
3485 : __detail::__lazy_split_view_inner_iter_cat<_Base<_Const>>
3488 using _Base = lazy_split_view::_Base<_Const>;
3493 auto [__pcur, __pend] = subrange{_M_i._M_parent->_M_pattern};
3494 auto __end = ranges::end(_M_i._M_parent->_M_base);
3495 if constexpr (__detail::__tiny_range<_Pattern>)
3497 const auto& __cur = _M_i_current();
3500 if (__pcur == __pend)
3501 return _M_incremented;
3502 return *__cur == *__pcur;
3506 auto __cur = _M_i_current();
3509 if (__pcur == __pend)
3510 return _M_incremented;
3513 if (*__cur != *__pcur)
3515 if (++__pcur == __pend)
3517 } while (++__cur != __end);
3523 _M_i_current() noexcept
3524 { return _M_i.__current(); }
3527 _M_i_current() const noexcept
3528 { return _M_i.__current(); }
3530 _OuterIter<_Const> _M_i = _OuterIter<_Const>();
3531 bool _M_incremented = false;
3534 using iterator_concept
3535 = typename _OuterIter<_Const>::iterator_concept;
3536 // iterator_category defined in __lazy_split_view_inner_iter_cat
3537 using value_type = range_value_t<_Base>;
3538 using difference_type = range_difference_t<_Base>;
3540 _InnerIter() = default;
3543 _InnerIter(_OuterIter<_Const> __i)
3544 : _M_i(std::move(__i))
3547 constexpr const iterator_t<_Base>&
3548 base() const& noexcept
3549 { return _M_i_current(); }
3551 constexpr iterator_t<_Base>
3552 base() && requires forward_range<_Vp>
3553 { return std::move(_M_i_current()); }
3555 constexpr decltype(auto)
3557 { return *_M_i_current(); }
3559 constexpr _InnerIter&
3562 _M_incremented = true;
3563 if constexpr (!forward_range<_Base>)
3564 if constexpr (_Pattern::size() == 0)
3570 constexpr decltype(auto)
3573 if constexpr (forward_range<_Base>)
3583 friend constexpr bool
3584 operator==(const _InnerIter& __x, const _InnerIter& __y)
3585 requires forward_range<_Base>
3586 { return __x._M_i == __y._M_i; }
3588 friend constexpr bool
3589 operator==(const _InnerIter& __x, default_sentinel_t)
3590 { return __x.__at_end(); }
3592 friend constexpr decltype(auto)
3593 iter_move(const _InnerIter& __i)
3594 noexcept(noexcept(ranges::iter_move(__i._M_i_current())))
3595 { return ranges::iter_move(__i._M_i_current()); }
3597 friend constexpr void
3598 iter_swap(const _InnerIter& __x, const _InnerIter& __y)
3599 noexcept(noexcept(ranges::iter_swap(__x._M_i_current(),
3600 __y._M_i_current())))
3601 requires indirectly_swappable<iterator_t<_Base>>
3602 { ranges::iter_swap(__x._M_i_current(), __y._M_i_current()); }
3605 _Vp _M_base = _Vp();
3606 _Pattern _M_pattern = _Pattern();
3607 [[no_unique_address]]
3608 __detail::__maybe_present_t<!forward_range<_Vp>,
3609 __detail::__non_propagating_cache<iterator_t<_Vp>>> _M_current;
3613 lazy_split_view() requires (default_initializable<_Vp>
3614 && default_initializable<_Pattern>)
3618 lazy_split_view(_Vp __base, _Pattern __pattern)
3619 : _M_base(std::move(__base)), _M_pattern(std::move(__pattern))
3622 template<input_range _Range>
3623 requires constructible_from<_Vp, views::all_t<_Range>>
3624 && constructible_from<_Pattern, single_view<range_value_t<_Range>>>
3626 lazy_split_view(_Range&& __r, range_value_t<_Range> __e)
3627 : _M_base(views::all(std::forward<_Range>(__r))),
3628 _M_pattern(views::single(std::move(__e)))
3632 base() const& requires copy_constructible<_Vp>
3637 { return std::move(_M_base); }
3642 if constexpr (forward_range<_Vp>)
3644 constexpr bool __simple
3645 = __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
3646 return _OuterIter<__simple>{this, ranges::begin(_M_base)};
3650 _M_current = ranges::begin(_M_base);
3651 return _OuterIter<false>{this};
3656 begin() const requires forward_range<_Vp> && forward_range<const _Vp>
3658 return _OuterIter<true>{this, ranges::begin(_M_base)};
3662 end() requires forward_range<_Vp> && common_range<_Vp>
3664 constexpr bool __simple
3665 = __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
3666 return _OuterIter<__simple>{this, ranges::end(_M_base)};
3672 if constexpr (forward_range<_Vp>
3673 && forward_range<const _Vp>
3674 && common_range<const _Vp>)
3675 return _OuterIter<true>{this, ranges::end(_M_base)};
3677 return default_sentinel;
3681 template<typename _Range, typename _Pattern>
3682 lazy_split_view(_Range&&, _Pattern&&)
3683 -> lazy_split_view<views::all_t<_Range>, views::all_t<_Pattern>>;
3685 template<input_range _Range>
3686 lazy_split_view(_Range&&, range_value_t<_Range>)
3687 -> lazy_split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
3693 template<typename _Range, typename _Pattern>
3694 concept __can_lazy_split_view
3695 = requires { lazy_split_view(std::declval<_Range>(), std::declval<_Pattern>()); };
3696 } // namespace __detail
3698 struct _LazySplit : __adaptor::_RangeAdaptor<_LazySplit>
3700 template<viewable_range _Range, typename _Pattern>
3701 requires __detail::__can_lazy_split_view<_Range, _Pattern>
3703 operator() [[nodiscard]] (_Range&& __r, _Pattern&& __f) const
3705 return lazy_split_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
3708 using _RangeAdaptor<_LazySplit>::operator();
3709 static constexpr int _S_arity = 2;
3710 // The pattern argument of views::lazy_split is not always simple -- it can be
3711 // a non-view range, the value category of which affects whether the call
3712 // is well-formed. But a scalar or a view pattern argument is surely
3714 template<typename _Pattern>
3715 static constexpr bool _S_has_simple_extra_args
3716 = is_scalar_v<_Pattern> || (view<_Pattern>
3717 && copy_constructible<_Pattern>);
3720 inline constexpr _LazySplit lazy_split;
3721 } // namespace views
3723 template<forward_range _Vp, forward_range _Pattern>
3724 requires view<_Vp> && view<_Pattern>
3725 && indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
3727 class split_view : public view_interface<split_view<_Vp, _Pattern>>
3730 _Vp _M_base = _Vp();
3731 _Pattern _M_pattern = _Pattern();
3732 __detail::__non_propagating_cache<subrange<iterator_t<_Vp>>> _M_cached_begin;
3738 split_view() requires (default_initializable<_Vp>
3739 && default_initializable<_Pattern>)
3743 split_view(_Vp __base, _Pattern __pattern)
3744 : _M_base(std::move(__base)), _M_pattern(std::move(__pattern))
3747 template<forward_range _Range>
3748 requires constructible_from<_Vp, views::all_t<_Range>>
3749 && constructible_from<_Pattern, single_view<range_value_t<_Range>>>
3751 split_view(_Range&& __r, range_value_t<_Range> __e)
3752 : _M_base(views::all(std::forward<_Range>(__r))),
3753 _M_pattern(views::single(std::move(__e)))
3757 base() const& requires copy_constructible<_Vp>
3762 { return std::move(_M_base); }
3767 if (!_M_cached_begin)
3768 _M_cached_begin = _M_find_next(ranges::begin(_M_base));
3769 return {this, ranges::begin(_M_base), *_M_cached_begin};
3775 if constexpr (common_range<_Vp>)
3776 return _Iterator{this, ranges::end(_M_base), {}};
3778 return _Sentinel{this};
3781 constexpr subrange<iterator_t<_Vp>>
3782 _M_find_next(iterator_t<_Vp> __it)
3784 auto [__b, __e] = ranges::search(subrange(__it, ranges::end(_M_base)), _M_pattern);
3785 if (__b != ranges::end(_M_base) && ranges::empty(_M_pattern))
3797 split_view* _M_parent = nullptr;
3798 iterator_t<_Vp> _M_cur = iterator_t<_Vp>();
3799 subrange<iterator_t<_Vp>> _M_next = subrange<iterator_t<_Vp>>();
3800 bool _M_trailing_empty = false;
3802 friend struct _Sentinel;
3805 using iterator_concept = forward_iterator_tag;
3806 using iterator_category = input_iterator_tag;
3807 using value_type = subrange<iterator_t<_Vp>>;
3808 using difference_type = range_difference_t<_Vp>;
3810 _Iterator() = default;
3813 _Iterator(split_view* __parent,
3814 iterator_t<_Vp> __current,
3815 subrange<iterator_t<_Vp>> __next)
3816 : _M_parent(__parent),
3817 _M_cur(std::move(__current)),
3818 _M_next(std::move(__next))
3821 constexpr iterator_t<_Vp>
3825 constexpr value_type
3827 { return {_M_cur, _M_next.begin()}; }
3829 constexpr _Iterator&
3832 _M_cur = _M_next.begin();
3833 if (_M_cur != ranges::end(_M_parent->_M_base))
3835 _M_cur = _M_next.end();
3836 if (_M_cur == ranges::end(_M_parent->_M_base))
3838 _M_trailing_empty = true;
3839 _M_next = {_M_cur, _M_cur};
3842 _M_next = _M_parent->_M_find_next(_M_cur);
3845 _M_trailing_empty = false;
3857 friend constexpr bool
3858 operator==(const _Iterator& __x, const _Iterator& __y)
3860 return __x._M_cur == __y._M_cur
3861 && __x._M_trailing_empty == __y._M_trailing_empty;
3868 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
3871 _M_equal(const _Iterator& __x) const
3872 { return __x._M_cur == _M_end && !__x._M_trailing_empty; }
3875 _Sentinel() = default;
3878 _Sentinel(split_view* __parent)
3879 : _M_end(ranges::end(__parent->_M_base))
3882 friend constexpr bool
3883 operator==(const _Iterator& __x, const _Sentinel& __y)
3884 { return __y._M_equal(__x); }
3888 template<typename _Range, typename _Pattern>
3889 split_view(_Range&&, _Pattern&&)
3890 -> split_view<views::all_t<_Range>, views::all_t<_Pattern>>;
3892 template<forward_range _Range>
3893 split_view(_Range&&, range_value_t<_Range>)
3894 -> split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
3900 template<typename _Range, typename _Pattern>
3901 concept __can_split_view
3902 = requires { split_view(std::declval<_Range>(), std::declval<_Pattern>()); };
3903 } // namespace __detail
3905 struct _Split : __adaptor::_RangeAdaptor<_Split>
3907 template<viewable_range _Range, typename _Pattern>
3908 requires __detail::__can_split_view<_Range, _Pattern>
3910 operator() [[nodiscard]] (_Range&& __r, _Pattern&& __f) const
3912 return split_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
3915 using _RangeAdaptor<_Split>::operator();
3916 static constexpr int _S_arity = 2;
3917 template<typename _Pattern>
3918 static constexpr bool _S_has_simple_extra_args
3919 = _LazySplit::_S_has_simple_extra_args<_Pattern>;
3922 inline constexpr _Split split;
3923 } // namespace views
3929 template<input_or_output_iterator _Iter>
3931 operator() [[nodiscard]] (_Iter __i, iter_difference_t<_Iter> __n) const
3933 if constexpr (contiguous_iterator<_Iter>)
3934 return span(std::__to_address(__i), __n);
3935 else if constexpr (random_access_iterator<_Iter>)
3936 return subrange(__i, __i + __n);
3938 return subrange(counted_iterator(std::move(__i), __n),
3943 inline constexpr _Counted counted{};
3944 } // namespace views
3947 requires (!common_range<_Vp>) && copyable<iterator_t<_Vp>>
3948 class common_view : public view_interface<common_view<_Vp>>
3951 _Vp _M_base = _Vp();
3954 common_view() requires default_initializable<_Vp> = default;
3957 common_view(_Vp __r)
3958 : _M_base(std::move(__r))
3962 base() const& requires copy_constructible<_Vp>
3967 { return std::move(_M_base); }
3969 // _GLIBCXX_RESOLVE_LIB_DEFECTS
3970 // 4012. common_view::begin/end are missing the simple-view check
3972 begin() requires (!__detail::__simple_view<_Vp>)
3974 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3975 return ranges::begin(_M_base);
3977 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
3978 (ranges::begin(_M_base));
3982 begin() const requires range<const _Vp>
3984 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
3985 return ranges::begin(_M_base);
3987 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
3988 (ranges::begin(_M_base));
3992 end() requires (!__detail::__simple_view<_Vp>)
3994 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3995 return ranges::begin(_M_base) + ranges::size(_M_base);
3997 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
3998 (ranges::end(_M_base));
4002 end() const requires range<const _Vp>
4004 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
4005 return ranges::begin(_M_base) + ranges::size(_M_base);
4007 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
4008 (ranges::end(_M_base));
4012 size() requires sized_range<_Vp>
4013 { return ranges::size(_M_base); }
4016 size() const requires sized_range<const _Vp>
4017 { return ranges::size(_M_base); }
4020 template<typename _Range>
4021 common_view(_Range&&) -> common_view<views::all_t<_Range>>;
4023 template<typename _Tp>
4024 inline constexpr bool enable_borrowed_range<common_view<_Tp>>
4025 = enable_borrowed_range<_Tp>;
4031 template<typename _Range>
4032 concept __already_common = common_range<_Range>
4033 && requires { views::all(std::declval<_Range>()); };
4035 template<typename _Range>
4036 concept __can_common_view
4037 = requires { common_view{std::declval<_Range>()}; };
4038 } // namespace __detail
4040 struct _Common : __adaptor::_RangeAdaptorClosure<_Common>
4042 template<viewable_range _Range>
4043 requires __detail::__already_common<_Range>
4044 || __detail::__can_common_view<_Range>
4046 operator() [[nodiscard]] (_Range&& __r) const
4048 if constexpr (__detail::__already_common<_Range>)
4049 return views::all(std::forward<_Range>(__r));
4051 return common_view{std::forward<_Range>(__r)};
4054 static constexpr bool _S_has_simple_call_op = true;
4057 inline constexpr _Common common;
4058 } // namespace views
4061 requires bidirectional_range<_Vp>
4062 class reverse_view : public view_interface<reverse_view<_Vp>>
4065 static constexpr bool _S_needs_cached_begin
4066 = !common_range<_Vp> && !(random_access_range<_Vp>
4067 && sized_sentinel_for<sentinel_t<_Vp>,
4070 _Vp _M_base = _Vp();
4071 [[no_unique_address]]
4072 __detail::__maybe_present_t<_S_needs_cached_begin,
4073 __detail::_CachedPosition<_Vp>>
4077 reverse_view() requires default_initializable<_Vp> = default;
4080 reverse_view(_Vp __r)
4081 : _M_base(std::move(__r))
4085 base() const& requires copy_constructible<_Vp>
4090 { return std::move(_M_base); }
4092 constexpr reverse_iterator<iterator_t<_Vp>>
4095 if constexpr (_S_needs_cached_begin)
4096 if (_M_cached_begin._M_has_value())
4097 return std::make_reverse_iterator(_M_cached_begin._M_get(_M_base));
4099 auto __it = ranges::next(ranges::begin(_M_base), ranges::end(_M_base));
4100 if constexpr (_S_needs_cached_begin)
4101 _M_cached_begin._M_set(_M_base, __it);
4102 return std::make_reverse_iterator(std::move(__it));
4106 begin() requires common_range<_Vp>
4107 { return std::make_reverse_iterator(ranges::end(_M_base)); }
4110 begin() const requires common_range<const _Vp>
4111 { return std::make_reverse_iterator(ranges::end(_M_base)); }
4113 constexpr reverse_iterator<iterator_t<_Vp>>
4115 { return std::make_reverse_iterator(ranges::begin(_M_base)); }
4118 end() const requires common_range<const _Vp>
4119 { return std::make_reverse_iterator(ranges::begin(_M_base)); }
4122 size() requires sized_range<_Vp>
4123 { return ranges::size(_M_base); }
4126 size() const requires sized_range<const _Vp>
4127 { return ranges::size(_M_base); }
4130 template<typename _Range>
4131 reverse_view(_Range&&) -> reverse_view<views::all_t<_Range>>;
4133 template<typename _Tp>
4134 inline constexpr bool enable_borrowed_range<reverse_view<_Tp>>
4135 = enable_borrowed_range<_Tp>;
4142 inline constexpr bool __is_reversible_subrange = false;
4144 template<typename _Iter, subrange_kind _Kind>
4145 inline constexpr bool
4146 __is_reversible_subrange<subrange<reverse_iterator<_Iter>,
4147 reverse_iterator<_Iter>,
4151 inline constexpr bool __is_reverse_view = false;
4153 template<typename _Vp>
4154 inline constexpr bool __is_reverse_view<reverse_view<_Vp>> = true;
4156 template<typename _Range>
4157 concept __can_reverse_view
4158 = requires { reverse_view{std::declval<_Range>()}; };
4159 } // namespace __detail
4161 struct _Reverse : __adaptor::_RangeAdaptorClosure<_Reverse>
4163 template<viewable_range _Range>
4164 requires __detail::__is_reverse_view<remove_cvref_t<_Range>>
4165 || __detail::__is_reversible_subrange<remove_cvref_t<_Range>>
4166 || __detail::__can_reverse_view<_Range>
4168 operator() [[nodiscard]] (_Range&& __r) const
4170 using _Tp = remove_cvref_t<_Range>;
4171 if constexpr (__detail::__is_reverse_view<_Tp>)
4172 return std::forward<_Range>(__r).base();
4173 else if constexpr (__detail::__is_reversible_subrange<_Tp>)
4175 using _Iter = decltype(ranges::begin(__r).base());
4176 if constexpr (sized_range<_Tp>)
4177 return subrange<_Iter, _Iter, subrange_kind::sized>
4178 {__r.end().base(), __r.begin().base(), __r.size()};
4180 return subrange<_Iter, _Iter, subrange_kind::unsized>
4181 {__r.end().base(), __r.begin().base()};
4184 return reverse_view{std::forward<_Range>(__r)};
4187 static constexpr bool _S_has_simple_call_op = true;
4190 inline constexpr _Reverse reverse;
4191 } // namespace views
4195#if __cpp_lib_tuple_like // >= C++23
4196 template<typename _Tp, size_t _Nm>
4197 concept __has_tuple_element = __tuple_like<_Tp> && _Nm < tuple_size_v<_Tp>;
4199 template<typename _Tp, size_t _Nm>
4200 concept __has_tuple_element = requires(_Tp __t)
4202 typename tuple_size<_Tp>::type;
4203 requires _Nm < tuple_size_v<_Tp>;
4204 typename tuple_element_t<_Nm, _Tp>;
4205 { std::get<_Nm>(__t) }
4206 -> convertible_to<const tuple_element_t<_Nm, _Tp>&>;
4210 template<typename _Tp, size_t _Nm>
4211 concept __returnable_element
4212 = is_reference_v<_Tp> || move_constructible<tuple_element_t<_Nm, _Tp>>;
4215 template<input_range _Vp, size_t _Nm>
4217 && __detail::__has_tuple_element<range_value_t<_Vp>, _Nm>
4218 && __detail::__has_tuple_element<remove_reference_t<range_reference_t<_Vp>>,
4220 && __detail::__returnable_element<range_reference_t<_Vp>, _Nm>
4221 class elements_view : public view_interface<elements_view<_Vp, _Nm>>
4224 elements_view() requires default_initializable<_Vp> = default;
4227 elements_view(_Vp __base)
4228 : _M_base(std::move(__base))
4232 base() const& requires copy_constructible<_Vp>
4237 { return std::move(_M_base); }
4240 begin() requires (!__detail::__simple_view<_Vp>)
4241 { return _Iterator<false>(ranges::begin(_M_base)); }
4244 begin() const requires range<const _Vp>
4245 { return _Iterator<true>(ranges::begin(_M_base)); }
4248 end() requires (!__detail::__simple_view<_Vp> && !common_range<_Vp>)
4249 { return _Sentinel<false>{ranges::end(_M_base)}; }
4252 end() requires (!__detail::__simple_view<_Vp> && common_range<_Vp>)
4253 { return _Iterator<false>{ranges::end(_M_base)}; }
4256 end() const requires range<const _Vp>
4257 { return _Sentinel<true>{ranges::end(_M_base)}; }
4260 end() const requires common_range<const _Vp>
4261 { return _Iterator<true>{ranges::end(_M_base)}; }
4264 size() requires sized_range<_Vp>
4265 { return ranges::size(_M_base); }
4268 size() const requires sized_range<const _Vp>
4269 { return ranges::size(_M_base); }
4272 template<bool _Const>
4273 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
4275 template<bool _Const>
4279 template<bool _Const>
4280 requires forward_range<_Base<_Const>>
4281 struct __iter_cat<_Const>
4284 static auto _S_iter_cat()
4286 using _Base = elements_view::_Base<_Const>;
4287 using _Cat = typename iterator_traits<iterator_t<_Base>>::iterator_category;
4288 using _Res = decltype((std::get<_Nm>(*std::declval<iterator_t<_Base>>())));
4289 if constexpr (!is_lvalue_reference_v<_Res>)
4290 return input_iterator_tag{};
4291 else if constexpr (derived_from<_Cat, random_access_iterator_tag>)
4292 return random_access_iterator_tag{};
4297 using iterator_category = decltype(_S_iter_cat());
4300 template<bool _Const>
4303 template<bool _Const>
4304 struct _Iterator : __iter_cat<_Const>
4307 using _Base = elements_view::_Base<_Const>;
4309 iterator_t<_Base> _M_current = iterator_t<_Base>();
4311 static constexpr decltype(auto)
4312 _S_get_element(const iterator_t<_Base>& __i)
4314 if constexpr (is_reference_v<range_reference_t<_Base>>)
4315 return std::get<_Nm>(*__i);
4318 using _Et = remove_cv_t<tuple_element_t<_Nm, range_reference_t<_Base>>>;
4319 return static_cast<_Et>(std::get<_Nm>(*__i));
4326 if constexpr (random_access_range<_Base>)
4327 return random_access_iterator_tag{};
4328 else if constexpr (bidirectional_range<_Base>)
4329 return bidirectional_iterator_tag{};
4330 else if constexpr (forward_range<_Base>)
4331 return forward_iterator_tag{};
4333 return input_iterator_tag{};
4336 friend _Iterator<!_Const>;
4339 using iterator_concept = decltype(_S_iter_concept());
4340 // iterator_category defined in elements_view::__iter_cat
4342 = remove_cvref_t<tuple_element_t<_Nm, range_value_t<_Base>>>;
4343 using difference_type = range_difference_t<_Base>;
4345 _Iterator() requires default_initializable<iterator_t<_Base>> = default;
4348 _Iterator(iterator_t<_Base> __current)
4349 : _M_current(std::move(__current))
4353 _Iterator(_Iterator<!_Const> __i)
4354 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
4355 : _M_current(std::move(__i._M_current))
4358 constexpr const iterator_t<_Base>&
4359 base() const& noexcept
4360 { return _M_current; }
4362 constexpr iterator_t<_Base>
4364 { return std::move(_M_current); }
4366 constexpr decltype(auto)
4368 { return _S_get_element(_M_current); }
4370 constexpr _Iterator&
4382 operator++(int) requires forward_range<_Base>
4389 constexpr _Iterator&
4390 operator--() requires bidirectional_range<_Base>
4397 operator--(int) requires bidirectional_range<_Base>
4404 constexpr _Iterator&
4405 operator+=(difference_type __n)
4406 requires random_access_range<_Base>
4412 constexpr _Iterator&
4413 operator-=(difference_type __n)
4414 requires random_access_range<_Base>
4420 constexpr decltype(auto)
4421 operator[](difference_type __n) const
4422 requires random_access_range<_Base>
4423 { return _S_get_element(_M_current + __n); }
4425 friend constexpr bool
4426 operator==(const _Iterator& __x, const _Iterator& __y)
4427 requires equality_comparable<iterator_t<_Base>>
4428 { return __x._M_current == __y._M_current; }
4430 friend constexpr bool
4431 operator<(const _Iterator& __x, const _Iterator& __y)
4432 requires random_access_range<_Base>
4433 { return __x._M_current < __y._M_current; }
4435 friend constexpr bool
4436 operator>(const _Iterator& __x, const _Iterator& __y)
4437 requires random_access_range<_Base>
4438 { return __y._M_current < __x._M_current; }
4440 friend constexpr bool
4441 operator<=(const _Iterator& __x, const _Iterator& __y)
4442 requires random_access_range<_Base>
4443 { return !(__y._M_current > __x._M_current); }
4445 friend constexpr bool
4446 operator>=(const _Iterator& __x, const _Iterator& __y)
4447 requires random_access_range<_Base>
4448 { return !(__x._M_current > __y._M_current); }
4450#ifdef __cpp_lib_three_way_comparison
4451 friend constexpr auto
4452 operator<=>(const _Iterator& __x, const _Iterator& __y)
4453 requires random_access_range<_Base>
4454 && three_way_comparable<iterator_t<_Base>>
4455 { return __x._M_current <=> __y._M_current; }
4458 friend constexpr _Iterator
4459 operator+(const _Iterator& __x, difference_type __y)
4460 requires random_access_range<_Base>
4461 { return _Iterator{__x} += __y; }
4463 friend constexpr _Iterator
4464 operator+(difference_type __x, const _Iterator& __y)
4465 requires random_access_range<_Base>
4466 { return __y + __x; }
4468 friend constexpr _Iterator
4469 operator-(const _Iterator& __x, difference_type __y)
4470 requires random_access_range<_Base>
4471 { return _Iterator{__x} -= __y; }
4473 // _GLIBCXX_RESOLVE_LIB_DEFECTS
4474 // 3483. transform_view::iterator's difference is overconstrained
4475 friend constexpr difference_type
4476 operator-(const _Iterator& __x, const _Iterator& __y)
4477 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
4478 { return __x._M_current - __y._M_current; }
4480 template <bool> friend struct _Sentinel;
4483 template<bool _Const>
4487 template<bool _Const2>
4489 _M_equal(const _Iterator<_Const2>& __x) const
4490 { return __x._M_current == _M_end; }
4492 template<bool _Const2>
4494 _M_distance_from(const _Iterator<_Const2>& __i) const
4495 { return _M_end - __i._M_current; }
4497 using _Base = elements_view::_Base<_Const>;
4498 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
4501 _Sentinel() = default;
4504 _Sentinel(sentinel_t<_Base> __end)
4505 : _M_end(std::move(__end))
4509 _Sentinel(_Sentinel<!_Const> __other)
4511 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
4512 : _M_end(std::move(__other._M_end))
4515 constexpr sentinel_t<_Base>
4519 template<bool _Const2>
4520 requires sentinel_for<sentinel_t<_Base>,
4521 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
4522 friend constexpr bool
4523 operator==(const _Iterator<_Const2>& __x, const _Sentinel& __y)
4524 { return __y._M_equal(__x); }
4526 template<bool _Const2,
4527 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
4528 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
4529 friend constexpr range_difference_t<_Base2>
4530 operator-(const _Iterator<_Const2>& __x, const _Sentinel& __y)
4531 { return -__y._M_distance_from(__x); }
4533 template<bool _Const2,
4534 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
4535 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
4536 friend constexpr range_difference_t<_Base2>
4537 operator-(const _Sentinel& __x, const _Iterator<_Const2>& __y)
4538 { return __x._M_distance_from(__y); }
4540 friend _Sentinel<!_Const>;
4543 _Vp _M_base = _Vp();
4546 template<typename _Tp, size_t _Nm>
4547 inline constexpr bool enable_borrowed_range<elements_view<_Tp, _Nm>>
4548 = enable_borrowed_range<_Tp>;
4550 // _GLIBCXX_RESOLVE_LIB_DEFECTS
4551 // 3563. keys_view example is broken
4552 template<typename _Range>
4553 using keys_view = elements_view<_Range, 0>;
4555 template<typename _Range>
4556 using values_view = elements_view<_Range, 1>;
4562 template<size_t _Nm, typename _Range>
4563 concept __can_elements_view
4564 = requires { elements_view<all_t<_Range>, _Nm>{std::declval<_Range>()}; };
4565 } // namespace __detail
4567 template<size_t _Nm>
4568 struct _Elements : __adaptor::_RangeAdaptorClosure<_Elements<_Nm>>
4570 template<viewable_range _Range>
4571 requires __detail::__can_elements_view<_Nm, _Range>
4573 operator() [[nodiscard]] (_Range&& __r) const
4575 return elements_view<all_t<_Range>, _Nm>{std::forward<_Range>(__r)};
4578 static constexpr bool _S_has_simple_call_op = true;
4581 template<size_t _Nm>
4582 inline constexpr _Elements<_Nm> elements;
4583 inline constexpr auto keys = elements<0>;
4584 inline constexpr auto values = elements<1>;
4585 } // namespace views
4587#ifdef __cpp_lib_ranges_zip // C++ >= 23
4590 template<typename... _Rs>
4591 concept __zip_is_common = (sizeof...(_Rs) == 1 && (common_range<_Rs> && ...))
4592 || (!(bidirectional_range<_Rs> && ...) && (common_range<_Rs> && ...))
4593 || ((random_access_range<_Rs> && ...) && (sized_range<_Rs> && ...));
4595 template<typename _Fp, typename _Tuple>
4597 __tuple_transform(_Fp&& __f, _Tuple&& __tuple)
4599 return std::apply([&]<typename... _Ts>(_Ts&&... __elts) {
4600 return tuple<invoke_result_t<_Fp&, _Ts>...>
4601 (std::__invoke(__f, std::forward<_Ts>(__elts))...);
4602 }, std::forward<_Tuple>(__tuple));
4605 template<typename _Fp, typename _Tuple>
4607 __tuple_for_each(_Fp&& __f, _Tuple&& __tuple)
4609 std::apply([&]<typename... _Ts>(_Ts&&... __elts) {
4610 (std::__invoke(__f, std::forward<_Ts>(__elts)), ...);
4611 }, std::forward<_Tuple>(__tuple));
4613 } // namespace __detail
4615 template<input_range... _Vs>
4616 requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0)
4617 class zip_view : public view_interface<zip_view<_Vs...>>
4619 tuple<_Vs...> _M_views;
4621 template<bool> class _Iterator;
4622 template<bool> class _Sentinel;
4625 zip_view() = default;
4628 zip_view(_Vs... __views)
4629 : _M_views(std::move(__views)...)
4633 begin() requires (!(__detail::__simple_view<_Vs> && ...))
4634 { return _Iterator<false>(__detail::__tuple_transform(ranges::begin, _M_views)); }
4637 begin() const requires (range<const _Vs> && ...)
4638 { return _Iterator<true>(__detail::__tuple_transform(ranges::begin, _M_views)); }
4641 end() requires (!(__detail::__simple_view<_Vs> && ...))
4643 if constexpr (!__detail::__zip_is_common<_Vs...>)
4644 return _Sentinel<false>(__detail::__tuple_transform(ranges::end, _M_views));
4645 else if constexpr ((random_access_range<_Vs> && ...))
4646 return begin() + iter_difference_t<_Iterator<false>>(size());
4648 return _Iterator<false>(__detail::__tuple_transform(ranges::end, _M_views));
4652 end() const requires (range<const _Vs> && ...)
4654 if constexpr (!__detail::__zip_is_common<const _Vs...>)
4655 return _Sentinel<true>(__detail::__tuple_transform(ranges::end, _M_views));
4656 else if constexpr ((random_access_range<const _Vs> && ...))
4657 return begin() + iter_difference_t<_Iterator<true>>(size());
4659 return _Iterator<true>(__detail::__tuple_transform(ranges::end, _M_views));
4663 size() requires (sized_range<_Vs> && ...)
4665 return std::apply([](auto... sizes) {
4666 using _CT = __detail::__make_unsigned_like_t<common_type_t<decltype(sizes)...>>;
4667 return ranges::min({_CT(sizes)...});
4668 }, __detail::__tuple_transform(ranges::size, _M_views));
4672 size() const requires (sized_range<const _Vs> && ...)
4674 return std::apply([](auto... sizes) {
4675 using _CT = __detail::__make_unsigned_like_t<common_type_t<decltype(sizes)...>>;
4676 return ranges::min({_CT(sizes)...});
4677 }, __detail::__tuple_transform(ranges::size, _M_views));
4681 template<typename... _Rs>
4682 zip_view(_Rs&&...) -> zip_view<views::all_t<_Rs>...>;
4684 template<typename... _Views>
4685 inline constexpr bool enable_borrowed_range<zip_view<_Views...>>
4686 = (enable_borrowed_range<_Views> && ...);
4690 template<bool _Const, typename... _Vs>
4691 concept __all_random_access
4692 = (random_access_range<__maybe_const_t<_Const, _Vs>> && ...);
4694 template<bool _Const, typename... _Vs>
4695 concept __all_bidirectional
4696 = (bidirectional_range<__maybe_const_t<_Const, _Vs>> && ...);
4698 template<bool _Const, typename... _Vs>
4699 concept __all_forward
4700 = (forward_range<__maybe_const_t<_Const, _Vs>> && ...);
4702 template<bool _Const, typename... _Views>
4703 struct __zip_view_iter_cat
4706 template<bool _Const, typename... _Views>
4707 requires __all_forward<_Const, _Views...>
4708 struct __zip_view_iter_cat<_Const, _Views...>
4709 { using iterator_category = input_iterator_tag; };
4710 } // namespace __detail
4712 template<input_range... _Vs>
4713 requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0)
4714 template<bool _Const>
4715 class zip_view<_Vs...>::_Iterator
4716 : public __detail::__zip_view_iter_cat<_Const, _Vs...>
4718#ifdef __clang__ // LLVM-61763 workaround
4721 tuple<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>...> _M_current;
4724 _Iterator(decltype(_M_current) __current)
4725 : _M_current(std::move(__current))
4731 if constexpr (__detail::__all_random_access<_Const, _Vs...>)
4732 return random_access_iterator_tag{};
4733 else if constexpr (__detail::__all_bidirectional<_Const, _Vs...>)
4734 return bidirectional_iterator_tag{};
4735 else if constexpr (__detail::__all_forward<_Const, _Vs...>)
4736 return forward_iterator_tag{};
4738 return input_iterator_tag{};
4741#ifndef __clang__ // LLVM-61763 workaround
4742 template<move_constructible _Fp, input_range... _Ws>
4743 requires (view<_Ws> && ...) && (sizeof...(_Ws) > 0) && is_object_v<_Fp>
4744 && regular_invocable<_Fp&, range_reference_t<_Ws>...>
4745 && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Ws>...>>
4746 friend class zip_transform_view;
4750 // iterator_category defined in __zip_view_iter_cat
4751 using iterator_concept = decltype(_S_iter_concept());
4753 = tuple<range_value_t<__detail::__maybe_const_t<_Const, _Vs>>...>;
4754 using difference_type
4755 = common_type_t<range_difference_t<__detail::__maybe_const_t<_Const, _Vs>>...>;
4757 _Iterator() = default;
4760 _Iterator(_Iterator<!_Const> __i)
4762 && (convertible_to<iterator_t<_Vs>,
4763 iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4764 : _M_current(std::move(__i._M_current))
4770 auto __f = [](auto& __i) -> decltype(auto) {
4773 return __detail::__tuple_transform(__f, _M_current);
4776 constexpr _Iterator&
4779 __detail::__tuple_for_each([](auto& __i) { ++__i; }, _M_current);
4789 requires __detail::__all_forward<_Const, _Vs...>
4796 constexpr _Iterator&
4798 requires __detail::__all_bidirectional<_Const, _Vs...>
4800 __detail::__tuple_for_each([](auto& __i) { --__i; }, _M_current);
4806 requires __detail::__all_bidirectional<_Const, _Vs...>
4813 constexpr _Iterator&
4814 operator+=(difference_type __x)
4815 requires __detail::__all_random_access<_Const, _Vs...>
4817 auto __f = [&]<typename _It>(_It& __i) {
4818 __i += iter_difference_t<_It>(__x);
4820 __detail::__tuple_for_each(__f, _M_current);
4824 constexpr _Iterator&
4825 operator-=(difference_type __x)
4826 requires __detail::__all_random_access<_Const, _Vs...>
4828 auto __f = [&]<typename _It>(_It& __i) {
4829 __i -= iter_difference_t<_It>(__x);
4831 __detail::__tuple_for_each(__f, _M_current);
4836 operator[](difference_type __n) const
4837 requires __detail::__all_random_access<_Const, _Vs...>
4839 auto __f = [&]<typename _It>(_It& __i) -> decltype(auto) {
4840 return __i[iter_difference_t<_It>(__n)];
4842 return __detail::__tuple_transform(__f, _M_current);
4845 friend constexpr bool
4846 operator==(const _Iterator& __x, const _Iterator& __y)
4847 requires (equality_comparable<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4849 if constexpr (__detail::__all_bidirectional<_Const, _Vs...>)
4850 return __x._M_current == __y._M_current;
4852 return [&]<size_t... _Is>(index_sequence<_Is...>) {
4853 return ((std::get<_Is>(__x._M_current) == std::get<_Is>(__y._M_current)) || ...);
4854 }(make_index_sequence<sizeof...(_Vs)>{});
4857 friend constexpr auto
4858 operator<=>(const _Iterator& __x, const _Iterator& __y)
4859 requires __detail::__all_random_access<_Const, _Vs...>
4860 { return __x._M_current <=> __y._M_current; }
4862 friend constexpr _Iterator
4863 operator+(const _Iterator& __i, difference_type __n)
4864 requires __detail::__all_random_access<_Const, _Vs...>
4871 friend constexpr _Iterator
4872 operator+(difference_type __n, const _Iterator& __i)
4873 requires __detail::__all_random_access<_Const, _Vs...>
4880 friend constexpr _Iterator
4881 operator-(const _Iterator& __i, difference_type __n)
4882 requires __detail::__all_random_access<_Const, _Vs...>
4889 friend constexpr difference_type
4890 operator-(const _Iterator& __x, const _Iterator& __y)
4891 requires (sized_sentinel_for<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>,
4892 iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4894 return [&]<size_t... _Is>(index_sequence<_Is...>) {
4895 return ranges::min({difference_type(std::get<_Is>(__x._M_current)
4896 - std::get<_Is>(__y._M_current))...},
4898 [](difference_type __i) {
4899 return __detail::__to_unsigned_like(__i < 0 ? -__i : __i);
4901 }(make_index_sequence<sizeof...(_Vs)>{});
4904 friend constexpr auto
4905 iter_move(const _Iterator& __i)
4906 { return __detail::__tuple_transform(ranges::iter_move, __i._M_current); }
4908 friend constexpr void
4909 iter_swap(const _Iterator& __l, const _Iterator& __r)
4910 requires (indirectly_swappable<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4912 [&]<size_t... _Is>(index_sequence<_Is...>) {
4913 (ranges::iter_swap(std::get<_Is>(__l._M_current), std::get<_Is>(__r._M_current)), ...);
4914 }(make_index_sequence<sizeof...(_Vs)>{});
4917 friend class zip_view;
4920 template<input_range... _Vs>
4921 requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0)
4922 template<bool _Const>
4923 class zip_view<_Vs...>::_Sentinel
4925 tuple<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>...> _M_end;
4928 _Sentinel(decltype(_M_end) __end)
4932 friend class zip_view;
4935 _Sentinel() = default;
4938 _Sentinel(_Sentinel<!_Const> __i)
4940 && (convertible_to<sentinel_t<_Vs>,
4941 sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4942 : _M_end(std::move(__i._M_end))
4945 template<bool _OtherConst>
4946 requires (sentinel_for<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>,
4947 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vs>>> && ...)
4948 friend constexpr bool
4949 operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
4951 return [&]<size_t... _Is>(index_sequence<_Is...>) {
4952 return ((std::get<_Is>(__x._M_current) == std::get<_Is>(__y._M_end)) || ...);
4953 }(make_index_sequence<sizeof...(_Vs)>{});
4956 template<bool _OtherConst>
4957 requires (sized_sentinel_for<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>,
4958 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vs>>> && ...)
4959 friend constexpr auto
4960 operator-(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
4963 = common_type_t<range_difference_t<__detail::__maybe_const_t<_OtherConst, _Vs>>...>;
4964 return [&]<size_t... _Is>(index_sequence<_Is...>) {
4965 return ranges::min({_Ret(std::get<_Is>(__x._M_current) - std::get<_Is>(__y._M_end))...},
4968 return __detail::__to_unsigned_like(__i < 0 ? -__i : __i);
4970 }(make_index_sequence<sizeof...(_Vs)>{});
4973 template<bool _OtherConst>
4974 requires (sized_sentinel_for<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>,
4975 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vs>>> && ...)
4976 friend constexpr auto
4977 operator-(const _Sentinel& __y, const _Iterator<_OtherConst>& __x)
4978 { return -(__x - __y); }
4985 template<typename... _Ts>
4986 concept __can_zip_view
4987 = requires { zip_view<all_t<_Ts>...>(std::declval<_Ts>()...); };
4992 template<typename... _Ts>
4993 requires (sizeof...(_Ts) == 0 || __detail::__can_zip_view<_Ts...>)
4995 operator() [[nodiscard]] (_Ts&&... __ts) const
4997 if constexpr (sizeof...(_Ts) == 0)
4998 return views::empty<tuple<>>;
5000 return zip_view<all_t<_Ts>...>(std::forward<_Ts>(__ts)...);
5004 inline constexpr _Zip zip;
5009 template<typename _Range, bool _Const>
5010 using __range_iter_cat
5011 = typename iterator_traits<iterator_t<__maybe_const_t<_Const, _Range>>>::iterator_category;
5014 template<move_constructible _Fp, input_range... _Vs>
5015 requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0) && is_object_v<_Fp>
5016 && regular_invocable<_Fp&, range_reference_t<_Vs>...>
5017 && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Vs>...>>
5018 class zip_transform_view : public view_interface<zip_transform_view<_Fp, _Vs...>>
5020 [[no_unique_address]] __detail::__box<_Fp> _M_fun;
5021 zip_view<_Vs...> _M_zip;
5023 using _InnerView = zip_view<_Vs...>;
5025 template<bool _Const>
5026 using __ziperator = iterator_t<__detail::__maybe_const_t<_Const, _InnerView>>;
5028 template<bool _Const>
5029 using __zentinel = sentinel_t<__detail::__maybe_const_t<_Const, _InnerView>>;
5031 template<bool _Const>
5032 using _Base = __detail::__maybe_const_t<_Const, _InnerView>;
5034 template<bool _Const>
5038 template<bool _Const>
5039 requires forward_range<_Base<_Const>>
5040 struct __iter_cat<_Const>
5046 using __detail::__maybe_const_t;
5047 using __detail::__range_iter_cat;
5048 using _Res = invoke_result_t<__maybe_const_t<_Const, _Fp>&,
5049 range_reference_t<__maybe_const_t<_Const, _Vs>>...>;
5050 // _GLIBCXX_RESOLVE_LIB_DEFECTS
5051 // 3798. Rvalue reference and iterator_category
5052 if constexpr (!is_reference_v<_Res>)
5053 return input_iterator_tag{};
5054 else if constexpr ((derived_from<__range_iter_cat<_Vs, _Const>,
5055 random_access_iterator_tag> && ...))
5056 return random_access_iterator_tag{};
5057 else if constexpr ((derived_from<__range_iter_cat<_Vs, _Const>,
5058 bidirectional_iterator_tag> && ...))
5059 return bidirectional_iterator_tag{};
5060 else if constexpr ((derived_from<__range_iter_cat<_Vs, _Const>,
5061 forward_iterator_tag> && ...))
5062 return forward_iterator_tag{};
5064 return input_iterator_tag{};
5067 using iterator_category = decltype(_S_iter_cat());
5070 template<bool> class _Iterator;
5071 template<bool> class _Sentinel;
5074 zip_transform_view() = default;
5077 zip_transform_view(_Fp __fun, _Vs... __views)
5078 : _M_fun(std::move(__fun)), _M_zip(std::move(__views)...)
5083 { return _Iterator<false>(*this, _M_zip.begin()); }
5087 requires range<const _InnerView>
5088 && regular_invocable<const _Fp&, range_reference_t<const _Vs>...>
5089 { return _Iterator<true>(*this, _M_zip.begin()); }
5094 if constexpr (common_range<_InnerView>)
5095 return _Iterator<false>(*this, _M_zip.end());
5097 return _Sentinel<false>(_M_zip.end());
5102 requires range<const _InnerView>
5103 && regular_invocable<const _Fp&, range_reference_t<const _Vs>...>
5105 if constexpr (common_range<const _InnerView>)
5106 return _Iterator<true>(*this, _M_zip.end());
5108 return _Sentinel<true>(_M_zip.end());
5112 size() requires sized_range<_InnerView>
5113 { return _M_zip.size(); }
5116 size() const requires sized_range<const _InnerView>
5117 { return _M_zip.size(); }
5120 template<class _Fp, class... Rs>
5121 zip_transform_view(_Fp, Rs&&...) -> zip_transform_view<_Fp, views::all_t<Rs>...>;
5123 template<move_constructible _Fp, input_range... _Vs>
5124 requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0) && is_object_v<_Fp>
5125 && regular_invocable<_Fp&, range_reference_t<_Vs>...>
5126 && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Vs>...>>
5127 template<bool _Const>
5128 class zip_transform_view<_Fp, _Vs...>::_Iterator : public __iter_cat<_Const>
5130 using _Parent = __detail::__maybe_const_t<_Const, zip_transform_view>;
5132 _Parent* _M_parent = nullptr;
5133 __ziperator<_Const> _M_inner;
5136 _Iterator(_Parent& __parent, __ziperator<_Const> __inner)
5137 : _M_parent(std::__addressof(__parent)), _M_inner(std::move(__inner))
5140 friend class zip_transform_view;
5143 // iterator_category defined in zip_transform_view::__iter_cat
5144 using iterator_concept = typename __ziperator<_Const>::iterator_concept;
5146 = remove_cvref_t<invoke_result_t<__detail::__maybe_const_t<_Const, _Fp>&,
5147 range_reference_t<__detail::__maybe_const_t<_Const, _Vs>>...>>;
5148 using difference_type = range_difference_t<_Base<_Const>>;
5150 _Iterator() = default;
5153 _Iterator(_Iterator<!_Const> __i)
5154 requires _Const && convertible_to<__ziperator<false>, __ziperator<_Const>>
5155 : _M_parent(__i._M_parent), _M_inner(std::move(__i._M_inner))
5158 constexpr decltype(auto)
5161 return std::apply([&](const auto&... __iters) -> decltype(auto) {
5162 return std::__invoke(*_M_parent->_M_fun, *__iters...);
5163 }, _M_inner._M_current);
5166 constexpr _Iterator&
5178 operator++(int) requires forward_range<_Base<_Const>>
5185 constexpr _Iterator&
5186 operator--() requires bidirectional_range<_Base<_Const>>
5193 operator--(int) requires bidirectional_range<_Base<_Const>>
5200 constexpr _Iterator&
5201 operator+=(difference_type __x) requires random_access_range<_Base<_Const>>
5207 constexpr _Iterator&
5208 operator-=(difference_type __x) requires random_access_range<_Base<_Const>>
5214 constexpr decltype(auto)
5215 operator[](difference_type __n) const requires random_access_range<_Base<_Const>>
5217 return std::apply([&]<typename... _Is>(const _Is&... __iters) -> decltype(auto) {
5218 return std::__invoke(*_M_parent->_M_fun, __iters[iter_difference_t<_Is>(__n)]...);
5219 }, _M_inner._M_current);
5222 friend constexpr bool
5223 operator==(const _Iterator& __x, const _Iterator& __y)
5224 requires equality_comparable<__ziperator<_Const>>
5225 { return __x._M_inner == __y._M_inner; }
5227 friend constexpr auto
5228 operator<=>(const _Iterator& __x, const _Iterator& __y)
5229 requires random_access_range<_Base<_Const>>
5230 { return __x._M_inner <=> __y._M_inner; }
5232 friend constexpr _Iterator
5233 operator+(const _Iterator& __i, difference_type __n)
5234 requires random_access_range<_Base<_Const>>
5235 { return _Iterator(*__i._M_parent, __i._M_inner + __n); }
5237 friend constexpr _Iterator
5238 operator+(difference_type __n, const _Iterator& __i)
5239 requires random_access_range<_Base<_Const>>
5240 { return _Iterator(*__i._M_parent, __i._M_inner + __n); }
5242 friend constexpr _Iterator
5243 operator-(const _Iterator& __i, difference_type __n)
5244 requires random_access_range<_Base<_Const>>
5245 { return _Iterator(*__i._M_parent, __i._M_inner - __n); }
5247 friend constexpr difference_type
5248 operator-(const _Iterator& __x, const _Iterator& __y)
5249 requires sized_sentinel_for<__ziperator<_Const>, __ziperator<_Const>>
5250 { return __x._M_inner - __y._M_inner; }
5253 template<move_constructible _Fp, input_range... _Vs>
5254 requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0) && is_object_v<_Fp>
5255 && regular_invocable<_Fp&, range_reference_t<_Vs>...>
5256 && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Vs>...>>
5257 template<bool _Const>
5258 class zip_transform_view<_Fp, _Vs...>::_Sentinel
5260 __zentinel<_Const> _M_inner;
5263 _Sentinel(__zentinel<_Const> __inner)
5267 friend class zip_transform_view;
5270 _Sentinel() = default;
5273 _Sentinel(_Sentinel<!_Const> __i)
5274 requires _Const && convertible_to<__zentinel<false>, __zentinel<_Const>>
5275 : _M_inner(std::move(__i._M_inner))
5278 template<bool _OtherConst>
5279 requires sentinel_for<__zentinel<_Const>, __ziperator<_OtherConst>>
5280 friend constexpr bool
5281 operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
5282 { return __x._M_inner == __y._M_inner; }
5284 template<bool _OtherConst>
5285 requires sized_sentinel_for<__zentinel<_Const>, __ziperator<_OtherConst>>
5286 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
5287 operator-(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
5288 { return __x._M_inner - __y._M_inner; }
5290 template<bool _OtherConst>
5291 requires sized_sentinel_for<__zentinel<_Const>, __ziperator<_OtherConst>>
5292 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
5293 operator-(const _Sentinel& __x, const _Iterator<_OtherConst>& __y)
5294 { return __x._M_inner - __y._M_inner; }
5301 template<typename _Fp, typename... _Ts>
5302 concept __can_zip_transform_view
5303 = requires { zip_transform_view(std::declval<_Fp>(), std::declval<_Ts>()...); };
5306 struct _ZipTransform
5308 template<typename _Fp, typename... _Ts>
5309 requires (sizeof...(_Ts) == 0) || __detail::__can_zip_transform_view<_Fp, _Ts...>
5311 operator() [[nodiscard]] (_Fp&& __f, _Ts&&... __ts) const
5313 if constexpr (sizeof...(_Ts) == 0)
5314 return views::empty<decay_t<invoke_result_t<decay_t<_Fp>&>>>;
5316 return zip_transform_view(std::forward<_Fp>(__f), std::forward<_Ts>(__ts)...);
5320 inline constexpr _ZipTransform zip_transform;
5323 template<forward_range _Vp, size_t _Nm>
5324 requires view<_Vp> && (_Nm > 0)
5325 class adjacent_view : public view_interface<adjacent_view<_Vp, _Nm>>
5327 _Vp _M_base = _Vp();
5329 template<bool> class _Iterator;
5330 template<bool> class _Sentinel;
5332 struct __as_sentinel
5336 adjacent_view() requires default_initializable<_Vp> = default;
5339 adjacent_view(_Vp __base)
5340 : _M_base(std::move(__base))
5343 // _GLIBCXX_RESOLVE_LIB_DEFECTS
5344 // 3848. adjacent_view, adjacent_transform_view and slide_view missing base accessor
5346 base() const & requires copy_constructible<_Vp>
5351 { return std::move(_M_base); }
5354 begin() requires (!__detail::__simple_view<_Vp>)
5355 { return _Iterator<false>(ranges::begin(_M_base), ranges::end(_M_base)); }
5358 begin() const requires range<const _Vp>
5359 { return _Iterator<true>(ranges::begin(_M_base), ranges::end(_M_base)); }
5362 end() requires (!__detail::__simple_view<_Vp>)
5364 if constexpr (common_range<_Vp>)
5365 return _Iterator<false>(__as_sentinel{}, ranges::begin(_M_base), ranges::end(_M_base));
5367 return _Sentinel<false>(ranges::end(_M_base));
5371 end() const requires range<const _Vp>
5373 if constexpr (common_range<const _Vp>)
5374 return _Iterator<true>(__as_sentinel{}, ranges::begin(_M_base), ranges::end(_M_base));
5376 return _Sentinel<true>(ranges::end(_M_base));
5380 size() requires sized_range<_Vp>
5382 using _ST = decltype(ranges::size(_M_base));
5383 using _CT = common_type_t<_ST, size_t>;
5384 auto __sz = static_cast<_CT>(ranges::size(_M_base));
5385 __sz -= std::min<_CT>(__sz, _Nm - 1);
5386 return static_cast<_ST>(__sz);
5390 size() const requires sized_range<const _Vp>
5392 using _ST = decltype(ranges::size(_M_base));
5393 using _CT = common_type_t<_ST, size_t>;
5394 auto __sz = static_cast<_CT>(ranges::size(_M_base));
5395 __sz -= std::min<_CT>(__sz, _Nm - 1);
5396 return static_cast<_ST>(__sz);
5400 template<typename _Vp, size_t _Nm>
5401 inline constexpr bool enable_borrowed_range<adjacent_view<_Vp, _Nm>>
5402 = enable_borrowed_range<_Vp>;
5406 // Yields tuple<_Tp, ..., _Tp> with _Nm elements.
5407 template<typename _Tp, size_t _Nm>
5408 using __repeated_tuple = decltype(std::tuple_cat(std::declval<array<_Tp, _Nm>>()));
5410 // For a functor F that is callable with N arguments, the expression
5411 // declval<__unarize<F, N>>(x) is equivalent to declval<F>(x, ..., x).
5412 template<typename _Fp, size_t _Nm>
5415 template<typename... _Ts>
5416 static invoke_result_t<_Fp, _Ts...>
5417 __tuple_apply(const tuple<_Ts...>&); // not defined
5419 template<typename _Tp>
5420 decltype(__tuple_apply(std::declval<__repeated_tuple<_Tp, _Nm>>()))
5421 operator()(_Tp&&); // not defined
5425 template<forward_range _Vp, size_t _Nm>
5426 requires view<_Vp> && (_Nm > 0)
5427 template<bool _Const>
5428 class adjacent_view<_Vp, _Nm>::_Iterator
5430#ifdef __clang__ // LLVM-61763 workaround
5433 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
5434 array<iterator_t<_Base>, _Nm> _M_current = array<iterator_t<_Base>, _Nm>();
5437 _Iterator(iterator_t<_Base> __first, sentinel_t<_Base> __last)
5439 for (auto& __i : _M_current)
5442 ranges::advance(__first, 1, __last);
5447 _Iterator(__as_sentinel, iterator_t<_Base> __first, iterator_t<_Base> __last)
5449 if constexpr (!bidirectional_range<_Base>)
5450 for (auto& __it : _M_current)
5453 for (size_t __i = 0; __i < _Nm; ++__i)
5455 _M_current[_Nm - 1 - __i] = __last;
5456 ranges::advance(__last, -1, __first);
5463 if constexpr (random_access_range<_Base>)
5464 return random_access_iterator_tag{};
5465 else if constexpr (bidirectional_range<_Base>)
5466 return bidirectional_iterator_tag{};
5468 return forward_iterator_tag{};
5471 friend class adjacent_view;
5473#ifndef __clang__ // LLVM-61763 workaround
5474 template<forward_range _Wp, move_constructible _Fp, size_t _Mm>
5475 requires view<_Wp> && (_Mm > 0) && is_object_v<_Fp>
5476 && regular_invocable<__detail::__unarize<_Fp&, _Mm>, range_reference_t<_Wp>>
5477 && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Mm>,
5478 range_reference_t<_Wp>>>
5479 friend class adjacent_transform_view;
5483 using iterator_category = input_iterator_tag;
5484 using iterator_concept = decltype(_S_iter_concept());
5485 using value_type = conditional_t<_Nm == 2,
5486 pair<range_value_t<_Base>, range_value_t<_Base>>,
5487 __detail::__repeated_tuple<range_value_t<_Base>, _Nm>>;
5488 using difference_type = range_difference_t<_Base>;
5490 _Iterator() = default;
5493 _Iterator(_Iterator<!_Const> __i)
5494 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
5496 for (size_t __j = 0; __j < _Nm; ++__j)
5497 _M_current[__j] = std::move(__i._M_current[__j]);
5503 auto __f = [](auto& __i) -> decltype(auto) { return *__i; };
5504 return __detail::__tuple_transform(__f, _M_current);
5507 constexpr _Iterator&
5510 for (auto& __i : _M_current)
5523 constexpr _Iterator&
5524 operator--() requires bidirectional_range<_Base>
5526 for (auto& __i : _M_current)
5532 operator--(int) requires bidirectional_range<_Base>
5539 constexpr _Iterator&
5540 operator+=(difference_type __x)
5541 requires random_access_range<_Base>
5543 for (auto& __i : _M_current)
5548 constexpr _Iterator&
5549 operator-=(difference_type __x)
5550 requires random_access_range<_Base>
5552 for (auto& __i : _M_current)
5558 operator[](difference_type __n) const
5559 requires random_access_range<_Base>
5561 auto __f = [&](auto& __i) -> decltype(auto) { return __i[__n]; };
5562 return __detail::__tuple_transform(__f, _M_current);
5565 friend constexpr bool
5566 operator==(const _Iterator& __x, const _Iterator& __y)
5567 { return __x._M_current.back() == __y._M_current.back(); }
5569 friend constexpr bool
5570 operator<(const _Iterator& __x, const _Iterator& __y)
5571 requires random_access_range<_Base>
5572 { return __x._M_current.back() < __y._M_current.back(); }
5574 friend constexpr bool
5575 operator>(const _Iterator& __x, const _Iterator& __y)
5576 requires random_access_range<_Base>
5577 { return __y < __x; }
5579 friend constexpr bool
5580 operator<=(const _Iterator& __x, const _Iterator& __y)
5581 requires random_access_range<_Base>
5582 { return !(__y < __x); }
5584 friend constexpr bool
5585 operator>=(const _Iterator& __x, const _Iterator& __y)
5586 requires random_access_range<_Base>
5587 { return !(__x < __y); }
5589 friend constexpr auto
5590 operator<=>(const _Iterator& __x, const _Iterator& __y)
5591 requires random_access_range<_Base>
5592 && three_way_comparable<iterator_t<_Base>>
5593 { return __x._M_current.back() <=> __y._M_current.back(); }
5595 friend constexpr _Iterator
5596 operator+(const _Iterator& __i, difference_type __n)
5597 requires random_access_range<_Base>
5604 friend constexpr _Iterator
5605 operator+(difference_type __n, const _Iterator& __i)
5606 requires random_access_range<_Base>
5613 friend constexpr _Iterator
5614 operator-(const _Iterator& __i, difference_type __n)
5615 requires random_access_range<_Base>
5622 friend constexpr difference_type
5623 operator-(const _Iterator& __x, const _Iterator& __y)
5624 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
5625 { return __x._M_current.back() - __y._M_current.back(); }
5627 friend constexpr auto
5628 iter_move(const _Iterator& __i)
5629 { return __detail::__tuple_transform(ranges::iter_move, __i._M_current); }
5631 friend constexpr void
5632 iter_swap(const _Iterator& __l, const _Iterator& __r)
5633 requires indirectly_swappable<iterator_t<_Base>>
5635 for (size_t __i = 0; __i < _Nm; __i++)
5636 ranges::iter_swap(__l._M_current[__i], __r._M_current[__i]);
5640 template<forward_range _Vp, size_t _Nm>
5641 requires view<_Vp> && (_Nm > 0)
5642 template<bool _Const>
5643 class adjacent_view<_Vp, _Nm>::_Sentinel
5645 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
5647 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
5650 _Sentinel(sentinel_t<_Base> __end)
5654 friend class adjacent_view;
5657 _Sentinel() = default;
5660 _Sentinel(_Sentinel<!_Const> __i)
5661 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
5662 : _M_end(std::move(__i._M_end))
5665 template<bool _OtherConst>
5666 requires sentinel_for<sentinel_t<_Base>,
5667 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
5668 friend constexpr bool
5669 operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
5670 { return __x._M_current.back() == __y._M_end; }
5672 template<bool _OtherConst>
5673 requires sized_sentinel_for<sentinel_t<_Base>,
5674 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
5675 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _Vp>>
5676 operator-(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
5677 { return __x._M_current.back() - __y._M_end; }
5679 template<bool _OtherConst>
5680 requires sized_sentinel_for<sentinel_t<_Base>,
5681 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
5682 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _Vp>>
5683 operator-(const _Sentinel& __y, const _Iterator<_OtherConst>& __x)
5684 { return __y._M_end - __x._M_current.back(); }
5691 template<size_t _Nm, typename _Range>
5692 concept __can_adjacent_view
5693 = requires { adjacent_view<all_t<_Range>, _Nm>(std::declval<_Range>()); };
5696 template<size_t _Nm>
5697 struct _Adjacent : __adaptor::_RangeAdaptorClosure<_Adjacent<_Nm>>
5699 template<viewable_range _Range>
5700 requires (_Nm == 0) || __detail::__can_adjacent_view<_Nm, _Range>
5702 operator() [[nodiscard]] (_Range&& __r) const
5704 if constexpr (_Nm == 0)
5705 return views::empty<tuple<>>;
5707 return adjacent_view<all_t<_Range>, _Nm>(std::forward<_Range>(__r));
5711 template<size_t _Nm>
5712 inline constexpr _Adjacent<_Nm> adjacent;
5714 inline constexpr auto pairwise = adjacent<2>;
5717 template<forward_range _Vp, move_constructible _Fp, size_t _Nm>
5718 requires view<_Vp> && (_Nm > 0) && is_object_v<_Fp>
5719 && regular_invocable<__detail::__unarize<_Fp&, _Nm>, range_reference_t<_Vp>>
5720 && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Nm>,
5721 range_reference_t<_Vp>>>
5722 class adjacent_transform_view : public view_interface<adjacent_transform_view<_Vp, _Fp, _Nm>>
5724 [[no_unique_address]] __detail::__box<_Fp> _M_fun;
5725 adjacent_view<_Vp, _Nm> _M_inner;
5727 using _InnerView = adjacent_view<_Vp, _Nm>;
5729 template<bool _Const>
5730 using _InnerIter = iterator_t<__detail::__maybe_const_t<_Const, _InnerView>>;
5732 template<bool _Const>
5733 using _InnerSent = sentinel_t<__detail::__maybe_const_t<_Const, _InnerView>>;
5735 template<bool> class _Iterator;
5736 template<bool> class _Sentinel;
5739 adjacent_transform_view() = default;
5742 adjacent_transform_view(_Vp __base, _Fp __fun)
5743 : _M_fun(std::move(__fun)), _M_inner(std::move(__base))
5746 // _GLIBCXX_RESOLVE_LIB_DEFECTS
5747 // 3848. adjacent_view, adjacent_transform_view and slide_view missing base accessor
5748 // 3947. Unexpected constraints on adjacent_transform_view::base()
5750 base() const & requires copy_constructible<_Vp>
5751 { return _M_inner.base(); }
5755 { return std::move(_M_inner.base()); }
5759 { return _Iterator<false>(*this, _M_inner.begin()); }
5763 requires range<const _InnerView>
5764 && regular_invocable<__detail::__unarize<const _Fp&, _Nm>,
5765 range_reference_t<const _Vp>>
5766 { return _Iterator<true>(*this, _M_inner.begin()); }
5771 if constexpr (common_range<_InnerView>)
5772 return _Iterator<false>(*this, _M_inner.end());
5774 return _Sentinel<false>(_M_inner.end());
5779 requires range<const _InnerView>
5780 && regular_invocable<__detail::__unarize<const _Fp&, _Nm>,
5781 range_reference_t<const _Vp>>
5783 if constexpr (common_range<const _InnerView>)
5784 return _Iterator<true>(*this, _M_inner.end());
5786 return _Sentinel<true>(_M_inner.end());
5790 size() requires sized_range<_InnerView>
5791 { return _M_inner.size(); }
5794 size() const requires sized_range<const _InnerView>
5795 { return _M_inner.size(); }
5798 template<forward_range _Vp, move_constructible _Fp, size_t _Nm>
5799 requires view<_Vp> && (_Nm > 0) && is_object_v<_Fp>
5800 && regular_invocable<__detail::__unarize<_Fp&, _Nm>, range_reference_t<_Vp>>
5801 && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Nm>,
5802 range_reference_t<_Vp>>>
5803 template<bool _Const>
5804 class adjacent_transform_view<_Vp, _Fp, _Nm>::_Iterator
5806 using _Parent = __detail::__maybe_const_t<_Const, adjacent_transform_view>;
5807 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
5809 _Parent* _M_parent = nullptr;
5810 _InnerIter<_Const> _M_inner;
5813 _Iterator(_Parent& __parent, _InnerIter<_Const> __inner)
5814 : _M_parent(std::__addressof(__parent)), _M_inner(std::move(__inner))
5820 using __detail::__maybe_const_t;
5821 using __detail::__unarize;
5822 using _Res = invoke_result_t<__unarize<__maybe_const_t<_Const, _Fp>&, _Nm>,
5823 range_reference_t<_Base>>;
5824 using _Cat = typename iterator_traits<iterator_t<_Base>>::iterator_category;
5825 // _GLIBCXX_RESOLVE_LIB_DEFECTS
5826 // 3798. Rvalue reference and iterator_category
5827 if constexpr (!is_reference_v<_Res>)
5828 return input_iterator_tag{};
5829 else if constexpr (derived_from<_Cat, random_access_iterator_tag>)
5830 return random_access_iterator_tag{};
5831 else if constexpr (derived_from<_Cat, bidirectional_iterator_tag>)
5832 return bidirectional_iterator_tag{};
5833 else if constexpr (derived_from<_Cat, forward_iterator_tag>)
5834 return forward_iterator_tag{};
5836 return input_iterator_tag{};
5839 friend class adjacent_transform_view;
5842 using iterator_category = decltype(_S_iter_cat());
5843 using iterator_concept = typename _InnerIter<_Const>::iterator_concept;
5845 = remove_cvref_t<invoke_result_t
5846 <__detail::__unarize<__detail::__maybe_const_t<_Const, _Fp>&, _Nm>,
5847 range_reference_t<_Base>>>;
5848 using difference_type = range_difference_t<_Base>;
5850 _Iterator() = default;
5853 _Iterator(_Iterator<!_Const> __i)
5854 requires _Const && convertible_to<_InnerIter<false>, _InnerIter<_Const>>
5855 : _M_parent(__i._M_parent), _M_inner(std::move(__i._M_inner))
5858 constexpr decltype(auto)
5861 return std::apply([&](const auto&... __iters) -> decltype(auto) {
5862 return std::__invoke(*_M_parent->_M_fun, *__iters...);
5863 }, _M_inner._M_current);
5866 constexpr _Iterator&
5881 constexpr _Iterator&
5882 operator--() requires bidirectional_range<_Base>
5889 operator--(int) requires bidirectional_range<_Base>
5896 constexpr _Iterator&
5897 operator+=(difference_type __x) requires random_access_range<_Base>
5903 constexpr _Iterator&
5904 operator-=(difference_type __x) requires random_access_range<_Base>
5910 constexpr decltype(auto)
5911 operator[](difference_type __n) const requires random_access_range<_Base>
5913 return std::apply([&](const auto&... __iters) -> decltype(auto) {
5914 return std::__invoke(*_M_parent->_M_fun, __iters[__n]...);
5915 }, _M_inner._M_current);
5918 friend constexpr bool
5919 operator==(const _Iterator& __x, const _Iterator& __y)
5920 { return __x._M_inner == __y._M_inner; }
5922 friend constexpr bool
5923 operator<(const _Iterator& __x, const _Iterator& __y)
5924 requires random_access_range<_Base>
5925 { return __x._M_inner < __y._M_inner; }
5927 friend constexpr bool
5928 operator>(const _Iterator& __x, const _Iterator& __y)
5929 requires random_access_range<_Base>
5930 { return __x._M_inner > __y._M_inner; }
5932 friend constexpr bool
5933 operator<=(const _Iterator& __x, const _Iterator& __y)
5934 requires random_access_range<_Base>
5935 { return __x._M_inner <= __y._M_inner; }
5937 friend constexpr bool
5938 operator>=(const _Iterator& __x, const _Iterator& __y)
5939 requires random_access_range<_Base>
5940 { return __x._M_inner >= __y._M_inner; }
5942 friend constexpr auto
5943 operator<=>(const _Iterator& __x, const _Iterator& __y)
5944 requires random_access_range<_Base> &&
5945 three_way_comparable<_InnerIter<_Const>>
5946 { return __x._M_inner <=> __y._M_inner; }
5948 friend constexpr _Iterator
5949 operator+(const _Iterator& __i, difference_type __n)
5950 requires random_access_range<_Base>
5951 { return _Iterator(*__i._M_parent, __i._M_inner + __n); }
5953 friend constexpr _Iterator
5954 operator+(difference_type __n, const _Iterator& __i)
5955 requires random_access_range<_Base>
5956 { return _Iterator(*__i._M_parent, __i._M_inner + __n); }
5958 friend constexpr _Iterator
5959 operator-(const _Iterator& __i, difference_type __n)
5960 requires random_access_range<_Base>
5961 { return _Iterator(*__i._M_parent, __i._M_inner - __n); }
5963 friend constexpr difference_type
5964 operator-(const _Iterator& __x, const _Iterator& __y)
5965 requires sized_sentinel_for<_InnerIter<_Const>, _InnerIter<_Const>>
5966 { return __x._M_inner - __y._M_inner; }
5969 template<forward_range _Vp, move_constructible _Fp, size_t _Nm>
5970 requires view<_Vp> && (_Nm > 0) && is_object_v<_Fp>
5971 && regular_invocable<__detail::__unarize<_Fp&, _Nm>, range_reference_t<_Vp>>
5972 && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Nm>,
5973 range_reference_t<_Vp>>>
5974 template<bool _Const>
5975 class adjacent_transform_view<_Vp, _Fp, _Nm>::_Sentinel
5977 _InnerSent<_Const> _M_inner;
5980 _Sentinel(_InnerSent<_Const> __inner)
5984 friend class adjacent_transform_view;
5987 _Sentinel() = default;
5990 _Sentinel(_Sentinel<!_Const> __i)
5991 requires _Const && convertible_to<_InnerSent<false>, _InnerSent<_Const>>
5992 : _M_inner(std::move(__i._M_inner))
5995 template<bool _OtherConst>
5996 requires sentinel_for<_InnerSent<_Const>, _InnerIter<_OtherConst>>
5997 friend constexpr bool
5998 operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
5999 { return __x._M_inner == __y._M_inner; }
6001 template<bool _OtherConst>
6002 requires sized_sentinel_for<_InnerSent<_Const>, _InnerIter<_OtherConst>>
6003 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
6004 operator-(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
6005 { return __x._M_inner - __y._M_inner; }
6007 template<bool _OtherConst>
6008 requires sized_sentinel_for<_InnerSent<_Const>, _InnerIter<_OtherConst>>
6009 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
6010 operator-(const _Sentinel& __x, const _Iterator<_OtherConst>& __y)
6011 { return __x._M_inner - __y._M_inner; }
6018 template<size_t _Nm, typename _Range, typename _Fp>
6019 concept __can_adjacent_transform_view
6020 = requires { adjacent_transform_view<all_t<_Range>, decay_t<_Fp>, _Nm>
6021 (std::declval<_Range>(), std::declval<_Fp>()); };
6024 template<size_t _Nm>
6025 struct _AdjacentTransform : __adaptor::_RangeAdaptor<_AdjacentTransform<_Nm>>
6027 template<viewable_range _Range, typename _Fp>
6028 requires (_Nm == 0) || __detail::__can_adjacent_transform_view<_Nm, _Range, _Fp>
6030 operator() [[nodiscard]] (_Range&& __r, _Fp&& __f) const
6032 if constexpr (_Nm == 0)
6033 return zip_transform(std::forward<_Fp>(__f));
6035 return adjacent_transform_view<all_t<_Range>, decay_t<_Fp>, _Nm>
6036 (std::forward<_Range>(__r), std::forward<_Fp>(__f));
6039 using __adaptor::_RangeAdaptor<_AdjacentTransform>::operator();
6040 static constexpr int _S_arity = 2;
6041 static constexpr bool _S_has_simple_extra_args = true;
6044 template<size_t _Nm>
6045 inline constexpr _AdjacentTransform<_Nm> adjacent_transform;
6047 inline constexpr auto pairwise_transform = adjacent_transform<2>;
6049#endif // __cpp_lib_ranges_zip
6051#ifdef __cpp_lib_ranges_chunk // C++ >= 23
6054 template<typename _Tp>
6055 constexpr _Tp __div_ceil(_Tp __num, _Tp __denom)
6057 _Tp __r = __num / __denom;
6058 if (__num % __denom)
6065 requires input_range<_Vp>
6066 class chunk_view : public view_interface<chunk_view<_Vp>>
6069 range_difference_t<_Vp> _M_n;
6070 range_difference_t<_Vp> _M_remainder = 0;
6071 __detail::__non_propagating_cache<iterator_t<_Vp>> _M_current;
6078 chunk_view(_Vp __base, range_difference_t<_Vp> __n)
6079 : _M_base(std::move(__base)), _M_n(__n)
6080 { __glibcxx_assert(__n >= 0); }
6083 base() const & requires copy_constructible<_Vp>
6088 { return std::move(_M_base); }
6090 constexpr _OuterIter
6093 _M_current = ranges::begin(_M_base);
6094 _M_remainder = _M_n;
6095 return _OuterIter(*this);
6098 constexpr default_sentinel_t
6099 end() const noexcept
6100 { return default_sentinel; }
6103 size() requires sized_range<_Vp>
6105 return __detail::__to_unsigned_like(__detail::__div_ceil
6106 (ranges::distance(_M_base), _M_n));
6110 size() const requires sized_range<const _Vp>
6112 return __detail::__to_unsigned_like(__detail::__div_ceil
6113 (ranges::distance(_M_base), _M_n));
6117 template<typename _Range>
6118 chunk_view(_Range&&, range_difference_t<_Range>) -> chunk_view<views::all_t<_Range>>;
6121 requires input_range<_Vp>
6122 class chunk_view<_Vp>::_OuterIter
6124 chunk_view* _M_parent;
6127 _OuterIter(chunk_view& __parent) noexcept
6128 : _M_parent(std::__addressof(__parent))
6134 using iterator_concept = input_iterator_tag;
6135 using difference_type = range_difference_t<_Vp>;
6139 _OuterIter(_OuterIter&&) = default;
6140 _OuterIter& operator=(_OuterIter&&) = default;
6142 constexpr value_type
6145 __glibcxx_assert(*this != default_sentinel);
6146 return value_type(*_M_parent);
6149 constexpr _OuterIter&
6152 __glibcxx_assert(*this != default_sentinel);
6153 ranges::advance(*_M_parent->_M_current, _M_parent->_M_remainder,
6154 ranges::end(_M_parent->_M_base));
6155 _M_parent->_M_remainder = _M_parent->_M_n;
6163 friend constexpr bool
6164 operator==(const _OuterIter& __x, default_sentinel_t)
6166 return *__x._M_parent->_M_current == ranges::end(__x._M_parent->_M_base)
6167 && __x._M_parent->_M_remainder != 0;
6170 friend constexpr difference_type
6171 operator-(default_sentinel_t, const _OuterIter& __x)
6172 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6174 const auto __dist = ranges::end(__x._M_parent->_M_base) - *__x._M_parent->_M_current;
6176 if (__dist < __x._M_parent->_M_remainder)
6177 return __dist == 0 ? 0 : 1;
6179 return 1 + __detail::__div_ceil(__dist - __x._M_parent->_M_remainder,
6180 __x._M_parent->_M_n);
6183 friend constexpr difference_type
6184 operator-(const _OuterIter& __x, default_sentinel_t __y)
6185 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6186 { return -(__y - __x); }
6190 requires input_range<_Vp>
6191 struct chunk_view<_Vp>::_OuterIter::value_type : view_interface<value_type>
6194 chunk_view* _M_parent;
6197 value_type(chunk_view& __parent) noexcept
6198 : _M_parent(std::__addressof(__parent))
6204 constexpr _InnerIter
6205 begin() const noexcept
6206 { return _InnerIter(*_M_parent); }
6208 constexpr default_sentinel_t
6209 end() const noexcept
6210 { return default_sentinel; }
6214 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6216 return __detail::__to_unsigned_like
6217 (ranges::min(_M_parent->_M_remainder,
6218 ranges::end(_M_parent->_M_base) - *_M_parent->_M_current));
6223 requires input_range<_Vp>
6224 class chunk_view<_Vp>::_InnerIter
6226 chunk_view* _M_parent;
6229 _InnerIter(chunk_view& __parent) noexcept
6230 : _M_parent(std::__addressof(__parent))
6233 friend _OuterIter::value_type;
6236 using iterator_concept = input_iterator_tag;
6237 using difference_type = range_difference_t<_Vp>;
6238 using value_type = range_value_t<_Vp>;
6240 _InnerIter(_InnerIter&&) = default;
6241 _InnerIter& operator=(_InnerIter&&) = default;
6243 constexpr const iterator_t<_Vp>&
6245 { return *_M_parent->_M_current; }
6247 constexpr range_reference_t<_Vp>
6250 __glibcxx_assert(*this != default_sentinel);
6251 return **_M_parent->_M_current;
6254 constexpr _InnerIter&
6257 __glibcxx_assert(*this != default_sentinel);
6258 ++*_M_parent->_M_current;
6259 if (*_M_parent->_M_current == ranges::end(_M_parent->_M_base))
6260 _M_parent->_M_remainder = 0;
6262 --_M_parent->_M_remainder;
6270 friend constexpr bool
6271 operator==(const _InnerIter& __x, default_sentinel_t) noexcept
6272 { return __x._M_parent->_M_remainder == 0; }
6274 friend constexpr difference_type
6275 operator-(default_sentinel_t, const _InnerIter& __x)
6276 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6278 return ranges::min(__x._M_parent->_M_remainder,
6279 ranges::end(__x._M_parent->_M_base) - *__x._M_parent->_M_current);
6282 friend constexpr difference_type
6283 operator-(const _InnerIter& __x, default_sentinel_t __y)
6284 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6285 { return -(__y - __x); }
6287 // _GLIBCXX_RESOLVE_LIB_DEFECTS
6288 // 3851. chunk_view::inner-iterator missing custom iter_move and iter_swap
6289 friend constexpr range_rvalue_reference_t<_Vp>
6290 iter_move(const _InnerIter& __i)
6291 noexcept(noexcept(ranges::iter_move(*__i._M_parent->_M_current)))
6292 { return ranges::iter_move(*__i._M_parent->_M_current); }
6294 friend constexpr void
6295 iter_swap(const _InnerIter& __x, const _InnerIter& __y)
6296 noexcept(noexcept(ranges::iter_swap(*__x._M_parent->_M_current,
6297 *__x._M_parent->_M_current)))
6298 requires indirectly_swappable<iterator_t<_Vp>>
6299 { return ranges::iter_swap(*__x._M_parent->_M_current, *__y._M_parent->_M_current); }
6303 requires forward_range<_Vp>
6304 class chunk_view<_Vp> : public view_interface<chunk_view<_Vp>>
6307 range_difference_t<_Vp> _M_n;
6308 template<bool> class _Iterator;
6312 chunk_view(_Vp __base, range_difference_t<_Vp> __n)
6313 : _M_base(std::move(__base)), _M_n(__n)
6314 { __glibcxx_assert(__n > 0); }
6317 base() const & requires copy_constructible<_Vp>
6322 { return std::move(_M_base); }
6325 begin() requires (!__detail::__simple_view<_Vp>)
6326 { return _Iterator<false>(this, ranges::begin(_M_base)); }
6329 begin() const requires forward_range<const _Vp>
6330 { return _Iterator<true>(this, ranges::begin(_M_base)); }
6333 end() requires (!__detail::__simple_view<_Vp>)
6335 if constexpr (common_range<_Vp> && sized_range<_Vp>)
6337 auto __missing = (_M_n - ranges::distance(_M_base) % _M_n) % _M_n;
6338 return _Iterator<false>(this, ranges::end(_M_base), __missing);
6340 else if constexpr (common_range<_Vp> && !bidirectional_range<_Vp>)
6341 return _Iterator<false>(this, ranges::end(_M_base));
6343 return default_sentinel;
6347 end() const requires forward_range<const _Vp>
6349 if constexpr (common_range<const _Vp> && sized_range<const _Vp>)
6351 auto __missing = (_M_n - ranges::distance(_M_base) % _M_n) % _M_n;
6352 return _Iterator<true>(this, ranges::end(_M_base), __missing);
6354 else if constexpr (common_range<const _Vp> && !bidirectional_range<const _Vp>)
6355 return _Iterator<true>(this, ranges::end(_M_base));
6357 return default_sentinel;
6361 size() requires sized_range<_Vp>
6363 return __detail::__to_unsigned_like(__detail::__div_ceil
6364 (ranges::distance(_M_base), _M_n));
6368 size() const requires sized_range<const _Vp>
6370 return __detail::__to_unsigned_like(__detail::__div_ceil
6371 (ranges::distance(_M_base), _M_n));
6375 template<typename _Vp>
6376 inline constexpr bool enable_borrowed_range<chunk_view<_Vp>>
6377 = forward_range<_Vp> && enable_borrowed_range<_Vp>;
6380 requires forward_range<_Vp>
6381 template<bool _Const>
6382 class chunk_view<_Vp>::_Iterator
6384 using _Parent = __detail::__maybe_const_t<_Const, chunk_view>;
6385 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
6387 iterator_t<_Base> _M_current = iterator_t<_Base>();
6388 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
6389 range_difference_t<_Base> _M_n = 0;
6390 range_difference_t<_Base> _M_missing = 0;
6393 _Iterator(_Parent* __parent, iterator_t<_Base> __current,
6394 range_difference_t<_Base> __missing = 0)
6395 : _M_current(__current), _M_end(ranges::end(__parent->_M_base)),
6396 _M_n(__parent->_M_n), _M_missing(__missing)
6402 if constexpr (random_access_range<_Base>)
6403 return random_access_iterator_tag{};
6404 else if constexpr (bidirectional_range<_Base>)
6405 return bidirectional_iterator_tag{};
6407 return forward_iterator_tag{};
6413 using iterator_category = input_iterator_tag;
6414 using iterator_concept = decltype(_S_iter_cat());
6415 using value_type = decltype(views::take(subrange(_M_current, _M_end), _M_n));
6416 using difference_type = range_difference_t<_Base>;
6418 _Iterator() = default;
6420 constexpr _Iterator(_Iterator<!_Const> __i)
6422 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
6423 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
6424 : _M_current(std::move(__i._M_current)), _M_end(std::move(__i._M_end)),
6425 _M_n(__i._M_n), _M_missing(__i._M_missing)
6428 constexpr iterator_t<_Base>
6430 { return _M_current; }
6432 constexpr value_type
6435 __glibcxx_assert(_M_current != _M_end);
6436 return views::take(subrange(_M_current, _M_end), _M_n);
6439 constexpr _Iterator&
6442 __glibcxx_assert(_M_current != _M_end);
6443 _M_missing = ranges::advance(_M_current, _M_n, _M_end);
6455 constexpr _Iterator&
6456 operator--() requires bidirectional_range<_Base>
6458 ranges::advance(_M_current, _M_missing - _M_n);
6464 operator--(int) requires bidirectional_range<_Base>
6471 constexpr _Iterator&
6472 operator+=(difference_type __x)
6473 requires random_access_range<_Base>
6477 __glibcxx_assert(ranges::distance(_M_current, _M_end) > _M_n * (__x - 1));
6478 _M_missing = ranges::advance(_M_current, _M_n * __x, _M_end);
6482 ranges::advance(_M_current, _M_n * __x + _M_missing);
6488 constexpr _Iterator&
6489 operator-=(difference_type __x)
6490 requires random_access_range<_Base>
6491 { return *this += -__x; }
6493 constexpr value_type
6494 operator[](difference_type __n) const
6495 requires random_access_range<_Base>
6496 { return *(*this + __n); }
6498 friend constexpr bool
6499 operator==(const _Iterator& __x, const _Iterator& __y)
6500 { return __x._M_current == __y._M_current; }
6502 friend constexpr bool
6503 operator==(const _Iterator& __x, default_sentinel_t)
6504 { return __x._M_current == __x._M_end; }
6506 friend constexpr bool
6507 operator<(const _Iterator& __x, const _Iterator& __y)
6508 requires random_access_range<_Base>
6509 { return __x._M_current > __y._M_current; }
6511 friend constexpr bool
6512 operator>(const _Iterator& __x, const _Iterator& __y)
6513 requires random_access_range<_Base>
6514 { return __y < __x; }
6516 friend constexpr bool
6517 operator<=(const _Iterator& __x, const _Iterator& __y)
6518 requires random_access_range<_Base>
6519 { return !(__y < __x); }
6521 friend constexpr bool
6522 operator>=(const _Iterator& __x, const _Iterator& __y)
6523 requires random_access_range<_Base>
6524 { return !(__x < __y); }
6526 friend constexpr auto
6527 operator<=>(const _Iterator& __x, const _Iterator& __y)
6528 requires random_access_range<_Base>
6529 && three_way_comparable<iterator_t<_Base>>
6530 { return __x._M_current <=> __y._M_current; }
6532 friend constexpr _Iterator
6533 operator+(const _Iterator& __i, difference_type __n)
6534 requires random_access_range<_Base>
6541 friend constexpr _Iterator
6542 operator+(difference_type __n, const _Iterator& __i)
6543 requires random_access_range<_Base>
6550 friend constexpr _Iterator
6551 operator-(const _Iterator& __i, difference_type __n)
6552 requires random_access_range<_Base>
6559 friend constexpr difference_type
6560 operator-(const _Iterator& __x, const _Iterator& __y)
6561 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
6563 return (__x._M_current - __y._M_current
6564 + __x._M_missing - __y._M_missing) / __x._M_n;
6567 friend constexpr difference_type
6568 operator-(default_sentinel_t __y, const _Iterator& __x)
6569 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
6570 { return __detail::__div_ceil(__x._M_end - __x._M_current, __x._M_n); }
6572 friend constexpr difference_type
6573 operator-(const _Iterator& __x, default_sentinel_t __y)
6574 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
6575 { return -(__y - __x); }
6582 template<typename _Range, typename _Dp>
6583 concept __can_chunk_view
6584 = requires { chunk_view(std::declval<_Range>(), std::declval<_Dp>()); };
6587 struct _Chunk : __adaptor::_RangeAdaptor<_Chunk>
6589 template<viewable_range _Range, typename _Dp = range_difference_t<_Range>>
6590 requires __detail::__can_chunk_view<_Range, _Dp>
6592 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n) const
6593 { return chunk_view(std::forward<_Range>(__r), __n); }
6595 using __adaptor::_RangeAdaptor<_Chunk>::operator();
6596 static constexpr int _S_arity = 2;
6597 static constexpr bool _S_has_simple_extra_args = true;
6600 inline constexpr _Chunk chunk;
6602#endif // __cpp_lib_ranges_chunk
6604#ifdef __cpp_lib_ranges_slide // C++ >= 23
6607 template<typename _Vp>
6608 concept __slide_caches_nothing = random_access_range<_Vp> && sized_range<_Vp>;
6610 template<typename _Vp>
6611 concept __slide_caches_last
6612 = !__slide_caches_nothing<_Vp> && bidirectional_range<_Vp> && common_range<_Vp>;
6614 template<typename _Vp>
6615 concept __slide_caches_first
6616 = !__slide_caches_nothing<_Vp> && !__slide_caches_last<_Vp>;
6619 template<forward_range _Vp>
6621 class slide_view : public view_interface<slide_view<_Vp>>
6624 range_difference_t<_Vp> _M_n;
6625 [[no_unique_address]]
6626 __detail::__maybe_present_t<__detail::__slide_caches_first<_Vp>,
6627 __detail::_CachedPosition<_Vp>, 0> _M_cached_begin;
6628 [[no_unique_address]]
6629 __detail::__maybe_present_t<__detail::__slide_caches_last<_Vp>,
6630 __detail::_CachedPosition<_Vp>, 1> _M_cached_end;
6632 template<bool> class _Iterator;
6637 slide_view(_Vp __base, range_difference_t<_Vp> __n)
6638 : _M_base(std::move(__base)), _M_n(__n)
6639 { __glibcxx_assert(__n > 0); }
6641 // _GLIBCXX_RESOLVE_LIB_DEFECTS
6642 // 3848. adjacent_view, adjacent_transform_view and slide_view missing base accessor
6644 base() const & requires copy_constructible<_Vp>
6649 { return std::move(_M_base); }
6652 begin() requires (!(__detail::__simple_view<_Vp>
6653 && __detail::__slide_caches_nothing<const _Vp>))
6655 if constexpr (__detail::__slide_caches_first<_Vp>)
6657 iterator_t<_Vp> __it;
6658 if (_M_cached_begin._M_has_value())
6659 __it = _M_cached_begin._M_get(_M_base);
6662 __it = ranges::next(ranges::begin(_M_base), _M_n - 1, ranges::end(_M_base));
6663 _M_cached_begin._M_set(_M_base, __it);
6665 return _Iterator<false>(ranges::begin(_M_base), std::move(__it), _M_n);
6668 return _Iterator<false>(ranges::begin(_M_base), _M_n);
6672 begin() const requires __detail::__slide_caches_nothing<const _Vp>
6673 { return _Iterator<true>(ranges::begin(_M_base), _M_n); }
6676 end() requires (!(__detail::__simple_view<_Vp>
6677 && __detail::__slide_caches_nothing<const _Vp>))
6679 if constexpr (__detail::__slide_caches_nothing<_Vp>)
6680 return _Iterator<false>(ranges::begin(_M_base) + range_difference_t<_Vp>(size()),
6682 else if constexpr (__detail::__slide_caches_last<_Vp>)
6684 iterator_t<_Vp> __it;
6685 if (_M_cached_end._M_has_value())
6686 __it = _M_cached_end._M_get(_M_base);
6689 __it = ranges::prev(ranges::end(_M_base), _M_n - 1, ranges::begin(_M_base));
6690 _M_cached_end._M_set(_M_base, __it);
6692 return _Iterator<false>(std::move(__it), _M_n);
6694 else if constexpr (common_range<_Vp>)
6695 return _Iterator<false>(ranges::end(_M_base), ranges::end(_M_base), _M_n);
6697 return _Sentinel(ranges::end(_M_base));
6701 end() const requires __detail::__slide_caches_nothing<const _Vp>
6702 { return begin() + range_difference_t<const _Vp>(size()); }
6705 size() requires sized_range<_Vp>
6707 auto __sz = ranges::distance(_M_base) - _M_n + 1;
6710 return __detail::__to_unsigned_like(__sz);
6714 size() const requires sized_range<const _Vp>
6716 auto __sz = ranges::distance(_M_base) - _M_n + 1;
6719 return __detail::__to_unsigned_like(__sz);
6723 template<typename _Range>
6724 slide_view(_Range&&, range_difference_t<_Range>) -> slide_view<views::all_t<_Range>>;
6726 template<typename _Vp>
6727 inline constexpr bool enable_borrowed_range<slide_view<_Vp>>
6728 = enable_borrowed_range<_Vp>;
6730 template<forward_range _Vp>
6732 template<bool _Const>
6733 class slide_view<_Vp>::_Iterator
6735 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
6736 static constexpr bool _S_last_elt_present
6737 = __detail::__slide_caches_first<_Base>;
6739 iterator_t<_Base> _M_current = iterator_t<_Base>();
6740 [[no_unique_address]]
6741 __detail::__maybe_present_t<_S_last_elt_present, iterator_t<_Base>>
6742 _M_last_elt = decltype(_M_last_elt)();
6743 range_difference_t<_Base> _M_n = 0;
6746 _Iterator(iterator_t<_Base> __current, range_difference_t<_Base> __n)
6747 requires (!_S_last_elt_present)
6748 : _M_current(__current), _M_n(__n)
6752 _Iterator(iterator_t<_Base> __current, iterator_t<_Base> __last_elt,
6753 range_difference_t<_Base> __n)
6754 requires _S_last_elt_present
6755 : _M_current(__current), _M_last_elt(__last_elt), _M_n(__n)
6761 if constexpr (random_access_range<_Base>)
6762 return random_access_iterator_tag{};
6763 else if constexpr (bidirectional_range<_Base>)
6764 return bidirectional_iterator_tag{};
6766 return forward_iterator_tag{};
6770 friend slide_view::_Sentinel;
6773 using iterator_category = input_iterator_tag;
6774 using iterator_concept = decltype(_S_iter_concept());
6775 using value_type = decltype(views::counted(_M_current, _M_n));
6776 using difference_type = range_difference_t<_Base>;
6778 _Iterator() = default;
6781 _Iterator(_Iterator<!_Const> __i)
6782 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
6783 : _M_current(std::move(__i._M_current)), _M_n(__i._M_n)
6788 { return views::counted(_M_current, _M_n); }
6790 constexpr _Iterator&
6794 if constexpr (_S_last_elt_present)
6807 constexpr _Iterator&
6808 operator--() requires bidirectional_range<_Base>
6811 if constexpr (_S_last_elt_present)
6817 operator--(int) requires bidirectional_range<_Base>
6824 constexpr _Iterator&
6825 operator+=(difference_type __x)
6826 requires random_access_range<_Base>
6829 if constexpr (_S_last_elt_present)
6834 constexpr _Iterator&
6835 operator-=(difference_type __x)
6836 requires random_access_range<_Base>
6839 if constexpr (_S_last_elt_present)
6845 operator[](difference_type __n) const
6846 requires random_access_range<_Base>
6847 { return views::counted(_M_current + __n, _M_n); }
6849 friend constexpr bool
6850 operator==(const _Iterator& __x, const _Iterator& __y)
6852 if constexpr (_S_last_elt_present)
6853 return __x._M_last_elt == __y._M_last_elt;
6855 return __x._M_current == __y._M_current;
6858 friend constexpr bool
6859 operator<(const _Iterator& __x, const _Iterator& __y)
6860 requires random_access_range<_Base>
6861 { return __x._M_current < __y._M_current; }
6863 friend constexpr bool
6864 operator>(const _Iterator& __x, const _Iterator& __y)
6865 requires random_access_range<_Base>
6866 { return __y < __x; }
6868 friend constexpr bool
6869 operator<=(const _Iterator& __x, const _Iterator& __y)
6870 requires random_access_range<_Base>
6871 { return !(__y < __x); }
6873 friend constexpr bool
6874 operator>=(const _Iterator& __x, const _Iterator& __y)
6875 requires random_access_range<_Base>
6876 { return !(__x < __y); }
6878 friend constexpr auto
6879 operator<=>(const _Iterator& __x, const _Iterator& __y)
6880 requires random_access_range<_Base>
6881 && three_way_comparable<iterator_t<_Base>>
6882 { return __x._M_current <=> __y._M_current; }
6884 friend constexpr _Iterator
6885 operator+(const _Iterator& __i, difference_type __n)
6886 requires random_access_range<_Base>
6893 friend constexpr _Iterator
6894 operator+(difference_type __n, const _Iterator& __i)
6895 requires random_access_range<_Base>
6902 friend constexpr _Iterator
6903 operator-(const _Iterator& __i, difference_type __n)
6904 requires random_access_range<_Base>
6911 friend constexpr difference_type
6912 operator-(const _Iterator& __x, const _Iterator& __y)
6913 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
6915 if constexpr (_S_last_elt_present)
6916 return __x._M_last_elt - __y._M_last_elt;
6918 return __x._M_current - __y._M_current;
6922 template<forward_range _Vp>
6924 class slide_view<_Vp>::_Sentinel
6926 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
6929 _Sentinel(sentinel_t<_Vp> __end)
6936 _Sentinel() = default;
6938 friend constexpr bool
6939 operator==(const _Iterator<false>& __x, const _Sentinel& __y)
6940 { return __x._M_last_elt == __y._M_end; }
6942 friend constexpr range_difference_t<_Vp>
6943 operator-(const _Iterator<false>& __x, const _Sentinel& __y)
6944 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6945 { return __x._M_last_elt - __y._M_end; }
6947 friend constexpr range_difference_t<_Vp>
6948 operator-(const _Sentinel& __y, const _Iterator<false>& __x)
6949 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6950 { return __y._M_end -__x._M_last_elt; }
6957 template<typename _Range, typename _Dp>
6958 concept __can_slide_view
6959 = requires { slide_view(std::declval<_Range>(), std::declval<_Dp>()); };
6962 struct _Slide : __adaptor::_RangeAdaptor<_Slide>
6964 template<viewable_range _Range, typename _Dp = range_difference_t<_Range>>
6965 requires __detail::__can_slide_view<_Range, _Dp>
6967 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n) const
6968 { return slide_view(std::forward<_Range>(__r), __n); }
6970 using __adaptor::_RangeAdaptor<_Slide>::operator();
6971 static constexpr int _S_arity = 2;
6972 static constexpr bool _S_has_simple_extra_args = true;
6975 inline constexpr _Slide slide;
6977#endif // __cpp_lib_ranges_slide
6979#ifdef __cpp_lib_ranges_chunk_by // C++ >= 23
6980 template<forward_range _Vp,
6981 indirect_binary_predicate<iterator_t<_Vp>, iterator_t<_Vp>> _Pred>
6982 requires view<_Vp> && is_object_v<_Pred>
6983 class chunk_by_view : public view_interface<chunk_by_view<_Vp, _Pred>>
6985 _Vp _M_base = _Vp();
6986 __detail::__box<_Pred> _M_pred;
6987 __detail::_CachedPosition<_Vp> _M_cached_begin;
6989 constexpr iterator_t<_Vp>
6990 _M_find_next(iterator_t<_Vp> __current)
6992 __glibcxx_assert(_M_pred.has_value());
6993 auto __pred = [this]<typename _Tp, typename _Up>(_Tp&& __x, _Up&& __y) {
6994 return !bool((*_M_pred)(std::forward<_Tp>(__x), std::forward<_Up>(__y)));
6996 auto __it = ranges::adjacent_find(__current, ranges::end(_M_base), __pred);
6997 return ranges::next(__it, 1, ranges::end(_M_base));
7000 constexpr iterator_t<_Vp>
7001 _M_find_prev(iterator_t<_Vp> __current) requires bidirectional_range<_Vp>
7003 __glibcxx_assert(_M_pred.has_value());
7004 auto __pred = [this]<typename _Tp, typename _Up>(_Tp&& __x, _Up&& __y) {
7005 return !bool((*_M_pred)(std::forward<_Up>(__y), std::forward<_Tp>(__x)));
7007 auto __rbegin = std::make_reverse_iterator(__current);
7008 auto __rend = std::make_reverse_iterator(ranges::begin(_M_base));
7009 __glibcxx_assert(__rbegin != __rend);
7010 auto __it = ranges::adjacent_find(__rbegin, __rend, __pred).base();
7011 return ranges::prev(__it, 1, ranges::begin(_M_base));
7017 chunk_by_view() requires (default_initializable<_Vp>
7018 && default_initializable<_Pred>)
7022 chunk_by_view(_Vp __base, _Pred __pred)
7023 : _M_base(std::move(__base)), _M_pred(std::move(__pred))
7027 base() const & requires copy_constructible<_Vp>
7032 { return std::move(_M_base); }
7034 constexpr const _Pred&
7036 { return *_M_pred; }
7041 __glibcxx_assert(_M_pred.has_value());
7042 iterator_t<_Vp> __it;
7043 if (_M_cached_begin._M_has_value())
7044 __it = _M_cached_begin._M_get(_M_base);
7047 __it = _M_find_next(ranges::begin(_M_base));
7048 _M_cached_begin._M_set(_M_base, __it);
7050 return _Iterator(*this, ranges::begin(_M_base), __it);
7056 if constexpr (common_range<_Vp>)
7057 return _Iterator(*this, ranges::end(_M_base), ranges::end(_M_base));
7059 return default_sentinel;
7063 template<typename _Range, typename _Pred>
7064 chunk_by_view(_Range&&, _Pred) -> chunk_by_view<views::all_t<_Range>, _Pred>;
7066 template<forward_range _Vp,
7067 indirect_binary_predicate<iterator_t<_Vp>, iterator_t<_Vp>> _Pred>
7068 requires view<_Vp> && is_object_v<_Pred>
7069 class chunk_by_view<_Vp, _Pred>::_Iterator
7071 chunk_by_view* _M_parent = nullptr;
7072 iterator_t<_Vp> _M_current = iterator_t<_Vp>();
7073 iterator_t<_Vp> _M_next = iterator_t<_Vp>();
7076 _Iterator(chunk_by_view& __parent, iterator_t<_Vp> __current, iterator_t<_Vp> __next)
7077 : _M_parent(std::__addressof(__parent)), _M_current(__current), _M_next(__next)
7083 if constexpr (bidirectional_range<_Vp>)
7084 return bidirectional_iterator_tag{};
7086 return forward_iterator_tag{};
7089 friend chunk_by_view;
7092 using value_type = subrange<iterator_t<_Vp>>;
7093 using difference_type = range_difference_t<_Vp>;
7094 using iterator_category = input_iterator_tag;
7095 using iterator_concept = decltype(_S_iter_concept());
7097 _Iterator() = default;
7099 constexpr value_type
7102 __glibcxx_assert(_M_current != _M_next);
7103 return ranges::subrange(_M_current, _M_next);
7106 constexpr _Iterator&
7109 __glibcxx_assert(_M_current != _M_next);
7110 _M_current = _M_next;
7111 _M_next = _M_parent->_M_find_next(_M_current);
7123 constexpr _Iterator&
7124 operator--() requires bidirectional_range<_Vp>
7126 _M_next = _M_current;
7127 _M_current = _M_parent->_M_find_prev(_M_next);
7132 operator--(int) requires bidirectional_range<_Vp>
7139 friend constexpr bool
7140 operator==(const _Iterator& __x, const _Iterator& __y)
7141 { return __x._M_current == __y._M_current; }
7143 friend constexpr bool
7144 operator==(const _Iterator& __x, default_sentinel_t)
7145 { return __x._M_current == __x._M_next; }
7152 template<typename _Range, typename _Pred>
7153 concept __can_chunk_by_view
7154 = requires { chunk_by_view(std::declval<_Range>(), std::declval<_Pred>()); };
7157 struct _ChunkBy : __adaptor::_RangeAdaptor<_ChunkBy>
7159 template<viewable_range _Range, typename _Pred>
7160 requires __detail::__can_chunk_by_view<_Range, _Pred>
7162 operator() [[nodiscard]] (_Range&& __r, _Pred&& __pred) const
7163 { return chunk_by_view(std::forward<_Range>(__r), std::forward<_Pred>(__pred)); }
7165 using __adaptor::_RangeAdaptor<_ChunkBy>::operator();
7166 static constexpr int _S_arity = 2;
7167 static constexpr bool _S_has_simple_extra_args = true;
7170 inline constexpr _ChunkBy chunk_by;
7172#endif // __cpp_lib_ranges_chunk_by
7174#ifdef __cpp_lib_ranges_join_with // C++ >= 23
7177 template<typename _Range, typename _Pattern>
7178 concept __compatible_joinable_ranges
7179 = common_with<range_value_t<_Range>, range_value_t<_Pattern>>
7180 && common_reference_with<range_reference_t<_Range>,
7181 range_reference_t<_Pattern>>
7182 && common_reference_with<range_rvalue_reference_t<_Range>,
7183 range_rvalue_reference_t<_Pattern>>;
7185 template<typename _Range>
7186 concept __bidirectional_common = bidirectional_range<_Range> && common_range<_Range>;
7189 template<input_range _Vp, forward_range _Pattern>
7190 requires view<_Vp> && view<_Pattern>
7191 && input_range<range_reference_t<_Vp>>
7192 && __detail::__compatible_joinable_ranges<range_reference_t<_Vp>, _Pattern>
7193 class join_with_view : public view_interface<join_with_view<_Vp, _Pattern>>
7195 using _InnerRange = range_reference_t<_Vp>;
7197 _Vp _M_base = _Vp();
7198 [[no_unique_address]]
7199 __detail::__maybe_present_t<!forward_range<_Vp>,
7200 __detail::__non_propagating_cache<iterator_t<_Vp>>> _M_outer_it;
7201 __detail::__non_propagating_cache<remove_cv_t<_InnerRange>> _M_inner;
7202 _Pattern _M_pattern = _Pattern();
7204 template<bool _Const> using _Base = __detail::__maybe_const_t<_Const, _Vp>;
7205 template<bool _Const> using _InnerBase = range_reference_t<_Base<_Const>>;
7206 template<bool _Const> using _PatternBase = __detail::__maybe_const_t<_Const, _Pattern>;
7208 template<bool _Const> using _OuterIter = iterator_t<_Base<_Const>>;
7209 template<bool _Const> using _InnerIter = iterator_t<_InnerBase<_Const>>;
7210 template<bool _Const> using _PatternIter = iterator_t<_PatternBase<_Const>>;
7212 template<bool _Const>
7213 static constexpr bool _S_ref_is_glvalue = is_reference_v<_InnerBase<_Const>>;
7215 template<bool _Const>
7219 template<bool _Const>
7220 requires _S_ref_is_glvalue<_Const>
7221 && forward_range<_Base<_Const>>
7222 && forward_range<_InnerBase<_Const>>
7223 struct __iter_cat<_Const>
7229 using _OuterIter = join_with_view::_OuterIter<_Const>;
7230 using _InnerIter = join_with_view::_InnerIter<_Const>;
7231 using _PatternIter = join_with_view::_PatternIter<_Const>;
7232 using _OuterCat = typename iterator_traits<_OuterIter>::iterator_category;
7233 using _InnerCat = typename iterator_traits<_InnerIter>::iterator_category;
7234 using _PatternCat = typename iterator_traits<_PatternIter>::iterator_category;
7235 // _GLIBCXX_RESOLVE_LIB_DEFECTS
7236 // 3798. Rvalue reference and iterator_category
7237 if constexpr (!is_reference_v<common_reference_t<iter_reference_t<_InnerIter>,
7238 iter_reference_t<_PatternIter>>>)
7239 return input_iterator_tag{};
7240 else if constexpr (derived_from<_OuterCat, bidirectional_iterator_tag>
7241 && derived_from<_InnerCat, bidirectional_iterator_tag>
7242 && derived_from<_PatternCat, bidirectional_iterator_tag>
7243 && common_range<_InnerBase<_Const>>
7244 && common_range<_PatternBase<_Const>>)
7245 return bidirectional_iterator_tag{};
7246 else if constexpr (derived_from<_OuterCat, forward_iterator_tag>
7247 && derived_from<_InnerCat, forward_iterator_tag>
7248 && derived_from<_PatternCat, forward_iterator_tag>)
7249 return forward_iterator_tag{};
7251 return input_iterator_tag{};
7254 using iterator_category = decltype(_S_iter_cat());
7257 template<bool> struct _Iterator;
7258 template<bool> struct _Sentinel;
7261 join_with_view() requires (default_initializable<_Vp>
7262 && default_initializable<_Pattern>)
7266 join_with_view(_Vp __base, _Pattern __pattern)
7267 : _M_base(std::move(__base)), _M_pattern(std::move(__pattern))
7270 template<input_range _Range>
7271 requires constructible_from<_Vp, views::all_t<_Range>>
7272 && constructible_from<_Pattern, single_view<range_value_t<_InnerRange>>>
7274 join_with_view(_Range&& __r, range_value_t<_InnerRange> __e)
7275 : _M_base(views::all(std::forward<_Range>(__r))),
7276 _M_pattern(views::single(std::move(__e)))
7280 base() const& requires copy_constructible<_Vp>
7285 { return std::move(_M_base); }
7290 if constexpr (forward_range<_Vp>)
7292 constexpr bool __use_const = is_reference_v<_InnerRange>
7293 && __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
7294 return _Iterator<__use_const>{*this, ranges::begin(_M_base)};
7298 _M_outer_it = ranges::begin(_M_base);
7299 return _Iterator<false>{*this};
7305 requires forward_range<const _Vp>
7306 && forward_range<const _Pattern>
7307 && is_reference_v<range_reference_t<const _Vp>>
7308 && input_range<range_reference_t<const _Vp>>
7309 { return _Iterator<true>{*this, ranges::begin(_M_base)}; }
7314 constexpr bool __use_const
7315 = __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
7316 if constexpr (is_reference_v<_InnerRange>
7317 && forward_range<_Vp> && common_range<_Vp>
7318 && forward_range<_InnerRange> && common_range<_InnerRange>)
7319 return _Iterator<__use_const>{*this, ranges::end(_M_base)};
7321 return _Sentinel<__use_const>{*this};
7326 requires forward_range<const _Vp>
7327 && forward_range<const _Pattern>
7328 && is_reference_v<range_reference_t<const _Vp>>
7329 && input_range<range_reference_t<const _Vp>>
7331 using _InnerConstRange = range_reference_t<const _Vp>;
7332 if constexpr (forward_range<_InnerConstRange>
7333 && common_range<const _Vp>
7334 && common_range<_InnerConstRange>)
7335 return _Iterator<true>{*this, ranges::end(_M_base)};
7337 return _Sentinel<true>{*this};
7341 template<typename _Range, typename _Pattern>
7342 join_with_view(_Range&&, _Pattern&&)
7343 -> join_with_view<views::all_t<_Range>, views::all_t<_Pattern>>;
7345 template<input_range _Range>
7346 join_with_view(_Range&&, range_value_t<range_reference_t<_Range>>)
7347 -> join_with_view<views::all_t<_Range>,
7348 single_view<range_value_t<range_reference_t<_Range>>>>;
7350 template<input_range _Vp, forward_range _Pattern>
7351 requires view<_Vp> && view<_Pattern>
7352 && input_range<range_reference_t<_Vp>>
7353 && __detail::__compatible_joinable_ranges<range_reference_t<_Vp>, _Pattern>
7354 template<bool _Const>
7355 class join_with_view<_Vp, _Pattern>::_Iterator : public __iter_cat<_Const>
7357 using _Parent = __detail::__maybe_const_t<_Const, join_with_view>;
7358 using _Base = join_with_view::_Base<_Const>;
7359 using _InnerBase = join_with_view::_InnerBase<_Const>;
7360 using _PatternBase = join_with_view::_PatternBase<_Const>;
7362 using _OuterIter = join_with_view::_OuterIter<_Const>;
7363 using _InnerIter = join_with_view::_InnerIter<_Const>;
7364 using _PatternIter = join_with_view::_PatternIter<_Const>;
7366 static constexpr bool _S_ref_is_glvalue = join_with_view::_S_ref_is_glvalue<_Const>;
7368 _Parent* _M_parent = nullptr;
7369 [[no_unique_address]]
7370 __detail::__maybe_present_t<forward_range<_Base>, _OuterIter> _M_outer_it;
7371 variant<_PatternIter, _InnerIter> _M_inner_it;
7373 constexpr _OuterIter&
7376 if constexpr (forward_range<_Base>)
7379 return *_M_parent->_M_outer_it;
7382 constexpr const _OuterIter&
7383 _M_get_outer() const
7385 if constexpr (forward_range<_Base>)
7388 return *_M_parent->_M_outer_it;
7392 _Iterator(_Parent& __parent, _OuterIter __outer)
7393 requires forward_range<_Base>
7394 : _M_parent(std::__addressof(__parent)), _M_outer_it(std::move(__outer))
7396 if (_M_get_outer() != ranges::end(_M_parent->_M_base))
7398 auto&& __inner = _M_update_inner();
7399 _M_inner_it.template emplace<1>(ranges::begin(__inner));
7405 _Iterator(_Parent& __parent)
7406 requires (!forward_range<_Base>)
7407 : _M_parent(std::__addressof(__parent))
7409 if (_M_get_outer() != ranges::end(_M_parent->_M_base))
7411 auto&& __inner = _M_update_inner();
7412 _M_inner_it.template emplace<1>(ranges::begin(__inner));
7420 _OuterIter& __outer = _M_get_outer();
7421 if constexpr (_S_ref_is_glvalue)
7422 return __detail::__as_lvalue(*__outer);
7424 return _M_parent->_M_inner._M_emplace_deref(__outer);
7430 if constexpr (_S_ref_is_glvalue)
7431 return __detail::__as_lvalue(*_M_get_outer());
7433 return *_M_parent->_M_inner;
7441 if (_M_inner_it.index() == 0)
7443 if (std::get<0>(_M_inner_it) != ranges::end(_M_parent->_M_pattern))
7446 auto&& __inner = _M_update_inner();
7447 _M_inner_it.template emplace<1>(ranges::begin(__inner));
7451 auto&& __inner = _M_get_inner();
7452 if (std::get<1>(_M_inner_it) != ranges::end(__inner))
7455 if (++_M_get_outer() == ranges::end(_M_parent->_M_base))
7457 if constexpr (_S_ref_is_glvalue)
7458 _M_inner_it.template emplace<0>();
7462 _M_inner_it.template emplace<0>(ranges::begin(_M_parent->_M_pattern));
7470 if constexpr (_S_ref_is_glvalue
7471 && bidirectional_range<_Base>
7472 && __detail::__bidirectional_common<_InnerBase>
7473 && __detail::__bidirectional_common<_PatternBase>)
7474 return bidirectional_iterator_tag{};
7475 else if constexpr (_S_ref_is_glvalue
7476 && forward_range<_Base>
7477 && forward_range<_InnerBase>)
7478 return forward_iterator_tag{};
7480 return input_iterator_tag{};
7483 friend join_with_view;
7486 using iterator_concept = decltype(_S_iter_concept());
7487 // iterator_category defined in join_with_view::__iter_cat
7488 using value_type = common_type_t<iter_value_t<_InnerIter>,
7489 iter_value_t<_PatternIter>>;
7490 using difference_type = common_type_t<iter_difference_t<_OuterIter>,
7491 iter_difference_t<_InnerIter>,
7492 iter_difference_t<_PatternIter>>;
7494 _Iterator() = default;
7497 _Iterator(_Iterator<!_Const> __i)
7499 && convertible_to<iterator_t<_Vp>, _OuterIter>
7500 && convertible_to<iterator_t<_InnerRange>, _InnerIter>
7501 && convertible_to<iterator_t<_Pattern>, _PatternIter>
7502 : _M_parent(__i._M_parent),
7503 _M_outer_it(std::move(__i._M_outer_it))
7505 if (__i._M_inner_it.index() == 0)
7506 _M_inner_it.template emplace<0>(std::get<0>(std::move(__i._M_inner_it)));
7508 _M_inner_it.template emplace<1>(std::get<1>(std::move(__i._M_inner_it)));
7511 constexpr common_reference_t<iter_reference_t<_InnerIter>,
7512 iter_reference_t<_PatternIter>>
7515 if (_M_inner_it.index() == 0)
7516 return *std::get<0>(_M_inner_it);
7518 return *std::get<1>(_M_inner_it);
7521 constexpr _Iterator&
7524 if (_M_inner_it.index() == 0)
7525 ++std::get<0>(_M_inner_it);
7527 ++std::get<1>(_M_inner_it);
7538 requires _S_ref_is_glvalue
7539 && forward_iterator<_OuterIter> && forward_iterator<_InnerIter>
7541 _Iterator __tmp = *this;
7546 constexpr _Iterator&
7548 requires _S_ref_is_glvalue
7549 && bidirectional_range<_Base>
7550 && __detail::__bidirectional_common<_InnerBase>
7551 && __detail::__bidirectional_common<_PatternBase>
7553 if (_M_outer_it == ranges::end(_M_parent->_M_base))
7555 auto&& __inner = *--_M_outer_it;
7556 _M_inner_it.template emplace<1>(ranges::end(__inner));
7561 if (_M_inner_it.index() == 0)
7563 auto& __it = std::get<0>(_M_inner_it);
7564 if (__it == ranges::begin(_M_parent->_M_pattern))
7566 auto&& __inner = *--_M_outer_it;
7567 _M_inner_it.template emplace<1>(ranges::end(__inner));
7574 auto& __it = std::get<1>(_M_inner_it);
7575 auto&& __inner = *_M_outer_it;
7576 if (__it == ranges::begin(__inner))
7577 _M_inner_it.template emplace<0>(ranges::end(_M_parent->_M_pattern));
7583 if (_M_inner_it.index() == 0)
7584 --std::get<0>(_M_inner_it);
7586 --std::get<1>(_M_inner_it);
7592 requires _S_ref_is_glvalue && bidirectional_range<_Base>
7593 && __detail::__bidirectional_common<_InnerBase>
7594 && __detail::__bidirectional_common<_PatternBase>
7596 _Iterator __tmp = *this;
7601 friend constexpr bool
7602 operator==(const _Iterator& __x, const _Iterator& __y)
7603 requires _S_ref_is_glvalue
7604 && forward_range<_Base> && equality_comparable<_InnerIter>
7605 { return __x._M_outer_it == __y._M_outer_it && __x._M_inner_it ==__y._M_inner_it; }
7607 friend constexpr common_reference_t<iter_rvalue_reference_t<_InnerIter>,
7608 iter_rvalue_reference_t<_PatternIter>>
7609 iter_move(const _Iterator& __x)
7611 if (__x._M_inner_it.index() == 0)
7612 return ranges::iter_move(std::get<0>(__x._M_inner_it));
7614 return ranges::iter_move(std::get<1>(__x._M_inner_it));
7617 friend constexpr void
7618 iter_swap(const _Iterator& __x, const _Iterator& __y)
7619 requires indirectly_swappable<_InnerIter, _PatternIter>
7621 if (__x._M_inner_it.index() == 0)
7623 if (__y._M_inner_it.index() == 0)
7624 ranges::iter_swap(std::get<0>(__x._M_inner_it), std::get<0>(__y._M_inner_it));
7626 ranges::iter_swap(std::get<0>(__x._M_inner_it), std::get<1>(__y._M_inner_it));
7630 if (__y._M_inner_it.index() == 0)
7631 ranges::iter_swap(std::get<1>(__x._M_inner_it), std::get<0>(__y._M_inner_it));
7633 ranges::iter_swap(std::get<1>(__x._M_inner_it), std::get<1>(__y._M_inner_it));
7638 template<input_range _Vp, forward_range _Pattern>
7639 requires view<_Vp> && view<_Pattern>
7640 && input_range<range_reference_t<_Vp>>
7641 && __detail::__compatible_joinable_ranges<range_reference_t<_Vp>, _Pattern>
7642 template<bool _Const>
7643 class join_with_view<_Vp, _Pattern>::_Sentinel
7645 using _Parent = __detail::__maybe_const_t<_Const, join_with_view>;
7646 using _Base = join_with_view::_Base<_Const>;
7648 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
7651 _Sentinel(_Parent& __parent)
7652 : _M_end(ranges::end(__parent._M_base))
7655 friend join_with_view;
7658 _Sentinel() = default;
7661 _Sentinel(_Sentinel<!_Const> __s)
7662 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
7663 : _M_end(std::move(__s._M_end))
7666 template<bool _OtherConst>
7667 requires sentinel_for<sentinel_t<_Base>,
7668 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
7669 friend constexpr bool
7670 operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
7671 { return __x._M_get_outer() == __y._M_end; }
7678 template<typename _Range, typename _Pattern>
7679 concept __can_join_with_view
7680 = requires { join_with_view(std::declval<_Range>(), std::declval<_Pattern>()); };
7681 } // namespace __detail
7683 struct _JoinWith : __adaptor::_RangeAdaptor<_JoinWith>
7685 template<viewable_range _Range, typename _Pattern>
7686 requires __detail::__can_join_with_view<_Range, _Pattern>
7688 operator() [[nodiscard]] (_Range&& __r, _Pattern&& __f) const
7690 return join_with_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
7693 using _RangeAdaptor<_JoinWith>::operator();
7694 static constexpr int _S_arity = 2;
7695 template<typename _Pattern>
7696 static constexpr bool _S_has_simple_extra_args
7697 = _LazySplit::_S_has_simple_extra_args<_Pattern>;
7700 inline constexpr _JoinWith join_with;
7701 } // namespace views
7702#endif // __cpp_lib_ranges_join_with
7704#ifdef __cpp_lib_ranges_repeat // C++ >= 23
7705 template<move_constructible _Tp, semiregular _Bound = unreachable_sentinel_t>
7706 requires is_object_v<_Tp> && same_as<_Tp, remove_cv_t<_Tp>>
7707 && (__detail::__is_integer_like<_Bound> || same_as<_Bound, unreachable_sentinel_t>)
7708 class repeat_view : public view_interface<repeat_view<_Tp, _Bound>>
7710 __detail::__box<_Tp> _M_value;
7711 [[no_unique_address]] _Bound _M_bound = _Bound();
7715 template<typename _Range>
7716 friend constexpr auto
7717 views::__detail::__take_of_repeat_view(_Range&&, range_difference_t<_Range>);
7719 template<typename _Range>
7720 friend constexpr auto
7721 views::__detail::__drop_of_repeat_view(_Range&&, range_difference_t<_Range>);
7724 repeat_view() requires default_initializable<_Tp> = default;
7727 repeat_view(const _Tp& __value, _Bound __bound = _Bound())
7728 requires copy_constructible<_Tp>
7729 : _M_value(__value), _M_bound(__bound)
7731 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7732 __glibcxx_assert(__bound >= 0);
7736 repeat_view(_Tp&& __value, _Bound __bound = _Bound())
7737 : _M_value(std::move(__value)), _M_bound(__bound)
7740 template<typename... _Args, typename... _BoundArgs>
7741 requires constructible_from<_Tp, _Args...>
7742 && constructible_from<_Bound, _BoundArgs...>
7744 repeat_view(piecewise_construct_t,
7745 tuple<_Args...> __args,
7746 tuple<_BoundArgs...> __bound_args = tuple<>{})
7747 : _M_value(std::make_from_tuple<_Tp>(std::move(__args))),
7748 _M_bound(std::make_from_tuple<_Bound>(std::move(__bound_args)))
7753 { return _Iterator(std::__addressof(*_M_value)); }
7756 end() const requires (!same_as<_Bound, unreachable_sentinel_t>)
7757 { return _Iterator(std::__addressof(*_M_value), _M_bound); }
7759 constexpr unreachable_sentinel_t
7760 end() const noexcept
7761 { return unreachable_sentinel; }
7764 size() const requires (!same_as<_Bound, unreachable_sentinel_t>)
7765 { return __detail::__to_unsigned_like(_M_bound); }
7768 // _GLIBCXX_RESOLVE_LIB_DEFECTS
7769 // 4053. Unary call to std::views::repeat does not decay the argument
7770 template<typename _Tp, typename _Bound = unreachable_sentinel_t>
7771 repeat_view(_Tp, _Bound = _Bound()) -> repeat_view<_Tp, _Bound>;
7773 template<move_constructible _Tp, semiregular _Bound>
7774 requires is_object_v<_Tp> && same_as<_Tp, remove_cv_t<_Tp>>
7775 && (__detail::__is_integer_like<_Bound> || same_as<_Bound, unreachable_sentinel_t>)
7776 class repeat_view<_Tp, _Bound>::_Iterator
7779 = __conditional_t<same_as<_Bound, unreachable_sentinel_t>, ptrdiff_t, _Bound>;
7781 const _Tp* _M_value = nullptr;
7782 __index_type _M_current = __index_type();
7785 _Iterator(const _Tp* __value, __index_type __bound = __index_type())
7786 : _M_value(__value), _M_current(__bound)
7788 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7789 __glibcxx_assert(__bound >= 0);
7795 using iterator_concept = random_access_iterator_tag;
7796 using iterator_category = random_access_iterator_tag;
7797 using value_type = _Tp;
7798 using difference_type = __conditional_t<__detail::__is_signed_integer_like<__index_type>,
7800 __detail::__iota_diff_t<__index_type>>;
7802 _Iterator() = default;
7804 constexpr const _Tp&
7805 operator*() const noexcept
7806 { return *_M_value; }
7808 constexpr _Iterator&
7823 constexpr _Iterator&
7826 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7827 __glibcxx_assert(_M_current > 0);
7840 constexpr _Iterator&
7841 operator+=(difference_type __n)
7843 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7844 __glibcxx_assert(_M_current + __n >= 0);
7849 constexpr _Iterator&
7850 operator-=(difference_type __n)
7852 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7853 __glibcxx_assert(_M_current - __n >= 0);
7858 constexpr const _Tp&
7859 operator[](difference_type __n) const noexcept
7860 { return *(*this + __n); }
7862 friend constexpr bool
7863 operator==(const _Iterator& __x, const _Iterator& __y)
7864 { return __x._M_current == __y._M_current; }
7866 friend constexpr auto
7867 operator<=>(const _Iterator& __x, const _Iterator& __y)
7868 { return __x._M_current <=> __y._M_current; }
7870 friend constexpr _Iterator
7871 operator+(_Iterator __i, difference_type __n)
7877 friend constexpr _Iterator
7878 operator+(difference_type __n, _Iterator __i)
7879 { return __i + __n; }
7881 friend constexpr _Iterator
7882 operator-(_Iterator __i, difference_type __n)
7888 friend constexpr difference_type
7889 operator-(const _Iterator& __x, const _Iterator& __y)
7891 return (static_cast<difference_type>(__x._M_current)
7892 - static_cast<difference_type>(__y._M_current));
7900 template<typename _Tp, typename _Bound>
7901 inline constexpr bool __is_repeat_view<repeat_view<_Tp, _Bound>> = true;
7903 template<typename _Tp>
7904 concept __can_repeat_view
7905 = requires { repeat_view(std::declval<_Tp>()); };
7907 template<typename _Tp, typename _Bound>
7908 concept __can_bounded_repeat_view
7909 = requires { repeat_view(std::declval<_Tp>(), std::declval<_Bound>()); };
7914 template<typename _Tp>
7915 requires __detail::__can_repeat_view<_Tp>
7917 operator() [[nodiscard]] (_Tp&& __value) const
7919 // _GLIBCXX_RESOLVE_LIB_DEFECTS
7920 // 4054. Repeating a repeat_view should repeat the view
7921 return repeat_view<decay_t<_Tp>>(std::forward<_Tp>(__value));
7924 template<typename _Tp, typename _Bound>
7925 requires __detail::__can_bounded_repeat_view<_Tp, _Bound>
7927 operator() [[nodiscard]] (_Tp&& __value, _Bound __bound) const
7928 { return repeat_view(std::forward<_Tp>(__value), __bound); }
7931 inline constexpr _Repeat repeat;
7935 template<typename _Range>
7937 __take_of_repeat_view(_Range&& __r, range_difference_t<_Range> __n)
7939 using _Tp = remove_cvref_t<_Range>;
7940 static_assert(__is_repeat_view<_Tp>);
7941 if constexpr (sized_range<_Tp>)
7942 return views::repeat(*std::forward<_Range>(__r)._M_value,
7943 std::min(ranges::distance(__r), __n));
7945 return views::repeat(*std::forward<_Range>(__r)._M_value, __n);
7948 template<typename _Range>
7950 __drop_of_repeat_view(_Range&& __r, range_difference_t<_Range> __n)
7952 using _Tp = remove_cvref_t<_Range>;
7953 static_assert(__is_repeat_view<_Tp>);
7954 if constexpr (sized_range<_Tp>)
7956 auto __sz = ranges::distance(__r);
7957 return views::repeat(*std::forward<_Range>(__r)._M_value,
7958 __sz - std::min(__sz, __n));
7965#endif // __cpp_lib_ranges_repeat
7967#ifdef __cpp_lib_ranges_stride // C++ >= 23
7968 template<input_range _Vp>
7970 class stride_view : public view_interface<stride_view<_Vp>>
7973 range_difference_t<_Vp> _M_stride;
7975 template<bool _Const> using _Base = __detail::__maybe_const_t<_Const, _Vp>;
7977 template<bool _Const>
7981 template<bool _Const>
7982 requires forward_range<_Base<_Const>>
7983 struct __iter_cat<_Const>
7989 using _Cat = typename iterator_traits<iterator_t<_Base<_Const>>>::iterator_category;
7990 if constexpr (derived_from<_Cat, random_access_iterator_tag>)
7991 return random_access_iterator_tag{};
7996 using iterator_category = decltype(_S_iter_cat());
7999 template<bool> class _Iterator;
8003 stride_view(_Vp __base, range_difference_t<_Vp> __stride)
8004 : _M_base(std::move(__base)), _M_stride(__stride)
8005 { __glibcxx_assert(__stride > 0); }
8008 base() const& requires copy_constructible<_Vp>
8013 { return std::move(_M_base); }
8015 constexpr range_difference_t<_Vp>
8016 stride() const noexcept
8017 { return _M_stride; }
8020 begin() requires (!__detail::__simple_view<_Vp>)
8021 { return _Iterator<false>(this, ranges::begin(_M_base)); }
8024 begin() const requires range<const _Vp>
8025 { return _Iterator<true>(this, ranges::begin(_M_base)); }
8028 end() requires (!__detail::__simple_view<_Vp>)
8030 if constexpr (common_range<_Vp> && sized_range<_Vp> && forward_range<_Vp>)
8032 auto __missing = (_M_stride - ranges::distance(_M_base) % _M_stride) % _M_stride;
8033 return _Iterator<false>(this, ranges::end(_M_base), __missing);
8035 else if constexpr (common_range<_Vp> && !bidirectional_range<_Vp>)
8036 return _Iterator<false>(this, ranges::end(_M_base));
8038 return default_sentinel;
8042 end() const requires range<const _Vp>
8044 if constexpr (common_range<const _Vp> && sized_range<const _Vp>
8045 && forward_range<const _Vp>)
8047 auto __missing = (_M_stride - ranges::distance(_M_base) % _M_stride) % _M_stride;
8048 return _Iterator<true>(this, ranges::end(_M_base), __missing);
8050 else if constexpr (common_range<const _Vp> && !bidirectional_range<const _Vp>)
8051 return _Iterator<true>(this, ranges::end(_M_base));
8053 return default_sentinel;
8057 size() requires sized_range<_Vp>
8059 return __detail::__to_unsigned_like
8060 (__detail::__div_ceil(ranges::distance(_M_base), _M_stride));
8064 size() const requires sized_range<const _Vp>
8066 return __detail::__to_unsigned_like
8067 (__detail::__div_ceil(ranges::distance(_M_base), _M_stride));
8071 template<typename _Range>
8072 stride_view(_Range&&, range_difference_t<_Range>) -> stride_view<views::all_t<_Range>>;
8074 template<typename _Vp>
8075 inline constexpr bool enable_borrowed_range<stride_view<_Vp>>
8076 = enable_borrowed_range<_Vp>;
8078 template<input_range _Vp>
8080 template<bool _Const>
8081 class stride_view<_Vp>::_Iterator : public __iter_cat<_Const>
8083 using _Parent = __detail::__maybe_const_t<_Const, stride_view>;
8084 using _Base = stride_view::_Base<_Const>;
8086 iterator_t<_Base> _M_current = iterator_t<_Base>();
8087 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
8088 range_difference_t<_Base> _M_stride = 0;
8089 range_difference_t<_Base> _M_missing = 0;
8092 _Iterator(_Parent* __parent, iterator_t<_Base> __current,
8093 range_difference_t<_Base> __missing = 0)
8094 : _M_current(std::move(__current)), _M_end(ranges::end(__parent->_M_base)),
8095 _M_stride(__parent->_M_stride), _M_missing(__missing)
8101 if constexpr (random_access_range<_Base>)
8102 return random_access_iterator_tag{};
8103 else if constexpr (bidirectional_range<_Base>)
8104 return bidirectional_iterator_tag{};
8105 else if constexpr (forward_range<_Base>)
8106 return forward_iterator_tag{};
8108 return input_iterator_tag{};
8114 using difference_type = range_difference_t<_Base>;
8115 using value_type = range_value_t<_Base>;
8116 using iterator_concept = decltype(_S_iter_concept());
8117 // iterator_category defined in stride_view::__iter_cat
8119 _Iterator() requires default_initializable<iterator_t<_Base>> = default;
8122 _Iterator(_Iterator<!_Const> __other)
8124 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
8125 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
8126 : _M_current(std::move(__other._M_current)), _M_end(std::move(__other._M_end)),
8127 _M_stride(__other._M_stride), _M_missing(__other._M_missing)
8130 constexpr iterator_t<_Base>
8132 { return std::move(_M_current); }
8134 constexpr const iterator_t<_Base>&
8135 base() const & noexcept
8136 { return _M_current; }
8138 constexpr decltype(auto)
8140 { return *_M_current; }
8142 constexpr _Iterator&
8145 __glibcxx_assert(_M_current != _M_end);
8146 _M_missing = ranges::advance(_M_current, _M_stride, _M_end);
8155 operator++(int) requires forward_range<_Base>
8162 constexpr _Iterator&
8163 operator--() requires bidirectional_range<_Base>
8165 ranges::advance(_M_current, _M_missing - _M_stride);
8171 operator--(int) requires bidirectional_range<_Base>
8178 constexpr _Iterator&
8179 operator+=(difference_type __n) requires random_access_range<_Base>
8183 __glibcxx_assert(ranges::distance(_M_current, _M_end) > _M_stride * (__n - 1));
8184 _M_missing = ranges::advance(_M_current, _M_stride * __n, _M_end);
8188 ranges::advance(_M_current, _M_stride * __n + _M_missing);
8194 constexpr _Iterator&
8195 operator-=(difference_type __n) requires random_access_range<_Base>
8196 { return *this += -__n; }
8198 constexpr decltype(auto) operator[](difference_type __n) const
8199 requires random_access_range<_Base>
8200 { return *(*this + __n); }
8202 friend constexpr bool
8203 operator==(const _Iterator& __x, default_sentinel_t)
8204 { return __x._M_current == __x._M_end; }
8206 friend constexpr bool
8207 operator==(const _Iterator& __x, const _Iterator& __y)
8208 requires equality_comparable<iterator_t<_Base>>
8209 { return __x._M_current == __y._M_current; }
8211 friend constexpr bool
8212 operator<(const _Iterator& __x, const _Iterator& __y)
8213 requires random_access_range<_Base>
8214 { return __x._M_current < __y._M_current; }
8216 friend constexpr bool
8217 operator>(const _Iterator& __x, const _Iterator& __y)
8218 requires random_access_range<_Base>
8219 { return __y._M_current < __x._M_current; }
8221 friend constexpr bool
8222 operator<=(const _Iterator& __x, const _Iterator& __y)
8223 requires random_access_range<_Base>
8224 { return !(__y._M_current < __x._M_current); }
8226 friend constexpr bool
8227 operator>=(const _Iterator& __x, const _Iterator& __y)
8228 requires random_access_range<_Base>
8229 { return !(__x._M_current < __y._M_current); }
8231 friend constexpr auto
8232 operator<=>(const _Iterator& __x, const _Iterator& __y)
8233 requires random_access_range<_Base> && three_way_comparable<iterator_t<_Base>>
8234 { return __x._M_current <=> __y._M_current; }
8236 friend constexpr _Iterator
8237 operator+(const _Iterator& __i, difference_type __n)
8238 requires random_access_range<_Base>
8245 friend constexpr _Iterator
8246 operator+(difference_type __n, const _Iterator& __i)
8247 requires random_access_range<_Base>
8248 { return __i + __n; }
8250 friend constexpr _Iterator
8251 operator-(const _Iterator& __i, difference_type __n)
8252 requires random_access_range<_Base>
8259 friend constexpr difference_type
8260 operator-(const _Iterator& __x, const _Iterator& __y)
8261 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
8263 auto __n = __x._M_current - __y._M_current;
8264 if constexpr (forward_range<_Base>)
8265 return (__n + __x._M_missing - __y._M_missing) / __x._M_stride;
8267 return -__detail::__div_ceil(-__n, __x._M_stride);
8269 return __detail::__div_ceil(__n, __x._M_stride);
8272 friend constexpr difference_type
8273 operator-(default_sentinel_t __y, const _Iterator& __x)
8274 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
8275 { return __detail::__div_ceil(__x._M_end - __x._M_current, __x._M_stride); }
8277 friend constexpr difference_type
8278 operator-(const _Iterator& __x, default_sentinel_t __y)
8279 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
8280 { return -(__y - __x); }
8282 friend constexpr range_rvalue_reference_t<_Base>
8283 iter_move(const _Iterator& __i)
8284 noexcept(noexcept(ranges::iter_move(__i._M_current)))
8285 { return ranges::iter_move(__i._M_current); }
8287 friend constexpr void
8288 iter_swap(const _Iterator& __x, const _Iterator& __y)
8289 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
8290 requires indirectly_swappable<iterator_t<_Base>>
8291 { ranges::iter_swap(__x._M_current, __y._M_current); }
8298 template<typename _Range, typename _Dp>
8299 concept __can_stride_view
8300 = requires { stride_view(std::declval<_Range>(), std::declval<_Dp>()); };
8303 struct _Stride : __adaptor::_RangeAdaptor<_Stride>
8305 template<viewable_range _Range, typename _Dp = range_difference_t<_Range>>
8306 requires __detail::__can_stride_view<_Range, _Dp>
8308 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n) const
8309 { return stride_view(std::forward<_Range>(__r), __n); }
8311 using __adaptor::_RangeAdaptor<_Stride>::operator();
8312 static constexpr int _S_arity = 2;
8313 static constexpr bool _S_has_simple_extra_args = true;
8316 inline constexpr _Stride stride;
8318#endif // __cpp_lib_ranges_stride
8320#ifdef __cpp_lib_ranges_cartesian_product // C++ >= 23
8323 template<bool _Const, typename _First, typename... _Vs>
8324 concept __cartesian_product_is_random_access
8325 = (random_access_range<__maybe_const_t<_Const, _First>>
8327 && (random_access_range<__maybe_const_t<_Const, _Vs>>
8328 && sized_range<__maybe_const_t<_Const, _Vs>>));
8330 template<typename _Range>
8331 concept __cartesian_product_common_arg
8332 = common_range<_Range> || (sized_range<_Range> && random_access_range<_Range>);
8334 template<bool _Const, typename _First, typename... _Vs>
8335 concept __cartesian_product_is_bidirectional
8336 = (bidirectional_range<__maybe_const_t<_Const, _First>>
8338 && (bidirectional_range<__maybe_const_t<_Const, _Vs>>
8339 && __cartesian_product_common_arg<__maybe_const_t<_Const, _Vs>>));
8341 template<typename _First, typename... _Vs>
8342 concept __cartesian_product_is_common = __cartesian_product_common_arg<_First>;
8344 template<typename... _Vs>
8345 concept __cartesian_product_is_sized = (sized_range<_Vs> && ...);
8347 template<bool _Const, template<typename> class FirstSent, typename _First, typename... _Vs>
8348 concept __cartesian_is_sized_sentinel
8349 = (sized_sentinel_for<FirstSent<__maybe_const_t<_Const, _First>>,
8350 iterator_t<__maybe_const_t<_Const, _First>>>
8352 && (sized_range<__maybe_const_t<_Const, _Vs>>
8353 && sized_sentinel_for<iterator_t<__maybe_const_t<_Const, _Vs>>,
8354 iterator_t<__maybe_const_t<_Const, _Vs>>>));
8356 template<__cartesian_product_common_arg _Range>
8358 __cartesian_common_arg_end(_Range& __r)
8360 if constexpr (common_range<_Range>)
8361 return ranges::end(__r);
8363 return ranges::begin(__r) + ranges::distance(__r);
8365 } // namespace __detail
8367 template<input_range _First, forward_range... _Vs>
8368 requires (view<_First> && ... && view<_Vs>)
8369 class cartesian_product_view : public view_interface<cartesian_product_view<_First, _Vs...>>
8371 tuple<_First, _Vs...> _M_bases;
8373 template<bool> class _Iterator;
8376 _S_difference_type()
8378 // TODO: Implement the recommended practice of using the smallest
8379 // sufficiently wide type according to the maximum sizes of the
8380 // underlying ranges?
8381 return common_type_t<ptrdiff_t,
8382 range_difference_t<_First>,
8383 range_difference_t<_Vs>...>{};
8387 cartesian_product_view() = default;
8390 cartesian_product_view(_First __first, _Vs... __rest)
8391 : _M_bases(std::move(__first), std::move(__rest)...)
8394 constexpr _Iterator<false>
8395 begin() requires (!__detail::__simple_view<_First> || ... || !__detail::__simple_view<_Vs>)
8396 { return _Iterator<false>(*this, __detail::__tuple_transform(ranges::begin, _M_bases)); }
8398 constexpr _Iterator<true>
8399 begin() const requires (range<const _First> && ... && range<const _Vs>)
8400 { return _Iterator<true>(*this, __detail::__tuple_transform(ranges::begin, _M_bases)); }
8402 constexpr _Iterator<false>
8403 end() requires ((!__detail::__simple_view<_First> || ... || !__detail::__simple_view<_Vs>)
8404 && __detail::__cartesian_product_is_common<_First, _Vs...>)
8406 auto __its = [this]<size_t... _Is>(index_sequence<_Is...>) {
8407 using _Ret = tuple<iterator_t<_First>, iterator_t<_Vs>...>;
8408 bool __empty_tail = (ranges::empty(std::get<1 + _Is>(_M_bases)) || ...);
8409 auto& __first = std::get<0>(_M_bases);
8410 return _Ret{(__empty_tail
8411 ? ranges::begin(__first)
8412 : __detail::__cartesian_common_arg_end(__first)),
8413 ranges::begin(std::get<1 + _Is>(_M_bases))...};
8414 }(make_index_sequence<sizeof...(_Vs)>{});
8416 return _Iterator<false>{*this, std::move(__its)};
8419 constexpr _Iterator<true>
8420 end() const requires __detail::__cartesian_product_is_common<const _First, const _Vs...>
8422 auto __its = [this]<size_t... _Is>(index_sequence<_Is...>) {
8423 using _Ret = tuple<iterator_t<const _First>, iterator_t<const _Vs>...>;
8424 bool __empty_tail = (ranges::empty(std::get<1 + _Is>(_M_bases)) || ...);
8425 auto& __first = std::get<0>(_M_bases);
8426 return _Ret{(__empty_tail
8427 ? ranges::begin(__first)
8428 : __detail::__cartesian_common_arg_end(__first)),
8429 ranges::begin(std::get<1 + _Is>(_M_bases))...};
8430 }(make_index_sequence<sizeof...(_Vs)>{});
8432 return _Iterator<true>{*this, std::move(__its)};
8435 constexpr default_sentinel_t
8436 end() const noexcept
8437 { return default_sentinel; }
8440 size() requires __detail::__cartesian_product_is_sized<_First, _Vs...>
8442 using _ST = __detail::__make_unsigned_like_t<decltype(_S_difference_type())>;
8443 return [&]<size_t... _Is>(index_sequence<_Is...>) {
8444 auto __size = static_cast<_ST>(1);
8445#ifdef _GLIBCXX_ASSERTIONS
8446 if constexpr (integral<_ST>)
8449 = (__builtin_mul_overflow(__size,
8450 static_cast<_ST>(ranges::size(std::get<_Is>(_M_bases))),
8453 __glibcxx_assert(!__overflow);
8457 __size = (static_cast<_ST>(ranges::size(std::get<_Is>(_M_bases))) * ...);
8459 }(make_index_sequence<1 + sizeof...(_Vs)>{});
8463 size() const requires __detail::__cartesian_product_is_sized<const _First, const _Vs...>
8465 using _ST = __detail::__make_unsigned_like_t<decltype(_S_difference_type())>;
8466 return [&]<size_t... _Is>(index_sequence<_Is...>) {
8467 auto __size = static_cast<_ST>(1);
8468#ifdef _GLIBCXX_ASSERTIONS
8469 if constexpr (integral<_ST>)
8472 = (__builtin_mul_overflow(__size,
8473 static_cast<_ST>(ranges::size(std::get<_Is>(_M_bases))),
8476 __glibcxx_assert(!__overflow);
8480 __size = (static_cast<_ST>(ranges::size(std::get<_Is>(_M_bases))) * ...);
8482 }(make_index_sequence<1 + sizeof...(_Vs)>{});
8486 template<typename... _Vs>
8487 cartesian_product_view(_Vs&&...) -> cartesian_product_view<views::all_t<_Vs>...>;
8489 template<input_range _First, forward_range... _Vs>
8490 requires (view<_First> && ... && view<_Vs>)
8491 template<bool _Const>
8492 class cartesian_product_view<_First, _Vs...>::_Iterator
8494 using _Parent = __maybe_const_t<_Const, cartesian_product_view>;
8495 _Parent* _M_parent = nullptr;
8496 tuple<iterator_t<__maybe_const_t<_Const, _First>>,
8497 iterator_t<__maybe_const_t<_Const, _Vs>>...> _M_current;
8500 _Iterator(_Parent& __parent, decltype(_M_current) __current)
8501 : _M_parent(std::__addressof(__parent)),
8502 _M_current(std::move(__current))
8508 if constexpr (__detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>)
8509 return random_access_iterator_tag{};
8510 else if constexpr (__detail::__cartesian_product_is_bidirectional<_Const, _First, _Vs...>)
8511 return bidirectional_iterator_tag{};
8512 else if constexpr (forward_range<__maybe_const_t<_Const, _First>>)
8513 return forward_iterator_tag{};
8515 return input_iterator_tag{};
8518 friend cartesian_product_view;
8521 using iterator_category = input_iterator_tag;
8522 using iterator_concept = decltype(_S_iter_concept());
8524 = tuple<range_value_t<__maybe_const_t<_Const, _First>>,
8525 range_value_t<__maybe_const_t<_Const, _Vs>>...>;
8527 = tuple<range_reference_t<__maybe_const_t<_Const, _First>>,
8528 range_reference_t<__maybe_const_t<_Const, _Vs>>...>;
8529 using difference_type = decltype(cartesian_product_view::_S_difference_type());
8531 _Iterator() = default;
8534 _Iterator(_Iterator<!_Const> __i)
8536 && (convertible_to<iterator_t<_First>, iterator_t<const _First>>
8537 && ... && convertible_to<iterator_t<_Vs>, iterator_t<const _Vs>>)
8538 : _M_parent(std::__addressof(__i._M_parent)),
8539 _M_current(std::move(__i._M_current))
8545 auto __f = [](auto& __i) -> decltype(auto) {
8548 return __detail::__tuple_transform(__f, _M_current);
8551 constexpr _Iterator&
8563 operator++(int) requires forward_range<__maybe_const_t<_Const, _First>>
8570 constexpr _Iterator&
8572 requires __detail::__cartesian_product_is_bidirectional<_Const, _First, _Vs...>
8580 requires __detail::__cartesian_product_is_bidirectional<_Const, _First, _Vs...>
8587 constexpr _Iterator&
8588 operator+=(difference_type __x)
8589 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8595 constexpr _Iterator&
8596 operator-=(difference_type __x)
8597 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8598 { return *this += -__x; }
8601 operator[](difference_type __n) const
8602 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8603 { return *((*this) + __n); }
8605 friend constexpr bool
8606 operator==(const _Iterator& __x, const _Iterator& __y)
8607 requires equality_comparable<iterator_t<__maybe_const_t<_Const, _First>>>
8608 { return __x._M_current == __y._M_current; }
8610 friend constexpr bool
8611 operator==(const _Iterator& __x, default_sentinel_t)
8613 return [&]<size_t... _Is>(index_sequence<_Is...>) {
8614 return ((std::get<_Is>(__x._M_current)
8615 == ranges::end(std::get<_Is>(__x._M_parent->_M_bases)))
8617 }(make_index_sequence<1 + sizeof...(_Vs)>{});
8620 friend constexpr auto
8621 operator<=>(const _Iterator& __x, const _Iterator& __y)
8622 requires __detail::__all_random_access<_Const, _First, _Vs...>
8623 { return __x._M_current <=> __y._M_current; }
8625 friend constexpr _Iterator
8626 operator+(_Iterator __x, difference_type __y)
8627 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8628 { return __x += __y; }
8630 friend constexpr _Iterator
8631 operator+(difference_type __x, _Iterator __y)
8632 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8633 { return __y += __x; }
8635 friend constexpr _Iterator
8636 operator-(_Iterator __x, difference_type __y)
8637 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8638 { return __x -= __y; }
8640 friend constexpr difference_type
8641 operator-(const _Iterator& __x, const _Iterator& __y)
8642 requires __detail::__cartesian_is_sized_sentinel<_Const, iterator_t, _First, _Vs...>
8643 { return __x._M_distance_from(__y._M_current); }
8645 friend constexpr difference_type
8646 operator-(const _Iterator& __i, default_sentinel_t)
8647 requires __detail::__cartesian_is_sized_sentinel<_Const, sentinel_t, _First, _Vs...>
8649 tuple __end_tuple = [&]<size_t... _Is>(index_sequence<_Is...>) {
8650 return tuple{ranges::end(std::get<0>(__i._M_parent->_M_bases)),
8651 ranges::begin(std::get<1 + _Is>(__i._M_parent->_M_bases))...};
8652 }(make_index_sequence<sizeof...(_Vs)>{});
8653 return __i._M_distance_from(__end_tuple);
8656 friend constexpr difference_type
8657 operator-(default_sentinel_t, const _Iterator& __i)
8658 requires __detail::__cartesian_is_sized_sentinel<_Const, sentinel_t, _First, _Vs...>
8659 { return -(__i - default_sentinel); }
8661 friend constexpr auto
8662 iter_move(const _Iterator& __i)
8663 { return __detail::__tuple_transform(ranges::iter_move, __i._M_current); }
8665 friend constexpr void
8666 iter_swap(const _Iterator& __l, const _Iterator& __r)
8667 requires (indirectly_swappable<iterator_t<__maybe_const_t<_Const, _First>>>
8669 && indirectly_swappable<iterator_t<__maybe_const_t<_Const, _Vs>>>)
8671 [&]<size_t... _Is>(index_sequence<_Is...>) {
8672 (ranges::iter_swap(std::get<_Is>(__l._M_current), std::get<_Is>(__r._M_current)), ...);
8673 }(make_index_sequence<1 + sizeof...(_Vs)>{});
8677 template<size_t _Nm = sizeof...(_Vs)>
8681 auto& __it = std::get<_Nm>(_M_current);
8683 if constexpr (_Nm > 0)
8684 if (__it == ranges::end(std::get<_Nm>(_M_parent->_M_bases)))
8686 __it = ranges::begin(std::get<_Nm>(_M_parent->_M_bases));
8691 template<size_t _Nm = sizeof...(_Vs)>
8695 auto& __it = std::get<_Nm>(_M_current);
8696 if constexpr (_Nm > 0)
8697 if (__it == ranges::begin(std::get<_Nm>(_M_parent->_M_bases)))
8699 __it = __detail::__cartesian_common_arg_end(std::get<_Nm>(_M_parent->_M_bases));
8705 template<size_t _Nm = sizeof...(_Vs)>
8707 _M_advance(difference_type __x)
8708 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8716 // Constant time iterator advancement.
8717 auto& __r = std::get<_Nm>(_M_parent->_M_bases);
8718 auto& __it = std::get<_Nm>(_M_current);
8719 if constexpr (_Nm == 0)
8721#ifdef _GLIBCXX_ASSERTIONS
8722 if constexpr (sized_range<__maybe_const_t<_Const, _First>>)
8724 auto __size = ranges::ssize(__r);
8725 auto __begin = ranges::begin(__r);
8726 auto __offset = __it - __begin;
8727 __glibcxx_assert(__offset + __x >= 0 && __offset + __x <= __size);
8734 auto __size = ranges::ssize(__r);
8735 auto __begin = ranges::begin(__r);
8736 auto __offset = __it - __begin;
8738 __x = __offset / __size;
8742 __offset = __size + __offset;
8745 __it = __begin + __offset;
8746 _M_advance<_Nm - 1>(__x);
8751 template<typename _Tuple>
8752 constexpr difference_type
8753 _M_distance_from(const _Tuple& __t) const
8755 return [&]<size_t... _Is>(index_sequence<_Is...>) {
8756 auto __sum = static_cast<difference_type>(0);
8757#ifdef _GLIBCXX_ASSERTIONS
8758 if constexpr (integral<difference_type>)
8761 = (__builtin_add_overflow(__sum, _M_scaled_distance<_Is>(__t), &__sum)
8763 __glibcxx_assert(!__overflow);
8767 __sum = (_M_scaled_distance<_Is>(__t) + ...);
8769 }(make_index_sequence<1 + sizeof...(_Vs)>{});
8772 template<size_t _Nm, typename _Tuple>
8773 constexpr difference_type
8774 _M_scaled_distance(const _Tuple& __t) const
8776 auto __dist = static_cast<difference_type>(std::get<_Nm>(_M_current)
8777 - std::get<_Nm>(__t));
8778#ifdef _GLIBCXX_ASSERTIONS
8779 if constexpr (integral<difference_type>)
8781 bool __overflow = __builtin_mul_overflow(__dist, _M_scaled_size<_Nm+1>(), &__dist);
8782 __glibcxx_assert(!__overflow);
8786 __dist *= _M_scaled_size<_Nm+1>();
8790 template<size_t _Nm>
8791 constexpr difference_type
8792 _M_scaled_size() const
8794 if constexpr (_Nm <= sizeof...(_Vs))
8796 auto __size = static_cast<difference_type>(ranges::size
8797 (std::get<_Nm>(_M_parent->_M_bases)));
8798#ifdef _GLIBCXX_ASSERTIONS
8799 if constexpr (integral<difference_type>)
8801 bool __overflow = __builtin_mul_overflow(__size, _M_scaled_size<_Nm+1>(), &__size);
8802 __glibcxx_assert(!__overflow);
8806 __size *= _M_scaled_size<_Nm+1>();
8810 return static_cast<difference_type>(1);
8818 template<typename... _Ts>
8819 concept __can_cartesian_product_view
8820 = requires { cartesian_product_view<all_t<_Ts>...>(std::declval<_Ts>()...); };
8823 struct _CartesianProduct
8825 template<typename... _Ts>
8826 requires (sizeof...(_Ts) == 0 || __detail::__can_cartesian_product_view<_Ts...>)
8828 operator() [[nodiscard]] (_Ts&&... __ts) const
8830 if constexpr (sizeof...(_Ts) == 0)
8831 return views::single(tuple{});
8833 return cartesian_product_view<all_t<_Ts>...>(std::forward<_Ts>(__ts)...);
8837 inline constexpr _CartesianProduct cartesian_product;
8839#endif // __cpp_lib_ranges_cartesian_product
8841#ifdef __cpp_lib_ranges_as_rvalue // C++ >= 23
8842 template<input_range _Vp>
8844 class as_rvalue_view : public view_interface<as_rvalue_view<_Vp>>
8846 _Vp _M_base = _Vp();
8849 as_rvalue_view() requires default_initializable<_Vp> = default;
8852 as_rvalue_view(_Vp __base)
8853 : _M_base(std::move(__base))
8857 base() const& requires copy_constructible<_Vp>
8862 { return std::move(_M_base); }
8865 begin() requires (!__detail::__simple_view<_Vp>)
8866 { return move_iterator(ranges::begin(_M_base)); }
8869 begin() const requires range<const _Vp>
8870 { return move_iterator(ranges::begin(_M_base)); }
8873 end() requires (!__detail::__simple_view<_Vp>)
8875 if constexpr (common_range<_Vp>)
8876 return move_iterator(ranges::end(_M_base));
8878 return move_sentinel(ranges::end(_M_base));
8882 end() const requires range<const _Vp>
8884 if constexpr (common_range<const _Vp>)
8885 return move_iterator(ranges::end(_M_base));
8887 return move_sentinel(ranges::end(_M_base));
8891 size() requires sized_range<_Vp>
8892 { return ranges::size(_M_base); }
8895 size() const requires sized_range<const _Vp>
8896 { return ranges::size(_M_base); }
8899 template<typename _Range>
8900 as_rvalue_view(_Range&&) -> as_rvalue_view<views::all_t<_Range>>;
8902 template<typename _Tp>
8903 inline constexpr bool enable_borrowed_range<as_rvalue_view<_Tp>>
8904 = enable_borrowed_range<_Tp>;
8910 template<typename _Tp>
8911 concept __can_as_rvalue_view = requires { as_rvalue_view(std::declval<_Tp>()); };
8914 struct _AsRvalue : __adaptor::_RangeAdaptorClosure<_AsRvalue>
8916 template<viewable_range _Range>
8917 requires __detail::__can_as_rvalue_view<_Range>
8919 operator() [[nodiscard]] (_Range&& __r) const
8921 if constexpr (same_as<range_rvalue_reference_t<_Range>,
8922 range_reference_t<_Range>>)
8923 return views::all(std::forward<_Range>(__r));
8925 return as_rvalue_view(std::forward<_Range>(__r));
8929 inline constexpr _AsRvalue as_rvalue;
8931#endif // __cpp_lib_as_rvalue
8933#ifdef __cpp_lib_ranges_enumerate // C++ >= 23
8936 template<typename _Range>
8937 concept __range_with_movable_reference = input_range<_Range>
8938 && move_constructible<range_reference_t<_Range>>
8939 && move_constructible<range_rvalue_reference_t<_Range>>;
8943 requires __detail::__range_with_movable_reference<_Vp>
8944 class enumerate_view : public view_interface<enumerate_view<_Vp>>
8946 _Vp _M_base = _Vp();
8948 template<bool _Const> class _Iterator;
8949 template<bool _Const> class _Sentinel;
8952 enumerate_view() requires default_initializable<_Vp> = default;
8955 enumerate_view(_Vp __base)
8956 : _M_base(std::move(__base))
8960 begin() requires (!__detail::__simple_view<_Vp>)
8961 { return _Iterator<false>(ranges::begin(_M_base), 0); }
8964 begin() const requires __detail::__range_with_movable_reference<const _Vp>
8965 { return _Iterator<true>(ranges::begin(_M_base), 0); }
8968 end() requires (!__detail::__simple_view<_Vp>)
8970 if constexpr (common_range<_Vp> && sized_range<_Vp>)
8971 return _Iterator<false>(ranges::end(_M_base), ranges::distance(_M_base));
8973 return _Sentinel<false>(ranges::end(_M_base));
8977 end() const requires __detail::__range_with_movable_reference<const _Vp>
8979 if constexpr (common_range<const _Vp> && sized_range<const _Vp>)
8980 return _Iterator<true>(ranges::end(_M_base), ranges::distance(_M_base));
8982 return _Sentinel<true>(ranges::end(_M_base));
8986 size() requires sized_range<_Vp>
8987 { return ranges::size(_M_base); }
8990 size() const requires sized_range<const _Vp>
8991 { return ranges::size(_M_base); }
8994 base() const & requires copy_constructible<_Vp>
8999 { return std::move(_M_base); }
9002 template<typename _Range>
9003 enumerate_view(_Range&&) -> enumerate_view<views::all_t<_Range>>;
9005 template<typename _Tp>
9006 inline constexpr bool enable_borrowed_range<enumerate_view<_Tp>>
9007 = enable_borrowed_range<_Tp>;
9010 requires __detail::__range_with_movable_reference<_Vp>
9011 template<bool _Const>
9012 class enumerate_view<_Vp>::_Iterator
9014 using _Base = __maybe_const_t<_Const, _Vp>;
9019 if constexpr (random_access_range<_Base>)
9020 return random_access_iterator_tag{};
9021 else if constexpr (bidirectional_range<_Base>)
9022 return bidirectional_iterator_tag{};
9023 else if constexpr (forward_range<_Base>)
9024 return forward_iterator_tag{};
9026 return input_iterator_tag{};
9029 friend enumerate_view;
9032 using iterator_category = input_iterator_tag;
9033 using iterator_concept = decltype(_S_iter_concept());
9034 using difference_type = range_difference_t<_Base>;
9035 using value_type = tuple<difference_type, range_value_t<_Base>>;
9038 using __reference_type = tuple<difference_type, range_reference_t<_Base>>;
9040 iterator_t<_Base> _M_current = iterator_t<_Base>();
9041 difference_type _M_pos = 0;
9044 _Iterator(iterator_t<_Base> __current, difference_type __pos)
9045 : _M_current(std::move(__current)), _M_pos(__pos)
9049 _Iterator() requires default_initializable<iterator_t<_Base>> = default;
9052 _Iterator(_Iterator<!_Const> __i)
9053 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
9054 : _M_current(std::move(__i._M_current)), _M_pos(__i._M_pos)
9057 constexpr const iterator_t<_Base> &
9058 base() const & noexcept
9059 { return _M_current; }
9061 constexpr iterator_t<_Base>
9063 { return std::move(_M_current); }
9065 constexpr difference_type
9066 index() const noexcept
9071 { return __reference_type(_M_pos, *_M_current); }
9073 constexpr _Iterator&
9086 operator++(int) requires forward_range<_Base>
9093 constexpr _Iterator&
9094 operator--() requires bidirectional_range<_Base>
9102 operator--(int) requires bidirectional_range<_Base>
9109 constexpr _Iterator&
9110 operator+=(difference_type __n) requires random_access_range<_Base>
9117 constexpr _Iterator&
9118 operator-=(difference_type __n) requires random_access_range<_Base>
9126 operator[](difference_type __n) const requires random_access_range<_Base>
9127 { return __reference_type(_M_pos + __n, _M_current[__n]); }
9129 friend constexpr bool
9130 operator==(const _Iterator& __x, const _Iterator& __y) noexcept
9131 { return __x._M_pos == __y._M_pos; }
9133 friend constexpr strong_ordering
9134 operator<=>(const _Iterator& __x, const _Iterator& __y) noexcept
9135 { return __x._M_pos <=> __y._M_pos; }
9137 friend constexpr _Iterator
9138 operator+(const _Iterator& __x, difference_type __y)
9139 requires random_access_range<_Base>
9140 { return (auto(__x) += __y); }
9142 friend constexpr _Iterator
9143 operator+(difference_type __x, const _Iterator& __y)
9144 requires random_access_range<_Base>
9145 { return auto(__y) += __x; }
9147 friend constexpr _Iterator
9148 operator-(const _Iterator& __x, difference_type __y)
9149 requires random_access_range<_Base>
9150 { return auto(__x) -= __y; }
9152 friend constexpr difference_type
9153 operator-(const _Iterator& __x, const _Iterator& __y)
9154 { return __x._M_pos - __y._M_pos; }
9156 friend constexpr auto
9157 iter_move(const _Iterator& __i)
9158 noexcept(noexcept(ranges::iter_move(__i._M_current))
9159 && is_nothrow_move_constructible_v<range_rvalue_reference_t<_Base>>)
9161 return tuple<difference_type, range_rvalue_reference_t<_Base>>
9162 (__i._M_pos, ranges::iter_move(__i._M_current));
9167 requires __detail::__range_with_movable_reference<_Vp>
9168 template<bool _Const>
9169 class enumerate_view<_Vp>::_Sentinel
9171 using _Base = __maybe_const_t<_Const, _Vp>;
9173 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
9176 _Sentinel(sentinel_t<_Base> __end)
9177 : _M_end(std::move(__end))
9180 friend enumerate_view;
9183 _Sentinel() = default;
9186 _Sentinel(_Sentinel<!_Const> __other)
9187 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
9188 : _M_end(std::move(__other._M_end))
9191 constexpr sentinel_t<_Base>
9195 template<bool _OtherConst>
9196 requires sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const_t<_OtherConst, _Vp>>>
9197 friend constexpr bool
9198 operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
9199 { return __x._M_current == __y._M_end; }
9201 template<bool _OtherConst>
9202 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const_t<_OtherConst, _Vp>>>
9203 friend constexpr range_difference_t<__maybe_const_t<_OtherConst, _Vp>>
9204 operator-(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
9205 { return __x._M_current - __y._M_end; }
9207 template<bool _OtherConst>
9208 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const_t<_OtherConst, _Vp>>>
9209 friend constexpr range_difference_t<__maybe_const_t<_OtherConst, _Vp>>
9210 operator-(const _Sentinel& __x, const _Iterator<_OtherConst>& __y)
9211 { return __x._M_end - __y._M_current; }
9218 template<typename _Tp>
9219 concept __can_enumerate_view
9220 = requires { enumerate_view<all_t<_Tp>>(std::declval<_Tp>()); };
9223 struct _Enumerate : __adaptor::_RangeAdaptorClosure<_Enumerate>
9225 template<viewable_range _Range>
9226 requires __detail::__can_enumerate_view<_Range>
9228 operator() [[nodiscard]] (_Range&& __r) const
9229 { return enumerate_view<all_t<_Range>>(std::forward<_Range>(__r)); }
9232 inline constexpr _Enumerate enumerate;
9234#endif // __cpp_lib_ranges_enumerate
9236#ifdef __cpp_lib_ranges_as_const // C++ >= 23
9238 requires input_range<_Vp>
9239 class as_const_view : public view_interface<as_const_view<_Vp>>
9241 _Vp _M_base = _Vp();
9244 as_const_view() requires default_initializable<_Vp> = default;
9247 as_const_view(_Vp __base)
9248 noexcept(is_nothrow_move_constructible_v<_Vp>)
9249 : _M_base(std::move(__base))
9254 noexcept(is_nothrow_copy_constructible_v<_Vp>)
9255 requires copy_constructible<_Vp>
9260 noexcept(is_nothrow_move_constructible_v<_Vp>)
9261 { return std::move(_M_base); }
9264 begin() requires (!__detail::__simple_view<_Vp>)
9265 { return ranges::cbegin(_M_base); }
9268 begin() const requires range<const _Vp>
9269 { return ranges::cbegin(_M_base); }
9272 end() requires (!__detail::__simple_view<_Vp>)
9273 { return ranges::cend(_M_base); }
9276 end() const requires range<const _Vp>
9277 { return ranges::cend(_M_base); }
9280 size() requires sized_range<_Vp>
9281 { return ranges::size(_M_base); }
9284 size() const requires sized_range<const _Vp>
9285 { return ranges::size(_M_base); }
9288 template<typename _Range>
9289 as_const_view(_Range&&) -> as_const_view<views::all_t<_Range>>;
9291 template<typename _Tp>
9292 inline constexpr bool enable_borrowed_range<as_const_view<_Tp>>
9293 = enable_borrowed_range<_Tp>;
9299 template<typename _Tp>
9300 inline constexpr bool __is_ref_view = false;
9302 template<typename _Range>
9303 inline constexpr bool __is_ref_view<ref_view<_Range>> = true;
9305 template<typename _Range>
9306 concept __can_as_const_view = requires { as_const_view(std::declval<_Range>()); };
9309 struct _AsConst : __adaptor::_RangeAdaptorClosure<_AsConst>
9311 template<viewable_range _Range>
9313 operator()(_Range&& __r) const
9314 noexcept(noexcept(as_const_view(std::declval<_Range>())))
9315 requires __detail::__can_as_const_view<_Range>
9317 using _Tp = remove_cvref_t<_Range>;
9318 using element_type = remove_reference_t<range_reference_t<_Range>>;
9319 if constexpr (constant_range<views::all_t<_Range>>)
9320 return views::all(std::forward<_Range>(__r));
9321 else if constexpr (__detail::__is_empty_view<_Tp>)
9322 return views::empty<const element_type>;
9323 else if constexpr (std::__detail::__is_span<_Tp>)
9324 return span<const element_type, _Tp::extent>(std::forward<_Range>(__r));
9325 else if constexpr (__detail::__is_ref_view<_Tp>
9326 && constant_range<const element_type>)
9327 return ref_view(static_cast<const element_type&>
9328 (std::forward<_Range>(__r).base()));
9329 else if constexpr (is_lvalue_reference_v<_Range>
9330 && constant_range<const _Tp>
9332 return ref_view(static_cast<const _Tp&>(__r));
9334 return as_const_view(std::forward<_Range>(__r));
9338 inline constexpr _AsConst as_const;
9340#endif // __cpp_lib_as_const
9341} // namespace ranges
9343 namespace views = ranges::views;
9345#if __cpp_lib_ranges_to_container // C++ >= 23
9348/// @cond undocumented
9351 template<typename _Container>
9352 constexpr bool __reservable_container
9353 = sized_range<_Container>
9354 && requires(_Container& __c, range_size_t<_Container> __n) {
9356 { __c.capacity() } -> same_as<decltype(__n)>;
9357 { __c.max_size() } -> same_as<decltype(__n)>;
9360 template<typename _Cont, typename _Range>
9361 constexpr bool __toable = requires {
9362 requires (!input_range<_Cont>
9363 || convertible_to<range_reference_t<_Range>,
9364 range_value_t<_Cont>>);
9366} // namespace __detail
9369 /// Convert a range to a container.
9371 * @tparam _Cont A container type.
9372 * @param __r A range that models the `input_range` concept.
9373 * @param __args... Arguments to pass to the container constructor.
9376 * This function converts a range to the `_Cont` type.
9378 * For example, `std::ranges::to<std::vector<int>>(some_view)`
9379 * will convert the view to `std::vector<int>`.
9381 * Additional constructor arguments for the container can be supplied after
9382 * the input range argument, e.g.
9383 * `std::ranges::to<std::vector<int, Alloc<int>>>(a_range, an_allocator)`.
9385 template<typename _Cont, input_range _Rg, typename... _Args>
9386 requires (!view<_Cont>)
9388 to [[nodiscard]] (_Rg&& __r, _Args&&... __args)
9390 static_assert(!is_const_v<_Cont> && !is_volatile_v<_Cont>);
9391 static_assert(is_class_v<_Cont>);
9393 if constexpr (__detail::__toable<_Cont, _Rg>)
9395 if constexpr (constructible_from<_Cont, _Rg, _Args...>)
9396 return _Cont(std::forward<_Rg>(__r),
9397 std::forward<_Args>(__args)...);
9398 else if constexpr (constructible_from<_Cont, from_range_t, _Rg, _Args...>)
9399 return _Cont(from_range, std::forward<_Rg>(__r),
9400 std::forward<_Args>(__args)...);
9401 else if constexpr (requires { requires common_range<_Rg>;
9402 typename __iter_category_t<iterator_t<_Rg>>;
9403 requires derived_from<__iter_category_t<iterator_t<_Rg>>,
9404 input_iterator_tag>;
9405 requires constructible_from<_Cont, iterator_t<_Rg>,
9406 sentinel_t<_Rg>, _Args...>;
9408 return _Cont(ranges::begin(__r), ranges::end(__r),
9409 std::forward<_Args>(__args)...);
9412 static_assert(constructible_from<_Cont, _Args...>);
9413 _Cont __c(std::forward<_Args>(__args)...);
9414 if constexpr (sized_range<_Rg>
9415 && __detail::__reservable_container<_Cont>)
9416 __c.reserve(static_cast<range_size_t<_Cont>>(ranges::size(__r)));
9417 // _GLIBCXX_RESOLVE_LIB_DEFECTS
9418 // 4016. container-insertable checks do not match what
9419 // container-inserter does
9420 auto __it = ranges::begin(__r);
9421 const auto __sent = ranges::end(__r);
9422 while (__it != __sent)
9424 if constexpr (requires { __c.emplace_back(*__it); })
9425 __c.emplace_back(*__it);
9426 else if constexpr (requires { __c.push_back(*__it); })
9427 __c.push_back(*__it);
9428 else if constexpr (requires { __c.emplace(__c.end(), *__it); })
9429 __c.emplace(__c.end(), *__it);
9431 __c.insert(__c.end(), *__it);
9439 static_assert(input_range<range_reference_t<_Rg>>);
9440 // _GLIBCXX_RESOLVE_LIB_DEFECTS
9441 // 3984. ranges::to's recursion branch may be ill-formed
9442 return ranges::to<_Cont>(ref_view(__r) | views::transform(
9443 []<typename _Elt>(_Elt&& __elem) {
9444 using _ValT = range_value_t<_Cont>;
9445 return ranges::to<_ValT>(std::forward<_Elt>(__elem));
9446 }), std::forward<_Args>(__args)...);
9450/// @cond undocumented
9453 template<typename _Rg>
9456 using iterator_category = input_iterator_tag;
9457 using value_type = range_value_t<_Rg>;
9458 using difference_type = ptrdiff_t;
9459 using pointer = add_pointer_t<range_reference_t<_Rg>>;
9460 using reference = range_reference_t<_Rg>;
9461 reference operator*() const;
9462 pointer operator->() const;
9463 _InputIter& operator++();
9464 _InputIter operator++(int);
9465 bool operator==(const _InputIter&) const;
9468 template<template<typename...> typename _Cont, input_range _Rg,
9471 = decltype(_Cont(std::declval<_Rg>(), std::declval<_Args>()...));
9473 template<template<typename...> typename _Cont, input_range _Rg,
9476 = decltype(_Cont(from_range, std::declval<_Rg>(),
9477 std::declval<_Args>()...));
9479 template<template<typename...> typename _Cont, input_range _Rg,
9482 = decltype(_Cont(std::declval<_InputIter<_Rg>>(),
9483 std::declval<_InputIter<_Rg>>(),
9484 std::declval<_Args>()...));
9486} // namespace __detail
9489 template<template<typename...> typename _Cont, input_range _Rg,
9492 to [[nodiscard]] (_Rg&& __r, _Args&&... __args)
9494 using __detail::_DeduceExpr1;
9495 using __detail::_DeduceExpr2;
9496 using __detail::_DeduceExpr3;
9497 if constexpr (requires { typename _DeduceExpr1<_Cont, _Rg, _Args...>; })
9498 return ranges::to<_DeduceExpr1<_Cont, _Rg, _Args...>>(
9499 std::forward<_Rg>(__r), std::forward<_Args>(__args)...);
9500 else if constexpr (requires { typename _DeduceExpr2<_Cont, _Rg, _Args...>; })
9501 return ranges::to<_DeduceExpr2<_Cont, _Rg, _Args...>>(
9502 std::forward<_Rg>(__r), std::forward<_Args>(__args)...);
9503 else if constexpr (requires { typename _DeduceExpr3<_Cont, _Rg, _Args...>; })
9504 return ranges::to<_DeduceExpr3<_Cont, _Rg, _Args...>>(
9505 std::forward<_Rg>(__r), std::forward<_Args>(__args)...);
9507 static_assert(false); // Cannot deduce container specialization.
9510/// @cond undocumented
9513 template<typename _Cont>
9516 template<typename _Range, typename... _Args>
9517 requires requires { ranges::to<_Cont>(std::declval<_Range>(),
9518 std::declval<_Args>()...); }
9520 operator()(_Range&& __r, _Args&&... __args) const
9522 return ranges::to<_Cont>(std::forward<_Range>(__r),
9523 std::forward<_Args>(__args)...);
9526} // namespace __detail
9529 /// ranges::to adaptor for converting a range to a container type
9531 * @tparam _Cont A container type.
9532 * @param __args... Arguments to pass to the container constructor.
9535 * This range adaptor returns a range adaptor closure object that converts
9536 * a range to the `_Cont` type.
9538 * For example, `some_view | std::ranges::to<std::vector<int>>()`
9539 * will convert the view to `std::vector<int>`.
9541 * Additional constructor arguments for the container can be supplied, e.g.
9542 * `r | std::ranges::to<std::vector<int, Alloc<int>>>(an_allocator)`.
9544 template<typename _Cont, typename... _Args>
9545 requires (!view<_Cont>)
9547 to [[nodiscard]] (_Args&&... __args)
9549 using __detail::_To;
9550 using views::__adaptor::_Partial;
9551 return _Partial<_To<_Cont>, decay_t<_Args>...>{0, std::forward<_Args>(__args)...};
9554/// @cond undocumented
9557 template<template<typename...> typename _Cont>
9560 template<typename _Range, typename... _Args>
9561 requires requires { ranges::to<_Cont>(std::declval<_Range>(),
9562 std::declval<_Args>()...); }
9564 operator()(_Range&& __r, _Args&&... __args) const
9566 return ranges::to<_Cont>(std::forward<_Range>(__r),
9567 std::forward<_Args>(__args)...);
9570} // namespace __detail
9573 /// ranges::to adaptor for converting a range to a deduced container type.
9575 * @tparam _Cont A container template.
9576 * @param __args... Arguments to pass to the container constructor.
9579 * This range adaptor returns a range adaptor closure object that converts
9580 * a range to a specialization of the `_Cont` class template. The specific
9581 * specialization of `_Cont` to be used is deduced automatically.
9583 * For example, `some_view | std::ranges::to<std::vector>(Alloc<int>{})`
9584 * will convert the view to `std::vector<T, Alloc<T>>`, where `T` is the
9585 * view's value type, i.e. `std::ranges::range_value_t<decltype(some_view)>`.
9587 * Additional constructor arguments for the container can be supplied, e.g.
9588 * `r | std::ranges::to<std::vector>(an_allocator)`.
9590 template<template<typename...> typename _Cont, typename... _Args>
9592 to [[nodiscard]] (_Args&&... __args)
9594 using __detail::_To2;
9595 using views::__adaptor::_Partial;
9596 return _Partial<_To2<_Cont>, decay_t<_Args>...>{0, std::forward<_Args>(__args)...};
9599} // namespace ranges
9600#endif // __cpp_lib_ranges_to_container
9602_GLIBCXX_END_NAMESPACE_VERSION
9604#endif // library concepts
9606#endif /* _GLIBCXX_RANGES */