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 static constexpr size_t
340 { return _M_value.operator->(); }
343 data() const noexcept
344 { return _M_value.operator->(); }
347 [[no_unique_address]] __detail::__box<_Tp> _M_value;
350 template<typename _Tp>
351 single_view(_Tp) -> single_view<_Tp>;
355 template<typename _Wp>
356 constexpr auto __to_signed_like(_Wp __w) noexcept
358 if constexpr (!integral<_Wp>)
359 return iter_difference_t<_Wp>();
360 else if constexpr (sizeof(iter_difference_t<_Wp>) > sizeof(_Wp))
361 return iter_difference_t<_Wp>(__w);
362 else if constexpr (sizeof(ptrdiff_t) > sizeof(_Wp))
363 return ptrdiff_t(__w);
364 else if constexpr (sizeof(long long) > sizeof(_Wp))
365 return (long long)(__w);
366#ifdef __SIZEOF_INT128__
367 else if constexpr (__SIZEOF_INT128__ > sizeof(_Wp))
368 return __int128(__w);
371 return __max_diff_type(__w);
374 template<typename _Wp>
375 using __iota_diff_t = decltype(__to_signed_like(std::declval<_Wp>()));
377 template<typename _It>
378 concept __decrementable = incrementable<_It>
381 { --__i } -> same_as<_It&>;
382 { __i-- } -> same_as<_It>;
385 template<typename _It>
386 concept __advanceable = __decrementable<_It> && totally_ordered<_It>
387 && requires( _It __i, const _It __j, const __iota_diff_t<_It> __n)
389 { __i += __n } -> same_as<_It&>;
390 { __i -= __n } -> same_as<_It&>;
394 { __j - __j } -> convertible_to<__iota_diff_t<_It>>;
397 template<typename _Winc>
398 struct __iota_view_iter_cat
401 template<incrementable _Winc>
402 struct __iota_view_iter_cat<_Winc>
403 { using iterator_category = input_iterator_tag; };
404 } // namespace __detail
406 template<weakly_incrementable _Winc,
407 semiregular _Bound = unreachable_sentinel_t>
408 requires std::__detail::__weakly_eq_cmp_with<_Winc, _Bound>
410 class iota_view : public view_interface<iota_view<_Winc, _Bound>>
415 struct _Iterator : __detail::__iota_view_iter_cat<_Winc>
421 using namespace __detail;
422 if constexpr (__advanceable<_Winc>)
423 return random_access_iterator_tag{};
424 else if constexpr (__decrementable<_Winc>)
425 return bidirectional_iterator_tag{};
426 else if constexpr (incrementable<_Winc>)
427 return forward_iterator_tag{};
429 return input_iterator_tag{};
433 using iterator_concept = decltype(_S_iter_concept());
434 // iterator_category defined in __iota_view_iter_cat
435 using value_type = _Winc;
436 using difference_type = __detail::__iota_diff_t<_Winc>;
438 _Iterator() requires default_initializable<_Winc> = default;
441 _Iterator(_Winc __value)
442 : _M_value(__value) { }
445 operator*() const noexcept(is_nothrow_copy_constructible_v<_Winc>)
460 operator++(int) requires incrementable<_Winc>
468 operator--() requires __detail::__decrementable<_Winc>
475 operator--(int) requires __detail::__decrementable<_Winc>
483 operator+=(difference_type __n) requires __detail::__advanceable<_Winc>
485 using __detail::__is_integer_like;
486 using __detail::__is_signed_integer_like;
487 if constexpr (__is_integer_like<_Winc>
488 && !__is_signed_integer_like<_Winc>)
490 if (__n >= difference_type(0))
491 _M_value += static_cast<_Winc>(__n);
493 _M_value -= static_cast<_Winc>(-__n);
501 operator-=(difference_type __n) requires __detail::__advanceable<_Winc>
503 using __detail::__is_integer_like;
504 using __detail::__is_signed_integer_like;
505 if constexpr (__is_integer_like<_Winc>
506 && !__is_signed_integer_like<_Winc>)
508 if (__n >= difference_type(0))
509 _M_value -= static_cast<_Winc>(__n);
511 _M_value += static_cast<_Winc>(-__n);
519 operator[](difference_type __n) const
520 requires __detail::__advanceable<_Winc>
521 { return _Winc(_M_value + __n); }
523 friend constexpr bool
524 operator==(const _Iterator& __x, const _Iterator& __y)
525 requires equality_comparable<_Winc>
526 { return __x._M_value == __y._M_value; }
528 friend constexpr bool
529 operator<(const _Iterator& __x, const _Iterator& __y)
530 requires totally_ordered<_Winc>
531 { return __x._M_value < __y._M_value; }
533 friend constexpr bool
534 operator>(const _Iterator& __x, const _Iterator& __y)
535 requires totally_ordered<_Winc>
536 { return __y < __x; }
538 friend constexpr bool
539 operator<=(const _Iterator& __x, const _Iterator& __y)
540 requires totally_ordered<_Winc>
541 { return !(__y < __x); }
543 friend constexpr bool
544 operator>=(const _Iterator& __x, const _Iterator& __y)
545 requires totally_ordered<_Winc>
546 { return !(__x < __y); }
548#ifdef __cpp_lib_three_way_comparison
549 friend constexpr auto
550 operator<=>(const _Iterator& __x, const _Iterator& __y)
551 requires totally_ordered<_Winc> && three_way_comparable<_Winc>
552 { return __x._M_value <=> __y._M_value; }
555 friend constexpr _Iterator
556 operator+(_Iterator __i, difference_type __n)
557 requires __detail::__advanceable<_Winc>
563 friend constexpr _Iterator
564 operator+(difference_type __n, _Iterator __i)
565 requires __detail::__advanceable<_Winc>
566 { return __i += __n; }
568 friend constexpr _Iterator
569 operator-(_Iterator __i, difference_type __n)
570 requires __detail::__advanceable<_Winc>
576 friend constexpr difference_type
577 operator-(const _Iterator& __x, const _Iterator& __y)
578 requires __detail::__advanceable<_Winc>
580 using __detail::__is_integer_like;
581 using __detail::__is_signed_integer_like;
582 using _Dt = difference_type;
583 if constexpr (__is_integer_like<_Winc>)
585 if constexpr (__is_signed_integer_like<_Winc>)
586 return _Dt(_Dt(__x._M_value) - _Dt(__y._M_value));
588 return (__y._M_value > __x._M_value)
589 ? _Dt(-_Dt(__y._M_value - __x._M_value))
590 : _Dt(__x._M_value - __y._M_value);
593 return __x._M_value - __y._M_value;
597 _Winc _M_value = _Winc();
607 _M_equal(const _Iterator& __x) const
608 { return __x._M_value == _M_bound; }
611 _M_distance_from(const _Iterator& __x) const
612 { return _M_bound - __x._M_value; }
614 _Bound _M_bound = _Bound();
617 _Sentinel() = default;
620 _Sentinel(_Bound __bound)
621 : _M_bound(__bound) { }
623 friend constexpr bool
624 operator==(const _Iterator& __x, const _Sentinel& __y)
625 { return __y._M_equal(__x); }
627 friend constexpr iter_difference_t<_Winc>
628 operator-(const _Iterator& __x, const _Sentinel& __y)
629 requires sized_sentinel_for<_Bound, _Winc>
630 { return -__y._M_distance_from(__x); }
632 friend constexpr iter_difference_t<_Winc>
633 operator-(const _Sentinel& __x, const _Iterator& __y)
634 requires sized_sentinel_for<_Bound, _Winc>
635 { return __x._M_distance_from(__y); }
640 _Winc _M_value = _Winc();
641 [[no_unique_address]] _Bound _M_bound = _Bound();
644 iota_view() requires default_initializable<_Winc> = default;
647 iota_view(_Winc __value)
652 iota_view(type_identity_t<_Winc> __value,
653 type_identity_t<_Bound> __bound)
654 : _M_value(__value), _M_bound(__bound)
656 if constexpr (totally_ordered_with<_Winc, _Bound>)
657 __glibcxx_assert( bool(__value <= __bound) );
661 iota_view(_Iterator __first, _Iterator __last)
662 requires same_as<_Winc, _Bound>
663 : iota_view(__first._M_value, __last._M_value)
667 iota_view(_Iterator __first, unreachable_sentinel_t __last)
668 requires same_as<_Bound, unreachable_sentinel_t>
669 : iota_view(__first._M_value, __last)
673 iota_view(_Iterator __first, _Sentinel __last)
674 requires (!same_as<_Winc, _Bound>) && (!same_as<_Bound, unreachable_sentinel_t>)
675 : iota_view(__first._M_value, __last._M_bound)
679 begin() const { return _Iterator{_M_value}; }
684 if constexpr (same_as<_Bound, unreachable_sentinel_t>)
685 return unreachable_sentinel;
687 return _Sentinel{_M_bound};
691 end() const requires same_as<_Winc, _Bound>
692 { return _Iterator{_M_bound}; }
696 requires (same_as<_Winc, _Bound> && __detail::__advanceable<_Winc>)
697 || (integral<_Winc> && integral<_Bound>)
698 || sized_sentinel_for<_Bound, _Winc>
700 using __detail::__is_integer_like;
701 using __detail::__to_unsigned_like;
702 if constexpr (integral<_Winc> && integral<_Bound>)
704 using _Up = make_unsigned_t<decltype(_M_bound - _M_value)>;
705 return _Up(_M_bound) - _Up(_M_value);
707 else if constexpr (__is_integer_like<_Winc>)
708 return __to_unsigned_like(_M_bound) - __to_unsigned_like(_M_value);
710 return __to_unsigned_like(_M_bound - _M_value);
714 template<typename _Winc, typename _Bound>
715 requires (!__detail::__is_integer_like<_Winc>
716 || !__detail::__is_integer_like<_Bound>
717 || (__detail::__is_signed_integer_like<_Winc>
718 == __detail::__is_signed_integer_like<_Bound>))
719 iota_view(_Winc, _Bound) -> iota_view<_Winc, _Bound>;
721 template<typename _Winc, typename _Bound>
722 inline constexpr bool
723 enable_borrowed_range<iota_view<_Winc, _Bound>> = true;
727 template<typename _Tp>
728 inline constexpr empty_view<_Tp> empty{};
732 template<typename _Tp>
733 concept __can_single_view
734 = requires { single_view<decay_t<_Tp>>(std::declval<_Tp>()); };
735 } // namespace __detail
739 template<__detail::__can_single_view _Tp>
741 operator() [[nodiscard]] (_Tp&& __e) const
742 noexcept(noexcept(single_view<decay_t<_Tp>>(std::forward<_Tp>(__e))))
743 { return single_view<decay_t<_Tp>>(std::forward<_Tp>(__e)); }
746 inline constexpr _Single single{};
750 template<typename... _Args>
751 concept __can_iota_view = requires { iota_view(std::declval<_Args>()...); };
752 } // namespace __detail
756 template<__detail::__can_iota_view _Tp>
758 operator() [[nodiscard]] (_Tp&& __e) const
759 { return iota_view(std::forward<_Tp>(__e)); }
761 template<typename _Tp, typename _Up>
762 requires __detail::__can_iota_view<_Tp, _Up>
764 operator() [[nodiscard]] (_Tp&& __e, _Up&& __f) const
765 { return iota_view(std::forward<_Tp>(__e), std::forward<_Up>(__f)); }
768 inline constexpr _Iota iota{};
774 template<typename _Val, typename _CharT, typename _Traits>
775 concept __stream_extractable
776 = requires(basic_istream<_CharT, _Traits>& is, _Val& t) { is >> t; };
777 } // namespace __detail
779 template<movable _Val, typename _CharT,
780 typename _Traits = char_traits<_CharT>>
781 requires default_initializable<_Val>
782 && __detail::__stream_extractable<_Val, _CharT, _Traits>
783 class basic_istream_view
784 : public view_interface<basic_istream_view<_Val, _CharT, _Traits>>
788 basic_istream_view(basic_istream<_CharT, _Traits>& __stream)
789 : _M_stream(std::__addressof(__stream))
795 *_M_stream >> _M_object;
796 return _Iterator{this};
799 constexpr default_sentinel_t
801 { return default_sentinel; }
804 basic_istream<_CharT, _Traits>* _M_stream;
805 _Val _M_object = _Val();
810 using iterator_concept = input_iterator_tag;
811 using difference_type = ptrdiff_t;
812 using value_type = _Val;
815 _Iterator(basic_istream_view* __parent) noexcept
816 : _M_parent(__parent)
819 _Iterator(const _Iterator&) = delete;
820 _Iterator(_Iterator&&) = default;
821 _Iterator& operator=(const _Iterator&) = delete;
822 _Iterator& operator=(_Iterator&&) = default;
827 *_M_parent->_M_stream >> _M_parent->_M_object;
837 { return _M_parent->_M_object; }
840 operator==(const _Iterator& __x, default_sentinel_t)
841 { return __x._M_at_end(); }
844 basic_istream_view* _M_parent;
848 { return !*_M_parent->_M_stream; }
854 template<typename _Val>
855 using istream_view = basic_istream_view<_Val, char>;
857 template<typename _Val>
858 using wistream_view = basic_istream_view<_Val, wchar_t>;
864 template<typename _Tp, typename _Up>
865 concept __can_istream_view = requires (_Up __e) {
866 basic_istream_view<_Tp, typename _Up::char_type, typename _Up::traits_type>(__e);
868 } // namespace __detail
870 template<typename _Tp>
873 template<typename _CharT, typename _Traits>
875 operator() [[nodiscard]] (basic_istream<_CharT, _Traits>& __e) const
876 requires __detail::__can_istream_view<_Tp, remove_reference_t<decltype(__e)>>
877 { return basic_istream_view<_Tp, _CharT, _Traits>(__e); }
880 template<typename _Tp>
881 inline constexpr _Istream<_Tp> istream;
885 // C++20 24.7 [range.adaptors] Range adaptors
889 template<typename _Tp, int _Disc>
892 // Alias for a type that is conditionally present
893 // (and is an empty type otherwise).
894 // Data members using this alias should use [[no_unique_address]] so that
895 // they take no space when not needed.
896 // The optional template parameter _Disc is for discriminating two otherwise
897 // equivalent absent types so that even they can overlap.
898 template<bool _Present, typename _Tp, int _Disc = 0>
899 using __maybe_present_t = __conditional_t<_Present, _Tp, _Absent<_Tp, _Disc>>;
901 // Alias for a type that is conditionally const.
902 template<bool _Const, typename _Tp>
903 using __maybe_const_t = __conditional_t<_Const, const _Tp, _Tp>;
905} // namespace __detail
907// Shorthand for __detail::__maybe_const_t.
908using __detail::__maybe_const_t;
910namespace views::__adaptor
912 // True if the range adaptor _Adaptor can be applied with _Args.
913 template<typename _Adaptor, typename... _Args>
914 concept __adaptor_invocable
915 = requires { std::declval<_Adaptor>()(declval<_Args>()...); };
917 // True if the range adaptor non-closure _Adaptor can be partially applied
919 template<typename _Adaptor, typename... _Args>
920 concept __adaptor_partial_app_viable = (_Adaptor::_S_arity > 1)
921 && (sizeof...(_Args) == _Adaptor::_S_arity - 1)
922 && (constructible_from<decay_t<_Args>, _Args> && ...);
924 template<typename _Adaptor, typename... _Args>
927 template<typename _Lhs, typename _Rhs>
930 // The base class of every range adaptor closure.
932 // The derived class should define the optional static data member
933 // _S_has_simple_call_op to true if the behavior of this adaptor is
934 // independent of the constness/value category of the adaptor object.
935 template<typename _Derived>
936 struct _RangeAdaptorClosure
939 template<typename _Tp, typename _Up>
940 requires (!same_as<_Tp, _RangeAdaptorClosure<_Up>>)
941 void __is_range_adaptor_closure_fn
942 (const _Tp&, const _RangeAdaptorClosure<_Up>&); // not defined
944 template<typename _Tp>
945 concept __is_range_adaptor_closure
946 = requires (_Tp __t) { __adaptor::__is_range_adaptor_closure_fn(__t, __t); };
948#pragma GCC diagnostic push
949#pragma GCC diagnostic ignored "-Wdangling-reference"
950 // range | adaptor is equivalent to adaptor(range).
951 template<typename _Self, typename _Range>
952 requires __is_range_adaptor_closure<_Self>
953 && __adaptor_invocable<_Self, _Range>
955 operator|(_Range&& __r, _Self&& __self)
956 { return std::forward<_Self>(__self)(std::forward<_Range>(__r)); }
958 // Compose the adaptors __lhs and __rhs into a pipeline, returning
959 // another range adaptor closure object.
960 template<typename _Lhs, typename _Rhs>
961 requires __is_range_adaptor_closure<_Lhs>
962 && __is_range_adaptor_closure<_Rhs>
964 operator|(_Lhs&& __lhs, _Rhs&& __rhs)
966 return _Pipe<decay_t<_Lhs>, decay_t<_Rhs>>{std::forward<_Lhs>(__lhs),
967 std::forward<_Rhs>(__rhs)};
969#pragma GCC diagnostic pop
971 // The base class of every range adaptor non-closure.
973 // The static data member _Derived::_S_arity must contain the total number of
974 // arguments that the adaptor takes, and the class _Derived must introduce
975 // _RangeAdaptor::operator() into the class scope via a using-declaration.
977 // The optional static data member _Derived::_S_has_simple_extra_args should
978 // be defined to true if the behavior of this adaptor is independent of the
979 // constness/value category of the extra arguments. This data member could
980 // also be defined as a variable template parameterized by the types of the
982 template<typename _Derived>
985 // Partially apply the arguments __args to the range adaptor _Derived,
986 // returning a range adaptor closure object.
987 template<typename... _Args>
988 requires __adaptor_partial_app_viable<_Derived, _Args...>
990 operator()(_Args&&... __args) const
992 return _Partial<_Derived, decay_t<_Args>...>{0, std::forward<_Args>(__args)...};
996 // True if the range adaptor closure _Adaptor has a simple operator(), i.e.
997 // one that's not overloaded according to constness or value category of the
999 template<typename _Adaptor>
1000 concept __closure_has_simple_call_op = _Adaptor::_S_has_simple_call_op;
1002 // True if the behavior of the range adaptor non-closure _Adaptor is
1003 // independent of the value category of its extra arguments _Args.
1004 template<typename _Adaptor, typename... _Args>
1005 concept __adaptor_has_simple_extra_args = _Adaptor::_S_has_simple_extra_args
1006 || _Adaptor::template _S_has_simple_extra_args<_Args...>;
1008 // A range adaptor closure that represents partial application of
1009 // the range adaptor _Adaptor with arguments _Args.
1010 template<typename _Adaptor, typename... _Args>
1011 struct _Partial : _RangeAdaptorClosure<_Partial<_Adaptor, _Args...>>
1013 tuple<_Args...> _M_args;
1015 // First parameter is to ensure this constructor is never used
1016 // instead of the copy/move constructor.
1017 template<typename... _Ts>
1019 _Partial(int, _Ts&&... __args)
1020 : _M_args(std::forward<_Ts>(__args)...)
1023 // Invoke _Adaptor with arguments __r, _M_args... according to the
1024 // value category of this _Partial object.
1025#if __cpp_explicit_this_parameter
1026 template<typename _Self, typename _Range>
1027 requires __adaptor_invocable<_Adaptor, _Range, __like_t<_Self, _Args>...>
1029 operator()(this _Self&& __self, _Range&& __r)
1031 auto __forwarder = [&__r] (auto&&... __args) {
1032 return _Adaptor{}(std::forward<_Range>(__r),
1033 std::forward<decltype(__args)>(__args)...);
1035 return std::apply(__forwarder, std::forward<_Self>(__self)._M_args);
1038 template<typename _Range>
1039 requires __adaptor_invocable<_Adaptor, _Range, const _Args&...>
1041 operator()(_Range&& __r) const &
1043 auto __forwarder = [&__r] (const auto&... __args) {
1044 return _Adaptor{}(std::forward<_Range>(__r), __args...);
1046 return std::apply(__forwarder, _M_args);
1049 template<typename _Range>
1050 requires __adaptor_invocable<_Adaptor, _Range, _Args...>
1052 operator()(_Range&& __r) &&
1054 auto __forwarder = [&__r] (auto&... __args) {
1055 return _Adaptor{}(std::forward<_Range>(__r), std::move(__args)...);
1057 return std::apply(__forwarder, _M_args);
1060 template<typename _Range>
1062 operator()(_Range&& __r) const && = delete;
1066 // A lightweight specialization of the above primary template for
1067 // the common case where _Adaptor accepts a single extra argument.
1068 template<typename _Adaptor, typename _Arg>
1069 struct _Partial<_Adaptor, _Arg> : _RangeAdaptorClosure<_Partial<_Adaptor, _Arg>>
1073 template<typename _Tp>
1075 _Partial(int, _Tp&& __arg)
1076 : _M_arg(std::forward<_Tp>(__arg))
1079#if __cpp_explicit_this_parameter
1080 template<typename _Self, typename _Range>
1081 requires __adaptor_invocable<_Adaptor, _Range, __like_t<_Self, _Arg>>
1083 operator()(this _Self&& __self, _Range&& __r)
1084 { return _Adaptor{}(std::forward<_Range>(__r), std::forward<_Self>(__self)._M_arg); }
1086 template<typename _Range>
1087 requires __adaptor_invocable<_Adaptor, _Range, const _Arg&>
1089 operator()(_Range&& __r) const &
1090 { return _Adaptor{}(std::forward<_Range>(__r), _M_arg); }
1092 template<typename _Range>
1093 requires __adaptor_invocable<_Adaptor, _Range, _Arg>
1095 operator()(_Range&& __r) &&
1096 { return _Adaptor{}(std::forward<_Range>(__r), std::move(_M_arg)); }
1098 template<typename _Range>
1100 operator()(_Range&& __r) const && = delete;
1104 // Partial specialization of the primary template for the case where the extra
1105 // arguments of the adaptor can always be safely and efficiently forwarded by
1106 // const reference. This lets us get away with a single operator() overload,
1107 // which makes overload resolution failure diagnostics more concise.
1108 template<typename _Adaptor, typename... _Args>
1109 requires __adaptor_has_simple_extra_args<_Adaptor, _Args...>
1110 && (is_trivially_copyable_v<_Args> && ...)
1111 struct _Partial<_Adaptor, _Args...> : _RangeAdaptorClosure<_Partial<_Adaptor, _Args...>>
1113 tuple<_Args...> _M_args;
1115 template<typename... _Ts>
1117 _Partial(int, _Ts&&... __args)
1118 : _M_args(std::forward<_Ts>(__args)...)
1121 // Invoke _Adaptor with arguments __r, const _M_args&... regardless
1122 // of the value category of this _Partial object.
1123 template<typename _Range>
1124 requires __adaptor_invocable<_Adaptor, _Range, const _Args&...>
1126 operator()(_Range&& __r) const
1128 auto __forwarder = [&__r] (const auto&... __args) {
1129 return _Adaptor{}(std::forward<_Range>(__r), __args...);
1131 return std::apply(__forwarder, _M_args);
1134 static constexpr bool _S_has_simple_call_op = true;
1137 // A lightweight specialization of the above template for the common case
1138 // where _Adaptor accepts a single extra argument.
1139 template<typename _Adaptor, typename _Arg>
1140 requires __adaptor_has_simple_extra_args<_Adaptor, _Arg>
1141 && is_trivially_copyable_v<_Arg>
1142 struct _Partial<_Adaptor, _Arg> : _RangeAdaptorClosure<_Partial<_Adaptor, _Arg>>
1146 template<typename _Tp>
1148 _Partial(int, _Tp&& __arg)
1149 : _M_arg(std::forward<_Tp>(__arg))
1152 template<typename _Range>
1153 requires __adaptor_invocable<_Adaptor, _Range, const _Arg&>
1155 operator()(_Range&& __r) const
1156 { return _Adaptor{}(std::forward<_Range>(__r), _M_arg); }
1158 static constexpr bool _S_has_simple_call_op = true;
1161 template<typename _Lhs, typename _Rhs, typename _Range>
1162 concept __pipe_invocable
1163 = requires { std::declval<_Rhs>()(std::declval<_Lhs>()(std::declval<_Range>())); };
1165 // A range adaptor closure that represents composition of the range
1166 // adaptor closures _Lhs and _Rhs.
1167 template<typename _Lhs, typename _Rhs>
1168 struct _Pipe : _RangeAdaptorClosure<_Pipe<_Lhs, _Rhs>>
1170 [[no_unique_address]] _Lhs _M_lhs;
1171 [[no_unique_address]] _Rhs _M_rhs;
1173 template<typename _Tp, typename _Up>
1175 _Pipe(_Tp&& __lhs, _Up&& __rhs)
1176 : _M_lhs(std::forward<_Tp>(__lhs)), _M_rhs(std::forward<_Up>(__rhs))
1179 // Invoke _M_rhs(_M_lhs(__r)) according to the value category of this
1180 // range adaptor closure object.
1181#if __cpp_explicit_this_parameter
1182 template<typename _Self, typename _Range>
1183 requires __pipe_invocable<__like_t<_Self, _Lhs>, __like_t<_Self, _Rhs>, _Range>
1185 operator()(this _Self&& __self, _Range&& __r)
1187 return (std::forward<_Self>(__self)._M_rhs
1188 (std::forward<_Self>(__self)._M_lhs
1189 (std::forward<_Range>(__r))));
1192 template<typename _Range>
1193 requires __pipe_invocable<const _Lhs&, const _Rhs&, _Range>
1195 operator()(_Range&& __r) const &
1196 { return _M_rhs(_M_lhs(std::forward<_Range>(__r))); }
1198 template<typename _Range>
1199 requires __pipe_invocable<_Lhs, _Rhs, _Range>
1201 operator()(_Range&& __r) &&
1202 { return std::move(_M_rhs)(std::move(_M_lhs)(std::forward<_Range>(__r))); }
1204 template<typename _Range>
1206 operator()(_Range&& __r) const && = delete;
1210 // A partial specialization of the above primary template for the case where
1211 // both adaptor operands have a simple operator(). This in turn lets us
1212 // implement composition using a single simple operator(), which makes
1213 // overload resolution failure diagnostics more concise.
1214 template<typename _Lhs, typename _Rhs>
1215 requires __closure_has_simple_call_op<_Lhs>
1216 && __closure_has_simple_call_op<_Rhs>
1217 struct _Pipe<_Lhs, _Rhs> : _RangeAdaptorClosure<_Pipe<_Lhs, _Rhs>>
1219 [[no_unique_address]] _Lhs _M_lhs;
1220 [[no_unique_address]] _Rhs _M_rhs;
1222 template<typename _Tp, typename _Up>
1224 _Pipe(_Tp&& __lhs, _Up&& __rhs)
1225 : _M_lhs(std::forward<_Tp>(__lhs)), _M_rhs(std::forward<_Up>(__rhs))
1228 template<typename _Range>
1229 requires __pipe_invocable<const _Lhs&, const _Rhs&, _Range>
1231 operator()(_Range&& __r) const
1232 { return _M_rhs(_M_lhs(std::forward<_Range>(__r))); }
1234 static constexpr bool _S_has_simple_call_op = true;
1236} // namespace views::__adaptor
1238#if __cpp_lib_ranges >= 202202L
1239 // P2387R3 Pipe support for user-defined range adaptors
1240 template<typename _Derived>
1241 requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
1242 class range_adaptor_closure
1243 : public views::__adaptor::_RangeAdaptorClosure<_Derived>
1247 template<range _Range> requires is_object_v<_Range>
1248 class ref_view : public view_interface<ref_view<_Range>>
1253 static void _S_fun(_Range&); // not defined
1254 static void _S_fun(_Range&&) = delete;
1257 template<__detail::__different_from<ref_view> _Tp>
1258 requires convertible_to<_Tp, _Range&>
1259 && requires { _S_fun(declval<_Tp>()); }
1262 noexcept(noexcept(static_cast<_Range&>(std::declval<_Tp>())))
1263 : _M_r(std::__addressof(static_cast<_Range&>(std::forward<_Tp>(__t))))
1270 constexpr iterator_t<_Range>
1272 { return ranges::begin(*_M_r); }
1274 constexpr sentinel_t<_Range>
1276 { return ranges::end(*_M_r); }
1279 empty() const requires requires { ranges::empty(*_M_r); }
1280 { return ranges::empty(*_M_r); }
1283 size() const requires sized_range<_Range>
1284 { return ranges::size(*_M_r); }
1287 data() const requires contiguous_range<_Range>
1288 { return ranges::data(*_M_r); }
1291 template<typename _Range>
1292 ref_view(_Range&) -> ref_view<_Range>;
1294 template<typename _Tp>
1295 inline constexpr bool enable_borrowed_range<ref_view<_Tp>> = true;
1297 template<range _Range>
1298 requires movable<_Range>
1299 && (!__detail::__is_initializer_list<remove_cv_t<_Range>>)
1300 class owning_view : public view_interface<owning_view<_Range>>
1303 _Range _M_r = _Range();
1306 owning_view() requires default_initializable<_Range> = default;
1309 owning_view(_Range&& __t)
1310 noexcept(is_nothrow_move_constructible_v<_Range>)
1311 : _M_r(std::move(__t))
1314 owning_view(owning_view&&) = default;
1315 owning_view& operator=(owning_view&&) = default;
1321 constexpr const _Range&
1322 base() const& noexcept
1327 { return std::move(_M_r); }
1329 constexpr const _Range&&
1330 base() const&& noexcept
1331 { return std::move(_M_r); }
1333 constexpr iterator_t<_Range>
1335 { return ranges::begin(_M_r); }
1337 constexpr sentinel_t<_Range>
1339 { return ranges::end(_M_r); }
1342 begin() const requires range<const _Range>
1343 { return ranges::begin(_M_r); }
1346 end() const requires range<const _Range>
1347 { return ranges::end(_M_r); }
1350 empty() requires requires { ranges::empty(_M_r); }
1351 { return ranges::empty(_M_r); }
1354 empty() const requires requires { ranges::empty(_M_r); }
1355 { return ranges::empty(_M_r); }
1358 size() requires sized_range<_Range>
1359 { return ranges::size(_M_r); }
1362 size() const requires sized_range<const _Range>
1363 { return ranges::size(_M_r); }
1366 data() requires contiguous_range<_Range>
1367 { return ranges::data(_M_r); }
1370 data() const requires contiguous_range<const _Range>
1371 { return ranges::data(_M_r); }
1374 template<typename _Tp>
1375 inline constexpr bool enable_borrowed_range<owning_view<_Tp>>
1376 = enable_borrowed_range<_Tp>;
1382 template<typename _Range>
1383 concept __can_ref_view = requires { ref_view{std::declval<_Range>()}; };
1385 template<typename _Range>
1386 concept __can_owning_view = requires { owning_view{std::declval<_Range>()}; };
1387 } // namespace __detail
1389 struct _All : __adaptor::_RangeAdaptorClosure<_All>
1391 template<typename _Range>
1392 static constexpr bool
1395 if constexpr (view<decay_t<_Range>>)
1396 return is_nothrow_constructible_v<decay_t<_Range>, _Range>;
1397 else if constexpr (__detail::__can_ref_view<_Range>)
1400 return noexcept(owning_view{std::declval<_Range>()});
1403 template<viewable_range _Range>
1404 requires view<decay_t<_Range>>
1405 || __detail::__can_ref_view<_Range>
1406 || __detail::__can_owning_view<_Range>
1408 operator() [[nodiscard]] (_Range&& __r) const
1409 noexcept(_S_noexcept<_Range>())
1411 if constexpr (view<decay_t<_Range>>)
1412 return std::forward<_Range>(__r);
1413 else if constexpr (__detail::__can_ref_view<_Range>)
1414 return ref_view{std::forward<_Range>(__r)};
1416 return owning_view{std::forward<_Range>(__r)};
1419 static constexpr bool _S_has_simple_call_op = true;
1422 inline constexpr _All all;
1424 template<viewable_range _Range>
1425 using all_t = decltype(all(std::declval<_Range>()));
1426 } // namespace views
1430 template<typename _Tp>
1431 struct __non_propagating_cache
1433 // When _Tp is not an object type (e.g. is a reference type), we make
1434 // __non_propagating_cache<_Tp> empty rather than ill-formed so that
1435 // users can easily conditionally declare data members with this type
1436 // (such as join_view::_M_inner).
1439 template<typename _Tp>
1440 requires is_object_v<_Tp>
1441 struct __non_propagating_cache<_Tp>
1442 : protected _Optional_base<_Tp>
1444 __non_propagating_cache() = default;
1447 __non_propagating_cache(const __non_propagating_cache&) noexcept
1451 __non_propagating_cache(__non_propagating_cache&& __other) noexcept
1452 { __other._M_reset(); }
1454 constexpr __non_propagating_cache&
1455 operator=(const __non_propagating_cache& __other) noexcept
1457 if (std::__addressof(__other) != this)
1462 constexpr __non_propagating_cache&
1463 operator=(__non_propagating_cache&& __other) noexcept
1470 constexpr __non_propagating_cache&
1471 operator=(_Tp __val)
1474 this->_M_payload._M_construct(std::move(__val));
1479 operator bool() const noexcept
1480 { return this->_M_is_engaged(); }
1483 operator*() noexcept
1484 { return this->_M_get(); }
1486 constexpr const _Tp&
1487 operator*() const noexcept
1488 { return this->_M_get(); }
1490 template<typename _Iter>
1492 _M_emplace_deref(const _Iter& __i)
1495 auto __f = [] (auto& __x) { return *__x; };
1496 this->_M_payload._M_apply(_Optional_func{__f}, __i);
1497 return this->_M_get();
1501 template<range _Range>
1502 struct _CachedPosition
1505 _M_has_value() const
1508 constexpr iterator_t<_Range>
1509 _M_get(const _Range&) const
1511 __glibcxx_assert(false);
1512 __builtin_unreachable();
1516 _M_set(const _Range&, const iterator_t<_Range>&) const
1520 template<forward_range _Range>
1521 struct _CachedPosition<_Range>
1522 : protected __non_propagating_cache<iterator_t<_Range>>
1525 _M_has_value() const
1526 { return this->_M_is_engaged(); }
1528 constexpr iterator_t<_Range>
1529 _M_get(const _Range&) const
1531 __glibcxx_assert(_M_has_value());
1536 _M_set(const _Range&, const iterator_t<_Range>& __it)
1538 __glibcxx_assert(!_M_has_value());
1539 std::construct_at(std::__addressof(this->_M_payload._M_payload),
1541 this->_M_payload._M_engaged = true;
1545 template<random_access_range _Range>
1546 requires (sizeof(range_difference_t<_Range>)
1547 <= sizeof(iterator_t<_Range>))
1548 struct _CachedPosition<_Range>
1551 range_difference_t<_Range> _M_offset = -1;
1554 _CachedPosition() = default;
1557 _CachedPosition(const _CachedPosition&) = default;
1560 _CachedPosition(_CachedPosition&& __other) noexcept
1561 { *this = std::move(__other); }
1563 constexpr _CachedPosition&
1564 operator=(const _CachedPosition&) = default;
1566 constexpr _CachedPosition&
1567 operator=(_CachedPosition&& __other) noexcept
1569 // Propagate the cached offset, but invalidate the source.
1570 _M_offset = __other._M_offset;
1571 __other._M_offset = -1;
1576 _M_has_value() const
1577 { return _M_offset >= 0; }
1579 constexpr iterator_t<_Range>
1580 _M_get(_Range& __r) const
1582 __glibcxx_assert(_M_has_value());
1583 return ranges::begin(__r) + _M_offset;
1587 _M_set(_Range& __r, const iterator_t<_Range>& __it)
1589 __glibcxx_assert(!_M_has_value());
1590 _M_offset = __it - ranges::begin(__r);
1593 } // namespace __detail
1597 template<typename _Base>
1598 struct __filter_view_iter_cat
1601 template<forward_range _Base>
1602 struct __filter_view_iter_cat<_Base>
1608 using _Cat = typename iterator_traits<iterator_t<_Base>>::iterator_category;
1609 if constexpr (derived_from<_Cat, bidirectional_iterator_tag>)
1610 return bidirectional_iterator_tag{};
1611 else if constexpr (derived_from<_Cat, forward_iterator_tag>)
1612 return forward_iterator_tag{};
1617 using iterator_category = decltype(_S_iter_cat());
1619 } // namespace __detail
1621 template<input_range _Vp,
1622 indirect_unary_predicate<iterator_t<_Vp>> _Pred>
1623 requires view<_Vp> && is_object_v<_Pred>
1624 class filter_view : public view_interface<filter_view<_Vp, _Pred>>
1629 struct _Iterator : __detail::__filter_view_iter_cat<_Vp>
1632 static constexpr auto
1635 if constexpr (bidirectional_range<_Vp>)
1636 return bidirectional_iterator_tag{};
1637 else if constexpr (forward_range<_Vp>)
1638 return forward_iterator_tag{};
1640 return input_iterator_tag{};
1645 using _Vp_iter = iterator_t<_Vp>;
1647 _Vp_iter _M_current = _Vp_iter();
1648 filter_view* _M_parent = nullptr;
1651 using iterator_concept = decltype(_S_iter_concept());
1652 // iterator_category defined in __filter_view_iter_cat
1653 using value_type = range_value_t<_Vp>;
1654 using difference_type = range_difference_t<_Vp>;
1656 _Iterator() requires default_initializable<_Vp_iter> = default;
1659 _Iterator(filter_view* __parent, _Vp_iter __current)
1660 : _M_current(std::move(__current)),
1664 constexpr const _Vp_iter&
1665 base() const & noexcept
1666 { return _M_current; }
1670 { return std::move(_M_current); }
1672 constexpr range_reference_t<_Vp>
1674 { return *_M_current; }
1678 requires __detail::__has_arrow<_Vp_iter>
1679 && copyable<_Vp_iter>
1680 { return _M_current; }
1682 constexpr _Iterator&
1685 _M_current = ranges::find_if(std::move(++_M_current),
1686 ranges::end(_M_parent->_M_base),
1687 std::ref(*_M_parent->_M_pred));
1696 operator++(int) requires forward_range<_Vp>
1703 constexpr _Iterator&
1704 operator--() requires bidirectional_range<_Vp>
1708 while (!std::__invoke(*_M_parent->_M_pred, *_M_current));
1713 operator--(int) requires bidirectional_range<_Vp>
1720 friend constexpr bool
1721 operator==(const _Iterator& __x, const _Iterator& __y)
1722 requires equality_comparable<_Vp_iter>
1723 { return __x._M_current == __y._M_current; }
1725 friend constexpr range_rvalue_reference_t<_Vp>
1726 iter_move(const _Iterator& __i)
1727 noexcept(noexcept(ranges::iter_move(__i._M_current)))
1728 { return ranges::iter_move(__i._M_current); }
1730 friend constexpr void
1731 iter_swap(const _Iterator& __x, const _Iterator& __y)
1732 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1733 requires indirectly_swappable<_Vp_iter>
1734 { ranges::iter_swap(__x._M_current, __y._M_current); }
1740 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
1743 __equal(const _Iterator& __i) const
1744 { return __i._M_current == _M_end; }
1747 _Sentinel() = default;
1750 _Sentinel(filter_view* __parent)
1751 : _M_end(ranges::end(__parent->_M_base))
1754 constexpr sentinel_t<_Vp>
1758 friend constexpr bool
1759 operator==(const _Iterator& __x, const _Sentinel& __y)
1760 { return __y.__equal(__x); }
1763 _Vp _M_base = _Vp();
1764 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
1765 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
1768 filter_view() requires (default_initializable<_Vp>
1769 && default_initializable<_Pred>)
1773 filter_view(_Vp __base, _Pred __pred)
1774 : _M_base(std::move(__base)), _M_pred(std::move(__pred))
1778 base() const& requires copy_constructible<_Vp>
1783 { return std::move(_M_base); }
1785 constexpr const _Pred&
1787 { return *_M_pred; }
1792 if (_M_cached_begin._M_has_value())
1793 return {this, _M_cached_begin._M_get(_M_base)};
1795 __glibcxx_assert(_M_pred.has_value());
1796 auto __it = ranges::find_if(ranges::begin(_M_base),
1797 ranges::end(_M_base),
1798 std::ref(*_M_pred));
1799 _M_cached_begin._M_set(_M_base, __it);
1800 return {this, std::move(__it)};
1806 if constexpr (common_range<_Vp>)
1807 return _Iterator{this, ranges::end(_M_base)};
1809 return _Sentinel{this};
1813 template<typename _Range, typename _Pred>
1814 filter_view(_Range&&, _Pred) -> filter_view<views::all_t<_Range>, _Pred>;
1820 template<typename _Range, typename _Pred>
1821 concept __can_filter_view
1822 = requires { filter_view(std::declval<_Range>(), std::declval<_Pred>()); };
1823 } // namespace __detail
1825 struct _Filter : __adaptor::_RangeAdaptor<_Filter>
1827 template<viewable_range _Range, typename _Pred>
1828 requires __detail::__can_filter_view<_Range, _Pred>
1830 operator() [[nodiscard]] (_Range&& __r, _Pred&& __p) const
1832 return filter_view(std::forward<_Range>(__r), std::forward<_Pred>(__p));
1835 using _RangeAdaptor<_Filter>::operator();
1836 static constexpr int _S_arity = 2;
1837 static constexpr bool _S_has_simple_extra_args = true;
1840 inline constexpr _Filter filter;
1841 } // namespace views
1843#if __cpp_lib_ranges >= 202207L // C++ >= 23
1844 template<input_range _Vp, move_constructible _Fp>
1846 template<input_range _Vp, copy_constructible _Fp>
1848 requires view<_Vp> && is_object_v<_Fp>
1849 && regular_invocable<_Fp&, range_reference_t<_Vp>>
1850 && std::__detail::__can_reference<invoke_result_t<_Fp&,
1851 range_reference_t<_Vp>>>
1852 class transform_view : public view_interface<transform_view<_Vp, _Fp>>
1855 template<bool _Const>
1856 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
1858 template<bool _Const>
1862 template<bool _Const>
1863 requires forward_range<_Base<_Const>>
1864 struct __iter_cat<_Const>
1870 using _Base = transform_view::_Base<_Const>;
1871 using _Res = invoke_result_t<_Fp&, range_reference_t<_Base>>;
1872 if constexpr (is_lvalue_reference_v<_Res>)
1875 = typename iterator_traits<iterator_t<_Base>>::iterator_category;
1876 if constexpr (derived_from<_Cat, contiguous_iterator_tag>)
1877 return random_access_iterator_tag{};
1882 return input_iterator_tag{};
1885 using iterator_category = decltype(_S_iter_cat());
1888 template<bool _Const>
1891 template<bool _Const>
1892 struct _Iterator : __iter_cat<_Const>
1895 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
1896 using _Base = transform_view::_Base<_Const>;
1901 if constexpr (random_access_range<_Base>)
1902 return random_access_iterator_tag{};
1903 else if constexpr (bidirectional_range<_Base>)
1904 return bidirectional_iterator_tag{};
1905 else if constexpr (forward_range<_Base>)
1906 return forward_iterator_tag{};
1908 return input_iterator_tag{};
1911 using _Base_iter = iterator_t<_Base>;
1913 _Base_iter _M_current = _Base_iter();
1914 _Parent* _M_parent = nullptr;
1917 using iterator_concept = decltype(_S_iter_concept());
1918 // iterator_category defined in __transform_view_iter_cat
1920 = remove_cvref_t<invoke_result_t<_Fp&, range_reference_t<_Base>>>;
1921 using difference_type = range_difference_t<_Base>;
1923 _Iterator() requires default_initializable<_Base_iter> = default;
1926 _Iterator(_Parent* __parent, _Base_iter __current)
1927 : _M_current(std::move(__current)),
1932 _Iterator(_Iterator<!_Const> __i)
1934 && convertible_to<iterator_t<_Vp>, _Base_iter>
1935 : _M_current(std::move(__i._M_current)), _M_parent(__i._M_parent)
1938 constexpr const _Base_iter&
1939 base() const & noexcept
1940 { return _M_current; }
1942 constexpr _Base_iter
1944 { return std::move(_M_current); }
1946 constexpr decltype(auto)
1948 noexcept(noexcept(std::__invoke(*_M_parent->_M_fun, *_M_current)))
1949 { return std::__invoke(*_M_parent->_M_fun, *_M_current); }
1951 constexpr _Iterator&
1963 operator++(int) requires forward_range<_Base>
1970 constexpr _Iterator&
1971 operator--() requires bidirectional_range<_Base>
1978 operator--(int) requires bidirectional_range<_Base>
1985 constexpr _Iterator&
1986 operator+=(difference_type __n) requires random_access_range<_Base>
1992 constexpr _Iterator&
1993 operator-=(difference_type __n) requires random_access_range<_Base>
1999 constexpr decltype(auto)
2000 operator[](difference_type __n) const
2001 requires random_access_range<_Base>
2002 { return std::__invoke(*_M_parent->_M_fun, _M_current[__n]); }
2004 friend constexpr bool
2005 operator==(const _Iterator& __x, const _Iterator& __y)
2006 requires equality_comparable<_Base_iter>
2007 { return __x._M_current == __y._M_current; }
2009 friend constexpr bool
2010 operator<(const _Iterator& __x, const _Iterator& __y)
2011 requires random_access_range<_Base>
2012 { return __x._M_current < __y._M_current; }
2014 friend constexpr bool
2015 operator>(const _Iterator& __x, const _Iterator& __y)
2016 requires random_access_range<_Base>
2017 { return __y < __x; }
2019 friend constexpr bool
2020 operator<=(const _Iterator& __x, const _Iterator& __y)
2021 requires random_access_range<_Base>
2022 { return !(__y < __x); }
2024 friend constexpr bool
2025 operator>=(const _Iterator& __x, const _Iterator& __y)
2026 requires random_access_range<_Base>
2027 { return !(__x < __y); }
2029#ifdef __cpp_lib_three_way_comparison
2030 friend constexpr auto
2031 operator<=>(const _Iterator& __x, const _Iterator& __y)
2032 requires random_access_range<_Base>
2033 && three_way_comparable<_Base_iter>
2034 { return __x._M_current <=> __y._M_current; }
2037 friend constexpr _Iterator
2038 operator+(_Iterator __i, difference_type __n)
2039 requires random_access_range<_Base>
2040 { return {__i._M_parent, __i._M_current + __n}; }
2042 friend constexpr _Iterator
2043 operator+(difference_type __n, _Iterator __i)
2044 requires random_access_range<_Base>
2045 { return {__i._M_parent, __i._M_current + __n}; }
2047 friend constexpr _Iterator
2048 operator-(_Iterator __i, difference_type __n)
2049 requires random_access_range<_Base>
2050 { return {__i._M_parent, __i._M_current - __n}; }
2052 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2053 // 3483. transform_view::iterator's difference is overconstrained
2054 friend constexpr difference_type
2055 operator-(const _Iterator& __x, const _Iterator& __y)
2056 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
2057 { return __x._M_current - __y._M_current; }
2059 friend constexpr decltype(auto)
2060 iter_move(const _Iterator& __i) noexcept(noexcept(*__i))
2062 if constexpr (is_lvalue_reference_v<decltype(*__i)>)
2063 return std::move(*__i);
2068 friend _Iterator<!_Const>;
2069 template<bool> friend struct _Sentinel;
2072 template<bool _Const>
2076 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
2077 using _Base = transform_view::_Base<_Const>;
2079 template<bool _Const2>
2081 __distance_from(const _Iterator<_Const2>& __i) const
2082 { return _M_end - __i._M_current; }
2084 template<bool _Const2>
2086 __equal(const _Iterator<_Const2>& __i) const
2087 { return __i._M_current == _M_end; }
2089 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2092 _Sentinel() = default;
2095 _Sentinel(sentinel_t<_Base> __end)
2100 _Sentinel(_Sentinel<!_Const> __i)
2102 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2103 : _M_end(std::move(__i._M_end))
2106 constexpr sentinel_t<_Base>
2110 template<bool _Const2>
2111 requires sentinel_for<sentinel_t<_Base>,
2112 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
2113 friend constexpr bool
2114 operator==(const _Iterator<_Const2>& __x, const _Sentinel& __y)
2115 { return __y.__equal(__x); }
2117 template<bool _Const2,
2118 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
2119 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2120 friend constexpr range_difference_t<_Base2>
2121 operator-(const _Iterator<_Const2>& __x, const _Sentinel& __y)
2122 { return -__y.__distance_from(__x); }
2124 template<bool _Const2,
2125 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
2126 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2127 friend constexpr range_difference_t<_Base2>
2128 operator-(const _Sentinel& __y, const _Iterator<_Const2>& __x)
2129 { return __y.__distance_from(__x); }
2131 friend _Sentinel<!_Const>;
2134 _Vp _M_base = _Vp();
2135 [[no_unique_address]] __detail::__box<_Fp> _M_fun;
2138 transform_view() requires (default_initializable<_Vp>
2139 && default_initializable<_Fp>)
2143 transform_view(_Vp __base, _Fp __fun)
2144 : _M_base(std::move(__base)), _M_fun(std::move(__fun))
2148 base() const& requires copy_constructible<_Vp>
2149 { return _M_base ; }
2153 { return std::move(_M_base); }
2155 constexpr _Iterator<false>
2157 { return _Iterator<false>{this, ranges::begin(_M_base)}; }
2159 constexpr _Iterator<true>
2161 requires range<const _Vp>
2162 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
2163 { return _Iterator<true>{this, ranges::begin(_M_base)}; }
2165 constexpr _Sentinel<false>
2167 { return _Sentinel<false>{ranges::end(_M_base)}; }
2169 constexpr _Iterator<false>
2170 end() requires common_range<_Vp>
2171 { return _Iterator<false>{this, ranges::end(_M_base)}; }
2173 constexpr _Sentinel<true>
2175 requires range<const _Vp>
2176 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
2177 { return _Sentinel<true>{ranges::end(_M_base)}; }
2179 constexpr _Iterator<true>
2181 requires common_range<const _Vp>
2182 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
2183 { return _Iterator<true>{this, ranges::end(_M_base)}; }
2186 size() requires sized_range<_Vp>
2187 { return ranges::size(_M_base); }
2190 size() const requires sized_range<const _Vp>
2191 { return ranges::size(_M_base); }
2194 template<typename _Range, typename _Fp>
2195 transform_view(_Range&&, _Fp) -> transform_view<views::all_t<_Range>, _Fp>;
2201 template<typename _Range, typename _Fp>
2202 concept __can_transform_view
2203 = requires { transform_view(std::declval<_Range>(), std::declval<_Fp>()); };
2204 } // namespace __detail
2206 struct _Transform : __adaptor::_RangeAdaptor<_Transform>
2208 template<viewable_range _Range, typename _Fp>
2209 requires __detail::__can_transform_view<_Range, _Fp>
2211 operator() [[nodiscard]] (_Range&& __r, _Fp&& __f) const
2213 return transform_view(std::forward<_Range>(__r), std::forward<_Fp>(__f));
2216 using _RangeAdaptor<_Transform>::operator();
2217 static constexpr int _S_arity = 2;
2218 static constexpr bool _S_has_simple_extra_args = true;
2221 inline constexpr _Transform transform;
2222 } // namespace views
2225 class take_view : public view_interface<take_view<_Vp>>
2228 template<bool _Const>
2229 using _CI = counted_iterator<
2230 iterator_t<__detail::__maybe_const_t<_Const, _Vp>>>;
2232 template<bool _Const>
2236 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2237 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2240 _Sentinel() = default;
2243 _Sentinel(sentinel_t<_Base> __end)
2248 _Sentinel(_Sentinel<!_Const> __s)
2249 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2250 : _M_end(std::move(__s._M_end))
2253 constexpr sentinel_t<_Base>
2257 friend constexpr bool
2258 operator==(const _CI<_Const>& __y, const _Sentinel& __x)
2259 { return __y.count() == 0 || __y.base() == __x._M_end; }
2261 template<bool _OtherConst = !_Const,
2262 typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
2263 requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2264 friend constexpr bool
2265 operator==(const _CI<_OtherConst>& __y, const _Sentinel& __x)
2266 { return __y.count() == 0 || __y.base() == __x._M_end; }
2268 friend _Sentinel<!_Const>;
2271 _Vp _M_base = _Vp();
2272 range_difference_t<_Vp> _M_count = 0;
2275 take_view() requires default_initializable<_Vp> = default;
2278 take_view(_Vp __base, range_difference_t<_Vp> __count)
2279 : _M_base(std::move(__base)), _M_count(std::move(__count))
2283 base() const& requires copy_constructible<_Vp>
2288 { return std::move(_M_base); }
2291 begin() requires (!__detail::__simple_view<_Vp>)
2293 if constexpr (sized_range<_Vp>)
2295 if constexpr (random_access_range<_Vp>)
2296 return ranges::begin(_M_base);
2300 return counted_iterator(ranges::begin(_M_base), __sz);
2304 return counted_iterator(ranges::begin(_M_base), _M_count);
2308 begin() const requires range<const _Vp>
2310 if constexpr (sized_range<const _Vp>)
2312 if constexpr (random_access_range<const _Vp>)
2313 return ranges::begin(_M_base);
2317 return counted_iterator(ranges::begin(_M_base), __sz);
2321 return counted_iterator(ranges::begin(_M_base), _M_count);
2325 end() requires (!__detail::__simple_view<_Vp>)
2327 if constexpr (sized_range<_Vp>)
2329 if constexpr (random_access_range<_Vp>)
2330 return ranges::begin(_M_base) + size();
2332 return default_sentinel;
2335 return _Sentinel<false>{ranges::end(_M_base)};
2339 end() const requires range<const _Vp>
2341 if constexpr (sized_range<const _Vp>)
2343 if constexpr (random_access_range<const _Vp>)
2344 return ranges::begin(_M_base) + size();
2346 return default_sentinel;
2349 return _Sentinel<true>{ranges::end(_M_base)};
2353 size() requires sized_range<_Vp>
2355 auto __n = ranges::size(_M_base);
2356 return std::min(__n, static_cast<decltype(__n)>(_M_count));
2360 size() const requires sized_range<const _Vp>
2362 auto __n = ranges::size(_M_base);
2363 return std::min(__n, static_cast<decltype(__n)>(_M_count));
2367 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2368 // 3447. Deduction guides for take_view and drop_view have different
2370 template<typename _Range>
2371 take_view(_Range&&, range_difference_t<_Range>)
2372 -> take_view<views::all_t<_Range>>;
2374 template<typename _Tp>
2375 inline constexpr bool enable_borrowed_range<take_view<_Tp>>
2376 = enable_borrowed_range<_Tp>;
2382 template<typename _Range>
2383 inline constexpr bool __is_empty_view = false;
2385 template<typename _Tp>
2386 inline constexpr bool __is_empty_view<empty_view<_Tp>> = true;
2388 template<typename _Range>
2389 inline constexpr bool __is_basic_string_view = false;
2391 template<typename _CharT, typename _Traits>
2392 inline constexpr bool __is_basic_string_view<basic_string_view<_CharT, _Traits>>
2395 using ranges::__detail::__is_subrange;
2397 template<typename _Range>
2398 inline constexpr bool __is_iota_view = false;
2400 template<typename _Winc, typename _Bound>
2401 inline constexpr bool __is_iota_view<iota_view<_Winc, _Bound>> = true;
2403 template<typename _Range>
2404 inline constexpr bool __is_repeat_view = false;
2406 template<typename _Range>
2408 __take_of_repeat_view(_Range&&, range_difference_t<_Range>); // defined later
2410 template<typename _Range, typename _Dp>
2411 concept __can_take_view
2412 = requires { take_view(std::declval<_Range>(), std::declval<_Dp>()); };
2413 } // namespace __detail
2415 struct _Take : __adaptor::_RangeAdaptor<_Take>
2417 template<viewable_range _Range, typename _Dp = range_difference_t<_Range>>
2418 requires __detail::__can_take_view<_Range, _Dp>
2420 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n) const
2422 using _Tp = remove_cvref_t<_Range>;
2423 if constexpr (__detail::__is_empty_view<_Tp>)
2425 else if constexpr (random_access_range<_Tp>
2427 && (std::__detail::__is_span<_Tp>
2428 || __detail::__is_basic_string_view<_Tp>
2429 || __detail::__is_subrange<_Tp>
2430 || __detail::__is_iota_view<_Tp>))
2432 __n = std::min<_Dp>(ranges::distance(__r), __n);
2433 auto __begin = ranges::begin(__r);
2434 auto __end = __begin + __n;
2435 if constexpr (std::__detail::__is_span<_Tp>)
2436 return span<typename _Tp::element_type>(__begin, __end);
2437 else if constexpr (__detail::__is_basic_string_view<_Tp>)
2438 return _Tp(__begin, __end);
2439 else if constexpr (__detail::__is_subrange<_Tp>)
2440 return subrange<iterator_t<_Tp>>(__begin, __end);
2442 return iota_view(*__begin, *__end);
2444 else if constexpr (__detail::__is_repeat_view<_Tp>)
2445 return __detail::__take_of_repeat_view(std::forward<_Range>(__r), __n);
2447 return take_view(std::forward<_Range>(__r), __n);
2450 using _RangeAdaptor<_Take>::operator();
2451 static constexpr int _S_arity = 2;
2452 // The count argument of views::take is not always simple -- it can be
2453 // e.g. a move-only class that's implicitly convertible to the difference
2454 // type. But an integer-like count argument is surely simple.
2455 template<typename _Tp>
2456 static constexpr bool _S_has_simple_extra_args
2457 = ranges::__detail::__is_integer_like<_Tp>;
2460 inline constexpr _Take take;
2461 } // namespace views
2463 template<view _Vp, typename _Pred>
2464 requires input_range<_Vp> && is_object_v<_Pred>
2465 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2466 class take_while_view : public view_interface<take_while_view<_Vp, _Pred>>
2468 template<bool _Const>
2472 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2474 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2475 const _Pred* _M_pred = nullptr;
2478 _Sentinel() = default;
2481 _Sentinel(sentinel_t<_Base> __end, const _Pred* __pred)
2482 : _M_end(__end), _M_pred(__pred)
2486 _Sentinel(_Sentinel<!_Const> __s)
2487 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2488 : _M_end(__s._M_end), _M_pred(__s._M_pred)
2491 constexpr sentinel_t<_Base>
2492 base() const { return _M_end; }
2494 friend constexpr bool
2495 operator==(const iterator_t<_Base>& __x, const _Sentinel& __y)
2496 { return __y._M_end == __x || !std::__invoke(*__y._M_pred, *__x); }
2498 template<bool _OtherConst = !_Const,
2499 typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
2500 requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2501 friend constexpr bool
2502 operator==(const iterator_t<_Base2>& __x, const _Sentinel& __y)
2503 { return __y._M_end == __x || !std::__invoke(*__y._M_pred, *__x); }
2505 friend _Sentinel<!_Const>;
2508 _Vp _M_base = _Vp();
2509 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
2512 take_while_view() requires (default_initializable<_Vp>
2513 && default_initializable<_Pred>)
2517 take_while_view(_Vp __base, _Pred __pred)
2518 : _M_base(std::move(__base)), _M_pred(std::move(__pred))
2522 base() const& requires copy_constructible<_Vp>
2527 { return std::move(_M_base); }
2529 constexpr const _Pred&
2531 { return *_M_pred; }
2534 begin() requires (!__detail::__simple_view<_Vp>)
2535 { return ranges::begin(_M_base); }
2538 begin() const requires range<const _Vp>
2539 && indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
2540 { return ranges::begin(_M_base); }
2543 end() requires (!__detail::__simple_view<_Vp>)
2544 { return _Sentinel<false>(ranges::end(_M_base),
2545 std::__addressof(*_M_pred)); }
2548 end() const requires range<const _Vp>
2549 && indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
2550 { return _Sentinel<true>(ranges::end(_M_base),
2551 std::__addressof(*_M_pred)); }
2554 template<typename _Range, typename _Pred>
2555 take_while_view(_Range&&, _Pred)
2556 -> take_while_view<views::all_t<_Range>, _Pred>;
2562 template<typename _Range, typename _Pred>
2563 concept __can_take_while_view
2564 = requires { take_while_view(std::declval<_Range>(), std::declval<_Pred>()); };
2565 } // namespace __detail
2567 struct _TakeWhile : __adaptor::_RangeAdaptor<_TakeWhile>
2569 template<viewable_range _Range, typename _Pred>
2570 requires __detail::__can_take_while_view<_Range, _Pred>
2572 operator() [[nodiscard]] (_Range&& __r, _Pred&& __p) const
2574 return take_while_view(std::forward<_Range>(__r), std::forward<_Pred>(__p));
2577 using _RangeAdaptor<_TakeWhile>::operator();
2578 static constexpr int _S_arity = 2;
2579 static constexpr bool _S_has_simple_extra_args = true;
2582 inline constexpr _TakeWhile take_while;
2583 } // namespace views
2586 class drop_view : public view_interface<drop_view<_Vp>>
2589 _Vp _M_base = _Vp();
2590 range_difference_t<_Vp> _M_count = 0;
2592 // ranges::next(begin(base), count, end(base)) is O(1) if _Vp satisfies
2593 // both random_access_range and sized_range. Otherwise, cache its result.
2594 static constexpr bool _S_needs_cached_begin
2595 = !(random_access_range<const _Vp> && sized_range<const _Vp>);
2596 [[no_unique_address]]
2597 __detail::__maybe_present_t<_S_needs_cached_begin,
2598 __detail::_CachedPosition<_Vp>>
2602 drop_view() requires default_initializable<_Vp> = default;
2605 drop_view(_Vp __base, range_difference_t<_Vp> __count)
2606 : _M_base(std::move(__base)), _M_count(__count)
2607 { __glibcxx_assert(__count >= 0); }
2610 base() const& requires copy_constructible<_Vp>
2615 { return std::move(_M_base); }
2617 // This overload is disabled for simple views with constant-time begin().
2620 requires (!(__detail::__simple_view<_Vp>
2621 && random_access_range<const _Vp>
2622 && sized_range<const _Vp>))
2624 if constexpr (_S_needs_cached_begin)
2625 if (_M_cached_begin._M_has_value())
2626 return _M_cached_begin._M_get(_M_base);
2628 auto __it = ranges::next(ranges::begin(_M_base),
2629 _M_count, ranges::end(_M_base));
2630 if constexpr (_S_needs_cached_begin)
2631 _M_cached_begin._M_set(_M_base, __it);
2635 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2636 // 3482. drop_view's const begin should additionally require sized_range
2639 requires random_access_range<const _Vp> && sized_range<const _Vp>
2641 return ranges::next(ranges::begin(_M_base), _M_count,
2642 ranges::end(_M_base));
2646 end() requires (!__detail::__simple_view<_Vp>)
2647 { return ranges::end(_M_base); }
2650 end() const requires range<const _Vp>
2651 { return ranges::end(_M_base); }
2654 size() requires sized_range<_Vp>
2656 const auto __s = ranges::size(_M_base);
2657 const auto __c = static_cast<decltype(__s)>(_M_count);
2658 return __s < __c ? 0 : __s - __c;
2662 size() const requires sized_range<const _Vp>
2664 const auto __s = ranges::size(_M_base);
2665 const auto __c = static_cast<decltype(__s)>(_M_count);
2666 return __s < __c ? 0 : __s - __c;
2670 template<typename _Range>
2671 drop_view(_Range&&, range_difference_t<_Range>)
2672 -> drop_view<views::all_t<_Range>>;
2674 template<typename _Tp>
2675 inline constexpr bool enable_borrowed_range<drop_view<_Tp>>
2676 = enable_borrowed_range<_Tp>;
2682 template<typename _Range>
2684 __drop_of_repeat_view(_Range&&, range_difference_t<_Range>); // defined later
2686 template<typename _Range, typename _Dp>
2687 concept __can_drop_view
2688 = requires { drop_view(std::declval<_Range>(), std::declval<_Dp>()); };
2689 } // namespace __detail
2691 struct _Drop : __adaptor::_RangeAdaptor<_Drop>
2693 template<viewable_range _Range, typename _Dp = range_difference_t<_Range>>
2694 requires __detail::__can_drop_view<_Range, _Dp>
2696 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n) const
2698 using _Tp = remove_cvref_t<_Range>;
2699 if constexpr (__detail::__is_empty_view<_Tp>)
2701 else if constexpr (random_access_range<_Tp>
2703 && (std::__detail::__is_span<_Tp>
2704 || __detail::__is_basic_string_view<_Tp>
2705 || __detail::__is_iota_view<_Tp>
2706 || __detail::__is_subrange<_Tp>))
2708 __n = std::min<_Dp>(ranges::distance(__r), __n);
2709 auto __begin = ranges::begin(__r) + __n;
2710 auto __end = ranges::end(__r);
2711 if constexpr (std::__detail::__is_span<_Tp>)
2712 return span<typename _Tp::element_type>(__begin, __end);
2713 else if constexpr (__detail::__is_subrange<_Tp>)
2715 if constexpr (_Tp::_S_store_size)
2717 using ranges::__detail::__to_unsigned_like;
2718 auto __m = ranges::distance(__r) - __n;
2719 return _Tp(__begin, __end, __to_unsigned_like(__m));
2722 return _Tp(__begin, __end);
2725 return _Tp(__begin, __end);
2727 else if constexpr (__detail::__is_repeat_view<_Tp>)
2728 return __detail::__drop_of_repeat_view(std::forward<_Range>(__r), __n);
2730 return drop_view(std::forward<_Range>(__r), __n);
2733 using _RangeAdaptor<_Drop>::operator();
2734 static constexpr int _S_arity = 2;
2735 template<typename _Tp>
2736 static constexpr bool _S_has_simple_extra_args
2737 = _Take::_S_has_simple_extra_args<_Tp>;
2740 inline constexpr _Drop drop;
2741 } // namespace views
2743 template<view _Vp, typename _Pred>
2744 requires input_range<_Vp> && is_object_v<_Pred>
2745 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2746 class drop_while_view : public view_interface<drop_while_view<_Vp, _Pred>>
2749 _Vp _M_base = _Vp();
2750 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
2751 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
2754 drop_while_view() requires (default_initializable<_Vp>
2755 && default_initializable<_Pred>)
2759 drop_while_view(_Vp __base, _Pred __pred)
2760 : _M_base(std::move(__base)), _M_pred(std::move(__pred))
2764 base() const& requires copy_constructible<_Vp>
2769 { return std::move(_M_base); }
2771 constexpr const _Pred&
2773 { return *_M_pred; }
2778 if (_M_cached_begin._M_has_value())
2779 return _M_cached_begin._M_get(_M_base);
2781 __glibcxx_assert(_M_pred.has_value());
2782 auto __it = ranges::find_if_not(ranges::begin(_M_base),
2783 ranges::end(_M_base),
2784 std::cref(*_M_pred));
2785 _M_cached_begin._M_set(_M_base, __it);
2791 { return ranges::end(_M_base); }
2794 template<typename _Range, typename _Pred>
2795 drop_while_view(_Range&&, _Pred)
2796 -> drop_while_view<views::all_t<_Range>, _Pred>;
2798 template<typename _Tp, typename _Pred>
2799 inline constexpr bool enable_borrowed_range<drop_while_view<_Tp, _Pred>>
2800 = enable_borrowed_range<_Tp>;
2806 template<typename _Range, typename _Pred>
2807 concept __can_drop_while_view
2808 = requires { drop_while_view(std::declval<_Range>(), std::declval<_Pred>()); };
2809 } // namespace __detail
2811 struct _DropWhile : __adaptor::_RangeAdaptor<_DropWhile>
2813 template<viewable_range _Range, typename _Pred>
2814 requires __detail::__can_drop_while_view<_Range, _Pred>
2816 operator() [[nodiscard]] (_Range&& __r, _Pred&& __p) const
2818 return drop_while_view(std::forward<_Range>(__r),
2819 std::forward<_Pred>(__p));
2822 using _RangeAdaptor<_DropWhile>::operator();
2823 static constexpr int _S_arity = 2;
2824 static constexpr bool _S_has_simple_extra_args = true;
2827 inline constexpr _DropWhile drop_while;
2828 } // namespace views
2832 template<typename _Tp>
2834 __as_lvalue(_Tp&& __t)
2835 { return static_cast<_Tp&>(__t); }
2836 } // namespace __detail
2838 template<input_range _Vp>
2839 requires view<_Vp> && input_range<range_reference_t<_Vp>>
2840 class join_view : public view_interface<join_view<_Vp>>
2843 using _InnerRange = range_reference_t<_Vp>;
2845 template<bool _Const>
2846 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2848 template<bool _Const>
2849 using _Outer_iter = iterator_t<_Base<_Const>>;
2851 template<bool _Const>
2852 using _Inner_iter = iterator_t<range_reference_t<_Base<_Const>>>;
2854 template<bool _Const>
2855 static constexpr bool _S_ref_is_glvalue
2856 = is_reference_v<range_reference_t<_Base<_Const>>>;
2858 template<bool _Const>
2862 template<bool _Const>
2863 requires _S_ref_is_glvalue<_Const>
2864 && forward_range<_Base<_Const>>
2865 && forward_range<range_reference_t<_Base<_Const>>>
2866 struct __iter_cat<_Const>
2869 static constexpr auto
2872 using _Outer_iter = join_view::_Outer_iter<_Const>;
2873 using _Inner_iter = join_view::_Inner_iter<_Const>;
2874 using _OuterCat = typename iterator_traits<_Outer_iter>::iterator_category;
2875 using _InnerCat = typename iterator_traits<_Inner_iter>::iterator_category;
2876 if constexpr (derived_from<_OuterCat, bidirectional_iterator_tag>
2877 && derived_from<_InnerCat, bidirectional_iterator_tag>
2878 && common_range<range_reference_t<_Base<_Const>>>)
2879 return bidirectional_iterator_tag{};
2880 else if constexpr (derived_from<_OuterCat, forward_iterator_tag>
2881 && derived_from<_InnerCat, forward_iterator_tag>)
2882 return forward_iterator_tag{};
2884 return input_iterator_tag{};
2887 using iterator_category = decltype(_S_iter_cat());
2890 template<bool _Const>
2893 template<bool _Const>
2894 struct _Iterator : __iter_cat<_Const>
2897 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
2898 using _Base = join_view::_Base<_Const>;
2902 static constexpr bool _S_ref_is_glvalue
2903 = join_view::_S_ref_is_glvalue<_Const>;
2908 auto __update_inner = [this] (const iterator_t<_Base>& __x) -> auto&& {
2909 if constexpr (_S_ref_is_glvalue)
2912 return _M_parent->_M_inner._M_emplace_deref(__x);
2915 _Outer_iter& __outer = _M_get_outer();
2916 for (; __outer != ranges::end(_M_parent->_M_base); ++__outer)
2918 auto&& __inner = __update_inner(__outer);
2919 _M_inner = ranges::begin(__inner);
2920 if (_M_inner != ranges::end(__inner))
2924 if constexpr (_S_ref_is_glvalue)
2928 static constexpr auto
2931 if constexpr (_S_ref_is_glvalue
2932 && bidirectional_range<_Base>
2933 && bidirectional_range<range_reference_t<_Base>>
2934 && common_range<range_reference_t<_Base>>)
2935 return bidirectional_iterator_tag{};
2936 else if constexpr (_S_ref_is_glvalue
2937 && forward_range<_Base>
2938 && forward_range<range_reference_t<_Base>>)
2939 return forward_iterator_tag{};
2941 return input_iterator_tag{};
2944 using _Outer_iter = join_view::_Outer_iter<_Const>;
2945 using _Inner_iter = join_view::_Inner_iter<_Const>;
2947 constexpr _Outer_iter&
2950 if constexpr (forward_range<_Base>)
2953 return *_M_parent->_M_outer;
2956 constexpr const _Outer_iter&
2957 _M_get_outer() const
2959 if constexpr (forward_range<_Base>)
2962 return *_M_parent->_M_outer;
2966 _Iterator(_Parent* __parent, _Outer_iter __outer) requires forward_range<_Base>
2967 : _M_outer(std::move(__outer)), _M_parent(__parent)
2971 _Iterator(_Parent* __parent) requires (!forward_range<_Base>)
2972 : _M_parent(__parent)
2975 [[no_unique_address]]
2976 __detail::__maybe_present_t<forward_range<_Base>, _Outer_iter> _M_outer;
2977 optional<_Inner_iter> _M_inner;
2978 _Parent* _M_parent = nullptr;
2981 using iterator_concept = decltype(_S_iter_concept());
2982 // iterator_category defined in __join_view_iter_cat
2983 using value_type = range_value_t<range_reference_t<_Base>>;
2984 using difference_type
2985 = common_type_t<range_difference_t<_Base>,
2986 range_difference_t<range_reference_t<_Base>>>;
2988 _Iterator() = default;
2991 _Iterator(_Iterator<!_Const> __i)
2993 && convertible_to<iterator_t<_Vp>, _Outer_iter>
2994 && convertible_to<iterator_t<_InnerRange>, _Inner_iter>
2995 : _M_outer(std::move(__i._M_outer)), _M_inner(std::move(__i._M_inner)),
2996 _M_parent(__i._M_parent)
2999 constexpr decltype(auto)
3001 { return **_M_inner; }
3003 // _GLIBCXX_RESOLVE_LIB_DEFECTS
3004 // 3500. join_view::iterator::operator->() is bogus
3005 constexpr _Inner_iter
3007 requires __detail::__has_arrow<_Inner_iter>
3008 && copyable<_Inner_iter>
3009 { return *_M_inner; }
3011 constexpr _Iterator&
3014 auto&& __inner_range = [this] () -> auto&& {
3015 if constexpr (_S_ref_is_glvalue)
3016 return *_M_get_outer();
3018 return *_M_parent->_M_inner;
3020 if (++*_M_inner == ranges::end(__inner_range))
3034 requires _S_ref_is_glvalue && forward_range<_Base>
3035 && forward_range<range_reference_t<_Base>>
3042 constexpr _Iterator&
3044 requires _S_ref_is_glvalue && bidirectional_range<_Base>
3045 && bidirectional_range<range_reference_t<_Base>>
3046 && common_range<range_reference_t<_Base>>
3048 if (_M_outer == ranges::end(_M_parent->_M_base))
3049 _M_inner = ranges::end(__detail::__as_lvalue(*--_M_outer));
3050 while (*_M_inner == ranges::begin(__detail::__as_lvalue(*_M_outer)))
3051 *_M_inner = ranges::end(__detail::__as_lvalue(*--_M_outer));
3058 requires _S_ref_is_glvalue && bidirectional_range<_Base>
3059 && bidirectional_range<range_reference_t<_Base>>
3060 && common_range<range_reference_t<_Base>>
3067 friend constexpr bool
3068 operator==(const _Iterator& __x, const _Iterator& __y)
3069 requires _S_ref_is_glvalue
3070 && forward_range<_Base>
3071 && equality_comparable<_Inner_iter>
3073 return (__x._M_outer == __y._M_outer
3074 && __x._M_inner == __y._M_inner);
3077 friend constexpr decltype(auto)
3078 iter_move(const _Iterator& __i)
3079 noexcept(noexcept(ranges::iter_move(*__i._M_inner)))
3080 { return ranges::iter_move(*__i._M_inner); }
3082 friend constexpr void
3083 iter_swap(const _Iterator& __x, const _Iterator& __y)
3084 noexcept(noexcept(ranges::iter_swap(*__x._M_inner, *__y._M_inner)))
3085 requires indirectly_swappable<_Inner_iter>
3086 { return ranges::iter_swap(*__x._M_inner, *__y._M_inner); }
3088 friend _Iterator<!_Const>;
3089 template<bool> friend struct _Sentinel;
3092 template<bool _Const>
3096 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
3097 using _Base = join_view::_Base<_Const>;
3099 template<bool _Const2>
3101 __equal(const _Iterator<_Const2>& __i) const
3102 { return __i._M_get_outer() == _M_end; }
3104 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
3107 _Sentinel() = default;
3110 _Sentinel(_Parent* __parent)
3111 : _M_end(ranges::end(__parent->_M_base))
3115 _Sentinel(_Sentinel<!_Const> __s)
3116 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
3117 : _M_end(std::move(__s._M_end))
3120 template<bool _Const2>
3121 requires sentinel_for<sentinel_t<_Base>,
3122 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
3123 friend constexpr bool
3124 operator==(const _Iterator<_Const2>& __x, const _Sentinel& __y)
3125 { return __y.__equal(__x); }
3127 friend _Sentinel<!_Const>;
3130 _Vp _M_base = _Vp();
3131 [[no_unique_address]]
3132 __detail::__maybe_present_t<!forward_range<_Vp>,
3133 __detail::__non_propagating_cache<iterator_t<_Vp>>> _M_outer;
3134 [[no_unique_address]]
3135 __detail::__non_propagating_cache<remove_cv_t<_InnerRange>> _M_inner;
3138 join_view() requires default_initializable<_Vp> = default;
3141 join_view(_Vp __base)
3142 : _M_base(std::move(__base))
3146 base() const& requires copy_constructible<_Vp>
3151 { return std::move(_M_base); }
3156 if constexpr (forward_range<_Vp>)
3158 constexpr bool __use_const
3159 = (__detail::__simple_view<_Vp>
3160 && is_reference_v<range_reference_t<_Vp>>);
3161 return _Iterator<__use_const>{this, ranges::begin(_M_base)};
3165 _M_outer = ranges::begin(_M_base);
3166 return _Iterator<false>{this};
3172 requires forward_range<const _Vp>
3173 && is_reference_v<range_reference_t<const _Vp>>
3174 && input_range<range_reference_t<const _Vp>>
3176 return _Iterator<true>{this, ranges::begin(_M_base)};
3182 if constexpr (forward_range<_Vp> && is_reference_v<_InnerRange>
3183 && forward_range<_InnerRange>
3184 && common_range<_Vp> && common_range<_InnerRange>)
3185 return _Iterator<__detail::__simple_view<_Vp>>{this,
3186 ranges::end(_M_base)};
3188 return _Sentinel<__detail::__simple_view<_Vp>>{this};
3193 requires forward_range<const _Vp>
3194 && is_reference_v<range_reference_t<const _Vp>>
3195 && input_range<range_reference_t<const _Vp>>
3197 if constexpr (is_reference_v<range_reference_t<const _Vp>>
3198 && forward_range<range_reference_t<const _Vp>>
3199 && common_range<const _Vp>
3200 && common_range<range_reference_t<const _Vp>>)
3201 return _Iterator<true>{this, ranges::end(_M_base)};
3203 return _Sentinel<true>{this};
3207 template<typename _Range>
3208 explicit join_view(_Range&&) -> join_view<views::all_t<_Range>>;
3214 template<typename _Range>
3215 concept __can_join_view
3216 = requires { join_view<all_t<_Range>>{std::declval<_Range>()}; };
3217 } // namespace __detail
3219 struct _Join : __adaptor::_RangeAdaptorClosure<_Join>
3221 template<viewable_range _Range>
3222 requires __detail::__can_join_view<_Range>
3224 operator() [[nodiscard]] (_Range&& __r) const
3226 // _GLIBCXX_RESOLVE_LIB_DEFECTS
3227 // 3474. Nesting join_views is broken because of CTAD
3228 return join_view<all_t<_Range>>{std::forward<_Range>(__r)};
3231 static constexpr bool _S_has_simple_call_op = true;
3234 inline constexpr _Join join;
3235 } // namespace views
3240 struct __require_constant;
3242 template<typename _Range>
3243 concept __tiny_range = sized_range<_Range>
3245 { typename __require_constant<remove_reference_t<_Range>::size()>; }
3246 && (remove_reference_t<_Range>::size() <= 1);
3248 template<typename _Base>
3249 struct __lazy_split_view_outer_iter_cat
3252 template<forward_range _Base>
3253 struct __lazy_split_view_outer_iter_cat<_Base>
3254 { using iterator_category = input_iterator_tag; };
3256 template<typename _Base>
3257 struct __lazy_split_view_inner_iter_cat
3260 template<forward_range _Base>
3261 struct __lazy_split_view_inner_iter_cat<_Base>
3264 static constexpr auto
3267 using _Cat = typename iterator_traits<iterator_t<_Base>>::iterator_category;
3268 if constexpr (derived_from<_Cat, forward_iterator_tag>)
3269 return forward_iterator_tag{};
3274 using iterator_category = decltype(_S_iter_cat());
3278 template<input_range _Vp, forward_range _Pattern>
3279 requires view<_Vp> && view<_Pattern>
3280 && indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
3282 && (forward_range<_Vp> || __detail::__tiny_range<_Pattern>)
3283 class lazy_split_view : public view_interface<lazy_split_view<_Vp, _Pattern>>
3286 template<bool _Const>
3287 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
3289 template<bool _Const>
3292 template<bool _Const>
3294 : __detail::__lazy_split_view_outer_iter_cat<_Base<_Const>>
3297 using _Parent = __detail::__maybe_const_t<_Const, lazy_split_view>;
3298 using _Base = lazy_split_view::_Base<_Const>;
3302 { return __current() == ranges::end(_M_parent->_M_base) && !_M_trailing_empty; }
3304 // [range.lazy.split.outer] p1
3305 // Many of the following specifications refer to the notional member
3306 // current of outer-iterator. current is equivalent to current_ if
3307 // V models forward_range, and parent_->current_ otherwise.
3309 __current() noexcept
3311 if constexpr (forward_range<_Vp>)
3314 return *_M_parent->_M_current;
3318 __current() const noexcept
3320 if constexpr (forward_range<_Vp>)
3323 return *_M_parent->_M_current;
3326 _Parent* _M_parent = nullptr;
3328 [[no_unique_address]]
3329 __detail::__maybe_present_t<forward_range<_Vp>,
3330 iterator_t<_Base>> _M_current;
3331 bool _M_trailing_empty = false;
3334 using iterator_concept = __conditional_t<forward_range<_Base>,
3335 forward_iterator_tag,
3336 input_iterator_tag>;
3337 // iterator_category defined in __lazy_split_view_outer_iter_cat
3338 using difference_type = range_difference_t<_Base>;
3340 struct value_type : view_interface<value_type>
3343 _OuterIter _M_i = _OuterIter();
3346 value_type() = default;
3349 value_type(_OuterIter __i)
3350 : _M_i(std::move(__i))
3353 constexpr _InnerIter<_Const>
3355 { return _InnerIter<_Const>{_M_i}; }
3357 constexpr default_sentinel_t
3358 end() const noexcept
3359 { return default_sentinel; }
3362 _OuterIter() = default;
3365 _OuterIter(_Parent* __parent) requires (!forward_range<_Base>)
3366 : _M_parent(__parent)
3370 _OuterIter(_Parent* __parent, iterator_t<_Base> __current)
3371 requires forward_range<_Base>
3372 : _M_parent(__parent),
3373 _M_current(std::move(__current))
3377 _OuterIter(_OuterIter<!_Const> __i)
3379 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
3380 : _M_parent(__i._M_parent), _M_current(std::move(__i._M_current)),
3381 _M_trailing_empty(__i._M_trailing_empty)
3384 constexpr value_type
3386 { return value_type{*this}; }
3388 constexpr _OuterIter&
3391 // _GLIBCXX_RESOLVE_LIB_DEFECTS
3392 // 3505. lazy_split_view::outer-iterator::operator++ misspecified
3393 const auto __end = ranges::end(_M_parent->_M_base);
3394 if (__current() == __end)
3396 _M_trailing_empty = false;
3399 const auto [__pbegin, __pend] = subrange{_M_parent->_M_pattern};
3400 if (__pbegin == __pend)
3402 else if constexpr (__detail::__tiny_range<_Pattern>)
3404 __current() = ranges::find(std::move(__current()), __end,
3406 if (__current() != __end)
3409 if (__current() == __end)
3410 _M_trailing_empty = true;
3417 = ranges::mismatch(__current(), __end, __pbegin, __pend);
3421 if (__current() == __end)
3422 _M_trailing_empty = true;
3425 } while (++__current() != __end);
3429 constexpr decltype(auto)
3432 if constexpr (forward_range<_Base>)
3442 friend constexpr bool
3443 operator==(const _OuterIter& __x, const _OuterIter& __y)
3444 requires forward_range<_Base>
3446 return __x._M_current == __y._M_current
3447 && __x._M_trailing_empty == __y._M_trailing_empty;
3450 friend constexpr bool
3451 operator==(const _OuterIter& __x, default_sentinel_t)
3452 { return __x.__at_end(); };
3454 friend _OuterIter<!_Const>;
3455 friend _InnerIter<_Const>;
3458 template<bool _Const>
3460 : __detail::__lazy_split_view_inner_iter_cat<_Base<_Const>>
3463 using _Base = lazy_split_view::_Base<_Const>;
3468 auto [__pcur, __pend] = subrange{_M_i._M_parent->_M_pattern};
3469 auto __end = ranges::end(_M_i._M_parent->_M_base);
3470 if constexpr (__detail::__tiny_range<_Pattern>)
3472 const auto& __cur = _M_i_current();
3475 if (__pcur == __pend)
3476 return _M_incremented;
3477 return *__cur == *__pcur;
3481 auto __cur = _M_i_current();
3484 if (__pcur == __pend)
3485 return _M_incremented;
3488 if (*__cur != *__pcur)
3490 if (++__pcur == __pend)
3492 } while (++__cur != __end);
3498 _M_i_current() noexcept
3499 { return _M_i.__current(); }
3502 _M_i_current() const noexcept
3503 { return _M_i.__current(); }
3505 _OuterIter<_Const> _M_i = _OuterIter<_Const>();
3506 bool _M_incremented = false;
3509 using iterator_concept
3510 = typename _OuterIter<_Const>::iterator_concept;
3511 // iterator_category defined in __lazy_split_view_inner_iter_cat
3512 using value_type = range_value_t<_Base>;
3513 using difference_type = range_difference_t<_Base>;
3515 _InnerIter() = default;
3518 _InnerIter(_OuterIter<_Const> __i)
3519 : _M_i(std::move(__i))
3522 constexpr const iterator_t<_Base>&
3523 base() const& noexcept
3524 { return _M_i_current(); }
3526 constexpr iterator_t<_Base>
3527 base() && requires forward_range<_Vp>
3528 { return std::move(_M_i_current()); }
3530 constexpr decltype(auto)
3532 { return *_M_i_current(); }
3534 constexpr _InnerIter&
3537 _M_incremented = true;
3538 if constexpr (!forward_range<_Base>)
3539 if constexpr (_Pattern::size() == 0)
3545 constexpr decltype(auto)
3548 if constexpr (forward_range<_Base>)
3558 friend constexpr bool
3559 operator==(const _InnerIter& __x, const _InnerIter& __y)
3560 requires forward_range<_Base>
3561 { return __x._M_i == __y._M_i; }
3563 friend constexpr bool
3564 operator==(const _InnerIter& __x, default_sentinel_t)
3565 { return __x.__at_end(); }
3567 friend constexpr decltype(auto)
3568 iter_move(const _InnerIter& __i)
3569 noexcept(noexcept(ranges::iter_move(__i._M_i_current())))
3570 { return ranges::iter_move(__i._M_i_current()); }
3572 friend constexpr void
3573 iter_swap(const _InnerIter& __x, const _InnerIter& __y)
3574 noexcept(noexcept(ranges::iter_swap(__x._M_i_current(),
3575 __y._M_i_current())))
3576 requires indirectly_swappable<iterator_t<_Base>>
3577 { ranges::iter_swap(__x._M_i_current(), __y._M_i_current()); }
3580 _Vp _M_base = _Vp();
3581 _Pattern _M_pattern = _Pattern();
3582 [[no_unique_address]]
3583 __detail::__maybe_present_t<!forward_range<_Vp>,
3584 __detail::__non_propagating_cache<iterator_t<_Vp>>> _M_current;
3588 lazy_split_view() requires (default_initializable<_Vp>
3589 && default_initializable<_Pattern>)
3593 lazy_split_view(_Vp __base, _Pattern __pattern)
3594 : _M_base(std::move(__base)), _M_pattern(std::move(__pattern))
3597 template<input_range _Range>
3598 requires constructible_from<_Vp, views::all_t<_Range>>
3599 && constructible_from<_Pattern, single_view<range_value_t<_Range>>>
3601 lazy_split_view(_Range&& __r, range_value_t<_Range> __e)
3602 : _M_base(views::all(std::forward<_Range>(__r))),
3603 _M_pattern(views::single(std::move(__e)))
3607 base() const& requires copy_constructible<_Vp>
3612 { return std::move(_M_base); }
3617 if constexpr (forward_range<_Vp>)
3619 constexpr bool __simple
3620 = __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
3621 return _OuterIter<__simple>{this, ranges::begin(_M_base)};
3625 _M_current = ranges::begin(_M_base);
3626 return _OuterIter<false>{this};
3631 begin() const requires forward_range<_Vp> && forward_range<const _Vp>
3633 return _OuterIter<true>{this, ranges::begin(_M_base)};
3637 end() requires forward_range<_Vp> && common_range<_Vp>
3639 constexpr bool __simple
3640 = __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
3641 return _OuterIter<__simple>{this, ranges::end(_M_base)};
3647 if constexpr (forward_range<_Vp>
3648 && forward_range<const _Vp>
3649 && common_range<const _Vp>)
3650 return _OuterIter<true>{this, ranges::end(_M_base)};
3652 return default_sentinel;
3656 template<typename _Range, typename _Pattern>
3657 lazy_split_view(_Range&&, _Pattern&&)
3658 -> lazy_split_view<views::all_t<_Range>, views::all_t<_Pattern>>;
3660 template<input_range _Range>
3661 lazy_split_view(_Range&&, range_value_t<_Range>)
3662 -> lazy_split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
3668 template<typename _Range, typename _Pattern>
3669 concept __can_lazy_split_view
3670 = requires { lazy_split_view(std::declval<_Range>(), std::declval<_Pattern>()); };
3671 } // namespace __detail
3673 struct _LazySplit : __adaptor::_RangeAdaptor<_LazySplit>
3675 template<viewable_range _Range, typename _Pattern>
3676 requires __detail::__can_lazy_split_view<_Range, _Pattern>
3678 operator() [[nodiscard]] (_Range&& __r, _Pattern&& __f) const
3680 return lazy_split_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
3683 using _RangeAdaptor<_LazySplit>::operator();
3684 static constexpr int _S_arity = 2;
3685 // The pattern argument of views::lazy_split is not always simple -- it can be
3686 // a non-view range, the value category of which affects whether the call
3687 // is well-formed. But a scalar or a view pattern argument is surely
3689 template<typename _Pattern>
3690 static constexpr bool _S_has_simple_extra_args
3691 = is_scalar_v<_Pattern> || (view<_Pattern>
3692 && copy_constructible<_Pattern>);
3695 inline constexpr _LazySplit lazy_split;
3696 } // namespace views
3698 template<forward_range _Vp, forward_range _Pattern>
3699 requires view<_Vp> && view<_Pattern>
3700 && indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
3702 class split_view : public view_interface<split_view<_Vp, _Pattern>>
3705 _Vp _M_base = _Vp();
3706 _Pattern _M_pattern = _Pattern();
3707 __detail::__non_propagating_cache<subrange<iterator_t<_Vp>>> _M_cached_begin;
3713 split_view() requires (default_initializable<_Vp>
3714 && default_initializable<_Pattern>)
3718 split_view(_Vp __base, _Pattern __pattern)
3719 : _M_base(std::move(__base)), _M_pattern(std::move(__pattern))
3722 template<forward_range _Range>
3723 requires constructible_from<_Vp, views::all_t<_Range>>
3724 && constructible_from<_Pattern, single_view<range_value_t<_Range>>>
3726 split_view(_Range&& __r, range_value_t<_Range> __e)
3727 : _M_base(views::all(std::forward<_Range>(__r))),
3728 _M_pattern(views::single(std::move(__e)))
3732 base() const& requires copy_constructible<_Vp>
3737 { return std::move(_M_base); }
3742 if (!_M_cached_begin)
3743 _M_cached_begin = _M_find_next(ranges::begin(_M_base));
3744 return {this, ranges::begin(_M_base), *_M_cached_begin};
3750 if constexpr (common_range<_Vp>)
3751 return _Iterator{this, ranges::end(_M_base), {}};
3753 return _Sentinel{this};
3756 constexpr subrange<iterator_t<_Vp>>
3757 _M_find_next(iterator_t<_Vp> __it)
3759 auto [__b, __e] = ranges::search(subrange(__it, ranges::end(_M_base)), _M_pattern);
3760 if (__b != ranges::end(_M_base) && ranges::empty(_M_pattern))
3772 split_view* _M_parent = nullptr;
3773 iterator_t<_Vp> _M_cur = iterator_t<_Vp>();
3774 subrange<iterator_t<_Vp>> _M_next = subrange<iterator_t<_Vp>>();
3775 bool _M_trailing_empty = false;
3777 friend struct _Sentinel;
3780 using iterator_concept = forward_iterator_tag;
3781 using iterator_category = input_iterator_tag;
3782 using value_type = subrange<iterator_t<_Vp>>;
3783 using difference_type = range_difference_t<_Vp>;
3785 _Iterator() = default;
3788 _Iterator(split_view* __parent,
3789 iterator_t<_Vp> __current,
3790 subrange<iterator_t<_Vp>> __next)
3791 : _M_parent(__parent),
3792 _M_cur(std::move(__current)),
3793 _M_next(std::move(__next))
3796 constexpr iterator_t<_Vp>
3800 constexpr value_type
3802 { return {_M_cur, _M_next.begin()}; }
3804 constexpr _Iterator&
3807 _M_cur = _M_next.begin();
3808 if (_M_cur != ranges::end(_M_parent->_M_base))
3810 _M_cur = _M_next.end();
3811 if (_M_cur == ranges::end(_M_parent->_M_base))
3813 _M_trailing_empty = true;
3814 _M_next = {_M_cur, _M_cur};
3817 _M_next = _M_parent->_M_find_next(_M_cur);
3820 _M_trailing_empty = false;
3832 friend constexpr bool
3833 operator==(const _Iterator& __x, const _Iterator& __y)
3835 return __x._M_cur == __y._M_cur
3836 && __x._M_trailing_empty == __y._M_trailing_empty;
3843 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
3846 _M_equal(const _Iterator& __x) const
3847 { return __x._M_cur == _M_end && !__x._M_trailing_empty; }
3850 _Sentinel() = default;
3853 _Sentinel(split_view* __parent)
3854 : _M_end(ranges::end(__parent->_M_base))
3857 friend constexpr bool
3858 operator==(const _Iterator& __x, const _Sentinel& __y)
3859 { return __y._M_equal(__x); }
3863 template<typename _Range, typename _Pattern>
3864 split_view(_Range&&, _Pattern&&)
3865 -> split_view<views::all_t<_Range>, views::all_t<_Pattern>>;
3867 template<forward_range _Range>
3868 split_view(_Range&&, range_value_t<_Range>)
3869 -> split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
3875 template<typename _Range, typename _Pattern>
3876 concept __can_split_view
3877 = requires { split_view(std::declval<_Range>(), std::declval<_Pattern>()); };
3878 } // namespace __detail
3880 struct _Split : __adaptor::_RangeAdaptor<_Split>
3882 template<viewable_range _Range, typename _Pattern>
3883 requires __detail::__can_split_view<_Range, _Pattern>
3885 operator() [[nodiscard]] (_Range&& __r, _Pattern&& __f) const
3887 return split_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
3890 using _RangeAdaptor<_Split>::operator();
3891 static constexpr int _S_arity = 2;
3892 template<typename _Pattern>
3893 static constexpr bool _S_has_simple_extra_args
3894 = _LazySplit::_S_has_simple_extra_args<_Pattern>;
3897 inline constexpr _Split split;
3898 } // namespace views
3904 template<input_or_output_iterator _Iter>
3906 operator() [[nodiscard]] (_Iter __i, iter_difference_t<_Iter> __n) const
3908 if constexpr (contiguous_iterator<_Iter>)
3909 return span(std::__to_address(__i), __n);
3910 else if constexpr (random_access_iterator<_Iter>)
3911 return subrange(__i, __i + __n);
3913 return subrange(counted_iterator(std::move(__i), __n),
3918 inline constexpr _Counted counted{};
3919 } // namespace views
3922 requires (!common_range<_Vp>) && copyable<iterator_t<_Vp>>
3923 class common_view : public view_interface<common_view<_Vp>>
3926 _Vp _M_base = _Vp();
3929 common_view() requires default_initializable<_Vp> = default;
3932 common_view(_Vp __r)
3933 : _M_base(std::move(__r))
3937 base() const& requires copy_constructible<_Vp>
3942 { return std::move(_M_base); }
3947 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3948 return ranges::begin(_M_base);
3950 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
3951 (ranges::begin(_M_base));
3955 begin() const requires range<const _Vp>
3957 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
3958 return ranges::begin(_M_base);
3960 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
3961 (ranges::begin(_M_base));
3967 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3968 return ranges::begin(_M_base) + ranges::size(_M_base);
3970 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
3971 (ranges::end(_M_base));
3975 end() const requires range<const _Vp>
3977 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
3978 return ranges::begin(_M_base) + ranges::size(_M_base);
3980 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
3981 (ranges::end(_M_base));
3985 size() requires sized_range<_Vp>
3986 { return ranges::size(_M_base); }
3989 size() const requires sized_range<const _Vp>
3990 { return ranges::size(_M_base); }
3993 template<typename _Range>
3994 common_view(_Range&&) -> common_view<views::all_t<_Range>>;
3996 template<typename _Tp>
3997 inline constexpr bool enable_borrowed_range<common_view<_Tp>>
3998 = enable_borrowed_range<_Tp>;
4004 template<typename _Range>
4005 concept __already_common = common_range<_Range>
4006 && requires { views::all(std::declval<_Range>()); };
4008 template<typename _Range>
4009 concept __can_common_view
4010 = requires { common_view{std::declval<_Range>()}; };
4011 } // namespace __detail
4013 struct _Common : __adaptor::_RangeAdaptorClosure<_Common>
4015 template<viewable_range _Range>
4016 requires __detail::__already_common<_Range>
4017 || __detail::__can_common_view<_Range>
4019 operator() [[nodiscard]] (_Range&& __r) const
4021 if constexpr (__detail::__already_common<_Range>)
4022 return views::all(std::forward<_Range>(__r));
4024 return common_view{std::forward<_Range>(__r)};
4027 static constexpr bool _S_has_simple_call_op = true;
4030 inline constexpr _Common common;
4031 } // namespace views
4034 requires bidirectional_range<_Vp>
4035 class reverse_view : public view_interface<reverse_view<_Vp>>
4038 static constexpr bool _S_needs_cached_begin
4039 = !common_range<_Vp> && !(random_access_range<_Vp>
4040 && sized_sentinel_for<sentinel_t<_Vp>,
4043 _Vp _M_base = _Vp();
4044 [[no_unique_address]]
4045 __detail::__maybe_present_t<_S_needs_cached_begin,
4046 __detail::_CachedPosition<_Vp>>
4050 reverse_view() requires default_initializable<_Vp> = default;
4053 reverse_view(_Vp __r)
4054 : _M_base(std::move(__r))
4058 base() const& requires copy_constructible<_Vp>
4063 { return std::move(_M_base); }
4065 constexpr reverse_iterator<iterator_t<_Vp>>
4068 if constexpr (_S_needs_cached_begin)
4069 if (_M_cached_begin._M_has_value())
4070 return std::make_reverse_iterator(_M_cached_begin._M_get(_M_base));
4072 auto __it = ranges::next(ranges::begin(_M_base), ranges::end(_M_base));
4073 if constexpr (_S_needs_cached_begin)
4074 _M_cached_begin._M_set(_M_base, __it);
4075 return std::make_reverse_iterator(std::move(__it));
4079 begin() requires common_range<_Vp>
4080 { return std::make_reverse_iterator(ranges::end(_M_base)); }
4083 begin() const requires common_range<const _Vp>
4084 { return std::make_reverse_iterator(ranges::end(_M_base)); }
4086 constexpr reverse_iterator<iterator_t<_Vp>>
4088 { return std::make_reverse_iterator(ranges::begin(_M_base)); }
4091 end() const requires common_range<const _Vp>
4092 { return std::make_reverse_iterator(ranges::begin(_M_base)); }
4095 size() requires sized_range<_Vp>
4096 { return ranges::size(_M_base); }
4099 size() const requires sized_range<const _Vp>
4100 { return ranges::size(_M_base); }
4103 template<typename _Range>
4104 reverse_view(_Range&&) -> reverse_view<views::all_t<_Range>>;
4106 template<typename _Tp>
4107 inline constexpr bool enable_borrowed_range<reverse_view<_Tp>>
4108 = enable_borrowed_range<_Tp>;
4115 inline constexpr bool __is_reversible_subrange = false;
4117 template<typename _Iter, subrange_kind _Kind>
4118 inline constexpr bool
4119 __is_reversible_subrange<subrange<reverse_iterator<_Iter>,
4120 reverse_iterator<_Iter>,
4124 inline constexpr bool __is_reverse_view = false;
4126 template<typename _Vp>
4127 inline constexpr bool __is_reverse_view<reverse_view<_Vp>> = true;
4129 template<typename _Range>
4130 concept __can_reverse_view
4131 = requires { reverse_view{std::declval<_Range>()}; };
4132 } // namespace __detail
4134 struct _Reverse : __adaptor::_RangeAdaptorClosure<_Reverse>
4136 template<viewable_range _Range>
4137 requires __detail::__is_reverse_view<remove_cvref_t<_Range>>
4138 || __detail::__is_reversible_subrange<remove_cvref_t<_Range>>
4139 || __detail::__can_reverse_view<_Range>
4141 operator() [[nodiscard]] (_Range&& __r) const
4143 using _Tp = remove_cvref_t<_Range>;
4144 if constexpr (__detail::__is_reverse_view<_Tp>)
4145 return std::forward<_Range>(__r).base();
4146 else if constexpr (__detail::__is_reversible_subrange<_Tp>)
4148 using _Iter = decltype(ranges::begin(__r).base());
4149 if constexpr (sized_range<_Tp>)
4150 return subrange<_Iter, _Iter, subrange_kind::sized>
4151 {__r.end().base(), __r.begin().base(), __r.size()};
4153 return subrange<_Iter, _Iter, subrange_kind::unsized>
4154 {__r.end().base(), __r.begin().base()};
4157 return reverse_view{std::forward<_Range>(__r)};
4160 static constexpr bool _S_has_simple_call_op = true;
4163 inline constexpr _Reverse reverse;
4164 } // namespace views
4168#if __cpp_lib_tuple_like // >= C++23
4169 template<typename _Tp, size_t _Nm>
4170 concept __has_tuple_element = __tuple_like<_Tp> && _Nm < tuple_size_v<_Tp>;
4172 template<typename _Tp, size_t _Nm>
4173 concept __has_tuple_element = requires(_Tp __t)
4175 typename tuple_size<_Tp>::type;
4176 requires _Nm < tuple_size_v<_Tp>;
4177 typename tuple_element_t<_Nm, _Tp>;
4178 { std::get<_Nm>(__t) }
4179 -> convertible_to<const tuple_element_t<_Nm, _Tp>&>;
4183 template<typename _Tp, size_t _Nm>
4184 concept __returnable_element
4185 = is_reference_v<_Tp> || move_constructible<tuple_element_t<_Nm, _Tp>>;
4188 template<input_range _Vp, size_t _Nm>
4190 && __detail::__has_tuple_element<range_value_t<_Vp>, _Nm>
4191 && __detail::__has_tuple_element<remove_reference_t<range_reference_t<_Vp>>,
4193 && __detail::__returnable_element<range_reference_t<_Vp>, _Nm>
4194 class elements_view : public view_interface<elements_view<_Vp, _Nm>>
4197 elements_view() requires default_initializable<_Vp> = default;
4200 elements_view(_Vp __base)
4201 : _M_base(std::move(__base))
4205 base() const& requires copy_constructible<_Vp>
4210 { return std::move(_M_base); }
4213 begin() requires (!__detail::__simple_view<_Vp>)
4214 { return _Iterator<false>(ranges::begin(_M_base)); }
4217 begin() const requires range<const _Vp>
4218 { return _Iterator<true>(ranges::begin(_M_base)); }
4221 end() requires (!__detail::__simple_view<_Vp> && !common_range<_Vp>)
4222 { return _Sentinel<false>{ranges::end(_M_base)}; }
4225 end() requires (!__detail::__simple_view<_Vp> && common_range<_Vp>)
4226 { return _Iterator<false>{ranges::end(_M_base)}; }
4229 end() const requires range<const _Vp>
4230 { return _Sentinel<true>{ranges::end(_M_base)}; }
4233 end() const requires common_range<const _Vp>
4234 { return _Iterator<true>{ranges::end(_M_base)}; }
4237 size() requires sized_range<_Vp>
4238 { return ranges::size(_M_base); }
4241 size() const requires sized_range<const _Vp>
4242 { return ranges::size(_M_base); }
4245 template<bool _Const>
4246 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
4248 template<bool _Const>
4252 template<bool _Const>
4253 requires forward_range<_Base<_Const>>
4254 struct __iter_cat<_Const>
4257 static auto _S_iter_cat()
4259 using _Base = elements_view::_Base<_Const>;
4260 using _Cat = typename iterator_traits<iterator_t<_Base>>::iterator_category;
4261 using _Res = decltype((std::get<_Nm>(*std::declval<iterator_t<_Base>>())));
4262 if constexpr (!is_lvalue_reference_v<_Res>)
4263 return input_iterator_tag{};
4264 else if constexpr (derived_from<_Cat, random_access_iterator_tag>)
4265 return random_access_iterator_tag{};
4270 using iterator_category = decltype(_S_iter_cat());
4273 template<bool _Const>
4276 template<bool _Const>
4277 struct _Iterator : __iter_cat<_Const>
4280 using _Base = elements_view::_Base<_Const>;
4282 iterator_t<_Base> _M_current = iterator_t<_Base>();
4284 static constexpr decltype(auto)
4285 _S_get_element(const iterator_t<_Base>& __i)
4287 if constexpr (is_reference_v<range_reference_t<_Base>>)
4288 return std::get<_Nm>(*__i);
4291 using _Et = remove_cv_t<tuple_element_t<_Nm, range_reference_t<_Base>>>;
4292 return static_cast<_Et>(std::get<_Nm>(*__i));
4299 if constexpr (random_access_range<_Base>)
4300 return random_access_iterator_tag{};
4301 else if constexpr (bidirectional_range<_Base>)
4302 return bidirectional_iterator_tag{};
4303 else if constexpr (forward_range<_Base>)
4304 return forward_iterator_tag{};
4306 return input_iterator_tag{};
4309 friend _Iterator<!_Const>;
4312 using iterator_concept = decltype(_S_iter_concept());
4313 // iterator_category defined in elements_view::__iter_cat
4315 = remove_cvref_t<tuple_element_t<_Nm, range_value_t<_Base>>>;
4316 using difference_type = range_difference_t<_Base>;
4318 _Iterator() requires default_initializable<iterator_t<_Base>> = default;
4321 _Iterator(iterator_t<_Base> __current)
4322 : _M_current(std::move(__current))
4326 _Iterator(_Iterator<!_Const> __i)
4327 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
4328 : _M_current(std::move(__i._M_current))
4331 constexpr const iterator_t<_Base>&
4332 base() const& noexcept
4333 { return _M_current; }
4335 constexpr iterator_t<_Base>
4337 { return std::move(_M_current); }
4339 constexpr decltype(auto)
4341 { return _S_get_element(_M_current); }
4343 constexpr _Iterator&
4355 operator++(int) requires forward_range<_Base>
4362 constexpr _Iterator&
4363 operator--() requires bidirectional_range<_Base>
4370 operator--(int) requires bidirectional_range<_Base>
4377 constexpr _Iterator&
4378 operator+=(difference_type __n)
4379 requires random_access_range<_Base>
4385 constexpr _Iterator&
4386 operator-=(difference_type __n)
4387 requires random_access_range<_Base>
4393 constexpr decltype(auto)
4394 operator[](difference_type __n) const
4395 requires random_access_range<_Base>
4396 { return _S_get_element(_M_current + __n); }
4398 friend constexpr bool
4399 operator==(const _Iterator& __x, const _Iterator& __y)
4400 requires equality_comparable<iterator_t<_Base>>
4401 { return __x._M_current == __y._M_current; }
4403 friend constexpr bool
4404 operator<(const _Iterator& __x, const _Iterator& __y)
4405 requires random_access_range<_Base>
4406 { return __x._M_current < __y._M_current; }
4408 friend constexpr bool
4409 operator>(const _Iterator& __x, const _Iterator& __y)
4410 requires random_access_range<_Base>
4411 { return __y._M_current < __x._M_current; }
4413 friend constexpr bool
4414 operator<=(const _Iterator& __x, const _Iterator& __y)
4415 requires random_access_range<_Base>
4416 { return !(__y._M_current > __x._M_current); }
4418 friend constexpr bool
4419 operator>=(const _Iterator& __x, const _Iterator& __y)
4420 requires random_access_range<_Base>
4421 { return !(__x._M_current > __y._M_current); }
4423#ifdef __cpp_lib_three_way_comparison
4424 friend constexpr auto
4425 operator<=>(const _Iterator& __x, const _Iterator& __y)
4426 requires random_access_range<_Base>
4427 && three_way_comparable<iterator_t<_Base>>
4428 { return __x._M_current <=> __y._M_current; }
4431 friend constexpr _Iterator
4432 operator+(const _Iterator& __x, difference_type __y)
4433 requires random_access_range<_Base>
4434 { return _Iterator{__x} += __y; }
4436 friend constexpr _Iterator
4437 operator+(difference_type __x, const _Iterator& __y)
4438 requires random_access_range<_Base>
4439 { return __y + __x; }
4441 friend constexpr _Iterator
4442 operator-(const _Iterator& __x, difference_type __y)
4443 requires random_access_range<_Base>
4444 { return _Iterator{__x} -= __y; }
4446 // _GLIBCXX_RESOLVE_LIB_DEFECTS
4447 // 3483. transform_view::iterator's difference is overconstrained
4448 friend constexpr difference_type
4449 operator-(const _Iterator& __x, const _Iterator& __y)
4450 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
4451 { return __x._M_current - __y._M_current; }
4453 template <bool> friend struct _Sentinel;
4456 template<bool _Const>
4460 template<bool _Const2>
4462 _M_equal(const _Iterator<_Const2>& __x) const
4463 { return __x._M_current == _M_end; }
4465 template<bool _Const2>
4467 _M_distance_from(const _Iterator<_Const2>& __i) const
4468 { return _M_end - __i._M_current; }
4470 using _Base = elements_view::_Base<_Const>;
4471 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
4474 _Sentinel() = default;
4477 _Sentinel(sentinel_t<_Base> __end)
4478 : _M_end(std::move(__end))
4482 _Sentinel(_Sentinel<!_Const> __other)
4484 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
4485 : _M_end(std::move(__other._M_end))
4488 constexpr sentinel_t<_Base>
4492 template<bool _Const2>
4493 requires sentinel_for<sentinel_t<_Base>,
4494 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
4495 friend constexpr bool
4496 operator==(const _Iterator<_Const2>& __x, const _Sentinel& __y)
4497 { return __y._M_equal(__x); }
4499 template<bool _Const2,
4500 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
4501 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
4502 friend constexpr range_difference_t<_Base2>
4503 operator-(const _Iterator<_Const2>& __x, const _Sentinel& __y)
4504 { return -__y._M_distance_from(__x); }
4506 template<bool _Const2,
4507 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
4508 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
4509 friend constexpr range_difference_t<_Base2>
4510 operator-(const _Sentinel& __x, const _Iterator<_Const2>& __y)
4511 { return __x._M_distance_from(__y); }
4513 friend _Sentinel<!_Const>;
4516 _Vp _M_base = _Vp();
4519 template<typename _Tp, size_t _Nm>
4520 inline constexpr bool enable_borrowed_range<elements_view<_Tp, _Nm>>
4521 = enable_borrowed_range<_Tp>;
4523 template<typename _Range>
4524 using keys_view = elements_view<views::all_t<_Range>, 0>;
4526 template<typename _Range>
4527 using values_view = elements_view<views::all_t<_Range>, 1>;
4533 template<size_t _Nm, typename _Range>
4534 concept __can_elements_view
4535 = requires { elements_view<all_t<_Range>, _Nm>{std::declval<_Range>()}; };
4536 } // namespace __detail
4538 template<size_t _Nm>
4539 struct _Elements : __adaptor::_RangeAdaptorClosure<_Elements<_Nm>>
4541 template<viewable_range _Range>
4542 requires __detail::__can_elements_view<_Nm, _Range>
4544 operator() [[nodiscard]] (_Range&& __r) const
4546 return elements_view<all_t<_Range>, _Nm>{std::forward<_Range>(__r)};
4549 static constexpr bool _S_has_simple_call_op = true;
4552 template<size_t _Nm>
4553 inline constexpr _Elements<_Nm> elements;
4554 inline constexpr auto keys = elements<0>;
4555 inline constexpr auto values = elements<1>;
4556 } // namespace views
4558#ifdef __cpp_lib_ranges_zip // C++ >= 23
4561 template<typename... _Rs>
4562 concept __zip_is_common = (sizeof...(_Rs) == 1 && (common_range<_Rs> && ...))
4563 || (!(bidirectional_range<_Rs> && ...) && (common_range<_Rs> && ...))
4564 || ((random_access_range<_Rs> && ...) && (sized_range<_Rs> && ...));
4566 template<typename _Fp, typename _Tuple>
4568 __tuple_transform(_Fp&& __f, _Tuple&& __tuple)
4570 return std::apply([&]<typename... _Ts>(_Ts&&... __elts) {
4571 return tuple<invoke_result_t<_Fp&, _Ts>...>
4572 (std::__invoke(__f, std::forward<_Ts>(__elts))...);
4573 }, std::forward<_Tuple>(__tuple));
4576 template<typename _Fp, typename _Tuple>
4578 __tuple_for_each(_Fp&& __f, _Tuple&& __tuple)
4580 std::apply([&]<typename... _Ts>(_Ts&&... __elts) {
4581 (std::__invoke(__f, std::forward<_Ts>(__elts)), ...);
4582 }, std::forward<_Tuple>(__tuple));
4584 } // namespace __detail
4586 template<input_range... _Vs>
4587 requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0)
4588 class zip_view : public view_interface<zip_view<_Vs...>>
4590 tuple<_Vs...> _M_views;
4592 template<bool> class _Iterator;
4593 template<bool> class _Sentinel;
4596 zip_view() = default;
4599 zip_view(_Vs... __views)
4600 : _M_views(std::move(__views)...)
4604 begin() requires (!(__detail::__simple_view<_Vs> && ...))
4605 { return _Iterator<false>(__detail::__tuple_transform(ranges::begin, _M_views)); }
4608 begin() const requires (range<const _Vs> && ...)
4609 { return _Iterator<true>(__detail::__tuple_transform(ranges::begin, _M_views)); }
4612 end() requires (!(__detail::__simple_view<_Vs> && ...))
4614 if constexpr (!__detail::__zip_is_common<_Vs...>)
4615 return _Sentinel<false>(__detail::__tuple_transform(ranges::end, _M_views));
4616 else if constexpr ((random_access_range<_Vs> && ...))
4617 return begin() + iter_difference_t<_Iterator<false>>(size());
4619 return _Iterator<false>(__detail::__tuple_transform(ranges::end, _M_views));
4623 end() const requires (range<const _Vs> && ...)
4625 if constexpr (!__detail::__zip_is_common<const _Vs...>)
4626 return _Sentinel<true>(__detail::__tuple_transform(ranges::end, _M_views));
4627 else if constexpr ((random_access_range<const _Vs> && ...))
4628 return begin() + iter_difference_t<_Iterator<true>>(size());
4630 return _Iterator<true>(__detail::__tuple_transform(ranges::end, _M_views));
4634 size() requires (sized_range<_Vs> && ...)
4636 return std::apply([](auto... sizes) {
4637 using _CT = __detail::__make_unsigned_like_t<common_type_t<decltype(sizes)...>>;
4638 return ranges::min({_CT(sizes)...});
4639 }, __detail::__tuple_transform(ranges::size, _M_views));
4643 size() const requires (sized_range<const _Vs> && ...)
4645 return std::apply([](auto... sizes) {
4646 using _CT = __detail::__make_unsigned_like_t<common_type_t<decltype(sizes)...>>;
4647 return ranges::min({_CT(sizes)...});
4648 }, __detail::__tuple_transform(ranges::size, _M_views));
4652 template<typename... _Rs>
4653 zip_view(_Rs&&...) -> zip_view<views::all_t<_Rs>...>;
4655 template<typename... _Views>
4656 inline constexpr bool enable_borrowed_range<zip_view<_Views...>>
4657 = (enable_borrowed_range<_Views> && ...);
4661 template<bool _Const, typename... _Vs>
4662 concept __all_random_access
4663 = (random_access_range<__maybe_const_t<_Const, _Vs>> && ...);
4665 template<bool _Const, typename... _Vs>
4666 concept __all_bidirectional
4667 = (bidirectional_range<__maybe_const_t<_Const, _Vs>> && ...);
4669 template<bool _Const, typename... _Vs>
4670 concept __all_forward
4671 = (forward_range<__maybe_const_t<_Const, _Vs>> && ...);
4673 template<bool _Const, typename... _Views>
4674 struct __zip_view_iter_cat
4677 template<bool _Const, typename... _Views>
4678 requires __all_forward<_Const, _Views...>
4679 struct __zip_view_iter_cat<_Const, _Views...>
4680 { using iterator_category = input_iterator_tag; };
4681 } // namespace __detail
4683 template<input_range... _Vs>
4684 requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0)
4685 template<bool _Const>
4686 class zip_view<_Vs...>::_Iterator
4687 : public __detail::__zip_view_iter_cat<_Const, _Vs...>
4689#ifdef __clang__ // LLVM-61763 workaround
4692 tuple<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>...> _M_current;
4695 _Iterator(decltype(_M_current) __current)
4696 : _M_current(std::move(__current))
4702 if constexpr (__detail::__all_random_access<_Const, _Vs...>)
4703 return random_access_iterator_tag{};
4704 else if constexpr (__detail::__all_bidirectional<_Const, _Vs...>)
4705 return bidirectional_iterator_tag{};
4706 else if constexpr (__detail::__all_forward<_Const, _Vs...>)
4707 return forward_iterator_tag{};
4709 return input_iterator_tag{};
4712#ifndef __clang__ // LLVM-61763 workaround
4713 template<move_constructible _Fp, input_range... _Ws>
4714 requires (view<_Ws> && ...) && (sizeof...(_Ws) > 0) && is_object_v<_Fp>
4715 && regular_invocable<_Fp&, range_reference_t<_Ws>...>
4716 && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Ws>...>>
4717 friend class zip_transform_view;
4721 // iterator_category defined in __zip_view_iter_cat
4722 using iterator_concept = decltype(_S_iter_concept());
4724 = tuple<range_value_t<__detail::__maybe_const_t<_Const, _Vs>>...>;
4725 using difference_type
4726 = common_type_t<range_difference_t<__detail::__maybe_const_t<_Const, _Vs>>...>;
4728 _Iterator() = default;
4731 _Iterator(_Iterator<!_Const> __i)
4733 && (convertible_to<iterator_t<_Vs>,
4734 iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4735 : _M_current(std::move(__i._M_current))
4741 auto __f = [](auto& __i) -> decltype(auto) {
4744 return __detail::__tuple_transform(__f, _M_current);
4747 constexpr _Iterator&
4750 __detail::__tuple_for_each([](auto& __i) { ++__i; }, _M_current);
4760 requires __detail::__all_forward<_Const, _Vs...>
4767 constexpr _Iterator&
4769 requires __detail::__all_bidirectional<_Const, _Vs...>
4771 __detail::__tuple_for_each([](auto& __i) { --__i; }, _M_current);
4777 requires __detail::__all_bidirectional<_Const, _Vs...>
4784 constexpr _Iterator&
4785 operator+=(difference_type __x)
4786 requires __detail::__all_random_access<_Const, _Vs...>
4788 auto __f = [&]<typename _It>(_It& __i) {
4789 __i += iter_difference_t<_It>(__x);
4791 __detail::__tuple_for_each(__f, _M_current);
4795 constexpr _Iterator&
4796 operator-=(difference_type __x)
4797 requires __detail::__all_random_access<_Const, _Vs...>
4799 auto __f = [&]<typename _It>(_It& __i) {
4800 __i -= iter_difference_t<_It>(__x);
4802 __detail::__tuple_for_each(__f, _M_current);
4807 operator[](difference_type __n) const
4808 requires __detail::__all_random_access<_Const, _Vs...>
4810 auto __f = [&]<typename _It>(_It& __i) -> decltype(auto) {
4811 return __i[iter_difference_t<_It>(__n)];
4813 return __detail::__tuple_transform(__f, _M_current);
4816 friend constexpr bool
4817 operator==(const _Iterator& __x, const _Iterator& __y)
4818 requires (equality_comparable<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4820 if constexpr (__detail::__all_bidirectional<_Const, _Vs...>)
4821 return __x._M_current == __y._M_current;
4823 return [&]<size_t... _Is>(index_sequence<_Is...>) {
4824 return ((std::get<_Is>(__x._M_current) == std::get<_Is>(__y._M_current)) || ...);
4825 }(make_index_sequence<sizeof...(_Vs)>{});
4828 friend constexpr auto
4829 operator<=>(const _Iterator& __x, const _Iterator& __y)
4830 requires __detail::__all_random_access<_Const, _Vs...>
4831 { return __x._M_current <=> __y._M_current; }
4833 friend constexpr _Iterator
4834 operator+(const _Iterator& __i, difference_type __n)
4835 requires __detail::__all_random_access<_Const, _Vs...>
4842 friend constexpr _Iterator
4843 operator+(difference_type __n, const _Iterator& __i)
4844 requires __detail::__all_random_access<_Const, _Vs...>
4851 friend constexpr _Iterator
4852 operator-(const _Iterator& __i, difference_type __n)
4853 requires __detail::__all_random_access<_Const, _Vs...>
4860 friend constexpr difference_type
4861 operator-(const _Iterator& __x, const _Iterator& __y)
4862 requires (sized_sentinel_for<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>,
4863 iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4865 return [&]<size_t... _Is>(index_sequence<_Is...>) {
4866 return ranges::min({difference_type(std::get<_Is>(__x._M_current)
4867 - std::get<_Is>(__y._M_current))...},
4869 [](difference_type __i) {
4870 return __detail::__to_unsigned_like(__i < 0 ? -__i : __i);
4872 }(make_index_sequence<sizeof...(_Vs)>{});
4875 friend constexpr auto
4876 iter_move(const _Iterator& __i)
4877 { return __detail::__tuple_transform(ranges::iter_move, __i._M_current); }
4879 friend constexpr void
4880 iter_swap(const _Iterator& __l, const _Iterator& __r)
4881 requires (indirectly_swappable<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4883 [&]<size_t... _Is>(index_sequence<_Is...>) {
4884 (ranges::iter_swap(std::get<_Is>(__l._M_current), std::get<_Is>(__r._M_current)), ...);
4885 }(make_index_sequence<sizeof...(_Vs)>{});
4888 friend class zip_view;
4891 template<input_range... _Vs>
4892 requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0)
4893 template<bool _Const>
4894 class zip_view<_Vs...>::_Sentinel
4896 tuple<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>...> _M_end;
4899 _Sentinel(decltype(_M_end) __end)
4903 friend class zip_view;
4906 _Sentinel() = default;
4909 _Sentinel(_Sentinel<!_Const> __i)
4911 && (convertible_to<sentinel_t<_Vs>,
4912 sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4913 : _M_end(std::move(__i._M_end))
4916 template<bool _OtherConst>
4917 requires (sentinel_for<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>,
4918 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vs>>> && ...)
4919 friend constexpr bool
4920 operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
4922 return [&]<size_t... _Is>(index_sequence<_Is...>) {
4923 return ((std::get<_Is>(__x._M_current) == std::get<_Is>(__y._M_end)) || ...);
4924 }(make_index_sequence<sizeof...(_Vs)>{});
4927 template<bool _OtherConst>
4928 requires (sized_sentinel_for<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>,
4929 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vs>>> && ...)
4930 friend constexpr auto
4931 operator-(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
4934 = common_type_t<range_difference_t<__detail::__maybe_const_t<_OtherConst, _Vs>>...>;
4935 return [&]<size_t... _Is>(index_sequence<_Is...>) {
4936 return ranges::min({_Ret(std::get<_Is>(__x._M_current) - std::get<_Is>(__y._M_end))...},
4939 return __detail::__to_unsigned_like(__i < 0 ? -__i : __i);
4941 }(make_index_sequence<sizeof...(_Vs)>{});
4944 template<bool _OtherConst>
4945 requires (sized_sentinel_for<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>,
4946 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vs>>> && ...)
4947 friend constexpr auto
4948 operator-(const _Sentinel& __y, const _Iterator<_OtherConst>& __x)
4949 { return -(__x - __y); }
4956 template<typename... _Ts>
4957 concept __can_zip_view
4958 = requires { zip_view<all_t<_Ts>...>(std::declval<_Ts>()...); };
4963 template<typename... _Ts>
4964 requires (sizeof...(_Ts) == 0 || __detail::__can_zip_view<_Ts...>)
4966 operator() [[nodiscard]] (_Ts&&... __ts) const
4968 if constexpr (sizeof...(_Ts) == 0)
4969 return views::empty<tuple<>>;
4971 return zip_view<all_t<_Ts>...>(std::forward<_Ts>(__ts)...);
4975 inline constexpr _Zip zip;
4980 template<typename _Range, bool _Const>
4981 using __range_iter_cat
4982 = typename iterator_traits<iterator_t<__maybe_const_t<_Const, _Range>>>::iterator_category;
4985 template<move_constructible _Fp, input_range... _Vs>
4986 requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0) && is_object_v<_Fp>
4987 && regular_invocable<_Fp&, range_reference_t<_Vs>...>
4988 && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Vs>...>>
4989 class zip_transform_view : public view_interface<zip_transform_view<_Fp, _Vs...>>
4991 [[no_unique_address]] __detail::__box<_Fp> _M_fun;
4992 zip_view<_Vs...> _M_zip;
4994 using _InnerView = zip_view<_Vs...>;
4996 template<bool _Const>
4997 using __ziperator = iterator_t<__detail::__maybe_const_t<_Const, _InnerView>>;
4999 template<bool _Const>
5000 using __zentinel = sentinel_t<__detail::__maybe_const_t<_Const, _InnerView>>;
5002 template<bool _Const>
5003 using _Base = __detail::__maybe_const_t<_Const, _InnerView>;
5005 template<bool _Const>
5009 template<bool _Const>
5010 requires forward_range<_Base<_Const>>
5011 struct __iter_cat<_Const>
5017 using __detail::__maybe_const_t;
5018 using __detail::__range_iter_cat;
5019 using _Res = invoke_result_t<__maybe_const_t<_Const, _Fp>&,
5020 range_reference_t<__maybe_const_t<_Const, _Vs>>...>;
5021 if constexpr (!is_lvalue_reference_v<_Res>)
5022 return input_iterator_tag{};
5023 else if constexpr ((derived_from<__range_iter_cat<_Vs, _Const>,
5024 random_access_iterator_tag> && ...))
5025 return random_access_iterator_tag{};
5026 else if constexpr ((derived_from<__range_iter_cat<_Vs, _Const>,
5027 bidirectional_iterator_tag> && ...))
5028 return bidirectional_iterator_tag{};
5029 else if constexpr ((derived_from<__range_iter_cat<_Vs, _Const>,
5030 forward_iterator_tag> && ...))
5031 return forward_iterator_tag{};
5033 return input_iterator_tag{};
5036 using iterator_category = decltype(_S_iter_cat());
5039 template<bool> class _Iterator;
5040 template<bool> class _Sentinel;
5043 zip_transform_view() = default;
5046 zip_transform_view(_Fp __fun, _Vs... __views)
5047 : _M_fun(std::move(__fun)), _M_zip(std::move(__views)...)
5052 { return _Iterator<false>(*this, _M_zip.begin()); }
5056 requires range<const _InnerView>
5057 && regular_invocable<const _Fp&, range_reference_t<const _Vs>...>
5058 { return _Iterator<true>(*this, _M_zip.begin()); }
5063 if constexpr (common_range<_InnerView>)
5064 return _Iterator<false>(*this, _M_zip.end());
5066 return _Sentinel<false>(_M_zip.end());
5071 requires range<const _InnerView>
5072 && regular_invocable<const _Fp&, range_reference_t<const _Vs>...>
5074 if constexpr (common_range<const _InnerView>)
5075 return _Iterator<true>(*this, _M_zip.end());
5077 return _Sentinel<true>(_M_zip.end());
5081 size() requires sized_range<_InnerView>
5082 { return _M_zip.size(); }
5085 size() const requires sized_range<const _InnerView>
5086 { return _M_zip.size(); }
5089 template<class _Fp, class... Rs>
5090 zip_transform_view(_Fp, Rs&&...) -> zip_transform_view<_Fp, views::all_t<Rs>...>;
5092 template<move_constructible _Fp, input_range... _Vs>
5093 requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0) && is_object_v<_Fp>
5094 && regular_invocable<_Fp&, range_reference_t<_Vs>...>
5095 && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Vs>...>>
5096 template<bool _Const>
5097 class zip_transform_view<_Fp, _Vs...>::_Iterator : public __iter_cat<_Const>
5099 using _Parent = __detail::__maybe_const_t<_Const, zip_transform_view>;
5101 _Parent* _M_parent = nullptr;
5102 __ziperator<_Const> _M_inner;
5105 _Iterator(_Parent& __parent, __ziperator<_Const> __inner)
5106 : _M_parent(std::__addressof(__parent)), _M_inner(std::move(__inner))
5109 friend class zip_transform_view;
5112 // iterator_category defined in zip_transform_view::__iter_cat
5113 using iterator_concept = typename __ziperator<_Const>::iterator_concept;
5115 = remove_cvref_t<invoke_result_t<__detail::__maybe_const_t<_Const, _Fp>&,
5116 range_reference_t<__detail::__maybe_const_t<_Const, _Vs>>...>>;
5117 using difference_type = range_difference_t<_Base<_Const>>;
5119 _Iterator() = default;
5122 _Iterator(_Iterator<!_Const> __i)
5123 requires _Const && convertible_to<__ziperator<false>, __ziperator<_Const>>
5124 : _M_parent(__i._M_parent), _M_inner(std::move(__i._M_inner))
5127 constexpr decltype(auto)
5130 return std::apply([&](const auto&... __iters) -> decltype(auto) {
5131 return std::__invoke(*_M_parent->_M_fun, *__iters...);
5132 }, _M_inner._M_current);
5135 constexpr _Iterator&
5147 operator++(int) requires forward_range<_Base<_Const>>
5154 constexpr _Iterator&
5155 operator--() requires bidirectional_range<_Base<_Const>>
5162 operator--(int) requires bidirectional_range<_Base<_Const>>
5169 constexpr _Iterator&
5170 operator+=(difference_type __x) requires random_access_range<_Base<_Const>>
5176 constexpr _Iterator&
5177 operator-=(difference_type __x) requires random_access_range<_Base<_Const>>
5183 constexpr decltype(auto)
5184 operator[](difference_type __n) const requires random_access_range<_Base<_Const>>
5186 return std::apply([&]<typename... _Is>(const _Is&... __iters) -> decltype(auto) {
5187 return std::__invoke(*_M_parent->_M_fun, __iters[iter_difference_t<_Is>(__n)]...);
5188 }, _M_inner._M_current);
5191 friend constexpr bool
5192 operator==(const _Iterator& __x, const _Iterator& __y)
5193 requires equality_comparable<__ziperator<_Const>>
5194 { return __x._M_inner == __y._M_inner; }
5196 friend constexpr auto
5197 operator<=>(const _Iterator& __x, const _Iterator& __y)
5198 requires random_access_range<_Base<_Const>>
5199 { return __x._M_inner <=> __y._M_inner; }
5201 friend constexpr _Iterator
5202 operator+(const _Iterator& __i, difference_type __n)
5203 requires random_access_range<_Base<_Const>>
5204 { return _Iterator(*__i._M_parent, __i._M_inner + __n); }
5206 friend constexpr _Iterator
5207 operator+(difference_type __n, const _Iterator& __i)
5208 requires random_access_range<_Base<_Const>>
5209 { return _Iterator(*__i._M_parent, __i._M_inner + __n); }
5211 friend constexpr _Iterator
5212 operator-(const _Iterator& __i, difference_type __n)
5213 requires random_access_range<_Base<_Const>>
5214 { return _Iterator(*__i._M_parent, __i._M_inner - __n); }
5216 friend constexpr difference_type
5217 operator-(const _Iterator& __x, const _Iterator& __y)
5218 requires sized_sentinel_for<__ziperator<_Const>, __ziperator<_Const>>
5219 { return __x._M_inner - __y._M_inner; }
5222 template<move_constructible _Fp, input_range... _Vs>
5223 requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0) && is_object_v<_Fp>
5224 && regular_invocable<_Fp&, range_reference_t<_Vs>...>
5225 && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Vs>...>>
5226 template<bool _Const>
5227 class zip_transform_view<_Fp, _Vs...>::_Sentinel
5229 __zentinel<_Const> _M_inner;
5232 _Sentinel(__zentinel<_Const> __inner)
5236 friend class zip_transform_view;
5239 _Sentinel() = default;
5242 _Sentinel(_Sentinel<!_Const> __i)
5243 requires _Const && convertible_to<__zentinel<false>, __zentinel<_Const>>
5244 : _M_inner(std::move(__i._M_inner))
5247 template<bool _OtherConst>
5248 requires sentinel_for<__zentinel<_Const>, __ziperator<_OtherConst>>
5249 friend constexpr bool
5250 operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
5251 { return __x._M_inner == __y._M_inner; }
5253 template<bool _OtherConst>
5254 requires sized_sentinel_for<__zentinel<_Const>, __ziperator<_OtherConst>>
5255 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
5256 operator-(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
5257 { return __x._M_inner - __y._M_inner; }
5259 template<bool _OtherConst>
5260 requires sized_sentinel_for<__zentinel<_Const>, __ziperator<_OtherConst>>
5261 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
5262 operator-(const _Sentinel& __x, const _Iterator<_OtherConst>& __y)
5263 { return __x._M_inner - __y._M_inner; }
5270 template<typename _Fp, typename... _Ts>
5271 concept __can_zip_transform_view
5272 = requires { zip_transform_view(std::declval<_Fp>(), std::declval<_Ts>()...); };
5275 struct _ZipTransform
5277 template<typename _Fp, typename... _Ts>
5278 requires (sizeof...(_Ts) == 0) || __detail::__can_zip_transform_view<_Fp, _Ts...>
5280 operator() [[nodiscard]] (_Fp&& __f, _Ts&&... __ts) const
5282 if constexpr (sizeof...(_Ts) == 0)
5283 return views::empty<decay_t<invoke_result_t<decay_t<_Fp>&>>>;
5285 return zip_transform_view(std::forward<_Fp>(__f), std::forward<_Ts>(__ts)...);
5289 inline constexpr _ZipTransform zip_transform;
5292 template<forward_range _Vp, size_t _Nm>
5293 requires view<_Vp> && (_Nm > 0)
5294 class adjacent_view : public view_interface<adjacent_view<_Vp, _Nm>>
5296 _Vp _M_base = _Vp();
5298 template<bool> class _Iterator;
5299 template<bool> class _Sentinel;
5301 struct __as_sentinel
5305 adjacent_view() requires default_initializable<_Vp> = default;
5308 adjacent_view(_Vp __base)
5309 : _M_base(std::move(__base))
5313 begin() requires (!__detail::__simple_view<_Vp>)
5314 { return _Iterator<false>(ranges::begin(_M_base), ranges::end(_M_base)); }
5317 begin() const requires range<const _Vp>
5318 { return _Iterator<true>(ranges::begin(_M_base), ranges::end(_M_base)); }
5321 end() requires (!__detail::__simple_view<_Vp>)
5323 if constexpr (common_range<_Vp>)
5324 return _Iterator<false>(__as_sentinel{}, ranges::begin(_M_base), ranges::end(_M_base));
5326 return _Sentinel<false>(ranges::end(_M_base));
5330 end() const requires range<const _Vp>
5332 if constexpr (common_range<const _Vp>)
5333 return _Iterator<true>(__as_sentinel{}, ranges::begin(_M_base), ranges::end(_M_base));
5335 return _Sentinel<true>(ranges::end(_M_base));
5339 size() requires sized_range<_Vp>
5341 using _ST = decltype(ranges::size(_M_base));
5342 using _CT = common_type_t<_ST, size_t>;
5343 auto __sz = static_cast<_CT>(ranges::size(_M_base));
5344 __sz -= std::min<_CT>(__sz, _Nm - 1);
5345 return static_cast<_ST>(__sz);
5349 size() const requires sized_range<const _Vp>
5351 using _ST = decltype(ranges::size(_M_base));
5352 using _CT = common_type_t<_ST, size_t>;
5353 auto __sz = static_cast<_CT>(ranges::size(_M_base));
5354 __sz -= std::min<_CT>(__sz, _Nm - 1);
5355 return static_cast<_ST>(__sz);
5359 template<typename _Vp, size_t _Nm>
5360 inline constexpr bool enable_borrowed_range<adjacent_view<_Vp, _Nm>>
5361 = enable_borrowed_range<_Vp>;
5365 // Yields tuple<_Tp, ..., _Tp> with _Nm elements.
5366 template<typename _Tp, size_t _Nm>
5367 using __repeated_tuple = decltype(std::tuple_cat(std::declval<array<_Tp, _Nm>>()));
5369 // For a functor F that is callable with N arguments, the expression
5370 // declval<__unarize<F, N>>(x) is equivalent to declval<F>(x, ..., x).
5371 template<typename _Fp, size_t _Nm>
5374 template<typename... _Ts>
5375 static invoke_result_t<_Fp, _Ts...>
5376 __tuple_apply(const tuple<_Ts...>&); // not defined
5378 template<typename _Tp>
5379 decltype(__tuple_apply(std::declval<__repeated_tuple<_Tp, _Nm>>()))
5380 operator()(_Tp&&); // not defined
5384 template<forward_range _Vp, size_t _Nm>
5385 requires view<_Vp> && (_Nm > 0)
5386 template<bool _Const>
5387 class adjacent_view<_Vp, _Nm>::_Iterator
5389#ifdef __clang__ // LLVM-61763 workaround
5392 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
5393 array<iterator_t<_Base>, _Nm> _M_current = array<iterator_t<_Base>, _Nm>();
5396 _Iterator(iterator_t<_Base> __first, sentinel_t<_Base> __last)
5398 for (auto& __i : _M_current)
5401 ranges::advance(__first, 1, __last);
5406 _Iterator(__as_sentinel, iterator_t<_Base> __first, iterator_t<_Base> __last)
5408 if constexpr (!bidirectional_range<_Base>)
5409 for (auto& __it : _M_current)
5412 for (size_t __i = 0; __i < _Nm; ++__i)
5414 _M_current[_Nm - 1 - __i] = __last;
5415 ranges::advance(__last, -1, __first);
5422 if constexpr (random_access_range<_Base>)
5423 return random_access_iterator_tag{};
5424 else if constexpr (bidirectional_range<_Base>)
5425 return bidirectional_iterator_tag{};
5427 return forward_iterator_tag{};
5430 friend class adjacent_view;
5432#ifndef __clang__ // LLVM-61763 workaround
5433 template<forward_range _Wp, move_constructible _Fp, size_t _Mm>
5434 requires view<_Wp> && (_Mm > 0) && is_object_v<_Fp>
5435 && regular_invocable<__detail::__unarize<_Fp&, _Mm>, range_reference_t<_Wp>>
5436 && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Mm>,
5437 range_reference_t<_Wp>>>
5438 friend class adjacent_transform_view;
5442 using iterator_category = input_iterator_tag;
5443 using iterator_concept = decltype(_S_iter_concept());
5444 using value_type = conditional_t<_Nm == 2,
5445 pair<range_value_t<_Base>, range_value_t<_Base>>,
5446 __detail::__repeated_tuple<range_value_t<_Base>, _Nm>>;
5447 using difference_type = range_difference_t<_Base>;
5449 _Iterator() = default;
5452 _Iterator(_Iterator<!_Const> __i)
5453 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
5455 for (size_t __j = 0; __j < _Nm; ++__j)
5456 _M_current[__j] = std::move(__i._M_current[__j]);
5462 auto __f = [](auto& __i) -> decltype(auto) { return *__i; };
5463 return __detail::__tuple_transform(__f, _M_current);
5466 constexpr _Iterator&
5469 for (auto& __i : _M_current)
5482 constexpr _Iterator&
5483 operator--() requires bidirectional_range<_Base>
5485 for (auto& __i : _M_current)
5491 operator--(int) requires bidirectional_range<_Base>
5498 constexpr _Iterator&
5499 operator+=(difference_type __x)
5500 requires random_access_range<_Base>
5502 for (auto& __i : _M_current)
5507 constexpr _Iterator&
5508 operator-=(difference_type __x)
5509 requires random_access_range<_Base>
5511 for (auto& __i : _M_current)
5517 operator[](difference_type __n) const
5518 requires random_access_range<_Base>
5520 auto __f = [&](auto& __i) -> decltype(auto) { return __i[__n]; };
5521 return __detail::__tuple_transform(__f, _M_current);
5524 friend constexpr bool
5525 operator==(const _Iterator& __x, const _Iterator& __y)
5526 { return __x._M_current.back() == __y._M_current.back(); }
5528 friend constexpr bool
5529 operator<(const _Iterator& __x, const _Iterator& __y)
5530 requires random_access_range<_Base>
5531 { return __x._M_current.back() < __y._M_current.back(); }
5533 friend constexpr bool
5534 operator>(const _Iterator& __x, const _Iterator& __y)
5535 requires random_access_range<_Base>
5536 { return __y < __x; }
5538 friend constexpr bool
5539 operator<=(const _Iterator& __x, const _Iterator& __y)
5540 requires random_access_range<_Base>
5541 { return !(__y < __x); }
5543 friend constexpr bool
5544 operator>=(const _Iterator& __x, const _Iterator& __y)
5545 requires random_access_range<_Base>
5546 { return !(__x < __y); }
5548 friend constexpr auto
5549 operator<=>(const _Iterator& __x, const _Iterator& __y)
5550 requires random_access_range<_Base>
5551 && three_way_comparable<iterator_t<_Base>>
5552 { return __x._M_current.back() <=> __y._M_current.back(); }
5554 friend constexpr _Iterator
5555 operator+(const _Iterator& __i, difference_type __n)
5556 requires random_access_range<_Base>
5563 friend constexpr _Iterator
5564 operator+(difference_type __n, const _Iterator& __i)
5565 requires random_access_range<_Base>
5572 friend constexpr _Iterator
5573 operator-(const _Iterator& __i, difference_type __n)
5574 requires random_access_range<_Base>
5581 friend constexpr difference_type
5582 operator-(const _Iterator& __x, const _Iterator& __y)
5583 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
5584 { return __x._M_current.back() - __y._M_current.back(); }
5586 friend constexpr auto
5587 iter_move(const _Iterator& __i)
5588 { return __detail::__tuple_transform(ranges::iter_move, __i._M_current); }
5590 friend constexpr void
5591 iter_swap(const _Iterator& __l, const _Iterator& __r)
5592 requires indirectly_swappable<iterator_t<_Base>>
5594 for (size_t __i = 0; __i < _Nm; __i++)
5595 ranges::iter_swap(__l._M_current[__i], __r._M_current[__i]);
5599 template<forward_range _Vp, size_t _Nm>
5600 requires view<_Vp> && (_Nm > 0)
5601 template<bool _Const>
5602 class adjacent_view<_Vp, _Nm>::_Sentinel
5604 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
5606 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
5609 _Sentinel(sentinel_t<_Base> __end)
5613 friend class adjacent_view;
5616 _Sentinel() = default;
5619 _Sentinel(_Sentinel<!_Const> __i)
5620 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
5621 : _M_end(std::move(__i._M_end))
5624 template<bool _OtherConst>
5625 requires sentinel_for<sentinel_t<_Base>,
5626 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
5627 friend constexpr bool
5628 operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
5629 { return __x._M_current.back() == __y._M_end; }
5631 template<bool _OtherConst>
5632 requires sized_sentinel_for<sentinel_t<_Base>,
5633 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
5634 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _Vp>>
5635 operator-(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
5636 { return __x._M_current.back() - __y._M_end; }
5638 template<bool _OtherConst>
5639 requires sized_sentinel_for<sentinel_t<_Base>,
5640 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
5641 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _Vp>>
5642 operator-(const _Sentinel& __y, const _Iterator<_OtherConst>& __x)
5643 { return __y._M_end - __x._M_current.back(); }
5650 template<size_t _Nm, typename _Range>
5651 concept __can_adjacent_view
5652 = requires { adjacent_view<all_t<_Range>, _Nm>(std::declval<_Range>()); };
5655 template<size_t _Nm>
5656 struct _Adjacent : __adaptor::_RangeAdaptorClosure<_Adjacent<_Nm>>
5658 template<viewable_range _Range>
5659 requires (_Nm == 0) || __detail::__can_adjacent_view<_Nm, _Range>
5661 operator() [[nodiscard]] (_Range&& __r) const
5663 if constexpr (_Nm == 0)
5664 return views::empty<tuple<>>;
5666 return adjacent_view<all_t<_Range>, _Nm>(std::forward<_Range>(__r));
5670 template<size_t _Nm>
5671 inline constexpr _Adjacent<_Nm> adjacent;
5673 inline constexpr auto pairwise = adjacent<2>;
5676 template<forward_range _Vp, move_constructible _Fp, size_t _Nm>
5677 requires view<_Vp> && (_Nm > 0) && is_object_v<_Fp>
5678 && regular_invocable<__detail::__unarize<_Fp&, _Nm>, range_reference_t<_Vp>>
5679 && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Nm>,
5680 range_reference_t<_Vp>>>
5681 class adjacent_transform_view : public view_interface<adjacent_transform_view<_Vp, _Fp, _Nm>>
5683 [[no_unique_address]] __detail::__box<_Fp> _M_fun;
5684 adjacent_view<_Vp, _Nm> _M_inner;
5686 using _InnerView = adjacent_view<_Vp, _Nm>;
5688 template<bool _Const>
5689 using _InnerIter = iterator_t<__detail::__maybe_const_t<_Const, _InnerView>>;
5691 template<bool _Const>
5692 using _InnerSent = sentinel_t<__detail::__maybe_const_t<_Const, _InnerView>>;
5694 template<bool> class _Iterator;
5695 template<bool> class _Sentinel;
5698 adjacent_transform_view() = default;
5701 adjacent_transform_view(_Vp __base, _Fp __fun)
5702 : _M_fun(std::move(__fun)), _M_inner(std::move(__base))
5707 { return _Iterator<false>(*this, _M_inner.begin()); }
5711 requires range<const _InnerView>
5712 && regular_invocable<__detail::__unarize<const _Fp&, _Nm>,
5713 range_reference_t<const _Vp>>
5714 { return _Iterator<true>(*this, _M_inner.begin()); }
5719 if constexpr (common_range<_InnerView>)
5720 return _Iterator<false>(*this, _M_inner.end());
5722 return _Sentinel<false>(_M_inner.end());
5727 requires range<const _InnerView>
5728 && regular_invocable<__detail::__unarize<const _Fp&, _Nm>,
5729 range_reference_t<const _Vp>>
5731 if constexpr (common_range<const _InnerView>)
5732 return _Iterator<true>(*this, _M_inner.end());
5734 return _Sentinel<true>(_M_inner.end());
5738 size() requires sized_range<_InnerView>
5739 { return _M_inner.size(); }
5742 size() const requires sized_range<const _InnerView>
5743 { return _M_inner.size(); }
5746 template<forward_range _Vp, move_constructible _Fp, size_t _Nm>
5747 requires view<_Vp> && (_Nm > 0) && is_object_v<_Fp>
5748 && regular_invocable<__detail::__unarize<_Fp&, _Nm>, range_reference_t<_Vp>>
5749 && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Nm>,
5750 range_reference_t<_Vp>>>
5751 template<bool _Const>
5752 class adjacent_transform_view<_Vp, _Fp, _Nm>::_Iterator
5754 using _Parent = __detail::__maybe_const_t<_Const, adjacent_transform_view>;
5755 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
5757 _Parent* _M_parent = nullptr;
5758 _InnerIter<_Const> _M_inner;
5761 _Iterator(_Parent& __parent, _InnerIter<_Const> __inner)
5762 : _M_parent(std::__addressof(__parent)), _M_inner(std::move(__inner))
5768 using __detail::__maybe_const_t;
5769 using __detail::__unarize;
5770 using _Res = invoke_result_t<__unarize<__maybe_const_t<_Const, _Fp>&, _Nm>,
5771 range_reference_t<_Base>>;
5772 using _Cat = typename iterator_traits<iterator_t<_Base>>::iterator_category;
5773 if constexpr (!is_lvalue_reference_v<_Res>)
5774 return input_iterator_tag{};
5775 else if constexpr (derived_from<_Cat, random_access_iterator_tag>)
5776 return random_access_iterator_tag{};
5777 else if constexpr (derived_from<_Cat, bidirectional_iterator_tag>)
5778 return bidirectional_iterator_tag{};
5779 else if constexpr (derived_from<_Cat, forward_iterator_tag>)
5780 return forward_iterator_tag{};
5782 return input_iterator_tag{};
5785 friend class adjacent_transform_view;
5788 using iterator_category = decltype(_S_iter_cat());
5789 using iterator_concept = typename _InnerIter<_Const>::iterator_concept;
5791 = remove_cvref_t<invoke_result_t
5792 <__detail::__unarize<__detail::__maybe_const_t<_Const, _Fp>&, _Nm>,
5793 range_reference_t<_Base>>>;
5794 using difference_type = range_difference_t<_Base>;
5796 _Iterator() = default;
5799 _Iterator(_Iterator<!_Const> __i)
5800 requires _Const && convertible_to<_InnerIter<false>, _InnerIter<_Const>>
5801 : _M_parent(__i._M_parent), _M_inner(std::move(__i._M_inner))
5804 constexpr decltype(auto)
5807 return std::apply([&](const auto&... __iters) -> decltype(auto) {
5808 return std::__invoke(*_M_parent->_M_fun, *__iters...);
5809 }, _M_inner._M_current);
5812 constexpr _Iterator&
5827 constexpr _Iterator&
5828 operator--() requires bidirectional_range<_Base>
5835 operator--(int) requires bidirectional_range<_Base>
5842 constexpr _Iterator&
5843 operator+=(difference_type __x) requires random_access_range<_Base>
5849 constexpr _Iterator&
5850 operator-=(difference_type __x) requires random_access_range<_Base>
5856 constexpr decltype(auto)
5857 operator[](difference_type __n) const requires random_access_range<_Base>
5859 return std::apply([&](const auto&... __iters) -> decltype(auto) {
5860 return std::__invoke(*_M_parent->_M_fun, __iters[__n]...);
5861 }, _M_inner._M_current);
5864 friend constexpr bool
5865 operator==(const _Iterator& __x, const _Iterator& __y)
5866 { return __x._M_inner == __y._M_inner; }
5868 friend constexpr bool
5869 operator<(const _Iterator& __x, const _Iterator& __y)
5870 requires random_access_range<_Base>
5871 { return __x._M_inner < __y._M_inner; }
5873 friend constexpr bool
5874 operator>(const _Iterator& __x, const _Iterator& __y)
5875 requires random_access_range<_Base>
5876 { return __x._M_inner > __y._M_inner; }
5878 friend constexpr bool
5879 operator<=(const _Iterator& __x, const _Iterator& __y)
5880 requires random_access_range<_Base>
5881 { return __x._M_inner <= __y._M_inner; }
5883 friend constexpr bool
5884 operator>=(const _Iterator& __x, const _Iterator& __y)
5885 requires random_access_range<_Base>
5886 { return __x._M_inner >= __y._M_inner; }
5888 friend constexpr auto
5889 operator<=>(const _Iterator& __x, const _Iterator& __y)
5890 requires random_access_range<_Base> &&
5891 three_way_comparable<_InnerIter<_Const>>
5892 { return __x._M_inner <=> __y._M_inner; }
5894 friend constexpr _Iterator
5895 operator+(const _Iterator& __i, difference_type __n)
5896 requires random_access_range<_Base>
5897 { return _Iterator(*__i._M_parent, __i._M_inner + __n); }
5899 friend constexpr _Iterator
5900 operator+(difference_type __n, const _Iterator& __i)
5901 requires random_access_range<_Base>
5902 { return _Iterator(*__i._M_parent, __i._M_inner + __n); }
5904 friend constexpr _Iterator
5905 operator-(const _Iterator& __i, difference_type __n)
5906 requires random_access_range<_Base>
5907 { return _Iterator(*__i._M_parent, __i._M_inner - __n); }
5909 friend constexpr difference_type
5910 operator-(const _Iterator& __x, const _Iterator& __y)
5911 requires sized_sentinel_for<_InnerIter<_Const>, _InnerIter<_Const>>
5912 { return __x._M_inner - __y._M_inner; }
5915 template<forward_range _Vp, move_constructible _Fp, size_t _Nm>
5916 requires view<_Vp> && (_Nm > 0) && is_object_v<_Fp>
5917 && regular_invocable<__detail::__unarize<_Fp&, _Nm>, range_reference_t<_Vp>>
5918 && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Nm>,
5919 range_reference_t<_Vp>>>
5920 template<bool _Const>
5921 class adjacent_transform_view<_Vp, _Fp, _Nm>::_Sentinel
5923 _InnerSent<_Const> _M_inner;
5926 _Sentinel(_InnerSent<_Const> __inner)
5930 friend class adjacent_transform_view;
5933 _Sentinel() = default;
5936 _Sentinel(_Sentinel<!_Const> __i)
5937 requires _Const && convertible_to<_InnerSent<false>, _InnerSent<_Const>>
5938 : _M_inner(std::move(__i._M_inner))
5941 template<bool _OtherConst>
5942 requires sentinel_for<_InnerSent<_Const>, _InnerIter<_OtherConst>>
5943 friend constexpr bool
5944 operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
5945 { return __x._M_inner == __y._M_inner; }
5947 template<bool _OtherConst>
5948 requires sized_sentinel_for<_InnerSent<_Const>, _InnerIter<_OtherConst>>
5949 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
5950 operator-(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
5951 { return __x._M_inner - __y._M_inner; }
5953 template<bool _OtherConst>
5954 requires sized_sentinel_for<_InnerSent<_Const>, _InnerIter<_OtherConst>>
5955 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
5956 operator-(const _Sentinel& __x, const _Iterator<_OtherConst>& __y)
5957 { return __x._M_inner - __y._M_inner; }
5964 template<size_t _Nm, typename _Range, typename _Fp>
5965 concept __can_adjacent_transform_view
5966 = requires { adjacent_transform_view<all_t<_Range>, decay_t<_Fp>, _Nm>
5967 (std::declval<_Range>(), std::declval<_Fp>()); };
5970 template<size_t _Nm>
5971 struct _AdjacentTransform : __adaptor::_RangeAdaptor<_AdjacentTransform<_Nm>>
5973 template<viewable_range _Range, typename _Fp>
5974 requires (_Nm == 0) || __detail::__can_adjacent_transform_view<_Nm, _Range, _Fp>
5976 operator() [[nodiscard]] (_Range&& __r, _Fp&& __f) const
5978 if constexpr (_Nm == 0)
5979 return zip_transform(std::forward<_Fp>(__f));
5981 return adjacent_transform_view<all_t<_Range>, decay_t<_Fp>, _Nm>
5982 (std::forward<_Range>(__r), std::forward<_Fp>(__f));
5985 using __adaptor::_RangeAdaptor<_AdjacentTransform>::operator();
5986 static constexpr int _S_arity = 2;
5987 static constexpr bool _S_has_simple_extra_args = true;
5990 template<size_t _Nm>
5991 inline constexpr _AdjacentTransform<_Nm> adjacent_transform;
5993 inline constexpr auto pairwise_transform = adjacent_transform<2>;
5995#endif // __cpp_lib_ranges_zip
5997#ifdef __cpp_lib_ranges_chunk // C++ >= 23
6000 template<typename _Tp>
6001 constexpr _Tp __div_ceil(_Tp __num, _Tp __denom)
6003 _Tp __r = __num / __denom;
6004 if (__num % __denom)
6011 requires input_range<_Vp>
6012 class chunk_view : public view_interface<chunk_view<_Vp>>
6015 range_difference_t<_Vp> _M_n;
6016 range_difference_t<_Vp> _M_remainder = 0;
6017 __detail::__non_propagating_cache<iterator_t<_Vp>> _M_current;
6024 chunk_view(_Vp __base, range_difference_t<_Vp> __n)
6025 : _M_base(std::move(__base)), _M_n(__n)
6026 { __glibcxx_assert(__n >= 0); }
6029 base() const & requires copy_constructible<_Vp>
6034 { return std::move(_M_base); }
6036 constexpr _OuterIter
6039 _M_current = ranges::begin(_M_base);
6040 _M_remainder = _M_n;
6041 return _OuterIter(*this);
6044 constexpr default_sentinel_t
6045 end() const noexcept
6046 { return default_sentinel; }
6049 size() requires sized_range<_Vp>
6051 return __detail::__to_unsigned_like(__detail::__div_ceil
6052 (ranges::distance(_M_base), _M_n));
6056 size() const requires sized_range<const _Vp>
6058 return __detail::__to_unsigned_like(__detail::__div_ceil
6059 (ranges::distance(_M_base), _M_n));
6063 template<typename _Range>
6064 chunk_view(_Range&&, range_difference_t<_Range>) -> chunk_view<views::all_t<_Range>>;
6067 requires input_range<_Vp>
6068 class chunk_view<_Vp>::_OuterIter
6070 chunk_view* _M_parent;
6073 _OuterIter(chunk_view& __parent) noexcept
6074 : _M_parent(std::__addressof(__parent))
6080 using iterator_concept = input_iterator_tag;
6081 using difference_type = range_difference_t<_Vp>;
6085 _OuterIter(_OuterIter&&) = default;
6086 _OuterIter& operator=(_OuterIter&&) = default;
6088 constexpr value_type
6091 __glibcxx_assert(*this != default_sentinel);
6092 return value_type(*_M_parent);
6095 constexpr _OuterIter&
6098 __glibcxx_assert(*this != default_sentinel);
6099 ranges::advance(*_M_parent->_M_current, _M_parent->_M_remainder,
6100 ranges::end(_M_parent->_M_base));
6101 _M_parent->_M_remainder = _M_parent->_M_n;
6109 friend constexpr bool
6110 operator==(const _OuterIter& __x, default_sentinel_t)
6112 return *__x._M_parent->_M_current == ranges::end(__x._M_parent->_M_base)
6113 && __x._M_parent->_M_remainder != 0;
6116 friend constexpr difference_type
6117 operator-(default_sentinel_t, const _OuterIter& __x)
6118 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6120 const auto __dist = ranges::end(__x._M_parent->_M_base) - *__x._M_parent->_M_current;
6122 if (__dist < __x._M_parent->_M_remainder)
6123 return __dist == 0 ? 0 : 1;
6125 return 1 + __detail::__div_ceil(__dist - __x._M_parent->_M_remainder,
6126 __x._M_parent->_M_n);
6129 friend constexpr difference_type
6130 operator-(const _OuterIter& __x, default_sentinel_t __y)
6131 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6132 { return -(__y - __x); }
6136 requires input_range<_Vp>
6137 struct chunk_view<_Vp>::_OuterIter::value_type : view_interface<value_type>
6140 chunk_view* _M_parent;
6143 value_type(chunk_view& __parent) noexcept
6144 : _M_parent(std::__addressof(__parent))
6150 constexpr _InnerIter
6151 begin() const noexcept
6152 { return _InnerIter(*_M_parent); }
6154 constexpr default_sentinel_t
6155 end() const noexcept
6156 { return default_sentinel; }
6160 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6162 return __detail::__to_unsigned_like
6163 (ranges::min(_M_parent->_M_remainder,
6164 ranges::end(_M_parent->_M_base) - *_M_parent->_M_current));
6169 requires input_range<_Vp>
6170 class chunk_view<_Vp>::_InnerIter
6172 chunk_view* _M_parent;
6175 _InnerIter(chunk_view& __parent) noexcept
6176 : _M_parent(std::__addressof(__parent))
6179 friend _OuterIter::value_type;
6182 using iterator_concept = input_iterator_tag;
6183 using difference_type = range_difference_t<_Vp>;
6184 using value_type = range_value_t<_Vp>;
6186 _InnerIter(_InnerIter&&) = default;
6187 _InnerIter& operator=(_InnerIter&&) = default;
6189 constexpr const iterator_t<_Vp>&
6191 { return *_M_parent->_M_current; }
6193 constexpr range_reference_t<_Vp>
6196 __glibcxx_assert(*this != default_sentinel);
6197 return **_M_parent->_M_current;
6200 constexpr _InnerIter&
6203 __glibcxx_assert(*this != default_sentinel);
6204 ++*_M_parent->_M_current;
6205 if (*_M_parent->_M_current == ranges::end(_M_parent->_M_base))
6206 _M_parent->_M_remainder = 0;
6208 --_M_parent->_M_remainder;
6216 friend constexpr bool
6217 operator==(const _InnerIter& __x, default_sentinel_t) noexcept
6218 { return __x._M_parent->_M_remainder == 0; }
6220 friend constexpr difference_type
6221 operator-(default_sentinel_t, const _InnerIter& __x)
6222 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6224 return ranges::min(__x._M_parent->_M_remainder,
6225 ranges::end(__x._M_parent->_M_base) - *__x._M_parent->_M_current);
6228 friend constexpr difference_type
6229 operator-(const _InnerIter& __x, default_sentinel_t __y)
6230 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6231 { return -(__y - __x); }
6235 requires forward_range<_Vp>
6236 class chunk_view<_Vp> : public view_interface<chunk_view<_Vp>>
6239 range_difference_t<_Vp> _M_n;
6240 template<bool> class _Iterator;
6244 chunk_view(_Vp __base, range_difference_t<_Vp> __n)
6245 : _M_base(std::move(__base)), _M_n(__n)
6246 { __glibcxx_assert(__n > 0); }
6249 base() const & requires copy_constructible<_Vp>
6254 { return std::move(_M_base); }
6257 begin() requires (!__detail::__simple_view<_Vp>)
6258 { return _Iterator<false>(this, ranges::begin(_M_base)); }
6261 begin() const requires forward_range<const _Vp>
6262 { return _Iterator<true>(this, ranges::begin(_M_base)); }
6265 end() requires (!__detail::__simple_view<_Vp>)
6267 if constexpr (common_range<_Vp> && sized_range<_Vp>)
6269 auto __missing = (_M_n - ranges::distance(_M_base) % _M_n) % _M_n;
6270 return _Iterator<false>(this, ranges::end(_M_base), __missing);
6272 else if constexpr (common_range<_Vp> && !bidirectional_range<_Vp>)
6273 return _Iterator<false>(this, ranges::end(_M_base));
6275 return default_sentinel;
6279 end() const requires forward_range<const _Vp>
6281 if constexpr (common_range<const _Vp> && sized_range<const _Vp>)
6283 auto __missing = (_M_n - ranges::distance(_M_base) % _M_n) % _M_n;
6284 return _Iterator<true>(this, ranges::end(_M_base), __missing);
6286 else if constexpr (common_range<const _Vp> && !bidirectional_range<const _Vp>)
6287 return _Iterator<true>(this, ranges::end(_M_base));
6289 return default_sentinel;
6293 size() requires sized_range<_Vp>
6295 return __detail::__to_unsigned_like(__detail::__div_ceil
6296 (ranges::distance(_M_base), _M_n));
6300 size() const requires sized_range<const _Vp>
6302 return __detail::__to_unsigned_like(__detail::__div_ceil
6303 (ranges::distance(_M_base), _M_n));
6307 template<typename _Vp>
6308 inline constexpr bool enable_borrowed_range<chunk_view<_Vp>>
6309 = forward_range<_Vp> && enable_borrowed_range<_Vp>;
6312 requires forward_range<_Vp>
6313 template<bool _Const>
6314 class chunk_view<_Vp>::_Iterator
6316 using _Parent = __detail::__maybe_const_t<_Const, chunk_view>;
6317 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
6319 iterator_t<_Base> _M_current = iterator_t<_Base>();
6320 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
6321 range_difference_t<_Base> _M_n = 0;
6322 range_difference_t<_Base> _M_missing = 0;
6325 _Iterator(_Parent* __parent, iterator_t<_Base> __current,
6326 range_difference_t<_Base> __missing = 0)
6327 : _M_current(__current), _M_end(ranges::end(__parent->_M_base)),
6328 _M_n(__parent->_M_n), _M_missing(__missing)
6334 if constexpr (random_access_range<_Base>)
6335 return random_access_iterator_tag{};
6336 else if constexpr (bidirectional_range<_Base>)
6337 return bidirectional_iterator_tag{};
6339 return forward_iterator_tag{};
6345 using iterator_category = input_iterator_tag;
6346 using iterator_concept = decltype(_S_iter_cat());
6347 using value_type = decltype(views::take(subrange(_M_current, _M_end), _M_n));
6348 using difference_type = range_difference_t<_Base>;
6350 _Iterator() = default;
6352 constexpr _Iterator(_Iterator<!_Const> __i)
6354 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
6355 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
6356 : _M_current(std::move(__i._M_current)), _M_end(std::move(__i._M_end)),
6357 _M_n(__i._M_n), _M_missing(__i._M_missing)
6360 constexpr iterator_t<_Base>
6362 { return _M_current; }
6364 constexpr value_type
6367 __glibcxx_assert(_M_current != _M_end);
6368 return views::take(subrange(_M_current, _M_end), _M_n);
6371 constexpr _Iterator&
6374 __glibcxx_assert(_M_current != _M_end);
6375 _M_missing = ranges::advance(_M_current, _M_n, _M_end);
6387 constexpr _Iterator&
6388 operator--() requires bidirectional_range<_Base>
6390 ranges::advance(_M_current, _M_missing - _M_n);
6396 operator--(int) requires bidirectional_range<_Base>
6403 constexpr _Iterator&
6404 operator+=(difference_type __x)
6405 requires random_access_range<_Base>
6409 __glibcxx_assert(ranges::distance(_M_current, _M_end) > _M_n * (__x - 1));
6410 _M_missing = ranges::advance(_M_current, _M_n * __x, _M_end);
6414 ranges::advance(_M_current, _M_n * __x + _M_missing);
6420 constexpr _Iterator&
6421 operator-=(difference_type __x)
6422 requires random_access_range<_Base>
6423 { return *this += -__x; }
6425 constexpr value_type
6426 operator[](difference_type __n) const
6427 requires random_access_range<_Base>
6428 { return *(*this + __n); }
6430 friend constexpr bool
6431 operator==(const _Iterator& __x, const _Iterator& __y)
6432 { return __x._M_current == __y._M_current; }
6434 friend constexpr bool
6435 operator==(const _Iterator& __x, default_sentinel_t)
6436 { return __x._M_current == __x._M_end; }
6438 friend constexpr bool
6439 operator<(const _Iterator& __x, const _Iterator& __y)
6440 requires random_access_range<_Base>
6441 { return __x._M_current > __y._M_current; }
6443 friend constexpr bool
6444 operator>(const _Iterator& __x, const _Iterator& __y)
6445 requires random_access_range<_Base>
6446 { return __y < __x; }
6448 friend constexpr bool
6449 operator<=(const _Iterator& __x, const _Iterator& __y)
6450 requires random_access_range<_Base>
6451 { return !(__y < __x); }
6453 friend constexpr bool
6454 operator>=(const _Iterator& __x, const _Iterator& __y)
6455 requires random_access_range<_Base>
6456 { return !(__x < __y); }
6458 friend constexpr auto
6459 operator<=>(const _Iterator& __x, const _Iterator& __y)
6460 requires random_access_range<_Base>
6461 && three_way_comparable<iterator_t<_Base>>
6462 { return __x._M_current <=> __y._M_current; }
6464 friend constexpr _Iterator
6465 operator+(const _Iterator& __i, difference_type __n)
6466 requires random_access_range<_Base>
6473 friend constexpr _Iterator
6474 operator+(difference_type __n, const _Iterator& __i)
6475 requires random_access_range<_Base>
6482 friend constexpr _Iterator
6483 operator-(const _Iterator& __i, difference_type __n)
6484 requires random_access_range<_Base>
6491 friend constexpr difference_type
6492 operator-(const _Iterator& __x, const _Iterator& __y)
6493 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
6495 return (__x._M_current - __y._M_current
6496 + __x._M_missing - __y._M_missing) / __x._M_n;
6499 friend constexpr difference_type
6500 operator-(default_sentinel_t __y, const _Iterator& __x)
6501 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
6502 { return __detail::__div_ceil(__x._M_end - __x._M_current, __x._M_n); }
6504 friend constexpr difference_type
6505 operator-(const _Iterator& __x, default_sentinel_t __y)
6506 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
6507 { return -(__y - __x); }
6514 template<typename _Range, typename _Dp>
6515 concept __can_chunk_view
6516 = requires { chunk_view(std::declval<_Range>(), std::declval<_Dp>()); };
6519 struct _Chunk : __adaptor::_RangeAdaptor<_Chunk>
6521 template<viewable_range _Range, typename _Dp = range_difference_t<_Range>>
6522 requires __detail::__can_chunk_view<_Range, _Dp>
6524 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n) const
6525 { return chunk_view(std::forward<_Range>(__r), __n); }
6527 using __adaptor::_RangeAdaptor<_Chunk>::operator();
6528 static constexpr int _S_arity = 2;
6529 static constexpr bool _S_has_simple_extra_args = true;
6532 inline constexpr _Chunk chunk;
6534#endif // __cpp_lib_ranges_chunk
6536#ifdef __cpp_lib_ranges_slide // C++ >= 23
6539 template<typename _Vp>
6540 concept __slide_caches_nothing = random_access_range<_Vp> && sized_range<_Vp>;
6542 template<typename _Vp>
6543 concept __slide_caches_last
6544 = !__slide_caches_nothing<_Vp> && bidirectional_range<_Vp> && common_range<_Vp>;
6546 template<typename _Vp>
6547 concept __slide_caches_first
6548 = !__slide_caches_nothing<_Vp> && !__slide_caches_last<_Vp>;
6551 template<forward_range _Vp>
6553 class slide_view : public view_interface<slide_view<_Vp>>
6556 range_difference_t<_Vp> _M_n;
6557 [[no_unique_address]]
6558 __detail::__maybe_present_t<__detail::__slide_caches_first<_Vp>,
6559 __detail::_CachedPosition<_Vp>, 0> _M_cached_begin;
6560 [[no_unique_address]]
6561 __detail::__maybe_present_t<__detail::__slide_caches_last<_Vp>,
6562 __detail::_CachedPosition<_Vp>, 1> _M_cached_end;
6564 template<bool> class _Iterator;
6569 slide_view(_Vp __base, range_difference_t<_Vp> __n)
6570 : _M_base(std::move(__base)), _M_n(__n)
6571 { __glibcxx_assert(__n > 0); }
6574 begin() requires (!(__detail::__simple_view<_Vp>
6575 && __detail::__slide_caches_nothing<const _Vp>))
6577 if constexpr (__detail::__slide_caches_first<_Vp>)
6579 iterator_t<_Vp> __it;
6580 if (_M_cached_begin._M_has_value())
6581 __it = _M_cached_begin._M_get(_M_base);
6584 __it = ranges::next(ranges::begin(_M_base), _M_n - 1, ranges::end(_M_base));
6585 _M_cached_begin._M_set(_M_base, __it);
6587 return _Iterator<false>(ranges::begin(_M_base), std::move(__it), _M_n);
6590 return _Iterator<false>(ranges::begin(_M_base), _M_n);
6594 begin() const requires __detail::__slide_caches_nothing<const _Vp>
6595 { return _Iterator<true>(ranges::begin(_M_base), _M_n); }
6598 end() requires (!(__detail::__simple_view<_Vp>
6599 && __detail::__slide_caches_nothing<const _Vp>))
6601 if constexpr (__detail::__slide_caches_nothing<_Vp>)
6602 return _Iterator<false>(ranges::begin(_M_base) + range_difference_t<_Vp>(size()),
6604 else if constexpr (__detail::__slide_caches_last<_Vp>)
6606 iterator_t<_Vp> __it;
6607 if (_M_cached_end._M_has_value())
6608 __it = _M_cached_end._M_get(_M_base);
6611 __it = ranges::prev(ranges::end(_M_base), _M_n - 1, ranges::begin(_M_base));
6612 _M_cached_end._M_set(_M_base, __it);
6614 return _Iterator<false>(std::move(__it), _M_n);
6616 else if constexpr (common_range<_Vp>)
6617 return _Iterator<false>(ranges::end(_M_base), ranges::end(_M_base), _M_n);
6619 return _Sentinel(ranges::end(_M_base));
6623 end() const requires __detail::__slide_caches_nothing<const _Vp>
6624 { return begin() + range_difference_t<const _Vp>(size()); }
6627 size() requires sized_range<_Vp>
6629 auto __sz = ranges::distance(_M_base) - _M_n + 1;
6632 return __detail::__to_unsigned_like(__sz);
6636 size() const requires sized_range<const _Vp>
6638 auto __sz = ranges::distance(_M_base) - _M_n + 1;
6641 return __detail::__to_unsigned_like(__sz);
6645 template<typename _Range>
6646 slide_view(_Range&&, range_difference_t<_Range>) -> slide_view<views::all_t<_Range>>;
6648 template<typename _Vp>
6649 inline constexpr bool enable_borrowed_range<slide_view<_Vp>>
6650 = enable_borrowed_range<_Vp>;
6652 template<forward_range _Vp>
6654 template<bool _Const>
6655 class slide_view<_Vp>::_Iterator
6657 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
6658 static constexpr bool _S_last_elt_present
6659 = __detail::__slide_caches_first<_Base>;
6661 iterator_t<_Base> _M_current = iterator_t<_Base>();
6662 [[no_unique_address]]
6663 __detail::__maybe_present_t<_S_last_elt_present, iterator_t<_Base>>
6664 _M_last_elt = decltype(_M_last_elt)();
6665 range_difference_t<_Base> _M_n = 0;
6668 _Iterator(iterator_t<_Base> __current, range_difference_t<_Base> __n)
6669 requires (!_S_last_elt_present)
6670 : _M_current(__current), _M_n(__n)
6674 _Iterator(iterator_t<_Base> __current, iterator_t<_Base> __last_elt,
6675 range_difference_t<_Base> __n)
6676 requires _S_last_elt_present
6677 : _M_current(__current), _M_last_elt(__last_elt), _M_n(__n)
6683 if constexpr (random_access_range<_Base>)
6684 return random_access_iterator_tag{};
6685 else if constexpr (bidirectional_range<_Base>)
6686 return bidirectional_iterator_tag{};
6688 return forward_iterator_tag{};
6692 friend slide_view::_Sentinel;
6695 using iterator_category = input_iterator_tag;
6696 using iterator_concept = decltype(_S_iter_concept());
6697 using value_type = decltype(views::counted(_M_current, _M_n));
6698 using difference_type = range_difference_t<_Base>;
6700 _Iterator() = default;
6703 _Iterator(_Iterator<!_Const> __i)
6704 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
6705 : _M_current(std::move(__i._M_current)), _M_n(__i._M_n)
6710 { return views::counted(_M_current, _M_n); }
6712 constexpr _Iterator&
6716 if constexpr (_S_last_elt_present)
6729 constexpr _Iterator&
6730 operator--() requires bidirectional_range<_Base>
6733 if constexpr (_S_last_elt_present)
6739 operator--(int) requires bidirectional_range<_Base>
6746 constexpr _Iterator&
6747 operator+=(difference_type __x)
6748 requires random_access_range<_Base>
6751 if constexpr (_S_last_elt_present)
6756 constexpr _Iterator&
6757 operator-=(difference_type __x)
6758 requires random_access_range<_Base>
6761 if constexpr (_S_last_elt_present)
6767 operator[](difference_type __n) const
6768 requires random_access_range<_Base>
6769 { return views::counted(_M_current + __n, _M_n); }
6771 friend constexpr bool
6772 operator==(const _Iterator& __x, const _Iterator& __y)
6774 if constexpr (_S_last_elt_present)
6775 return __x._M_last_elt == __y._M_last_elt;
6777 return __x._M_current == __y._M_current;
6780 friend constexpr bool
6781 operator<(const _Iterator& __x, const _Iterator& __y)
6782 requires random_access_range<_Base>
6783 { return __x._M_current < __y._M_current; }
6785 friend constexpr bool
6786 operator>(const _Iterator& __x, const _Iterator& __y)
6787 requires random_access_range<_Base>
6788 { return __y < __x; }
6790 friend constexpr bool
6791 operator<=(const _Iterator& __x, const _Iterator& __y)
6792 requires random_access_range<_Base>
6793 { return !(__y < __x); }
6795 friend constexpr bool
6796 operator>=(const _Iterator& __x, const _Iterator& __y)
6797 requires random_access_range<_Base>
6798 { return !(__x < __y); }
6800 friend constexpr auto
6801 operator<=>(const _Iterator& __x, const _Iterator& __y)
6802 requires random_access_range<_Base>
6803 && three_way_comparable<iterator_t<_Base>>
6804 { return __x._M_current <=> __y._M_current; }
6806 friend constexpr _Iterator
6807 operator+(const _Iterator& __i, difference_type __n)
6808 requires random_access_range<_Base>
6815 friend constexpr _Iterator
6816 operator+(difference_type __n, const _Iterator& __i)
6817 requires random_access_range<_Base>
6824 friend constexpr _Iterator
6825 operator-(const _Iterator& __i, difference_type __n)
6826 requires random_access_range<_Base>
6833 friend constexpr difference_type
6834 operator-(const _Iterator& __x, const _Iterator& __y)
6835 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
6837 if constexpr (_S_last_elt_present)
6838 return __x._M_last_elt - __y._M_last_elt;
6840 return __x._M_current - __y._M_current;
6844 template<forward_range _Vp>
6846 class slide_view<_Vp>::_Sentinel
6848 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
6851 _Sentinel(sentinel_t<_Vp> __end)
6858 _Sentinel() = default;
6860 friend constexpr bool
6861 operator==(const _Iterator<false>& __x, const _Sentinel& __y)
6862 { return __x._M_last_elt == __y._M_end; }
6864 friend constexpr range_difference_t<_Vp>
6865 operator-(const _Iterator<false>& __x, const _Sentinel& __y)
6866 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6867 { return __x._M_last_elt - __y._M_end; }
6869 friend constexpr range_difference_t<_Vp>
6870 operator-(const _Sentinel& __y, const _Iterator<false>& __x)
6871 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6872 { return __y._M_end -__x._M_last_elt; }
6879 template<typename _Range, typename _Dp>
6880 concept __can_slide_view
6881 = requires { slide_view(std::declval<_Range>(), std::declval<_Dp>()); };
6884 struct _Slide : __adaptor::_RangeAdaptor<_Slide>
6886 template<viewable_range _Range, typename _Dp = range_difference_t<_Range>>
6887 requires __detail::__can_slide_view<_Range, _Dp>
6889 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n) const
6890 { return slide_view(std::forward<_Range>(__r), __n); }
6892 using __adaptor::_RangeAdaptor<_Slide>::operator();
6893 static constexpr int _S_arity = 2;
6894 static constexpr bool _S_has_simple_extra_args = true;
6897 inline constexpr _Slide slide;
6899#endif // __cpp_lib_ranges_slide
6901#ifdef __cpp_lib_ranges_chunk_by // C++ >= 23
6902 template<forward_range _Vp,
6903 indirect_binary_predicate<iterator_t<_Vp>, iterator_t<_Vp>> _Pred>
6904 requires view<_Vp> && is_object_v<_Pred>
6905 class chunk_by_view : public view_interface<chunk_by_view<_Vp, _Pred>>
6907 _Vp _M_base = _Vp();
6908 __detail::__box<_Pred> _M_pred;
6909 __detail::_CachedPosition<_Vp> _M_cached_begin;
6911 constexpr iterator_t<_Vp>
6912 _M_find_next(iterator_t<_Vp> __current)
6914 __glibcxx_assert(_M_pred.has_value());
6915 auto __pred = [this]<typename _Tp, typename _Up>(_Tp&& __x, _Up&& __y) {
6916 return !bool((*_M_pred)(std::forward<_Tp>(__x), std::forward<_Up>(__y)));
6918 auto __it = ranges::adjacent_find(__current, ranges::end(_M_base), __pred);
6919 return ranges::next(__it, 1, ranges::end(_M_base));
6922 constexpr iterator_t<_Vp>
6923 _M_find_prev(iterator_t<_Vp> __current) requires bidirectional_range<_Vp>
6925 __glibcxx_assert(_M_pred.has_value());
6926 auto __pred = [this]<typename _Tp, typename _Up>(_Tp&& __x, _Up&& __y) {
6927 return !bool((*_M_pred)(std::forward<_Up>(__y), std::forward<_Tp>(__x)));
6929 auto __rbegin = std::make_reverse_iterator(__current);
6930 auto __rend = std::make_reverse_iterator(ranges::begin(_M_base));
6931 __glibcxx_assert(__rbegin != __rend);
6932 auto __it = ranges::adjacent_find(__rbegin, __rend, __pred).base();
6933 return ranges::prev(__it, 1, ranges::begin(_M_base));
6939 chunk_by_view() requires (default_initializable<_Vp>
6940 && default_initializable<_Pred>)
6944 chunk_by_view(_Vp __base, _Pred __pred)
6945 : _M_base(std::move(__base)), _M_pred(std::move(__pred))
6949 base() const & requires copy_constructible<_Vp>
6954 { return std::move(_M_base); }
6956 constexpr const _Pred&
6958 { return *_M_pred; }
6963 __glibcxx_assert(_M_pred.has_value());
6964 iterator_t<_Vp> __it;
6965 if (_M_cached_begin._M_has_value())
6966 __it = _M_cached_begin._M_get(_M_base);
6969 __it = _M_find_next(ranges::begin(_M_base));
6970 _M_cached_begin._M_set(_M_base, __it);
6972 return _Iterator(*this, ranges::begin(_M_base), __it);
6978 if constexpr (common_range<_Vp>)
6979 return _Iterator(*this, ranges::end(_M_base), ranges::end(_M_base));
6981 return default_sentinel;
6985 template<typename _Range, typename _Pred>
6986 chunk_by_view(_Range&&, _Pred) -> chunk_by_view<views::all_t<_Range>, _Pred>;
6988 template<forward_range _Vp,
6989 indirect_binary_predicate<iterator_t<_Vp>, iterator_t<_Vp>> _Pred>
6990 requires view<_Vp> && is_object_v<_Pred>
6991 class chunk_by_view<_Vp, _Pred>::_Iterator
6993 chunk_by_view* _M_parent = nullptr;
6994 iterator_t<_Vp> _M_current = iterator_t<_Vp>();
6995 iterator_t<_Vp> _M_next = iterator_t<_Vp>();
6998 _Iterator(chunk_by_view& __parent, iterator_t<_Vp> __current, iterator_t<_Vp> __next)
6999 : _M_parent(std::__addressof(__parent)), _M_current(__current), _M_next(__next)
7005 if constexpr (bidirectional_range<_Vp>)
7006 return bidirectional_iterator_tag{};
7008 return forward_iterator_tag{};
7011 friend chunk_by_view;
7014 using value_type = subrange<iterator_t<_Vp>>;
7015 using difference_type = range_difference_t<_Vp>;
7016 using iterator_category = input_iterator_tag;
7017 using iterator_concept = decltype(_S_iter_concept());
7019 _Iterator() = default;
7021 constexpr value_type
7024 __glibcxx_assert(_M_current != _M_next);
7025 return ranges::subrange(_M_current, _M_next);
7028 constexpr _Iterator&
7031 __glibcxx_assert(_M_current != _M_next);
7032 _M_current = _M_next;
7033 _M_next = _M_parent->_M_find_next(_M_current);
7045 constexpr _Iterator&
7046 operator--() requires bidirectional_range<_Vp>
7048 _M_next = _M_current;
7049 _M_current = _M_parent->_M_find_prev(_M_next);
7054 operator--(int) requires bidirectional_range<_Vp>
7061 friend constexpr bool
7062 operator==(const _Iterator& __x, const _Iterator& __y)
7063 { return __x._M_current == __y._M_current; }
7065 friend constexpr bool
7066 operator==(const _Iterator& __x, default_sentinel_t)
7067 { return __x._M_current == __x._M_next; }
7074 template<typename _Range, typename _Pred>
7075 concept __can_chunk_by_view
7076 = requires { chunk_by_view(std::declval<_Range>(), std::declval<_Pred>()); };
7079 struct _ChunkBy : __adaptor::_RangeAdaptor<_ChunkBy>
7081 template<viewable_range _Range, typename _Pred>
7082 requires __detail::__can_chunk_by_view<_Range, _Pred>
7084 operator() [[nodiscard]] (_Range&& __r, _Pred&& __pred) const
7085 { return chunk_by_view(std::forward<_Range>(__r), std::forward<_Pred>(__pred)); }
7087 using __adaptor::_RangeAdaptor<_ChunkBy>::operator();
7088 static constexpr int _S_arity = 2;
7089 static constexpr bool _S_has_simple_extra_args = true;
7092 inline constexpr _ChunkBy chunk_by;
7094#endif // __cpp_lib_ranges_chunk_by
7096#ifdef __cpp_lib_ranges_join_with // C++ >= 23
7099 template<typename _Range, typename _Pattern>
7100 concept __compatible_joinable_ranges
7101 = common_with<range_value_t<_Range>, range_value_t<_Pattern>>
7102 && common_reference_with<range_reference_t<_Range>,
7103 range_reference_t<_Pattern>>
7104 && common_reference_with<range_rvalue_reference_t<_Range>,
7105 range_rvalue_reference_t<_Pattern>>;
7107 template<typename _Range>
7108 concept __bidirectional_common = bidirectional_range<_Range> && common_range<_Range>;
7111 template<input_range _Vp, forward_range _Pattern>
7112 requires view<_Vp> && view<_Pattern>
7113 && input_range<range_reference_t<_Vp>>
7114 && __detail::__compatible_joinable_ranges<range_reference_t<_Vp>, _Pattern>
7115 class join_with_view : public view_interface<join_with_view<_Vp, _Pattern>>
7117 using _InnerRange = range_reference_t<_Vp>;
7119 _Vp _M_base = _Vp();
7120 [[no_unique_address]]
7121 __detail::__maybe_present_t<!forward_range<_Vp>,
7122 __detail::__non_propagating_cache<iterator_t<_Vp>>> _M_outer_it;
7123 __detail::__non_propagating_cache<remove_cv_t<_InnerRange>> _M_inner;
7124 _Pattern _M_pattern = _Pattern();
7126 template<bool _Const> using _Base = __detail::__maybe_const_t<_Const, _Vp>;
7127 template<bool _Const> using _InnerBase = range_reference_t<_Base<_Const>>;
7128 template<bool _Const> using _PatternBase = __detail::__maybe_const_t<_Const, _Pattern>;
7130 template<bool _Const> using _OuterIter = iterator_t<_Base<_Const>>;
7131 template<bool _Const> using _InnerIter = iterator_t<_InnerBase<_Const>>;
7132 template<bool _Const> using _PatternIter = iterator_t<_PatternBase<_Const>>;
7134 template<bool _Const>
7135 static constexpr bool _S_ref_is_glvalue = is_reference_v<_InnerBase<_Const>>;
7137 template<bool _Const>
7141 template<bool _Const>
7142 requires _S_ref_is_glvalue<_Const>
7143 && forward_range<_Base<_Const>>
7144 && forward_range<_InnerBase<_Const>>
7145 struct __iter_cat<_Const>
7151 using _OuterIter = join_with_view::_OuterIter<_Const>;
7152 using _InnerIter = join_with_view::_InnerIter<_Const>;
7153 using _PatternIter = join_with_view::_PatternIter<_Const>;
7154 using _OuterCat = typename iterator_traits<_OuterIter>::iterator_category;
7155 using _InnerCat = typename iterator_traits<_InnerIter>::iterator_category;
7156 using _PatternCat = typename iterator_traits<_PatternIter>::iterator_category;
7157 if constexpr (!is_lvalue_reference_v<common_reference_t<iter_reference_t<_InnerIter>,
7158 iter_reference_t<_PatternIter>>>)
7159 return input_iterator_tag{};
7160 else if constexpr (derived_from<_OuterCat, bidirectional_iterator_tag>
7161 && derived_from<_InnerCat, bidirectional_iterator_tag>
7162 && derived_from<_PatternCat, bidirectional_iterator_tag>
7163 && common_range<_InnerBase<_Const>>
7164 && common_range<_PatternBase<_Const>>)
7165 return bidirectional_iterator_tag{};
7166 else if constexpr (derived_from<_OuterCat, forward_iterator_tag>
7167 && derived_from<_InnerCat, forward_iterator_tag>
7168 && derived_from<_PatternCat, forward_iterator_tag>)
7169 return forward_iterator_tag{};
7171 return input_iterator_tag{};
7174 using iterator_category = decltype(_S_iter_cat());
7177 template<bool> struct _Iterator;
7178 template<bool> struct _Sentinel;
7181 join_with_view() requires (default_initializable<_Vp>
7182 && default_initializable<_Pattern>)
7186 join_with_view(_Vp __base, _Pattern __pattern)
7187 : _M_base(std::move(__base)), _M_pattern(std::move(__pattern))
7190 template<input_range _Range>
7191 requires constructible_from<_Vp, views::all_t<_Range>>
7192 && constructible_from<_Pattern, single_view<range_value_t<_InnerRange>>>
7194 join_with_view(_Range&& __r, range_value_t<_InnerRange> __e)
7195 : _M_base(views::all(std::forward<_Range>(__r))),
7196 _M_pattern(views::single(std::move(__e)))
7200 base() const& requires copy_constructible<_Vp>
7205 { return std::move(_M_base); }
7210 if constexpr (forward_range<_Vp>)
7212 constexpr bool __use_const = is_reference_v<_InnerRange>
7213 && __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
7214 return _Iterator<__use_const>{*this, ranges::begin(_M_base)};
7218 _M_outer_it = ranges::begin(_M_base);
7219 return _Iterator<false>{*this};
7225 requires forward_range<const _Vp>
7226 && forward_range<const _Pattern>
7227 && is_reference_v<range_reference_t<const _Vp>>
7228 && input_range<range_reference_t<const _Vp>>
7229 { return _Iterator<true>{*this, ranges::begin(_M_base)}; }
7234 constexpr bool __use_const
7235 = __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
7236 if constexpr (is_reference_v<_InnerRange>
7237 && forward_range<_Vp> && common_range<_Vp>
7238 && forward_range<_InnerRange> && common_range<_InnerRange>)
7239 return _Iterator<__use_const>{*this, ranges::end(_M_base)};
7241 return _Sentinel<__use_const>{*this};
7246 requires forward_range<const _Vp>
7247 && forward_range<const _Pattern>
7248 && is_reference_v<range_reference_t<const _Vp>>
7249 && input_range<range_reference_t<const _Vp>>
7251 using _InnerConstRange = range_reference_t<const _Vp>;
7252 if constexpr (forward_range<_InnerConstRange>
7253 && common_range<const _Vp>
7254 && common_range<_InnerConstRange>)
7255 return _Iterator<true>{*this, ranges::end(_M_base)};
7257 return _Sentinel<true>{*this};
7261 template<typename _Range, typename _Pattern>
7262 join_with_view(_Range&&, _Pattern&&)
7263 -> join_with_view<views::all_t<_Range>, views::all_t<_Pattern>>;
7265 template<input_range _Range>
7266 join_with_view(_Range&&, range_value_t<range_reference_t<_Range>>)
7267 -> join_with_view<views::all_t<_Range>,
7268 single_view<range_value_t<range_reference_t<_Range>>>>;
7270 template<input_range _Vp, forward_range _Pattern>
7271 requires view<_Vp> && view<_Pattern>
7272 && input_range<range_reference_t<_Vp>>
7273 && __detail::__compatible_joinable_ranges<range_reference_t<_Vp>, _Pattern>
7274 template<bool _Const>
7275 class join_with_view<_Vp, _Pattern>::_Iterator : public __iter_cat<_Const>
7277 using _Parent = __detail::__maybe_const_t<_Const, join_with_view>;
7278 using _Base = join_with_view::_Base<_Const>;
7279 using _InnerBase = join_with_view::_InnerBase<_Const>;
7280 using _PatternBase = join_with_view::_PatternBase<_Const>;
7282 using _OuterIter = join_with_view::_OuterIter<_Const>;
7283 using _InnerIter = join_with_view::_InnerIter<_Const>;
7284 using _PatternIter = join_with_view::_PatternIter<_Const>;
7286 static constexpr bool _S_ref_is_glvalue = join_with_view::_S_ref_is_glvalue<_Const>;
7288 _Parent* _M_parent = nullptr;
7289 [[no_unique_address]]
7290 __detail::__maybe_present_t<forward_range<_Base>, _OuterIter> _M_outer_it;
7291 variant<_PatternIter, _InnerIter> _M_inner_it;
7293 constexpr _OuterIter&
7296 if constexpr (forward_range<_Base>)
7299 return *_M_parent->_M_outer_it;
7302 constexpr const _OuterIter&
7303 _M_get_outer() const
7305 if constexpr (forward_range<_Base>)
7308 return *_M_parent->_M_outer_it;
7312 _Iterator(_Parent& __parent, _OuterIter __outer)
7313 requires forward_range<_Base>
7314 : _M_parent(std::__addressof(__parent)), _M_outer_it(std::move(__outer))
7316 if (_M_get_outer() != ranges::end(_M_parent->_M_base))
7318 auto&& __inner = _M_update_inner();
7319 _M_inner_it.template emplace<1>(ranges::begin(__inner));
7325 _Iterator(_Parent& __parent)
7326 requires (!forward_range<_Base>)
7327 : _M_parent(std::__addressof(__parent))
7329 if (_M_get_outer() != ranges::end(_M_parent->_M_base))
7331 auto&& __inner = _M_update_inner();
7332 _M_inner_it.template emplace<1>(ranges::begin(__inner));
7340 _OuterIter& __outer = _M_get_outer();
7341 if constexpr (_S_ref_is_glvalue)
7342 return __detail::__as_lvalue(*__outer);
7344 return _M_parent->_M_inner._M_emplace_deref(__outer);
7350 if constexpr (_S_ref_is_glvalue)
7351 return __detail::__as_lvalue(*_M_get_outer());
7353 return *_M_parent->_M_inner;
7361 if (_M_inner_it.index() == 0)
7363 if (std::get<0>(_M_inner_it) != ranges::end(_M_parent->_M_pattern))
7366 auto&& __inner = _M_update_inner();
7367 _M_inner_it.template emplace<1>(ranges::begin(__inner));
7371 auto&& __inner = _M_get_inner();
7372 if (std::get<1>(_M_inner_it) != ranges::end(__inner))
7375 if (++_M_get_outer() == ranges::end(_M_parent->_M_base))
7377 if constexpr (_S_ref_is_glvalue)
7378 _M_inner_it.template emplace<0>();
7382 _M_inner_it.template emplace<0>(ranges::begin(_M_parent->_M_pattern));
7390 if constexpr (_S_ref_is_glvalue
7391 && bidirectional_range<_Base>
7392 && __detail::__bidirectional_common<_InnerBase>
7393 && __detail::__bidirectional_common<_PatternBase>)
7394 return bidirectional_iterator_tag{};
7395 else if constexpr (_S_ref_is_glvalue
7396 && forward_range<_Base>
7397 && forward_range<_InnerBase>)
7398 return forward_iterator_tag{};
7400 return input_iterator_tag{};
7403 friend join_with_view;
7406 using iterator_concept = decltype(_S_iter_concept());
7407 // iterator_category defined in join_with_view::__iter_cat
7408 using value_type = common_type_t<iter_value_t<_InnerIter>,
7409 iter_value_t<_PatternIter>>;
7410 using difference_type = common_type_t<iter_difference_t<_OuterIter>,
7411 iter_difference_t<_InnerIter>,
7412 iter_difference_t<_PatternIter>>;
7414 _Iterator() = default;
7417 _Iterator(_Iterator<!_Const> __i)
7419 && convertible_to<iterator_t<_Vp>, _OuterIter>
7420 && convertible_to<iterator_t<_InnerRange>, _InnerIter>
7421 && convertible_to<iterator_t<_Pattern>, _PatternIter>
7422 : _M_parent(__i._M_parent),
7423 _M_outer_it(std::move(__i._M_outer_it))
7425 if (__i._M_inner_it.index() == 0)
7426 _M_inner_it.template emplace<0>(std::get<0>(std::move(__i._M_inner_it)));
7428 _M_inner_it.template emplace<1>(std::get<1>(std::move(__i._M_inner_it)));
7431 constexpr common_reference_t<iter_reference_t<_InnerIter>,
7432 iter_reference_t<_PatternIter>>
7435 if (_M_inner_it.index() == 0)
7436 return *std::get<0>(_M_inner_it);
7438 return *std::get<1>(_M_inner_it);
7441 constexpr _Iterator&
7444 if (_M_inner_it.index() == 0)
7445 ++std::get<0>(_M_inner_it);
7447 ++std::get<1>(_M_inner_it);
7458 requires _S_ref_is_glvalue
7459 && forward_iterator<_OuterIter> && forward_iterator<_InnerIter>
7461 _Iterator __tmp = *this;
7466 constexpr _Iterator&
7468 requires _S_ref_is_glvalue
7469 && bidirectional_range<_Base>
7470 && __detail::__bidirectional_common<_InnerBase>
7471 && __detail::__bidirectional_common<_PatternBase>
7473 if (_M_outer_it == ranges::end(_M_parent->_M_base))
7475 auto&& __inner = *--_M_outer_it;
7476 _M_inner_it.template emplace<1>(ranges::end(__inner));
7481 if (_M_inner_it.index() == 0)
7483 auto& __it = std::get<0>(_M_inner_it);
7484 if (__it == ranges::begin(_M_parent->_M_pattern))
7486 auto&& __inner = *--_M_outer_it;
7487 _M_inner_it.template emplace<1>(ranges::end(__inner));
7494 auto& __it = std::get<1>(_M_inner_it);
7495 auto&& __inner = *_M_outer_it;
7496 if (__it == ranges::begin(__inner))
7497 _M_inner_it.template emplace<0>(ranges::end(_M_parent->_M_pattern));
7503 if (_M_inner_it.index() == 0)
7504 --std::get<0>(_M_inner_it);
7506 --std::get<1>(_M_inner_it);
7512 requires _S_ref_is_glvalue && bidirectional_range<_Base>
7513 && __detail::__bidirectional_common<_InnerBase>
7514 && __detail::__bidirectional_common<_PatternBase>
7516 _Iterator __tmp = *this;
7521 friend constexpr bool
7522 operator==(const _Iterator& __x, const _Iterator& __y)
7523 requires _S_ref_is_glvalue
7524 && forward_range<_Base> && equality_comparable<_InnerIter>
7525 { return __x._M_outer_it == __y._M_outer_it && __x._M_inner_it ==__y._M_inner_it; }
7527 friend constexpr common_reference_t<iter_rvalue_reference_t<_InnerIter>,
7528 iter_rvalue_reference_t<_PatternIter>>
7529 iter_move(const _Iterator& __x)
7531 if (__x._M_inner_it.index() == 0)
7532 return ranges::iter_move(std::get<0>(__x._M_inner_it));
7534 return ranges::iter_move(std::get<1>(__x._M_inner_it));
7537 friend constexpr void
7538 iter_swap(const _Iterator& __x, const _Iterator& __y)
7539 requires indirectly_swappable<_InnerIter, _PatternIter>
7541 if (__x._M_inner_it.index() == 0)
7543 if (__y._M_inner_it.index() == 0)
7544 ranges::iter_swap(std::get<0>(__x._M_inner_it), std::get<0>(__y._M_inner_it));
7546 ranges::iter_swap(std::get<0>(__x._M_inner_it), std::get<1>(__y._M_inner_it));
7550 if (__y._M_inner_it.index() == 0)
7551 ranges::iter_swap(std::get<1>(__x._M_inner_it), std::get<0>(__y._M_inner_it));
7553 ranges::iter_swap(std::get<1>(__x._M_inner_it), std::get<1>(__y._M_inner_it));
7558 template<input_range _Vp, forward_range _Pattern>
7559 requires view<_Vp> && view<_Pattern>
7560 && input_range<range_reference_t<_Vp>>
7561 && __detail::__compatible_joinable_ranges<range_reference_t<_Vp>, _Pattern>
7562 template<bool _Const>
7563 class join_with_view<_Vp, _Pattern>::_Sentinel
7565 using _Parent = __detail::__maybe_const_t<_Const, join_with_view>;
7566 using _Base = join_with_view::_Base<_Const>;
7568 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
7571 _Sentinel(_Parent& __parent)
7572 : _M_end(ranges::end(__parent._M_base))
7575 friend join_with_view;
7578 _Sentinel() = default;
7581 _Sentinel(_Sentinel<!_Const> __s)
7582 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
7583 : _M_end(std::move(__s._M_end))
7586 template<bool _OtherConst>
7587 requires sentinel_for<sentinel_t<_Base>,
7588 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
7589 friend constexpr bool
7590 operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
7591 { return __x._M_get_outer() == __y._M_end; }
7598 template<typename _Range, typename _Pattern>
7599 concept __can_join_with_view
7600 = requires { join_with_view(std::declval<_Range>(), std::declval<_Pattern>()); };
7601 } // namespace __detail
7603 struct _JoinWith : __adaptor::_RangeAdaptor<_JoinWith>
7605 template<viewable_range _Range, typename _Pattern>
7606 requires __detail::__can_join_with_view<_Range, _Pattern>
7608 operator() [[nodiscard]] (_Range&& __r, _Pattern&& __f) const
7610 return join_with_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
7613 using _RangeAdaptor<_JoinWith>::operator();
7614 static constexpr int _S_arity = 2;
7615 template<typename _Pattern>
7616 static constexpr bool _S_has_simple_extra_args
7617 = _LazySplit::_S_has_simple_extra_args<_Pattern>;
7620 inline constexpr _JoinWith join_with;
7621 } // namespace views
7622#endif // __cpp_lib_ranges_join_with
7624#ifdef __cpp_lib_ranges_repeat // C++ >= 23
7625 template<move_constructible _Tp, semiregular _Bound = unreachable_sentinel_t>
7626 requires is_object_v<_Tp> && same_as<_Tp, remove_cv_t<_Tp>>
7627 && (__detail::__is_integer_like<_Bound> || same_as<_Bound, unreachable_sentinel_t>)
7628 class repeat_view : public view_interface<repeat_view<_Tp, _Bound>>
7630 __detail::__box<_Tp> _M_value;
7631 [[no_unique_address]] _Bound _M_bound = _Bound();
7635 template<typename _Range>
7636 friend constexpr auto
7637 views::__detail::__take_of_repeat_view(_Range&&, range_difference_t<_Range>);
7639 template<typename _Range>
7640 friend constexpr auto
7641 views::__detail::__drop_of_repeat_view(_Range&&, range_difference_t<_Range>);
7644 repeat_view() requires default_initializable<_Tp> = default;
7647 repeat_view(const _Tp& __value, _Bound __bound = _Bound())
7648 requires copy_constructible<_Tp>
7649 : _M_value(__value), _M_bound(__bound)
7651 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7652 __glibcxx_assert(__bound >= 0);
7656 repeat_view(_Tp&& __value, _Bound __bound = _Bound())
7657 : _M_value(std::move(__value)), _M_bound(__bound)
7660 template<typename... _Args, typename... _BoundArgs>
7661 requires constructible_from<_Tp, _Args...>
7662 && constructible_from<_Bound, _BoundArgs...>
7664 repeat_view(piecewise_construct_t,
7665 tuple<_Args...> __args,
7666 tuple<_BoundArgs...> __bound_args = tuple<>{})
7667 : _M_value(std::make_from_tuple<_Tp>(std::move(__args))),
7668 _M_bound(std::make_from_tuple<_Bound>(std::move(__bound_args)))
7673 { return _Iterator(std::__addressof(*_M_value)); }
7676 end() const requires (!same_as<_Bound, unreachable_sentinel_t>)
7677 { return _Iterator(std::__addressof(*_M_value), _M_bound); }
7679 constexpr unreachable_sentinel_t
7680 end() const noexcept
7681 { return unreachable_sentinel; }
7684 size() const requires (!same_as<_Bound, unreachable_sentinel_t>)
7685 { return __detail::__to_unsigned_like(_M_bound); }
7688 template<typename _Tp, typename _Bound>
7689 repeat_view(_Tp, _Bound) -> repeat_view<_Tp, _Bound>;
7691 template<move_constructible _Tp, semiregular _Bound>
7692 requires is_object_v<_Tp> && same_as<_Tp, remove_cv_t<_Tp>>
7693 && (__detail::__is_integer_like<_Bound> || same_as<_Bound, unreachable_sentinel_t>)
7694 class repeat_view<_Tp, _Bound>::_Iterator
7697 = __conditional_t<same_as<_Bound, unreachable_sentinel_t>, ptrdiff_t, _Bound>;
7699 const _Tp* _M_value = nullptr;
7700 __index_type _M_current = __index_type();
7703 _Iterator(const _Tp* __value, __index_type __bound = __index_type())
7704 : _M_value(__value), _M_current(__bound)
7706 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7707 __glibcxx_assert(__bound >= 0);
7713 using iterator_concept = random_access_iterator_tag;
7714 using iterator_category = random_access_iterator_tag;
7715 using value_type = _Tp;
7716 using difference_type = __conditional_t<__detail::__is_signed_integer_like<__index_type>,
7718 __detail::__iota_diff_t<__index_type>>;
7720 _Iterator() = default;
7722 constexpr const _Tp&
7723 operator*() const noexcept
7724 { return *_M_value; }
7726 constexpr _Iterator&
7741 constexpr _Iterator&
7744 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7745 __glibcxx_assert(_M_current > 0);
7758 constexpr _Iterator&
7759 operator+=(difference_type __n)
7761 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7762 __glibcxx_assert(_M_current + __n >= 0);
7767 constexpr _Iterator&
7768 operator-=(difference_type __n)
7770 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7771 __glibcxx_assert(_M_current - __n >= 0);
7776 constexpr const _Tp&
7777 operator[](difference_type __n) const noexcept
7778 { return *(*this + __n); }
7780 friend constexpr bool
7781 operator==(const _Iterator& __x, const _Iterator& __y)
7782 { return __x._M_current == __y._M_current; }
7784 friend constexpr auto
7785 operator<=>(const _Iterator& __x, const _Iterator& __y)
7786 { return __x._M_current <=> __y._M_current; }
7788 friend constexpr _Iterator
7789 operator+(_Iterator __i, difference_type __n)
7795 friend constexpr _Iterator
7796 operator+(difference_type __n, _Iterator __i)
7797 { return __i + __n; }
7799 friend constexpr _Iterator
7800 operator-(_Iterator __i, difference_type __n)
7806 friend constexpr difference_type
7807 operator-(const _Iterator& __x, const _Iterator& __y)
7809 return (static_cast<difference_type>(__x._M_current)
7810 - static_cast<difference_type>(__y._M_current));
7818 template<typename _Tp, typename _Bound>
7819 inline constexpr bool __is_repeat_view<repeat_view<_Tp, _Bound>> = true;
7821 template<typename _Tp>
7822 concept __can_repeat_view
7823 = requires { repeat_view(std::declval<_Tp>()); };
7825 template<typename _Tp, typename _Bound>
7826 concept __can_bounded_repeat_view
7827 = requires { repeat_view(std::declval<_Tp>(), std::declval<_Bound>()); };
7832 template<typename _Tp>
7833 requires __detail::__can_repeat_view<_Tp>
7835 operator() [[nodiscard]] (_Tp&& __value) const
7836 { return repeat_view(std::forward<_Tp>(__value)); }
7838 template<typename _Tp, typename _Bound>
7839 requires __detail::__can_bounded_repeat_view<_Tp, _Bound>
7841 operator() [[nodiscard]] (_Tp&& __value, _Bound __bound) const
7842 { return repeat_view(std::forward<_Tp>(__value), __bound); }
7845 inline constexpr _Repeat repeat;
7849 template<typename _Range>
7851 __take_of_repeat_view(_Range&& __r, range_difference_t<_Range> __n)
7853 using _Tp = remove_cvref_t<_Range>;
7854 static_assert(__is_repeat_view<_Tp>);
7855 if constexpr (sized_range<_Tp>)
7856 return views::repeat(*std::forward<_Range>(__r)._M_value,
7857 std::min(ranges::distance(__r), __n));
7859 return views::repeat(*std::forward<_Range>(__r)._M_value, __n);
7862 template<typename _Range>
7864 __drop_of_repeat_view(_Range&& __r, range_difference_t<_Range> __n)
7866 using _Tp = remove_cvref_t<_Range>;
7867 static_assert(__is_repeat_view<_Tp>);
7868 if constexpr (sized_range<_Tp>)
7870 auto __sz = ranges::distance(__r);
7871 return views::repeat(*std::forward<_Range>(__r)._M_value,
7872 __sz - std::min(__sz, __n));
7879#endif // __cpp_lib_ranges_repeat
7881#ifdef __cpp_lib_ranges_stride // C++ >= 23
7882 template<input_range _Vp>
7884 class stride_view : public view_interface<stride_view<_Vp>>
7887 range_difference_t<_Vp> _M_stride;
7889 template<bool _Const> using _Base = __detail::__maybe_const_t<_Const, _Vp>;
7891 template<bool _Const>
7895 template<bool _Const>
7896 requires forward_range<_Base<_Const>>
7897 struct __iter_cat<_Const>
7903 using _Cat = typename iterator_traits<iterator_t<_Base<_Const>>>::iterator_category;
7904 if constexpr (derived_from<_Cat, random_access_iterator_tag>)
7905 return random_access_iterator_tag{};
7910 using iterator_category = decltype(_S_iter_cat());
7913 template<bool> class _Iterator;
7917 stride_view(_Vp __base, range_difference_t<_Vp> __stride)
7918 : _M_base(std::move(__base)), _M_stride(__stride)
7919 { __glibcxx_assert(__stride > 0); }
7922 base() const& requires copy_constructible<_Vp>
7927 { return std::move(_M_base); }
7929 constexpr range_difference_t<_Vp>
7930 stride() const noexcept
7931 { return _M_stride; }
7934 begin() requires (!__detail::__simple_view<_Vp>)
7935 { return _Iterator<false>(this, ranges::begin(_M_base)); }
7938 begin() const requires range<const _Vp>
7939 { return _Iterator<true>(this, ranges::begin(_M_base)); }
7942 end() requires (!__detail::__simple_view<_Vp>)
7944 if constexpr (common_range<_Vp> && sized_range<_Vp> && forward_range<_Vp>)
7946 auto __missing = (_M_stride - ranges::distance(_M_base) % _M_stride) % _M_stride;
7947 return _Iterator<false>(this, ranges::end(_M_base), __missing);
7949 else if constexpr (common_range<_Vp> && !bidirectional_range<_Vp>)
7950 return _Iterator<false>(this, ranges::end(_M_base));
7952 return default_sentinel;
7956 end() const requires range<const _Vp>
7958 if constexpr (common_range<const _Vp> && sized_range<const _Vp>
7959 && forward_range<const _Vp>)
7961 auto __missing = (_M_stride - ranges::distance(_M_base) % _M_stride) % _M_stride;
7962 return _Iterator<true>(this, ranges::end(_M_base), __missing);
7964 else if constexpr (common_range<const _Vp> && !bidirectional_range<const _Vp>)
7965 return _Iterator<true>(this, ranges::end(_M_base));
7967 return default_sentinel;
7971 size() requires sized_range<_Vp>
7973 return __detail::__to_unsigned_like
7974 (__detail::__div_ceil(ranges::distance(_M_base), _M_stride));
7978 size() const requires sized_range<const _Vp>
7980 return __detail::__to_unsigned_like
7981 (__detail::__div_ceil(ranges::distance(_M_base), _M_stride));
7985 template<typename _Range>
7986 stride_view(_Range&&, range_difference_t<_Range>) -> stride_view<views::all_t<_Range>>;
7988 template<typename _Vp>
7989 inline constexpr bool enable_borrowed_range<stride_view<_Vp>>
7990 = enable_borrowed_range<_Vp>;
7992 template<input_range _Vp>
7994 template<bool _Const>
7995 class stride_view<_Vp>::_Iterator : public __iter_cat<_Const>
7997 using _Parent = __detail::__maybe_const_t<_Const, stride_view>;
7998 using _Base = stride_view::_Base<_Const>;
8000 iterator_t<_Base> _M_current = iterator_t<_Base>();
8001 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
8002 range_difference_t<_Base> _M_stride = 0;
8003 range_difference_t<_Base> _M_missing = 0;
8006 _Iterator(_Parent* __parent, iterator_t<_Base> __current,
8007 range_difference_t<_Base> __missing = 0)
8008 : _M_current(std::move(__current)), _M_end(ranges::end(__parent->_M_base)),
8009 _M_stride(__parent->_M_stride), _M_missing(__missing)
8015 if constexpr (random_access_range<_Base>)
8016 return random_access_iterator_tag{};
8017 else if constexpr (bidirectional_range<_Base>)
8018 return bidirectional_iterator_tag{};
8019 else if constexpr (forward_range<_Base>)
8020 return forward_iterator_tag{};
8022 return input_iterator_tag{};
8028 using difference_type = range_difference_t<_Base>;
8029 using value_type = range_value_t<_Base>;
8030 using iterator_concept = decltype(_S_iter_concept());
8031 // iterator_category defined in stride_view::__iter_cat
8033 _Iterator() requires default_initializable<iterator_t<_Base>> = default;
8036 _Iterator(_Iterator<!_Const> __other)
8038 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
8039 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
8040 : _M_current(std::move(__other._M_current)), _M_end(std::move(__other._M_end)),
8041 _M_stride(__other._M_stride), _M_missing(__other._M_missing)
8044 constexpr iterator_t<_Base>
8046 { return std::move(_M_current); }
8048 constexpr const iterator_t<_Base>&
8049 base() const & noexcept
8050 { return _M_current; }
8052 constexpr decltype(auto)
8054 { return *_M_current; }
8056 constexpr _Iterator&
8059 __glibcxx_assert(_M_current != _M_end);
8060 _M_missing = ranges::advance(_M_current, _M_stride, _M_end);
8069 operator++(int) requires forward_range<_Base>
8076 constexpr _Iterator&
8077 operator--() requires bidirectional_range<_Base>
8079 ranges::advance(_M_current, _M_missing - _M_stride);
8085 operator--(int) requires bidirectional_range<_Base>
8092 constexpr _Iterator&
8093 operator+=(difference_type __n) requires random_access_range<_Base>
8097 __glibcxx_assert(ranges::distance(_M_current, _M_end) > _M_stride * (__n - 1));
8098 _M_missing = ranges::advance(_M_current, _M_stride * __n, _M_end);
8102 ranges::advance(_M_current, _M_stride * __n + _M_missing);
8108 constexpr _Iterator&
8109 operator-=(difference_type __n) requires random_access_range<_Base>
8110 { return *this += -__n; }
8112 constexpr decltype(auto) operator[](difference_type __n) const
8113 requires random_access_range<_Base>
8114 { return *(*this + __n); }
8116 friend constexpr bool
8117 operator==(const _Iterator& __x, default_sentinel_t)
8118 { return __x._M_current == __x._M_end; }
8120 friend constexpr bool
8121 operator==(const _Iterator& __x, const _Iterator& __y)
8122 requires equality_comparable<iterator_t<_Base>>
8123 { return __x._M_current == __y._M_current; }
8125 friend constexpr bool
8126 operator<(const _Iterator& __x, const _Iterator& __y)
8127 requires random_access_range<_Base>
8128 { return __x._M_current < __y._M_current; }
8130 friend constexpr bool
8131 operator>(const _Iterator& __x, const _Iterator& __y)
8132 requires random_access_range<_Base>
8133 { return __y._M_current < __x._M_current; }
8135 friend constexpr bool
8136 operator<=(const _Iterator& __x, const _Iterator& __y)
8137 requires random_access_range<_Base>
8138 { return !(__y._M_current < __x._M_current); }
8140 friend constexpr bool
8141 operator>=(const _Iterator& __x, const _Iterator& __y)
8142 requires random_access_range<_Base>
8143 { return !(__x._M_current < __y._M_current); }
8145 friend constexpr auto
8146 operator<=>(const _Iterator& __x, const _Iterator& __y)
8147 requires random_access_range<_Base> && three_way_comparable<iterator_t<_Base>>
8148 { return __x._M_current <=> __y._M_current; }
8150 friend constexpr _Iterator
8151 operator+(const _Iterator& __i, difference_type __n)
8152 requires random_access_range<_Base>
8159 friend constexpr _Iterator
8160 operator+(difference_type __n, const _Iterator& __i)
8161 requires random_access_range<_Base>
8162 { return __i + __n; }
8164 friend constexpr _Iterator
8165 operator-(const _Iterator& __i, difference_type __n)
8166 requires random_access_range<_Base>
8173 friend constexpr difference_type
8174 operator-(const _Iterator& __x, const _Iterator& __y)
8175 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
8177 auto __n = __x._M_current - __y._M_current;
8178 if constexpr (forward_range<_Base>)
8179 return (__n + __x._M_missing - __y._M_missing) / __x._M_stride;
8181 return -__detail::__div_ceil(-__n, __x._M_stride);
8183 return __detail::__div_ceil(__n, __x._M_stride);
8186 friend constexpr difference_type
8187 operator-(default_sentinel_t __y, const _Iterator& __x)
8188 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
8189 { return __detail::__div_ceil(__x._M_end - __x._M_current, __x._M_stride); }
8191 friend constexpr difference_type
8192 operator-(const _Iterator& __x, default_sentinel_t __y)
8193 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
8194 { return -(__y - __x); }
8196 friend constexpr range_rvalue_reference_t<_Base>
8197 iter_move(const _Iterator& __i)
8198 noexcept(noexcept(ranges::iter_move(__i._M_current)))
8199 { return ranges::iter_move(__i._M_current); }
8201 friend constexpr void
8202 iter_swap(const _Iterator& __x, const _Iterator& __y)
8203 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
8204 requires indirectly_swappable<iterator_t<_Base>>
8205 { ranges::iter_swap(__x._M_current, __y._M_current); }
8212 template<typename _Range, typename _Dp>
8213 concept __can_stride_view
8214 = requires { stride_view(std::declval<_Range>(), std::declval<_Dp>()); };
8217 struct _Stride : __adaptor::_RangeAdaptor<_Stride>
8219 template<viewable_range _Range, typename _Dp = range_difference_t<_Range>>
8220 requires __detail::__can_stride_view<_Range, _Dp>
8222 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n) const
8223 { return stride_view(std::forward<_Range>(__r), __n); }
8225 using __adaptor::_RangeAdaptor<_Stride>::operator();
8226 static constexpr int _S_arity = 2;
8227 static constexpr bool _S_has_simple_extra_args = true;
8230 inline constexpr _Stride stride;
8232#endif // __cpp_lib_ranges_stride
8234#ifdef __cpp_lib_ranges_cartesian_product // C++ >= 23
8237 template<bool _Const, typename _First, typename... _Vs>
8238 concept __cartesian_product_is_random_access
8239 = (random_access_range<__maybe_const_t<_Const, _First>>
8241 && (random_access_range<__maybe_const_t<_Const, _Vs>>
8242 && sized_range<__maybe_const_t<_Const, _Vs>>));
8244 template<typename _Range>
8245 concept __cartesian_product_common_arg
8246 = common_range<_Range> || (sized_range<_Range> && random_access_range<_Range>);
8248 template<bool _Const, typename _First, typename... _Vs>
8249 concept __cartesian_product_is_bidirectional
8250 = (bidirectional_range<__maybe_const_t<_Const, _First>>
8252 && (bidirectional_range<__maybe_const_t<_Const, _Vs>>
8253 && __cartesian_product_common_arg<__maybe_const_t<_Const, _Vs>>));
8255 template<typename _First, typename... _Vs>
8256 concept __cartesian_product_is_common = __cartesian_product_common_arg<_First>;
8258 template<typename... _Vs>
8259 concept __cartesian_product_is_sized = (sized_range<_Vs> && ...);
8261 template<bool _Const, template<typename> class FirstSent, typename _First, typename... _Vs>
8262 concept __cartesian_is_sized_sentinel
8263 = (sized_sentinel_for<FirstSent<__maybe_const_t<_Const, _First>>,
8264 iterator_t<__maybe_const_t<_Const, _First>>>
8266 && (sized_range<__maybe_const_t<_Const, _Vs>>
8267 && sized_sentinel_for<iterator_t<__maybe_const_t<_Const, _Vs>>,
8268 iterator_t<__maybe_const_t<_Const, _Vs>>>));
8270 template<__cartesian_product_common_arg _Range>
8272 __cartesian_common_arg_end(_Range& __r)
8274 if constexpr (common_range<_Range>)
8275 return ranges::end(__r);
8277 return ranges::begin(__r) + ranges::distance(__r);
8279 } // namespace __detail
8281 template<input_range _First, forward_range... _Vs>
8282 requires (view<_First> && ... && view<_Vs>)
8283 class cartesian_product_view : public view_interface<cartesian_product_view<_First, _Vs...>>
8285 tuple<_First, _Vs...> _M_bases;
8287 template<bool> class _Iterator;
8290 _S_difference_type()
8292 // TODO: Implement the recommended practice of using the smallest
8293 // sufficiently wide type according to the maximum sizes of the
8294 // underlying ranges?
8295 return common_type_t<ptrdiff_t,
8296 range_difference_t<_First>,
8297 range_difference_t<_Vs>...>{};
8301 cartesian_product_view() = default;
8304 cartesian_product_view(_First __first, _Vs... __rest)
8305 : _M_bases(std::move(__first), std::move(__rest)...)
8308 constexpr _Iterator<false>
8309 begin() requires (!__detail::__simple_view<_First> || ... || !__detail::__simple_view<_Vs>)
8310 { return _Iterator<false>(*this, __detail::__tuple_transform(ranges::begin, _M_bases)); }
8312 constexpr _Iterator<true>
8313 begin() const requires (range<const _First> && ... && range<const _Vs>)
8314 { return _Iterator<true>(*this, __detail::__tuple_transform(ranges::begin, _M_bases)); }
8316 constexpr _Iterator<false>
8317 end() requires ((!__detail::__simple_view<_First> || ... || !__detail::__simple_view<_Vs>)
8318 && __detail::__cartesian_product_is_common<_First, _Vs...>)
8320 auto __its = [this]<size_t... _Is>(index_sequence<_Is...>) {
8321 using _Ret = tuple<iterator_t<_First>, iterator_t<_Vs>...>;
8322 bool __empty_tail = (ranges::empty(std::get<1 + _Is>(_M_bases)) || ...);
8323 auto& __first = std::get<0>(_M_bases);
8324 return _Ret{(__empty_tail
8325 ? ranges::begin(__first)
8326 : __detail::__cartesian_common_arg_end(__first)),
8327 ranges::begin(std::get<1 + _Is>(_M_bases))...};
8328 }(make_index_sequence<sizeof...(_Vs)>{});
8330 return _Iterator<false>{*this, std::move(__its)};
8333 constexpr _Iterator<true>
8334 end() const requires __detail::__cartesian_product_is_common<const _First, const _Vs...>
8336 auto __its = [this]<size_t... _Is>(index_sequence<_Is...>) {
8337 using _Ret = tuple<iterator_t<const _First>, iterator_t<const _Vs>...>;
8338 bool __empty_tail = (ranges::empty(std::get<1 + _Is>(_M_bases)) || ...);
8339 auto& __first = std::get<0>(_M_bases);
8340 return _Ret{(__empty_tail
8341 ? ranges::begin(__first)
8342 : __detail::__cartesian_common_arg_end(__first)),
8343 ranges::begin(std::get<1 + _Is>(_M_bases))...};
8344 }(make_index_sequence<sizeof...(_Vs)>{});
8346 return _Iterator<true>{*this, std::move(__its)};
8349 constexpr default_sentinel_t
8350 end() const noexcept
8351 { return default_sentinel; }
8354 size() requires __detail::__cartesian_product_is_sized<_First, _Vs...>
8356 using _ST = __detail::__make_unsigned_like_t<decltype(_S_difference_type())>;
8357 return [&]<size_t... _Is>(index_sequence<_Is...>) {
8358 auto __size = static_cast<_ST>(1);
8359#ifdef _GLIBCXX_ASSERTIONS
8360 if constexpr (integral<_ST>)
8363 = (__builtin_mul_overflow(__size,
8364 static_cast<_ST>(ranges::size(std::get<_Is>(_M_bases))),
8367 __glibcxx_assert(!__overflow);
8371 __size = (static_cast<_ST>(ranges::size(std::get<_Is>(_M_bases))) * ...);
8373 }(make_index_sequence<1 + sizeof...(_Vs)>{});
8377 size() const requires __detail::__cartesian_product_is_sized<const _First, const _Vs...>
8379 using _ST = __detail::__make_unsigned_like_t<decltype(_S_difference_type())>;
8380 return [&]<size_t... _Is>(index_sequence<_Is...>) {
8381 auto __size = static_cast<_ST>(1);
8382#ifdef _GLIBCXX_ASSERTIONS
8383 if constexpr (integral<_ST>)
8386 = (__builtin_mul_overflow(__size,
8387 static_cast<_ST>(ranges::size(std::get<_Is>(_M_bases))),
8390 __glibcxx_assert(!__overflow);
8394 __size = (static_cast<_ST>(ranges::size(std::get<_Is>(_M_bases))) * ...);
8396 }(make_index_sequence<1 + sizeof...(_Vs)>{});
8400 template<typename... _Vs>
8401 cartesian_product_view(_Vs&&...) -> cartesian_product_view<views::all_t<_Vs>...>;
8403 template<input_range _First, forward_range... _Vs>
8404 requires (view<_First> && ... && view<_Vs>)
8405 template<bool _Const>
8406 class cartesian_product_view<_First, _Vs...>::_Iterator
8408 using _Parent = __maybe_const_t<_Const, cartesian_product_view>;
8409 _Parent* _M_parent = nullptr;
8410 tuple<iterator_t<__maybe_const_t<_Const, _First>>,
8411 iterator_t<__maybe_const_t<_Const, _Vs>>...> _M_current;
8414 _Iterator(_Parent& __parent, decltype(_M_current) __current)
8415 : _M_parent(std::__addressof(__parent)),
8416 _M_current(std::move(__current))
8422 if constexpr (__detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>)
8423 return random_access_iterator_tag{};
8424 else if constexpr (__detail::__cartesian_product_is_bidirectional<_Const, _First, _Vs...>)
8425 return bidirectional_iterator_tag{};
8426 else if constexpr (forward_range<__maybe_const_t<_Const, _First>>)
8427 return forward_iterator_tag{};
8429 return input_iterator_tag{};
8432 friend cartesian_product_view;
8435 using iterator_category = input_iterator_tag;
8436 using iterator_concept = decltype(_S_iter_concept());
8438 = tuple<range_value_t<__maybe_const_t<_Const, _First>>,
8439 range_value_t<__maybe_const_t<_Const, _Vs>>...>;
8441 = tuple<range_reference_t<__maybe_const_t<_Const, _First>>,
8442 range_reference_t<__maybe_const_t<_Const, _Vs>>...>;
8443 using difference_type = decltype(cartesian_product_view::_S_difference_type());
8445 _Iterator() = default;
8448 _Iterator(_Iterator<!_Const> __i)
8450 && (convertible_to<iterator_t<_First>, iterator_t<const _First>>
8451 && ... && convertible_to<iterator_t<_Vs>, iterator_t<const _Vs>>)
8452 : _M_parent(std::__addressof(__i._M_parent)),
8453 _M_current(std::move(__i._M_current))
8459 auto __f = [](auto& __i) -> decltype(auto) {
8462 return __detail::__tuple_transform(__f, _M_current);
8465 constexpr _Iterator&
8477 operator++(int) requires forward_range<__maybe_const_t<_Const, _First>>
8484 constexpr _Iterator&
8486 requires __detail::__cartesian_product_is_bidirectional<_Const, _First, _Vs...>
8494 requires __detail::__cartesian_product_is_bidirectional<_Const, _First, _Vs...>
8501 constexpr _Iterator&
8502 operator+=(difference_type __x)
8503 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8509 constexpr _Iterator&
8510 operator-=(difference_type __x)
8511 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8512 { return *this += -__x; }
8515 operator[](difference_type __n) const
8516 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8517 { return *((*this) + __n); }
8519 friend constexpr bool
8520 operator==(const _Iterator& __x, const _Iterator& __y)
8521 requires equality_comparable<iterator_t<__maybe_const_t<_Const, _First>>>
8522 { return __x._M_current == __y._M_current; }
8524 friend constexpr bool
8525 operator==(const _Iterator& __x, default_sentinel_t)
8527 return [&]<size_t... _Is>(index_sequence<_Is...>) {
8528 return ((std::get<_Is>(__x._M_current)
8529 == ranges::end(std::get<_Is>(__x._M_parent->_M_bases)))
8531 }(make_index_sequence<1 + sizeof...(_Vs)>{});
8534 friend constexpr auto
8535 operator<=>(const _Iterator& __x, const _Iterator& __y)
8536 requires __detail::__all_random_access<_Const, _First, _Vs...>
8537 { return __x._M_current <=> __y._M_current; }
8539 friend constexpr _Iterator
8540 operator+(_Iterator __x, difference_type __y)
8541 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8542 { return __x += __y; }
8544 friend constexpr _Iterator
8545 operator+(difference_type __x, _Iterator __y)
8546 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8547 { return __y += __x; }
8549 friend constexpr _Iterator
8550 operator-(_Iterator __x, difference_type __y)
8551 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8552 { return __x -= __y; }
8554 friend constexpr difference_type
8555 operator-(const _Iterator& __x, const _Iterator& __y)
8556 requires __detail::__cartesian_is_sized_sentinel<_Const, iterator_t, _First, _Vs...>
8557 { return __x._M_distance_from(__y._M_current); }
8559 friend constexpr difference_type
8560 operator-(const _Iterator& __i, default_sentinel_t)
8561 requires __detail::__cartesian_is_sized_sentinel<_Const, sentinel_t, _First, _Vs...>
8563 tuple __end_tuple = [&]<size_t... _Is>(index_sequence<_Is...>) {
8564 return tuple{ranges::end(std::get<0>(__i._M_parent->_M_bases)),
8565 ranges::begin(std::get<1 + _Is>(__i._M_parent->_M_bases))...};
8566 }(make_index_sequence<sizeof...(_Vs)>{});
8567 return __i._M_distance_from(__end_tuple);
8570 friend constexpr difference_type
8571 operator-(default_sentinel_t, const _Iterator& __i)
8572 requires __detail::__cartesian_is_sized_sentinel<_Const, sentinel_t, _First, _Vs...>
8573 { return -(__i - default_sentinel); }
8575 friend constexpr auto
8576 iter_move(const _Iterator& __i)
8577 { return __detail::__tuple_transform(ranges::iter_move, __i._M_current); }
8579 friend constexpr void
8580 iter_swap(const _Iterator& __l, const _Iterator& __r)
8581 requires (indirectly_swappable<iterator_t<__maybe_const_t<_Const, _First>>>
8583 && indirectly_swappable<iterator_t<__maybe_const_t<_Const, _Vs>>>)
8585 [&]<size_t... _Is>(index_sequence<_Is...>) {
8586 (ranges::iter_swap(std::get<_Is>(__l._M_current), std::get<_Is>(__r._M_current)), ...);
8587 }(make_index_sequence<1 + sizeof...(_Vs)>{});
8591 template<size_t _Nm = sizeof...(_Vs)>
8595 auto& __it = std::get<_Nm>(_M_current);
8597 if constexpr (_Nm > 0)
8598 if (__it == ranges::end(std::get<_Nm>(_M_parent->_M_bases)))
8600 __it = ranges::begin(std::get<_Nm>(_M_parent->_M_bases));
8605 template<size_t _Nm = sizeof...(_Vs)>
8609 auto& __it = std::get<_Nm>(_M_current);
8610 if constexpr (_Nm > 0)
8611 if (__it == ranges::begin(std::get<_Nm>(_M_parent->_M_bases)))
8613 __it = __detail::__cartesian_common_arg_end(std::get<_Nm>(_M_parent->_M_bases));
8619 template<size_t _Nm = sizeof...(_Vs)>
8621 _M_advance(difference_type __x)
8622 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8630 // Constant time iterator advancement.
8631 auto& __r = std::get<_Nm>(_M_parent->_M_bases);
8632 auto& __it = std::get<_Nm>(_M_current);
8633 if constexpr (_Nm == 0)
8635#ifdef _GLIBCXX_ASSERTIONS
8636 if constexpr (sized_range<__maybe_const_t<_Const, _First>>)
8638 auto __size = ranges::ssize(__r);
8639 auto __begin = ranges::begin(__r);
8640 auto __offset = __it - __begin;
8641 __glibcxx_assert(__offset + __x >= 0 && __offset + __x <= __size);
8648 auto __size = ranges::ssize(__r);
8649 auto __begin = ranges::begin(__r);
8650 auto __offset = __it - __begin;
8652 __x = __offset / __size;
8656 __offset = __size + __offset;
8659 __it = __begin + __offset;
8660 _M_advance<_Nm - 1>(__x);
8665 template<typename _Tuple>
8666 constexpr difference_type
8667 _M_distance_from(const _Tuple& __t) const
8669 return [&]<size_t... _Is>(index_sequence<_Is...>) {
8670 auto __sum = static_cast<difference_type>(0);
8671#ifdef _GLIBCXX_ASSERTIONS
8672 if constexpr (integral<difference_type>)
8675 = (__builtin_add_overflow(__sum, _M_scaled_distance<_Is>(__t), &__sum)
8677 __glibcxx_assert(!__overflow);
8681 __sum = (_M_scaled_distance<_Is>(__t) + ...);
8683 }(make_index_sequence<1 + sizeof...(_Vs)>{});
8686 template<size_t _Nm, typename _Tuple>
8687 constexpr difference_type
8688 _M_scaled_distance(const _Tuple& __t) const
8690 auto __dist = static_cast<difference_type>(std::get<_Nm>(_M_current)
8691 - std::get<_Nm>(__t));
8692#ifdef _GLIBCXX_ASSERTIONS
8693 if constexpr (integral<difference_type>)
8695 bool __overflow = __builtin_mul_overflow(__dist, _M_scaled_size<_Nm+1>(), &__dist);
8696 __glibcxx_assert(!__overflow);
8700 __dist *= _M_scaled_size<_Nm+1>();
8704 template<size_t _Nm>
8705 constexpr difference_type
8706 _M_scaled_size() const
8708 if constexpr (_Nm <= sizeof...(_Vs))
8710 auto __size = static_cast<difference_type>(ranges::size
8711 (std::get<_Nm>(_M_parent->_M_bases)));
8712#ifdef _GLIBCXX_ASSERTIONS
8713 if constexpr (integral<difference_type>)
8715 bool __overflow = __builtin_mul_overflow(__size, _M_scaled_size<_Nm+1>(), &__size);
8716 __glibcxx_assert(!__overflow);
8720 __size *= _M_scaled_size<_Nm+1>();
8724 return static_cast<difference_type>(1);
8732 template<typename... _Ts>
8733 concept __can_cartesian_product_view
8734 = requires { cartesian_product_view<all_t<_Ts>...>(std::declval<_Ts>()...); };
8737 struct _CartesianProduct
8739 template<typename... _Ts>
8740 requires (sizeof...(_Ts) == 0 || __detail::__can_cartesian_product_view<_Ts...>)
8742 operator() [[nodiscard]] (_Ts&&... __ts) const
8744 if constexpr (sizeof...(_Ts) == 0)
8745 return views::single(tuple{});
8747 return cartesian_product_view<all_t<_Ts>...>(std::forward<_Ts>(__ts)...);
8751 inline constexpr _CartesianProduct cartesian_product;
8753#endif // __cpp_lib_ranges_cartesian_product
8755#ifdef __cpp_lib_ranges_as_rvalue // C++ >= 23
8756 template<input_range _Vp>
8758 class as_rvalue_view : public view_interface<as_rvalue_view<_Vp>>
8760 _Vp _M_base = _Vp();
8763 as_rvalue_view() requires default_initializable<_Vp> = default;
8766 as_rvalue_view(_Vp __base)
8767 : _M_base(std::move(__base))
8771 base() const& requires copy_constructible<_Vp>
8776 { return std::move(_M_base); }
8779 begin() requires (!__detail::__simple_view<_Vp>)
8780 { return move_iterator(ranges::begin(_M_base)); }
8783 begin() const requires range<const _Vp>
8784 { return move_iterator(ranges::begin(_M_base)); }
8787 end() requires (!__detail::__simple_view<_Vp>)
8789 if constexpr (common_range<_Vp>)
8790 return move_iterator(ranges::end(_M_base));
8792 return move_sentinel(ranges::end(_M_base));
8796 end() const requires range<const _Vp>
8798 if constexpr (common_range<const _Vp>)
8799 return move_iterator(ranges::end(_M_base));
8801 return move_sentinel(ranges::end(_M_base));
8805 size() requires sized_range<_Vp>
8806 { return ranges::size(_M_base); }
8809 size() const requires sized_range<const _Vp>
8810 { return ranges::size(_M_base); }
8813 template<typename _Range>
8814 as_rvalue_view(_Range&&) -> as_rvalue_view<views::all_t<_Range>>;
8816 template<typename _Tp>
8817 inline constexpr bool enable_borrowed_range<as_rvalue_view<_Tp>>
8818 = enable_borrowed_range<_Tp>;
8824 template<typename _Tp>
8825 concept __can_as_rvalue_view = requires { as_rvalue_view(std::declval<_Tp>()); };
8828 struct _AsRvalue : __adaptor::_RangeAdaptorClosure<_AsRvalue>
8830 template<viewable_range _Range>
8831 requires __detail::__can_as_rvalue_view<_Range>
8833 operator() [[nodiscard]] (_Range&& __r) const
8835 if constexpr (same_as<range_rvalue_reference_t<_Range>,
8836 range_reference_t<_Range>>)
8837 return views::all(std::forward<_Range>(__r));
8839 return as_rvalue_view(std::forward<_Range>(__r));
8843 inline constexpr _AsRvalue as_rvalue;
8845#endif // __cpp_lib_as_rvalue
8847#ifdef __cpp_lib_ranges_enumerate // C++ >= 23
8850 template<typename _Range>
8851 concept __range_with_movable_reference = input_range<_Range>
8852 && move_constructible<range_reference_t<_Range>>
8853 && move_constructible<range_rvalue_reference_t<_Range>>;
8857 requires __detail::__range_with_movable_reference<_Vp>
8858 class enumerate_view : public view_interface<enumerate_view<_Vp>>
8860 _Vp _M_base = _Vp();
8862 template<bool _Const> class _Iterator;
8863 template<bool _Const> class _Sentinel;
8866 enumerate_view() requires default_initializable<_Vp> = default;
8869 enumerate_view(_Vp __base)
8870 : _M_base(std::move(__base))
8874 begin() requires (!__detail::__simple_view<_Vp>)
8875 { return _Iterator<false>(ranges::begin(_M_base), 0); }
8878 begin() const requires __detail::__range_with_movable_reference<const _Vp>
8879 { return _Iterator<true>(ranges::begin(_M_base), 0); }
8882 end() requires (!__detail::__simple_view<_Vp>)
8884 if constexpr (common_range<_Vp> && sized_range<_Vp>)
8885 return _Iterator<false>(ranges::end(_M_base), ranges::distance(_M_base));
8887 return _Sentinel<false>(ranges::end(_M_base));
8891 end() const requires __detail::__range_with_movable_reference<const _Vp>
8893 if constexpr (common_range<const _Vp> && sized_range<const _Vp>)
8894 return _Iterator<true>(ranges::end(_M_base), ranges::distance(_M_base));
8896 return _Sentinel<true>(ranges::end(_M_base));
8900 size() requires sized_range<_Vp>
8901 { return ranges::size(_M_base); }
8904 size() const requires sized_range<const _Vp>
8905 { return ranges::size(_M_base); }
8908 base() const & requires copy_constructible<_Vp>
8913 { return std::move(_M_base); }
8916 template<typename _Range>
8917 enumerate_view(_Range&&) -> enumerate_view<views::all_t<_Range>>;
8919 template<typename _Tp>
8920 inline constexpr bool enable_borrowed_range<enumerate_view<_Tp>>
8921 = enable_borrowed_range<_Tp>;
8924 requires __detail::__range_with_movable_reference<_Vp>
8925 template<bool _Const>
8926 class enumerate_view<_Vp>::_Iterator
8928 using _Base = __maybe_const_t<_Const, _Vp>;
8933 if constexpr (random_access_range<_Base>)
8934 return random_access_iterator_tag{};
8935 else if constexpr (bidirectional_range<_Base>)
8936 return bidirectional_iterator_tag{};
8937 else if constexpr (forward_range<_Base>)
8938 return forward_iterator_tag{};
8940 return input_iterator_tag{};
8943 friend enumerate_view;
8946 using iterator_category = input_iterator_tag;
8947 using iterator_concept = decltype(_S_iter_concept());
8948 using difference_type = range_difference_t<_Base>;
8949 using value_type = tuple<difference_type, range_value_t<_Base>>;
8952 using __reference_type = tuple<difference_type, range_reference_t<_Base>>;
8954 iterator_t<_Base> _M_current = iterator_t<_Base>();
8955 difference_type _M_pos = 0;
8958 _Iterator(iterator_t<_Base> __current, difference_type __pos)
8959 : _M_current(std::move(__current)), _M_pos(__pos)
8963 _Iterator() requires default_initializable<iterator_t<_Base>> = default;
8966 _Iterator(_Iterator<!_Const> __i)
8967 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
8968 : _M_current(std::move(__i._M_current)), _M_pos(__i._M_pos)
8971 constexpr const iterator_t<_Base> &
8972 base() const & noexcept
8973 { return _M_current; }
8975 constexpr iterator_t<_Base>
8977 { return std::move(_M_current); }
8979 constexpr difference_type
8980 index() const noexcept
8985 { return __reference_type(_M_pos, *_M_current); }
8987 constexpr _Iterator&
9000 operator++(int) requires forward_range<_Base>
9007 constexpr _Iterator&
9008 operator--() requires bidirectional_range<_Base>
9016 operator--(int) requires bidirectional_range<_Base>
9023 constexpr _Iterator&
9024 operator+=(difference_type __n) requires random_access_range<_Base>
9031 constexpr _Iterator&
9032 operator-=(difference_type __n) requires random_access_range<_Base>
9040 operator[](difference_type __n) const requires random_access_range<_Base>
9041 { return __reference_type(_M_pos + __n, _M_current[__n]); }
9043 friend constexpr bool
9044 operator==(const _Iterator& __x, const _Iterator& __y) noexcept
9045 { return __x._M_pos == __y._M_pos; }
9047 friend constexpr strong_ordering
9048 operator<=>(const _Iterator& __x, const _Iterator& __y) noexcept
9049 { return __x._M_pos <=> __y._M_pos; }
9051 friend constexpr _Iterator
9052 operator+(const _Iterator& __x, difference_type __y)
9053 requires random_access_range<_Base>
9054 { return (auto(__x) += __y); }
9056 friend constexpr _Iterator
9057 operator+(difference_type __x, const _Iterator& __y)
9058 requires random_access_range<_Base>
9059 { return auto(__y) += __x; }
9061 friend constexpr _Iterator
9062 operator-(const _Iterator& __x, difference_type __y)
9063 requires random_access_range<_Base>
9064 { return auto(__x) -= __y; }
9066 friend constexpr difference_type
9067 operator-(const _Iterator& __x, const _Iterator& __y)
9068 { return __x._M_pos - __y._M_pos; }
9070 friend constexpr auto
9071 iter_move(const _Iterator& __i)
9072 noexcept(noexcept(ranges::iter_move(__i._M_current))
9073 && is_nothrow_move_constructible_v<range_rvalue_reference_t<_Base>>)
9075 return tuple<difference_type, range_rvalue_reference_t<_Base>>
9076 (__i._M_pos, ranges::iter_move(__i._M_current));
9081 requires __detail::__range_with_movable_reference<_Vp>
9082 template<bool _Const>
9083 class enumerate_view<_Vp>::_Sentinel
9085 using _Base = __maybe_const_t<_Const, _Vp>;
9087 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
9090 _Sentinel(sentinel_t<_Base> __end)
9091 : _M_end(std::move(__end))
9094 friend enumerate_view;
9097 _Sentinel() = default;
9100 _Sentinel(_Sentinel<!_Const> __other)
9101 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
9102 : _M_end(std::move(__other._M_end))
9105 constexpr sentinel_t<_Base>
9109 template<bool _OtherConst>
9110 requires sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const_t<_OtherConst, _Vp>>>
9111 friend constexpr bool
9112 operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
9113 { return __x._M_current == __y._M_end; }
9115 template<bool _OtherConst>
9116 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const_t<_OtherConst, _Vp>>>
9117 friend constexpr range_difference_t<__maybe_const_t<_OtherConst, _Vp>>
9118 operator-(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
9119 { return __x._M_current - __y._M_end; }
9121 template<bool _OtherConst>
9122 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const_t<_OtherConst, _Vp>>>
9123 friend constexpr range_difference_t<__maybe_const_t<_OtherConst, _Vp>>
9124 operator-(const _Sentinel& __x, const _Iterator<_OtherConst>& __y)
9125 { return __x._M_end - __y._M_current; }
9132 template<typename _Tp>
9133 concept __can_enumerate_view
9134 = requires { enumerate_view<all_t<_Tp>>(std::declval<_Tp>()); };
9137 struct _Enumerate : __adaptor::_RangeAdaptorClosure<_Enumerate>
9139 template<viewable_range _Range>
9140 requires __detail::__can_enumerate_view<_Range>
9142 operator() [[nodiscard]] (_Range&& __r) const
9143 { return enumerate_view<all_t<_Range>>(std::forward<_Range>(__r)); }
9146 inline constexpr _Enumerate enumerate;
9148#endif // __cpp_lib_ranges_enumerate
9150#ifdef __cpp_lib_ranges_as_const // C++ >= 23
9152 requires input_range<_Vp>
9153 class as_const_view : public view_interface<as_const_view<_Vp>>
9155 _Vp _M_base = _Vp();
9158 as_const_view() requires default_initializable<_Vp> = default;
9161 as_const_view(_Vp __base)
9162 noexcept(is_nothrow_move_constructible_v<_Vp>)
9163 : _M_base(std::move(__base))
9168 noexcept(is_nothrow_copy_constructible_v<_Vp>)
9169 requires copy_constructible<_Vp>
9174 noexcept(is_nothrow_move_constructible_v<_Vp>)
9175 { return std::move(_M_base); }
9178 begin() requires (!__detail::__simple_view<_Vp>)
9179 { return ranges::cbegin(_M_base); }
9182 begin() const requires range<const _Vp>
9183 { return ranges::cbegin(_M_base); }
9186 end() requires (!__detail::__simple_view<_Vp>)
9187 { return ranges::cend(_M_base); }
9190 end() const requires range<const _Vp>
9191 { return ranges::cend(_M_base); }
9194 size() requires sized_range<_Vp>
9195 { return ranges::size(_M_base); }
9198 size() const requires sized_range<const _Vp>
9199 { return ranges::size(_M_base); }
9202 template<typename _Range>
9203 as_const_view(_Range&&) -> as_const_view<views::all_t<_Range>>;
9205 template<typename _Tp>
9206 inline constexpr bool enable_borrowed_range<as_const_view<_Tp>>
9207 = enable_borrowed_range<_Tp>;
9213 template<typename _Tp>
9214 inline constexpr bool __is_ref_view = false;
9216 template<typename _Range>
9217 inline constexpr bool __is_ref_view<ref_view<_Range>> = true;
9219 template<typename _Range>
9220 concept __can_as_const_view = requires { as_const_view(std::declval<_Range>()); };
9223 struct _AsConst : __adaptor::_RangeAdaptorClosure<_AsConst>
9225 template<viewable_range _Range>
9227 operator()(_Range&& __r) const
9228 noexcept(noexcept(as_const_view(std::declval<_Range>())))
9229 requires __detail::__can_as_const_view<_Range>
9231 using _Tp = remove_cvref_t<_Range>;
9232 using element_type = remove_reference_t<range_reference_t<_Range>>;
9233 if constexpr (constant_range<views::all_t<_Range>>)
9234 return views::all(std::forward<_Range>(__r));
9235 else if constexpr (__detail::__is_empty_view<_Tp>)
9236 return views::empty<const element_type>;
9237 else if constexpr (std::__detail::__is_span<_Tp>)
9238 return span<const element_type, _Tp::extent>(std::forward<_Range>(__r));
9239 else if constexpr (__detail::__is_ref_view<_Tp>
9240 && constant_range<const element_type>)
9241 return ref_view(static_cast<const element_type&>
9242 (std::forward<_Range>(__r).base()));
9243 else if constexpr (is_lvalue_reference_v<_Range>
9244 && constant_range<const _Tp>
9246 return ref_view(static_cast<const _Tp&>(__r));
9248 return as_const_view(std::forward<_Range>(__r));
9252 inline constexpr _AsConst as_const;
9254#endif // __cpp_lib_as_const
9255} // namespace ranges
9257 namespace views = ranges::views;
9259#if __cpp_lib_ranges_to_container // C++ >= 23
9262/// @cond undocumented
9265 template<typename _Container>
9266 constexpr bool __reservable_container
9267 = sized_range<_Container>
9268 && requires(_Container& __c, range_size_t<_Container> __n) {
9270 { __c.capacity() } -> same_as<decltype(__n)>;
9271 { __c.max_size() } -> same_as<decltype(__n)>;
9274 template<typename _Cont, typename _Range>
9275 constexpr bool __toable = requires {
9276 requires (!input_range<_Cont>
9277 || convertible_to<range_reference_t<_Range>,
9278 range_value_t<_Cont>>);
9280} // namespace __detail
9283 /// Convert a range to a container.
9285 * @tparam _Cont A container type.
9286 * @param __r A range that models the `input_range` concept.
9287 * @param __args... Arguments to pass to the container constructor.
9290 * This function converts a range to the `_Cont` type.
9292 * For example, `std::ranges::to<std::vector<int>>(some_view)`
9293 * will convert the view to `std::vector<int>`.
9295 * Additional constructor arguments for the container can be supplied after
9296 * the input range argument, e.g.
9297 * `std::ranges::to<std::vector<int, Alloc<int>>>(a_range, an_allocator)`.
9299 template<typename _Cont, input_range _Rg, typename... _Args>
9300 requires (!view<_Cont>)
9302 to [[nodiscard]] (_Rg&& __r, _Args&&... __args)
9304 static_assert(!is_const_v<_Cont> && !is_volatile_v<_Cont>);
9305 static_assert(is_class_v<_Cont>);
9307 if constexpr (__detail::__toable<_Cont, _Rg>)
9309 if constexpr (constructible_from<_Cont, _Rg, _Args...>)
9310 return _Cont(std::forward<_Rg>(__r),
9311 std::forward<_Args>(__args)...);
9312 else if constexpr (constructible_from<_Cont, from_range_t, _Rg, _Args...>)
9313 return _Cont(from_range, std::forward<_Rg>(__r),
9314 std::forward<_Args>(__args)...);
9315 else if constexpr (requires { requires common_range<_Rg>;
9316 typename __iter_category_t<iterator_t<_Rg>>;
9317 requires derived_from<__iter_category_t<iterator_t<_Rg>>,
9318 input_iterator_tag>;
9319 requires constructible_from<_Cont, iterator_t<_Rg>,
9320 sentinel_t<_Rg>, _Args...>;
9322 return _Cont(ranges::begin(__r), ranges::end(__r),
9323 std::forward<_Args>(__args)...);
9326 using _RefT = range_reference_t<_Rg>;
9327 static_assert(constructible_from<_Cont, _Args...>);
9328 _Cont __c(std::forward<_Args>(__args)...);
9329 if constexpr (sized_range<_Rg>
9330 && __detail::__reservable_container<_Cont>)
9331 __c.reserve(static_cast<range_size_t<_Cont>>(ranges::size(__r)));
9332 // _GLIBCXX_RESOLVE_LIB_DEFECTS
9333 // 4016. container-insertable checks do not match what
9334 // container-inserter does
9335 auto __it = ranges::begin(__r);
9336 const auto __sent = ranges::end(__r);
9337 while (__it != __sent)
9339 if constexpr (requires { __c.emplace_back(*__it); })
9340 __c.emplace_back(*__it);
9341 else if constexpr (requires { __c.push_back(*__it); })
9342 __c.push_back(*__it);
9343 else if constexpr (requires { __c.emplace(__c.end(), *__it); })
9344 __c.emplace(__c.end(), *__it);
9346 __c.insert(__c.end(), *__it);
9354 static_assert(input_range<range_reference_t<_Rg>>);
9355 // _GLIBCXX_RESOLVE_LIB_DEFECTS
9356 // 3984. ranges::to's recursion branch may be ill-formed
9357 return ranges::to<_Cont>(ref_view(__r) | views::transform(
9358 []<typename _Elt>(_Elt&& __elem) {
9359 using _ValT = range_value_t<_Cont>;
9360 return ranges::to<_ValT>(std::forward<_Elt>(__elem));
9361 }), std::forward<_Args>(__args)...);
9365/// @cond undocumented
9368 template<typename _Rg>
9371 using iterator_category = input_iterator_tag;
9372 using value_type = range_value_t<_Rg>;
9373 using difference_type = ptrdiff_t;
9374 using pointer = add_pointer_t<range_reference_t<_Rg>>;
9375 using reference = range_reference_t<_Rg>;
9376 reference operator*() const;
9377 pointer operator->() const;
9378 _InputIter& operator++();
9379 _InputIter operator++(int);
9380 bool operator==(const _InputIter&) const;
9383 template<template<typename...> typename _Cont, input_range _Rg,
9386 = decltype(_Cont(std::declval<_Rg>(), std::declval<_Args>()...));
9388 template<template<typename...> typename _Cont, input_range _Rg,
9391 = decltype(_Cont(from_range, std::declval<_Rg>(),
9392 std::declval<_Args>()...));
9394 template<template<typename...> typename _Cont, input_range _Rg,
9397 = decltype(_Cont(std::declval<_InputIter<_Rg>>(),
9398 std::declval<_InputIter<_Rg>>(),
9399 std::declval<_Args>()...));
9401} // namespace __detail
9404 template<template<typename...> typename _Cont, input_range _Rg,
9407 to [[nodiscard]] (_Rg&& __r, _Args&&... __args)
9409 using __detail::_DeduceExpr1;
9410 using __detail::_DeduceExpr2;
9411 using __detail::_DeduceExpr3;
9412 if constexpr (requires { typename _DeduceExpr1<_Cont, _Rg, _Args...>; })
9413 return ranges::to<_DeduceExpr1<_Cont, _Rg, _Args...>>(
9414 std::forward<_Rg>(__r), std::forward<_Args>(__args)...);
9415 else if constexpr (requires { typename _DeduceExpr2<_Cont, _Rg, _Args...>; })
9416 return ranges::to<_DeduceExpr2<_Cont, _Rg, _Args...>>(
9417 std::forward<_Rg>(__r), std::forward<_Args>(__args)...);
9418 else if constexpr (requires { typename _DeduceExpr3<_Cont, _Rg, _Args...>; })
9419 return ranges::to<_DeduceExpr3<_Cont, _Rg, _Args...>>(
9420 std::forward<_Rg>(__r), std::forward<_Args>(__args)...);
9422 static_assert(false); // Cannot deduce container specialization.
9425/// @cond undocumented
9428 template<typename _Cont>
9431 template<typename _Range, typename... _Args>
9432 requires requires { ranges::to<_Cont>(std::declval<_Range>(),
9433 std::declval<_Args>()...); }
9435 operator()(_Range&& __r, _Args&&... __args) const
9437 return ranges::to<_Cont>(std::forward<_Range>(__r),
9438 std::forward<_Args>(__args)...);
9441} // namespace __detail
9444 /// ranges::to adaptor for converting a range to a container type
9446 * @tparam _Cont A container type.
9447 * @param __args... Arguments to pass to the container constructor.
9450 * This range adaptor returns a range adaptor closure object that converts
9451 * a range to the `_Cont` type.
9453 * For example, `some_view | std::ranges::to<std::vector<int>>()`
9454 * will convert the view to `std::vector<int>`.
9456 * Additional constructor arguments for the container can be supplied, e.g.
9457 * `r | std::ranges::to<std::vector<int, Alloc<int>>>(an_allocator)`.
9459 template<typename _Cont, typename... _Args>
9460 requires (!view<_Cont>)
9462 to [[nodiscard]] (_Args&&... __args)
9464 using __detail::_To;
9465 using views::__adaptor::_Partial;
9466 return _Partial<_To<_Cont>, decay_t<_Args>...>{0, std::forward<_Args>(__args)...};
9469/// @cond undocumented
9472 template<template<typename...> typename _Cont>
9475 template<typename _Range, typename... _Args>
9476 requires requires { ranges::to<_Cont>(std::declval<_Range>(),
9477 std::declval<_Args>()...); }
9479 operator()(_Range&& __r, _Args&&... __args) const
9481 return ranges::to<_Cont>(std::forward<_Range>(__r),
9482 std::forward<_Args>(__args)...);
9485} // namespace __detail
9488 /// ranges::to adaptor for converting a range to a deduced container type.
9490 * @tparam _Cont A container template.
9491 * @param __args... Arguments to pass to the container constructor.
9494 * This range adaptor returns a range adaptor closure object that converts
9495 * a range to a specialization of the `_Cont` class template. The specific
9496 * specialization of `_Cont` to be used is deduced automatically.
9498 * For example, `some_view | std::ranges::to<std::vector>(Alloc<int>{})`
9499 * will convert the view to `std::vector<T, Alloc<T>>`, where `T` is the
9500 * view's value type, i.e. `std::ranges::range_value_t<decltype(some_view)>`.
9502 * Additional constructor arguments for the container can be supplied, e.g.
9503 * `r | std::ranges::to<std::vector>(an_allocator)`.
9505 template<template<typename...> typename _Cont, typename... _Args>
9507 to [[nodiscard]] (_Args&&... __args)
9509 using __detail::_To2;
9510 using views::__adaptor::_Partial;
9511 return _Partial<_To2<_Cont>, decay_t<_Args>...>{0, std::forward<_Args>(__args)...};
9514} // namespace ranges
9515#endif // __cpp_lib_ranges_to_container
9517_GLIBCXX_END_NAMESPACE_VERSION
9519#endif // library concepts
9521#endif /* _GLIBCXX_RANGES */