3// Copyright (C) 2019-2025 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
36#pragma GCC system_header
44#include <initializer_list>
50#if __cplusplus > 202002L
54#include <bits/ranges_util.h>
55#include <bits/refwrap.h>
57#define __glibcxx_want_algorithm_default_value_type
58#define __glibcxx_want_ranges
59#define __glibcxx_want_ranges_as_const
60#define __glibcxx_want_ranges_as_rvalue
61#define __glibcxx_want_ranges_cache_latest
62#define __glibcxx_want_ranges_cartesian_product
63#define __glibcxx_want_ranges_concat
64#define __glibcxx_want_ranges_chunk
65#define __glibcxx_want_ranges_chunk_by
66#define __glibcxx_want_ranges_enumerate
67#define __glibcxx_want_ranges_join_with
68#define __glibcxx_want_ranges_repeat
69#define __glibcxx_want_ranges_slide
70#define __glibcxx_want_ranges_stride
71#define __glibcxx_want_ranges_to_container
72#define __glibcxx_want_ranges_to_input
73#define __glibcxx_want_ranges_zip
74#include <bits/version.h>
76#ifdef __glibcxx_generator // C++ >= 23 && __glibcxx_coroutine
77# include <bits/elements_of.h>
81 * @defgroup ranges Ranges
83 * Components for dealing with ranges of elements.
86namespace std _GLIBCXX_VISIBILITY(default)
88_GLIBCXX_BEGIN_NAMESPACE_VERSION
91 // [range.access] customization point objects
92 // [range.req] range and view concepts
93 // [range.dangling] dangling iterator handling
94 // Defined in <bits/ranges_base.h>
96 // [view.interface] View interface
97 // [range.subrange] Sub-ranges
98 // Defined in <bits/ranges_util.h>
100 // C++20 24.6 [range.factories] Range factories
102 /// A view that contains no elements.
103 template<typename _Tp> requires is_object_v<_Tp>
105 : public view_interface<empty_view<_Tp>>
108 static constexpr _Tp* begin() noexcept { return nullptr; }
109 static constexpr _Tp* end() noexcept { return nullptr; }
110 static constexpr _Tp* data() noexcept { return nullptr; }
111 static constexpr size_t size() noexcept { return 0; }
112 static constexpr bool empty() noexcept { return true; }
115 template<typename _Tp>
116 inline constexpr bool enable_borrowed_range<empty_view<_Tp>> = true;
120#if __cpp_lib_ranges >= 202207L // C++ >= 23
121 // P2494R2 Relaxing range adaptors to allow for move only types
122 template<typename _Tp>
123 concept __boxable = move_constructible<_Tp> && is_object_v<_Tp>;
125 template<typename _Tp>
126 concept __boxable = copy_constructible<_Tp> && is_object_v<_Tp>;
129 template<__boxable _Tp>
130 struct __box : std::optional<_Tp>
132 using std::optional<_Tp>::optional;
136 noexcept(is_nothrow_default_constructible_v<_Tp>)
137 requires default_initializable<_Tp>
138 : std::optional<_Tp>{std::in_place}
141 __box(const __box&) = default;
142 __box(__box&&) = default;
144 using std::optional<_Tp>::operator=;
146 // _GLIBCXX_RESOLVE_LIB_DEFECTS
147 // 3477. Simplify constraints for semiregular-box
148 // 3572. copyable-box should be fully constexpr
150 operator=(const __box& __that)
151 noexcept(is_nothrow_copy_constructible_v<_Tp>)
152 requires (!copyable<_Tp>) && copy_constructible<_Tp>
154 if (this != std::__addressof(__that))
157 this->emplace(*__that);
165 operator=(__box&& __that)
166 noexcept(is_nothrow_move_constructible_v<_Tp>)
167 requires (!movable<_Tp>)
169 if (this != std::__addressof(__that))
172 this->emplace(std::move(*__that));
180 template<typename _Tp>
181 concept __boxable_copyable
182 = copy_constructible<_Tp>
183 && (copyable<_Tp> || (is_nothrow_move_constructible_v<_Tp>
184 && is_nothrow_copy_constructible_v<_Tp>));
185 template<typename _Tp>
186 concept __boxable_movable
187 = (!copy_constructible<_Tp>)
188 && (movable<_Tp> || is_nothrow_move_constructible_v<_Tp>);
190 // For types which are already copyable (or since C++23, movable)
191 // this specialization of the box wrapper stores the object directly
192 // without going through std::optional. It provides just the subset of
193 // the primary template's API that we currently use.
194 template<__boxable _Tp>
195 requires __boxable_copyable<_Tp> || __boxable_movable<_Tp>
199 [[no_unique_address]] _Tp _M_value = _Tp();
202 __box() requires default_initializable<_Tp> = default;
205 __box(const _Tp& __t)
206 noexcept(is_nothrow_copy_constructible_v<_Tp>)
207 requires copy_constructible<_Tp>
213 noexcept(is_nothrow_move_constructible_v<_Tp>)
214 : _M_value(std::move(__t))
217 template<typename... _Args>
218 requires constructible_from<_Tp, _Args...>
220 __box(in_place_t, _Args&&... __args)
221 noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
222 : _M_value(std::forward<_Args>(__args)...)
225 __box(const __box&) = default;
226 __box(__box&&) = default;
227 __box& operator=(const __box&) requires copyable<_Tp> = default;
228 __box& operator=(__box&&) requires movable<_Tp> = default;
230 // When _Tp is nothrow_copy_constructible but not copy_assignable,
231 // copy assignment is implemented via destroy-then-copy-construct.
233 operator=(const __box& __that) noexcept
234 requires (!copyable<_Tp>) && copy_constructible<_Tp>
236 static_assert(is_nothrow_copy_constructible_v<_Tp>);
237 if (this != std::__addressof(__that))
240 std::construct_at(std::__addressof(_M_value), *__that);
245 // Likewise for move assignment.
247 operator=(__box&& __that) noexcept
248 requires (!movable<_Tp>)
250 static_assert(is_nothrow_move_constructible_v<_Tp>);
251 if (this != std::__addressof(__that))
254 std::construct_at(std::__addressof(_M_value), std::move(*__that));
260 has_value() const noexcept
264 operator*() & noexcept
268 operator*() const & noexcept
272 operator*() && noexcept
273 { return std::move(_M_value); }
275 constexpr const _Tp&&
276 operator*() const && noexcept
277 { return std::move(_M_value); }
280 operator->() noexcept
281 { return std::__addressof(_M_value); }
284 operator->() const noexcept
285 { return std::__addressof(_M_value); }
287 } // namespace __detail
289 /// A view that contains exactly one element.
290#if __cpp_lib_ranges >= 202207L // C++ >= 23
291 template<move_constructible _Tp>
293 template<copy_constructible _Tp>
295 requires is_object_v<_Tp>
296 class single_view : public view_interface<single_view<_Tp>>
299 single_view() requires default_initializable<_Tp> = default;
302 single_view(const _Tp& __t)
303 noexcept(is_nothrow_copy_constructible_v<_Tp>)
304 requires copy_constructible<_Tp>
309 single_view(_Tp&& __t)
310 noexcept(is_nothrow_move_constructible_v<_Tp>)
311 : _M_value(std::move(__t))
314 // _GLIBCXX_RESOLVE_LIB_DEFECTS
315 // 3428. single_view's in place constructor should be explicit
316 template<typename... _Args>
317 requires constructible_from<_Tp, _Args...>
319 single_view(in_place_t, _Args&&... __args)
320 noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
321 : _M_value{in_place, std::forward<_Args>(__args)...}
329 begin() const noexcept
334 { return data() + 1; }
338 { return data() + 1; }
340 // _GLIBCXX_RESOLVE_LIB_DEFECTS
341 // 4035. single_view should provide empty
342 static constexpr bool
346 static constexpr size_t
352 { return _M_value.operator->(); }
355 data() const noexcept
356 { return _M_value.operator->(); }
359 [[no_unique_address]] __detail::__box<_Tp> _M_value;
362 template<typename _Tp>
363 single_view(_Tp) -> single_view<_Tp>;
367 template<typename _Wp>
368 constexpr auto __to_signed_like(_Wp __w) noexcept
370 if constexpr (!integral<_Wp>)
371 return iter_difference_t<_Wp>();
372 else if constexpr (sizeof(iter_difference_t<_Wp>) > sizeof(_Wp))
373 return iter_difference_t<_Wp>(__w);
374 else if constexpr (sizeof(ptrdiff_t) > sizeof(_Wp))
375 return ptrdiff_t(__w);
376 else if constexpr (sizeof(long long) > sizeof(_Wp))
377 return (long long)(__w);
378#ifdef __SIZEOF_INT128__
379 else if constexpr (__SIZEOF_INT128__ > sizeof(_Wp))
380 return __int128(__w);
383 return __max_diff_type(__w);
386 template<typename _Wp>
387 using __iota_diff_t = decltype(__to_signed_like(std::declval<_Wp>()));
389 template<typename _It>
390 concept __decrementable = incrementable<_It>
393 { --__i } -> same_as<_It&>;
394 { __i-- } -> same_as<_It>;
397 template<typename _It>
398 concept __advanceable = __decrementable<_It> && totally_ordered<_It>
399 && requires( _It __i, const _It __j, const __iota_diff_t<_It> __n)
401 { __i += __n } -> same_as<_It&>;
402 { __i -= __n } -> same_as<_It&>;
406 { __j - __j } -> convertible_to<__iota_diff_t<_It>>;
409 template<typename _Winc>
410 struct __iota_view_iter_cat
413 template<incrementable _Winc>
414 struct __iota_view_iter_cat<_Winc>
415 { using iterator_category = input_iterator_tag; };
416 } // namespace __detail
418 template<weakly_incrementable _Winc,
419 semiregular _Bound = unreachable_sentinel_t>
420 requires std::__detail::__weakly_eq_cmp_with<_Winc, _Bound>
422 class iota_view : public view_interface<iota_view<_Winc, _Bound>>
427 struct _Iterator : __detail::__iota_view_iter_cat<_Winc>
433 using namespace __detail;
434 if constexpr (__advanceable<_Winc>)
435 return random_access_iterator_tag{};
436 else if constexpr (__decrementable<_Winc>)
437 return bidirectional_iterator_tag{};
438 else if constexpr (incrementable<_Winc>)
439 return forward_iterator_tag{};
441 return input_iterator_tag{};
445 using iterator_concept = decltype(_S_iter_concept());
446 // iterator_category defined in __iota_view_iter_cat
447 using value_type = _Winc;
448 using difference_type = __detail::__iota_diff_t<_Winc>;
450 _Iterator() requires default_initializable<_Winc> = default;
453 _Iterator(_Winc __value)
454 : _M_value(__value) { }
457 operator*() const noexcept(is_nothrow_copy_constructible_v<_Winc>)
472 operator++(int) requires incrementable<_Winc>
480 operator--() requires __detail::__decrementable<_Winc>
487 operator--(int) requires __detail::__decrementable<_Winc>
495 operator+=(difference_type __n) requires __detail::__advanceable<_Winc>
497 using __detail::__is_integer_like;
498 using __detail::__is_signed_integer_like;
499 if constexpr (__is_integer_like<_Winc>
500 && !__is_signed_integer_like<_Winc>)
502 if (__n >= difference_type(0))
503 _M_value += static_cast<_Winc>(__n);
505 _M_value -= static_cast<_Winc>(-__n);
513 operator-=(difference_type __n) requires __detail::__advanceable<_Winc>
515 using __detail::__is_integer_like;
516 using __detail::__is_signed_integer_like;
517 if constexpr (__is_integer_like<_Winc>
518 && !__is_signed_integer_like<_Winc>)
520 if (__n >= difference_type(0))
521 _M_value -= static_cast<_Winc>(__n);
523 _M_value += static_cast<_Winc>(-__n);
531 operator[](difference_type __n) const
532 requires __detail::__advanceable<_Winc>
533 { return _Winc(_M_value + __n); }
535 friend constexpr bool
536 operator==(const _Iterator& __x, const _Iterator& __y)
537 requires equality_comparable<_Winc>
538 { return __x._M_value == __y._M_value; }
540 friend constexpr bool
541 operator<(const _Iterator& __x, const _Iterator& __y)
542 requires totally_ordered<_Winc>
543 { return __x._M_value < __y._M_value; }
545 friend constexpr bool
546 operator>(const _Iterator& __x, const _Iterator& __y)
547 requires totally_ordered<_Winc>
548 { return __y < __x; }
550 friend constexpr bool
551 operator<=(const _Iterator& __x, const _Iterator& __y)
552 requires totally_ordered<_Winc>
553 { return !(__y < __x); }
555 friend constexpr bool
556 operator>=(const _Iterator& __x, const _Iterator& __y)
557 requires totally_ordered<_Winc>
558 { return !(__x < __y); }
560#ifdef __cpp_lib_three_way_comparison
561 friend constexpr auto
562 operator<=>(const _Iterator& __x, const _Iterator& __y)
563 requires totally_ordered<_Winc> && three_way_comparable<_Winc>
564 { return __x._M_value <=> __y._M_value; }
567 friend constexpr _Iterator
568 operator+(_Iterator __i, difference_type __n)
569 requires __detail::__advanceable<_Winc>
575 friend constexpr _Iterator
576 operator+(difference_type __n, _Iterator __i)
577 requires __detail::__advanceable<_Winc>
578 { return __i += __n; }
580 friend constexpr _Iterator
581 operator-(_Iterator __i, difference_type __n)
582 requires __detail::__advanceable<_Winc>
588 friend constexpr difference_type
589 operator-(const _Iterator& __x, const _Iterator& __y)
590 requires __detail::__advanceable<_Winc>
592 using __detail::__is_integer_like;
593 using __detail::__is_signed_integer_like;
594 using _Dt = difference_type;
595 if constexpr (__is_integer_like<_Winc>)
597 if constexpr (__is_signed_integer_like<_Winc>)
598 return _Dt(_Dt(__x._M_value) - _Dt(__y._M_value));
600 return (__y._M_value > __x._M_value)
601 ? _Dt(-_Dt(__y._M_value - __x._M_value))
602 : _Dt(__x._M_value - __y._M_value);
605 return __x._M_value - __y._M_value;
609 _Winc _M_value = _Winc();
619 _M_equal(const _Iterator& __x) const
620 { return __x._M_value == _M_bound; }
623 _M_distance_from(const _Iterator& __x) const
624 { return _M_bound - __x._M_value; }
626 _Bound _M_bound = _Bound();
629 _Sentinel() = default;
632 _Sentinel(_Bound __bound)
633 : _M_bound(__bound) { }
635 friend constexpr bool
636 operator==(const _Iterator& __x, const _Sentinel& __y)
637 { return __y._M_equal(__x); }
639 friend constexpr iter_difference_t<_Winc>
640 operator-(const _Iterator& __x, const _Sentinel& __y)
641 requires sized_sentinel_for<_Bound, _Winc>
642 { return -__y._M_distance_from(__x); }
644 friend constexpr iter_difference_t<_Winc>
645 operator-(const _Sentinel& __x, const _Iterator& __y)
646 requires sized_sentinel_for<_Bound, _Winc>
647 { return __x._M_distance_from(__y); }
652 _Winc _M_value = _Winc();
653 [[no_unique_address]] _Bound _M_bound = _Bound();
656 iota_view() requires default_initializable<_Winc> = default;
659 iota_view(_Winc __value)
664 iota_view(type_identity_t<_Winc> __value,
665 type_identity_t<_Bound> __bound)
666 : _M_value(__value), _M_bound(__bound)
668 if constexpr (totally_ordered_with<_Winc, _Bound>)
669 __glibcxx_assert( bool(__value <= __bound) );
673 iota_view(_Iterator __first, _Iterator __last)
674 requires same_as<_Winc, _Bound>
675 : iota_view(__first._M_value, __last._M_value)
679 iota_view(_Iterator __first, unreachable_sentinel_t __last)
680 requires same_as<_Bound, unreachable_sentinel_t>
681 : iota_view(__first._M_value, __last)
685 iota_view(_Iterator __first, _Sentinel __last)
686 requires (!same_as<_Winc, _Bound>) && (!same_as<_Bound, unreachable_sentinel_t>)
687 : iota_view(__first._M_value, __last._M_bound)
691 begin() const { return _Iterator{_M_value}; }
696 if constexpr (same_as<_Bound, unreachable_sentinel_t>)
697 return unreachable_sentinel;
699 return _Sentinel{_M_bound};
703 end() const requires same_as<_Winc, _Bound>
704 { return _Iterator{_M_bound}; }
706 // _GLIBCXX_RESOLVE_LIB_DEFECTS
707 // 4001. iota_view should provide empty
710 { return _M_value == _M_bound; }
714 requires (same_as<_Winc, _Bound> && __detail::__advanceable<_Winc>)
715 || (integral<_Winc> && integral<_Bound>)
716 || sized_sentinel_for<_Bound, _Winc>
718 using __detail::__is_integer_like;
719 using __detail::__to_unsigned_like;
720 if constexpr (integral<_Winc> && integral<_Bound>)
722 using _Up = make_unsigned_t<decltype(_M_bound - _M_value)>;
723 return _Up(_M_bound) - _Up(_M_value);
725 else if constexpr (__is_integer_like<_Winc>)
726 return __to_unsigned_like(_M_bound) - __to_unsigned_like(_M_value);
728 return __to_unsigned_like(_M_bound - _M_value);
732 template<typename _Winc, typename _Bound>
733 requires (!__detail::__is_integer_like<_Winc>
734 || !__detail::__is_integer_like<_Bound>
735 || (__detail::__is_signed_integer_like<_Winc>
736 == __detail::__is_signed_integer_like<_Bound>))
737 iota_view(_Winc, _Bound) -> iota_view<_Winc, _Bound>;
739 template<typename _Winc, typename _Bound>
740 inline constexpr bool
741 enable_borrowed_range<iota_view<_Winc, _Bound>> = true;
745 template<typename _Tp>
746 inline constexpr empty_view<_Tp> empty{};
750 template<typename _Tp>
751 concept __can_single_view
752 = requires { single_view<decay_t<_Tp>>(std::declval<_Tp>()); };
753 } // namespace __detail
757 template<__detail::__can_single_view _Tp>
759 operator() [[nodiscard]] (_Tp&& __e) const
760 noexcept(noexcept(single_view<decay_t<_Tp>>(std::forward<_Tp>(__e))))
761 { return single_view<decay_t<_Tp>>(std::forward<_Tp>(__e)); }
764 inline constexpr _Single single{};
768 template<typename... _Args>
769 concept __can_iota_view = requires { iota_view(std::declval<_Args>()...); };
770 } // namespace __detail
774 template<__detail::__can_iota_view _Tp>
776 operator() [[nodiscard]] (_Tp&& __e) const
777 { return iota_view(std::forward<_Tp>(__e)); }
779 template<typename _Tp, typename _Up>
780 requires __detail::__can_iota_view<_Tp, _Up>
782 operator() [[nodiscard]] (_Tp&& __e, _Up&& __f) const
783 { return iota_view(std::forward<_Tp>(__e), std::forward<_Up>(__f)); }
786 inline constexpr _Iota iota{};
792 template<typename _Val, typename _CharT, typename _Traits>
793 concept __stream_extractable
794 = requires(basic_istream<_CharT, _Traits>& is, _Val& t) { is >> t; };
795 } // namespace __detail
797 template<movable _Val, typename _CharT,
798 typename _Traits = char_traits<_CharT>>
799 requires default_initializable<_Val>
800 && __detail::__stream_extractable<_Val, _CharT, _Traits>
801 class basic_istream_view
802 : public view_interface<basic_istream_view<_Val, _CharT, _Traits>>
806 basic_istream_view(basic_istream<_CharT, _Traits>& __stream)
807 : _M_stream(std::__addressof(__stream))
813 *_M_stream >> _M_object;
814 return _Iterator{this};
817 constexpr default_sentinel_t
819 { return default_sentinel; }
822 basic_istream<_CharT, _Traits>* _M_stream;
823 _Val _M_object = _Val();
828 using iterator_concept = input_iterator_tag;
829 using difference_type = ptrdiff_t;
830 using value_type = _Val;
833 _Iterator(basic_istream_view* __parent) noexcept
834 : _M_parent(__parent)
837 _Iterator(const _Iterator&) = delete;
838 _Iterator(_Iterator&&) = default;
839 _Iterator& operator=(const _Iterator&) = delete;
840 _Iterator& operator=(_Iterator&&) = default;
845 *_M_parent->_M_stream >> _M_parent->_M_object;
855 { return _M_parent->_M_object; }
858 operator==(const _Iterator& __x, default_sentinel_t)
859 { return __x._M_at_end(); }
862 basic_istream_view* _M_parent;
866 { return !*_M_parent->_M_stream; }
872 template<typename _Val>
873 using istream_view = basic_istream_view<_Val, char>;
875 template<typename _Val>
876 using wistream_view = basic_istream_view<_Val, wchar_t>;
882 template<typename _Tp, typename _Up>
883 concept __can_istream_view = requires (_Up __e) {
884 basic_istream_view<_Tp, typename _Up::char_type, typename _Up::traits_type>(__e);
886 } // namespace __detail
888 template<typename _Tp>
891 template<typename _CharT, typename _Traits>
893 operator() [[nodiscard]] (basic_istream<_CharT, _Traits>& __e) const
894 requires __detail::__can_istream_view<_Tp, remove_reference_t<decltype(__e)>>
895 { return basic_istream_view<_Tp, _CharT, _Traits>(__e); }
898 template<typename _Tp>
899 inline constexpr _Istream<_Tp> istream;
903 // C++20 24.7 [range.adaptors] Range adaptors
907 template<typename _Tp, int _Disc>
910 // Alias for a type that is conditionally present
911 // (and is an empty type otherwise).
912 // Data members using this alias should use [[no_unique_address]] so that
913 // they take no space when not needed.
914 // The optional template parameter _Disc is for discriminating two otherwise
915 // equivalent absent types so that even they can overlap.
916 template<bool _Present, typename _Tp, int _Disc = 0>
917 using __maybe_present_t = __conditional_t<_Present, _Tp, _Absent<_Tp, _Disc>>;
919 // Alias for a type that is conditionally const.
920 template<bool _Const, typename _Tp>
921 using __maybe_const_t = __conditional_t<_Const, const _Tp, _Tp>;
923} // namespace __detail
925// Shorthand for __detail::__maybe_const_t.
926using __detail::__maybe_const_t;
928namespace views::__adaptor
930 // True if the range adaptor _Adaptor can be applied with _Args.
931 template<typename _Adaptor, typename... _Args>
932 concept __adaptor_invocable
933 = requires { std::declval<_Adaptor>()(declval<_Args>()...); };
935 // True if the range adaptor non-closure _Adaptor can be partially applied
937 template<typename _Adaptor, typename... _Args>
938 concept __adaptor_partial_app_viable = (_Adaptor::_S_arity > 1)
939 && (sizeof...(_Args) == _Adaptor::_S_arity - 1)
940 && (constructible_from<decay_t<_Args>, _Args> && ...);
942 template<typename _Adaptor, typename... _Args>
945 template<typename _Lhs, typename _Rhs>
948 // The base class of every range adaptor closure.
950 // The derived class should define the optional static data member
951 // _S_has_simple_call_op to true if the behavior of this adaptor is
952 // independent of the constness/value category of the adaptor object.
953 template<typename _Derived>
954 struct _RangeAdaptorClosure;
956 template<typename _Tp, typename _Up>
957 requires (!same_as<_Tp, _RangeAdaptorClosure<_Up>>)
958 void __is_range_adaptor_closure_fn
959 (const _Tp&, const _RangeAdaptorClosure<_Up>&); // not defined
961 template<typename _Tp>
962 concept __is_range_adaptor_closure
963 = requires (_Tp __t) { __adaptor::__is_range_adaptor_closure_fn(__t, __t); };
965#pragma GCC diagnostic push
966#pragma GCC diagnostic ignored "-Wdangling-reference"
967 // range | adaptor is equivalent to adaptor(range).
968 template<typename _Self, typename _Range>
969 requires __is_range_adaptor_closure<_Self>
970 && __adaptor_invocable<_Self, _Range>
972 operator|(_Range&& __r, _Self&& __self)
973 { return std::forward<_Self>(__self)(std::forward<_Range>(__r)); }
975 // Compose the adaptors __lhs and __rhs into a pipeline, returning
976 // another range adaptor closure object.
977 template<typename _Lhs, typename _Rhs>
978 requires __is_range_adaptor_closure<_Lhs>
979 && __is_range_adaptor_closure<_Rhs>
981 operator|(_Lhs&& __lhs, _Rhs&& __rhs)
983 return _Pipe<decay_t<_Lhs>, decay_t<_Rhs>>{std::forward<_Lhs>(__lhs),
984 std::forward<_Rhs>(__rhs)};
986#pragma GCC diagnostic pop
988 template<typename _Derived>
989 struct _RangeAdaptorClosure
991 // In non-modules compilation ADL finds these operators either way and
992 // the friend declarations are redundant. But with the std module these
993 // friend declarations enable ADL to find these operators without having
995 template<typename _Self, typename _Range>
996 requires __is_range_adaptor_closure<_Self>
997 && __adaptor_invocable<_Self, _Range>
998 friend constexpr auto
999 operator|(_Range&& __r, _Self&& __self);
1001 template<typename _Lhs, typename _Rhs>
1002 requires __is_range_adaptor_closure<_Lhs>
1003 && __is_range_adaptor_closure<_Rhs>
1004 friend constexpr auto
1005 operator|(_Lhs&& __lhs, _Rhs&& __rhs);
1008 // The base class of every range adaptor non-closure.
1010 // The static data member _Derived::_S_arity must contain the total number of
1011 // arguments that the adaptor takes, and the class _Derived must introduce
1012 // _RangeAdaptor::operator() into the class scope via a using-declaration.
1014 // The optional static data member _Derived::_S_has_simple_extra_args should
1015 // be defined to true if the behavior of this adaptor is independent of the
1016 // constness/value category of the extra arguments. This data member could
1017 // also be defined as a variable template parameterized by the types of the
1019 template<typename _Derived>
1020 struct _RangeAdaptor
1022 // Partially apply the arguments __args to the range adaptor _Derived,
1023 // returning a range adaptor closure object.
1024 template<typename... _Args>
1025 requires __adaptor_partial_app_viable<_Derived, _Args...>
1027 operator()(_Args&&... __args) const
1029 return _Partial<_Derived, decay_t<_Args>...>{0, std::forward<_Args>(__args)...};
1033 // True if the range adaptor closure _Adaptor has a simple operator(), i.e.
1034 // one that's not overloaded according to constness or value category of the
1036 template<typename _Adaptor>
1037 concept __closure_has_simple_call_op = _Adaptor::_S_has_simple_call_op;
1039 // True if the behavior of the range adaptor non-closure _Adaptor is
1040 // independent of the value category of its extra arguments _Args.
1041 template<typename _Adaptor, typename... _Args>
1042 concept __adaptor_has_simple_extra_args = _Adaptor::_S_has_simple_extra_args
1043 || _Adaptor::template _S_has_simple_extra_args<_Args...>;
1045 // A range adaptor closure that represents partial application of
1046 // the range adaptor _Adaptor with arguments _Args.
1047 template<typename _Adaptor, typename... _Args>
1048 struct _Partial : _RangeAdaptorClosure<_Partial<_Adaptor, _Args...>>
1050 tuple<_Args...> _M_args;
1052 // First parameter is to ensure this constructor is never used
1053 // instead of the copy/move constructor.
1054 template<typename... _Ts>
1056 _Partial(int, _Ts&&... __args)
1057 : _M_args(std::forward<_Ts>(__args)...)
1060 // Invoke _Adaptor with arguments __r, _M_args... according to the
1061 // value category of this _Partial object.
1062#if __cpp_explicit_this_parameter
1063 template<typename _Self, typename _Range>
1064 requires __adaptor_invocable<_Adaptor, _Range, __like_t<_Self, _Args>...>
1066 operator()(this _Self&& __self, _Range&& __r)
1068 auto __forwarder = [&__r] (auto&&... __args) {
1069 return _Adaptor{}(std::forward<_Range>(__r),
1070 std::forward<decltype(__args)>(__args)...);
1072 return std::apply(__forwarder, __like_t<_Self, _Partial>(__self)._M_args);
1075 template<typename _Range>
1076 requires __adaptor_invocable<_Adaptor, _Range, const _Args&...>
1078 operator()(_Range&& __r) const &
1080 auto __forwarder = [&__r] (const auto&... __args) {
1081 return _Adaptor{}(std::forward<_Range>(__r), __args...);
1083 return std::apply(__forwarder, _M_args);
1086 template<typename _Range>
1087 requires __adaptor_invocable<_Adaptor, _Range, _Args...>
1089 operator()(_Range&& __r) &&
1091 auto __forwarder = [&__r] (auto&... __args) {
1092 return _Adaptor{}(std::forward<_Range>(__r), std::move(__args)...);
1094 return std::apply(__forwarder, _M_args);
1097 template<typename _Range>
1099 operator()(_Range&& __r) const && = delete;
1103 // A lightweight specialization of the above primary template for
1104 // the common case where _Adaptor accepts a single extra argument.
1105 template<typename _Adaptor, typename _Arg>
1106 struct _Partial<_Adaptor, _Arg> : _RangeAdaptorClosure<_Partial<_Adaptor, _Arg>>
1110 template<typename _Tp>
1112 _Partial(int, _Tp&& __arg)
1113 : _M_arg(std::forward<_Tp>(__arg))
1116#if __cpp_explicit_this_parameter
1117 template<typename _Self, typename _Range>
1118 requires __adaptor_invocable<_Adaptor, _Range, __like_t<_Self, _Arg>>
1120 operator()(this _Self&& __self, _Range&& __r)
1122 return _Adaptor{}(std::forward<_Range>(__r),
1123 __like_t<_Self, _Partial>(__self)._M_arg);
1126 template<typename _Range>
1127 requires __adaptor_invocable<_Adaptor, _Range, const _Arg&>
1129 operator()(_Range&& __r) const &
1130 { return _Adaptor{}(std::forward<_Range>(__r), _M_arg); }
1132 template<typename _Range>
1133 requires __adaptor_invocable<_Adaptor, _Range, _Arg>
1135 operator()(_Range&& __r) &&
1136 { return _Adaptor{}(std::forward<_Range>(__r), std::move(_M_arg)); }
1138 template<typename _Range>
1140 operator()(_Range&& __r) const && = delete;
1144 // Partial specialization of the primary template for the case where the extra
1145 // arguments of the adaptor can always be safely and efficiently forwarded by
1146 // const reference. This lets us get away with a single operator() overload,
1147 // which makes overload resolution failure diagnostics more concise.
1148 template<typename _Adaptor, typename... _Args>
1149 requires __adaptor_has_simple_extra_args<_Adaptor, _Args...>
1150 && (is_trivially_copy_constructible_v<_Args> && ...)
1151 struct _Partial<_Adaptor, _Args...> : _RangeAdaptorClosure<_Partial<_Adaptor, _Args...>>
1153 tuple<_Args...> _M_args;
1155 template<typename... _Ts>
1157 _Partial(int, _Ts&&... __args)
1158 : _M_args(std::forward<_Ts>(__args)...)
1161 // Invoke _Adaptor with arguments __r, const _M_args&... regardless
1162 // of the value category of this _Partial object.
1163 template<typename _Range>
1164 requires __adaptor_invocable<_Adaptor, _Range, const _Args&...>
1166 operator()(_Range&& __r) const
1168 auto __forwarder = [&__r] (const auto&... __args) {
1169 return _Adaptor{}(std::forward<_Range>(__r), __args...);
1171 return std::apply(__forwarder, _M_args);
1174 static constexpr bool _S_has_simple_call_op = true;
1177 // A lightweight specialization of the above template for the common case
1178 // where _Adaptor accepts a single extra argument.
1179 template<typename _Adaptor, typename _Arg>
1180 requires __adaptor_has_simple_extra_args<_Adaptor, _Arg>
1181 && is_trivially_copy_constructible_v<_Arg>
1182 struct _Partial<_Adaptor, _Arg> : _RangeAdaptorClosure<_Partial<_Adaptor, _Arg>>
1186 template<typename _Tp>
1188 _Partial(int, _Tp&& __arg)
1189 : _M_arg(std::forward<_Tp>(__arg))
1192 template<typename _Range>
1193 requires __adaptor_invocable<_Adaptor, _Range, const _Arg&>
1195 operator()(_Range&& __r) const
1196 { return _Adaptor{}(std::forward<_Range>(__r), _M_arg); }
1198 static constexpr bool _S_has_simple_call_op = true;
1201 template<typename _Lhs, typename _Rhs, typename _Range>
1202 concept __pipe_invocable
1203 = requires { std::declval<_Rhs>()(std::declval<_Lhs>()(std::declval<_Range>())); };
1205 // A range adaptor closure that represents composition of the range
1206 // adaptor closures _Lhs and _Rhs.
1207 template<typename _Lhs, typename _Rhs>
1208 struct _Pipe : _RangeAdaptorClosure<_Pipe<_Lhs, _Rhs>>
1210 [[no_unique_address]] _Lhs _M_lhs;
1211 [[no_unique_address]] _Rhs _M_rhs;
1213 template<typename _Tp, typename _Up>
1215 _Pipe(_Tp&& __lhs, _Up&& __rhs)
1216 : _M_lhs(std::forward<_Tp>(__lhs)), _M_rhs(std::forward<_Up>(__rhs))
1219 // Invoke _M_rhs(_M_lhs(__r)) according to the value category of this
1220 // range adaptor closure object.
1221#if __cpp_explicit_this_parameter
1222 template<typename _Self, typename _Range>
1223 requires __pipe_invocable<__like_t<_Self, _Lhs>, __like_t<_Self, _Rhs>, _Range>
1225 operator()(this _Self&& __self, _Range&& __r)
1227 return (__like_t<_Self, _Pipe>(__self)._M_rhs
1228 (__like_t<_Self, _Pipe>(__self)._M_lhs
1229 (std::forward<_Range>(__r))));
1232 template<typename _Range>
1233 requires __pipe_invocable<const _Lhs&, const _Rhs&, _Range>
1235 operator()(_Range&& __r) const &
1236 { return _M_rhs(_M_lhs(std::forward<_Range>(__r))); }
1238 template<typename _Range>
1239 requires __pipe_invocable<_Lhs, _Rhs, _Range>
1241 operator()(_Range&& __r) &&
1242 { return std::move(_M_rhs)(std::move(_M_lhs)(std::forward<_Range>(__r))); }
1244 template<typename _Range>
1246 operator()(_Range&& __r) const && = delete;
1250 // A partial specialization of the above primary template for the case where
1251 // both adaptor operands have a simple operator(). This in turn lets us
1252 // implement composition using a single simple operator(), which makes
1253 // overload resolution failure diagnostics more concise.
1254 template<typename _Lhs, typename _Rhs>
1255 requires __closure_has_simple_call_op<_Lhs>
1256 && __closure_has_simple_call_op<_Rhs>
1257 struct _Pipe<_Lhs, _Rhs> : _RangeAdaptorClosure<_Pipe<_Lhs, _Rhs>>
1259 [[no_unique_address]] _Lhs _M_lhs;
1260 [[no_unique_address]] _Rhs _M_rhs;
1262 template<typename _Tp, typename _Up>
1264 _Pipe(_Tp&& __lhs, _Up&& __rhs)
1265 : _M_lhs(std::forward<_Tp>(__lhs)), _M_rhs(std::forward<_Up>(__rhs))
1268 template<typename _Range>
1269 requires __pipe_invocable<const _Lhs&, const _Rhs&, _Range>
1271 operator()(_Range&& __r) const
1272 { return _M_rhs(_M_lhs(std::forward<_Range>(__r))); }
1274 static constexpr bool _S_has_simple_call_op = true;
1276} // namespace views::__adaptor
1278#if __cpp_lib_ranges >= 202202L
1279 // P2387R3 Pipe support for user-defined range adaptors
1280 template<typename _Derived>
1281 requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
1282 class range_adaptor_closure
1283 : public views::__adaptor::_RangeAdaptorClosure<_Derived>
1287 template<range _Range> requires is_object_v<_Range>
1288 class ref_view : public view_interface<ref_view<_Range>>
1293 static void _S_fun(_Range&); // not defined
1294 static void _S_fun(_Range&&) = delete;
1297 template<__detail::__different_from<ref_view> _Tp>
1298 requires convertible_to<_Tp, _Range&>
1299 && requires { _S_fun(declval<_Tp>()); }
1302 noexcept(noexcept(static_cast<_Range&>(std::declval<_Tp>())))
1303 : _M_r(std::__addressof(static_cast<_Range&>(std::forward<_Tp>(__t))))
1310 constexpr iterator_t<_Range>
1312 { return ranges::begin(*_M_r); }
1314 constexpr sentinel_t<_Range>
1316 { return ranges::end(*_M_r); }
1319 empty() const requires requires { ranges::empty(*_M_r); }
1320 { return ranges::empty(*_M_r); }
1323 size() const requires sized_range<_Range>
1324 { return ranges::size(*_M_r); }
1327 data() const requires contiguous_range<_Range>
1328 { return ranges::data(*_M_r); }
1331 template<typename _Range>
1332 ref_view(_Range&) -> ref_view<_Range>;
1334 template<typename _Tp>
1335 inline constexpr bool enable_borrowed_range<ref_view<_Tp>> = true;
1337 template<range _Range>
1338 requires movable<_Range>
1339 && (!__detail::__is_initializer_list<remove_cv_t<_Range>>)
1340 class owning_view : public view_interface<owning_view<_Range>>
1343 _Range _M_r = _Range();
1346 owning_view() requires default_initializable<_Range> = default;
1349 owning_view(_Range&& __t)
1350 noexcept(is_nothrow_move_constructible_v<_Range>)
1351 : _M_r(std::move(__t))
1354 owning_view(owning_view&&) = default;
1355 owning_view& operator=(owning_view&&) = default;
1361 constexpr const _Range&
1362 base() const& noexcept
1367 { return std::move(_M_r); }
1369 constexpr const _Range&&
1370 base() const&& noexcept
1371 { return std::move(_M_r); }
1373 constexpr iterator_t<_Range>
1375 { return ranges::begin(_M_r); }
1377 constexpr sentinel_t<_Range>
1379 { return ranges::end(_M_r); }
1382 begin() const requires range<const _Range>
1383 { return ranges::begin(_M_r); }
1386 end() const requires range<const _Range>
1387 { return ranges::end(_M_r); }
1390 empty() requires requires { ranges::empty(_M_r); }
1391 { return ranges::empty(_M_r); }
1394 empty() const requires requires { ranges::empty(_M_r); }
1395 { return ranges::empty(_M_r); }
1398 size() requires sized_range<_Range>
1399 { return ranges::size(_M_r); }
1402 size() const requires sized_range<const _Range>
1403 { return ranges::size(_M_r); }
1406 data() requires contiguous_range<_Range>
1407 { return ranges::data(_M_r); }
1410 data() const requires contiguous_range<const _Range>
1411 { return ranges::data(_M_r); }
1414 template<typename _Tp>
1415 inline constexpr bool enable_borrowed_range<owning_view<_Tp>>
1416 = enable_borrowed_range<_Tp>;
1422 template<typename _Range>
1423 concept __can_ref_view = requires { ref_view{std::declval<_Range>()}; };
1425 template<typename _Range>
1426 concept __can_owning_view = requires { owning_view{std::declval<_Range>()}; };
1427 } // namespace __detail
1429 struct _All : __adaptor::_RangeAdaptorClosure<_All>
1431 template<typename _Range>
1432 static constexpr bool
1435 if constexpr (view<decay_t<_Range>>)
1436 return is_nothrow_constructible_v<decay_t<_Range>, _Range>;
1437 else if constexpr (__detail::__can_ref_view<_Range>)
1440 return noexcept(owning_view{std::declval<_Range>()});
1443 template<viewable_range _Range>
1444 requires view<decay_t<_Range>>
1445 || __detail::__can_ref_view<_Range>
1446 || __detail::__can_owning_view<_Range>
1448 operator() [[nodiscard]] (_Range&& __r) const
1449 noexcept(_S_noexcept<_Range>())
1451 if constexpr (view<decay_t<_Range>>)
1452 return std::forward<_Range>(__r);
1453 else if constexpr (__detail::__can_ref_view<_Range>)
1454 return ref_view{std::forward<_Range>(__r)};
1456 return owning_view{std::forward<_Range>(__r)};
1459 static constexpr bool _S_has_simple_call_op = true;
1462 inline constexpr _All all;
1464 template<viewable_range _Range>
1465 using all_t = decltype(all(std::declval<_Range>()));
1466 } // namespace views
1470 template<typename _Tp>
1471 struct __non_propagating_cache
1473 // When _Tp is not an object type (e.g. is a reference type), we make
1474 // __non_propagating_cache<_Tp> empty rather than ill-formed so that
1475 // users can easily conditionally declare data members with this type
1476 // (such as join_view::_M_inner).
1479 template<typename _Tp>
1480 requires is_object_v<_Tp>
1481 struct __non_propagating_cache<_Tp>
1482 : protected _Optional_base<_Tp>
1484 __non_propagating_cache() = default;
1487 __non_propagating_cache(const __non_propagating_cache&) noexcept
1491 __non_propagating_cache(__non_propagating_cache&& __other) noexcept
1492 { __other._M_reset(); }
1494 constexpr __non_propagating_cache&
1495 operator=(const __non_propagating_cache& __other) noexcept
1497 if (std::__addressof(__other) != this)
1502 constexpr __non_propagating_cache&
1503 operator=(__non_propagating_cache&& __other) noexcept
1510 constexpr __non_propagating_cache&
1511 operator=(_Tp __val)
1514 this->_M_payload._M_construct(std::move(__val));
1519 operator bool() const noexcept
1520 { return this->_M_is_engaged(); }
1523 operator*() noexcept
1524 { return this->_M_get(); }
1526 constexpr const _Tp&
1527 operator*() const noexcept
1528 { return this->_M_get(); }
1530 template<typename _Iter>
1532 _M_emplace_deref(const _Iter& __i)
1535 auto __f = [] (auto& __x) { return *__x; };
1536 this->_M_payload._M_apply(_Optional_func{__f}, __i);
1537 return this->_M_get();
1540 using _Optional_base<_Tp>::_M_reset;
1543 template<range _Range>
1544 struct _CachedPosition
1547 _M_has_value() const
1550 constexpr iterator_t<_Range>
1551 _M_get(const _Range&) const
1553 __glibcxx_assert(false);
1554 __builtin_unreachable();
1558 _M_set(const _Range&, const iterator_t<_Range>&) const
1562 template<forward_range _Range>
1563 struct _CachedPosition<_Range>
1564 : protected __non_propagating_cache<iterator_t<_Range>>
1567 _M_has_value() const
1568 { return this->_M_is_engaged(); }
1570 constexpr iterator_t<_Range>
1571 _M_get(const _Range&) const
1573 __glibcxx_assert(_M_has_value());
1578 _M_set(const _Range&, const iterator_t<_Range>& __it)
1580 __glibcxx_assert(!_M_has_value());
1581 std::construct_at(std::__addressof(this->_M_payload._M_payload),
1583 this->_M_payload._M_engaged = true;
1587 template<random_access_range _Range>
1588 requires (sizeof(range_difference_t<_Range>)
1589 <= sizeof(iterator_t<_Range>))
1590 struct _CachedPosition<_Range>
1593 range_difference_t<_Range> _M_offset = -1;
1596 _CachedPosition() = default;
1599 _CachedPosition(const _CachedPosition&) = default;
1602 _CachedPosition(_CachedPosition&& __other) noexcept
1603 { *this = std::move(__other); }
1605 constexpr _CachedPosition&
1606 operator=(const _CachedPosition&) = default;
1608 constexpr _CachedPosition&
1609 operator=(_CachedPosition&& __other) noexcept
1611 // Propagate the cached offset, but invalidate the source.
1612 _M_offset = __other._M_offset;
1613 __other._M_offset = -1;
1618 _M_has_value() const
1619 { return _M_offset >= 0; }
1621 constexpr iterator_t<_Range>
1622 _M_get(_Range& __r) const
1624 __glibcxx_assert(_M_has_value());
1625 return ranges::begin(__r) + _M_offset;
1629 _M_set(_Range& __r, const iterator_t<_Range>& __it)
1631 __glibcxx_assert(!_M_has_value());
1632 _M_offset = __it - ranges::begin(__r);
1635 } // namespace __detail
1639 template<typename _Base>
1640 struct __filter_view_iter_cat
1643 template<forward_range _Base>
1644 struct __filter_view_iter_cat<_Base>
1650 using _Cat = typename iterator_traits<iterator_t<_Base>>::iterator_category;
1651 if constexpr (derived_from<_Cat, bidirectional_iterator_tag>)
1652 return bidirectional_iterator_tag{};
1653 else if constexpr (derived_from<_Cat, forward_iterator_tag>)
1654 return forward_iterator_tag{};
1659 using iterator_category = decltype(_S_iter_cat());
1661 } // namespace __detail
1663 template<input_range _Vp,
1664 indirect_unary_predicate<iterator_t<_Vp>> _Pred>
1665 requires view<_Vp> && is_object_v<_Pred>
1666 class filter_view : public view_interface<filter_view<_Vp, _Pred>>
1671 struct _Iterator : __detail::__filter_view_iter_cat<_Vp>
1674 static constexpr auto
1677 if constexpr (bidirectional_range<_Vp>)
1678 return bidirectional_iterator_tag{};
1679 else if constexpr (forward_range<_Vp>)
1680 return forward_iterator_tag{};
1682 return input_iterator_tag{};
1687 using _Vp_iter = iterator_t<_Vp>;
1689 _Vp_iter _M_current = _Vp_iter();
1690 filter_view* _M_parent = nullptr;
1693 using iterator_concept = decltype(_S_iter_concept());
1694 // iterator_category defined in __filter_view_iter_cat
1695 using value_type = range_value_t<_Vp>;
1696 using difference_type = range_difference_t<_Vp>;
1698 _Iterator() requires default_initializable<_Vp_iter> = default;
1701 _Iterator(filter_view* __parent, _Vp_iter __current)
1702 : _M_current(std::move(__current)),
1706 constexpr const _Vp_iter&
1707 base() const & noexcept
1708 { return _M_current; }
1712 { return std::move(_M_current); }
1714 constexpr range_reference_t<_Vp>
1716 { return *_M_current; }
1720 requires __detail::__has_arrow<_Vp_iter>
1721 && copyable<_Vp_iter>
1722 { return _M_current; }
1724 constexpr _Iterator&
1727 _M_current = ranges::find_if(std::move(++_M_current),
1728 ranges::end(_M_parent->_M_base),
1729 std::ref(*_M_parent->_M_pred));
1738 operator++(int) requires forward_range<_Vp>
1745 constexpr _Iterator&
1746 operator--() requires bidirectional_range<_Vp>
1750 while (!std::__invoke(*_M_parent->_M_pred, *_M_current));
1755 operator--(int) requires bidirectional_range<_Vp>
1762 friend constexpr bool
1763 operator==(const _Iterator& __x, const _Iterator& __y)
1764 requires equality_comparable<_Vp_iter>
1765 { return __x._M_current == __y._M_current; }
1767 friend constexpr range_rvalue_reference_t<_Vp>
1768 iter_move(const _Iterator& __i)
1769 noexcept(noexcept(ranges::iter_move(__i._M_current)))
1770 { return ranges::iter_move(__i._M_current); }
1772 friend constexpr void
1773 iter_swap(const _Iterator& __x, const _Iterator& __y)
1774 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1775 requires indirectly_swappable<_Vp_iter>
1776 { ranges::iter_swap(__x._M_current, __y._M_current); }
1782 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
1785 __equal(const _Iterator& __i) const
1786 { return __i._M_current == _M_end; }
1789 _Sentinel() = default;
1792 _Sentinel(filter_view* __parent)
1793 : _M_end(ranges::end(__parent->_M_base))
1796 constexpr sentinel_t<_Vp>
1800 friend constexpr bool
1801 operator==(const _Iterator& __x, const _Sentinel& __y)
1802 { return __y.__equal(__x); }
1805 _Vp _M_base = _Vp();
1806 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
1807 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
1810 filter_view() requires (default_initializable<_Vp>
1811 && default_initializable<_Pred>)
1815 filter_view(_Vp __base, _Pred __pred)
1816 : _M_base(std::move(__base)), _M_pred(std::move(__pred))
1820 base() const& requires copy_constructible<_Vp>
1825 { return std::move(_M_base); }
1827 constexpr const _Pred&
1829 { return *_M_pred; }
1834 if (_M_cached_begin._M_has_value())
1835 return {this, _M_cached_begin._M_get(_M_base)};
1837 __glibcxx_assert(_M_pred.has_value());
1838 auto __it = ranges::find_if(ranges::begin(_M_base),
1839 ranges::end(_M_base),
1840 std::ref(*_M_pred));
1841 _M_cached_begin._M_set(_M_base, __it);
1842 return {this, std::move(__it)};
1848 if constexpr (common_range<_Vp>)
1849 return _Iterator{this, ranges::end(_M_base)};
1851 return _Sentinel{this};
1855 template<typename _Range, typename _Pred>
1856 filter_view(_Range&&, _Pred) -> filter_view<views::all_t<_Range>, _Pred>;
1862 template<typename _Range, typename _Pred>
1863 concept __can_filter_view
1864 = requires { filter_view(std::declval<_Range>(), std::declval<_Pred>()); };
1865 } // namespace __detail
1867 struct _Filter : __adaptor::_RangeAdaptor<_Filter>
1869 template<viewable_range _Range, typename _Pred>
1870 requires __detail::__can_filter_view<_Range, _Pred>
1872 operator() [[nodiscard]] (_Range&& __r, _Pred&& __p) const
1874 return filter_view(std::forward<_Range>(__r), std::forward<_Pred>(__p));
1877 using _RangeAdaptor<_Filter>::operator();
1878 static constexpr int _S_arity = 2;
1879 static constexpr bool _S_has_simple_extra_args = true;
1882 inline constexpr _Filter filter;
1883 } // namespace views
1885#if __cpp_lib_ranges >= 202207L // C++ >= 23
1886 template<input_range _Vp, move_constructible _Fp>
1888 template<input_range _Vp, copy_constructible _Fp>
1890 requires view<_Vp> && is_object_v<_Fp>
1891 && regular_invocable<_Fp&, range_reference_t<_Vp>>
1892 && std::__detail::__can_reference<invoke_result_t<_Fp&,
1893 range_reference_t<_Vp>>>
1894 class transform_view : public view_interface<transform_view<_Vp, _Fp>>
1897 template<bool _Const>
1898 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
1900 template<bool _Const>
1904 template<bool _Const>
1905 requires forward_range<_Base<_Const>>
1906 struct __iter_cat<_Const>
1912 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1913 // 3564. transform_view::iterator<true>::value_type and
1914 // iterator_category should use const F&
1915 using _Base = transform_view::_Base<_Const>;
1916 using _Res = invoke_result_t<__maybe_const_t<_Const, _Fp>&,
1917 range_reference_t<_Base>>;
1918 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1919 // 3798. Rvalue reference and iterator_category
1920 if constexpr (is_reference_v<_Res>)
1923 = typename iterator_traits<iterator_t<_Base>>::iterator_category;
1924 if constexpr (derived_from<_Cat, contiguous_iterator_tag>)
1925 return random_access_iterator_tag{};
1930 return input_iterator_tag{};
1933 using iterator_category = decltype(_S_iter_cat());
1936 template<bool _Const>
1939 template<bool _Const>
1940 struct _Iterator : __iter_cat<_Const>
1943 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
1944 using _Base = transform_view::_Base<_Const>;
1949 if constexpr (random_access_range<_Base>)
1950 return random_access_iterator_tag{};
1951 else if constexpr (bidirectional_range<_Base>)
1952 return bidirectional_iterator_tag{};
1953 else if constexpr (forward_range<_Base>)
1954 return forward_iterator_tag{};
1956 return input_iterator_tag{};
1959 using _Base_iter = iterator_t<_Base>;
1961 _Base_iter _M_current = _Base_iter();
1962 _Parent* _M_parent = nullptr;
1965 using iterator_concept = decltype(_S_iter_concept());
1966 // iterator_category defined in __transform_view_iter_cat
1968 = remove_cvref_t<invoke_result_t<__maybe_const_t<_Const, _Fp>&,
1969 range_reference_t<_Base>>>;
1970 using difference_type = range_difference_t<_Base>;
1972 _Iterator() requires default_initializable<_Base_iter> = default;
1975 _Iterator(_Parent* __parent, _Base_iter __current)
1976 : _M_current(std::move(__current)),
1981 _Iterator(_Iterator<!_Const> __i)
1983 && convertible_to<iterator_t<_Vp>, _Base_iter>
1984 : _M_current(std::move(__i._M_current)), _M_parent(__i._M_parent)
1987 constexpr const _Base_iter&
1988 base() const & noexcept
1989 { return _M_current; }
1991 constexpr _Base_iter
1993 { return std::move(_M_current); }
1995 constexpr decltype(auto)
1997 noexcept(noexcept(std::__invoke(*_M_parent->_M_fun, *_M_current)))
1998 { return std::__invoke(*_M_parent->_M_fun, *_M_current); }
2000 constexpr _Iterator&
2012 operator++(int) requires forward_range<_Base>
2019 constexpr _Iterator&
2020 operator--() requires bidirectional_range<_Base>
2027 operator--(int) requires bidirectional_range<_Base>
2034 constexpr _Iterator&
2035 operator+=(difference_type __n) requires random_access_range<_Base>
2041 constexpr _Iterator&
2042 operator-=(difference_type __n) requires random_access_range<_Base>
2048 constexpr decltype(auto)
2049 operator[](difference_type __n) const
2050 requires random_access_range<_Base>
2051 { return std::__invoke(*_M_parent->_M_fun, _M_current[__n]); }
2053 friend constexpr bool
2054 operator==(const _Iterator& __x, const _Iterator& __y)
2055 requires equality_comparable<_Base_iter>
2056 { return __x._M_current == __y._M_current; }
2058 friend constexpr bool
2059 operator<(const _Iterator& __x, const _Iterator& __y)
2060 requires random_access_range<_Base>
2061 { return __x._M_current < __y._M_current; }
2063 friend constexpr bool
2064 operator>(const _Iterator& __x, const _Iterator& __y)
2065 requires random_access_range<_Base>
2066 { return __y < __x; }
2068 friend constexpr bool
2069 operator<=(const _Iterator& __x, const _Iterator& __y)
2070 requires random_access_range<_Base>
2071 { return !(__y < __x); }
2073 friend constexpr bool
2074 operator>=(const _Iterator& __x, const _Iterator& __y)
2075 requires random_access_range<_Base>
2076 { return !(__x < __y); }
2078#ifdef __cpp_lib_three_way_comparison
2079 friend constexpr auto
2080 operator<=>(const _Iterator& __x, const _Iterator& __y)
2081 requires random_access_range<_Base>
2082 && three_way_comparable<_Base_iter>
2083 { return __x._M_current <=> __y._M_current; }
2086 friend constexpr _Iterator
2087 operator+(_Iterator __i, difference_type __n)
2088 requires random_access_range<_Base>
2089 { return {__i._M_parent, __i._M_current + __n}; }
2091 friend constexpr _Iterator
2092 operator+(difference_type __n, _Iterator __i)
2093 requires random_access_range<_Base>
2094 { return {__i._M_parent, __i._M_current + __n}; }
2096 friend constexpr _Iterator
2097 operator-(_Iterator __i, difference_type __n)
2098 requires random_access_range<_Base>
2099 { return {__i._M_parent, __i._M_current - __n}; }
2101 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2102 // 3483. transform_view::iterator's difference is overconstrained
2103 friend constexpr difference_type
2104 operator-(const _Iterator& __x, const _Iterator& __y)
2105 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
2106 { return __x._M_current - __y._M_current; }
2108 friend constexpr decltype(auto)
2109 iter_move(const _Iterator& __i) noexcept(noexcept(*__i))
2111 if constexpr (is_lvalue_reference_v<decltype(*__i)>)
2112 return std::move(*__i);
2117 friend _Iterator<!_Const>;
2118 template<bool> friend struct _Sentinel;
2121 template<bool _Const>
2125 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
2126 using _Base = transform_view::_Base<_Const>;
2128 template<bool _Const2>
2130 __distance_from(const _Iterator<_Const2>& __i) const
2131 { return _M_end - __i._M_current; }
2133 template<bool _Const2>
2135 __equal(const _Iterator<_Const2>& __i) const
2136 { return __i._M_current == _M_end; }
2138 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2141 _Sentinel() = default;
2144 _Sentinel(sentinel_t<_Base> __end)
2149 _Sentinel(_Sentinel<!_Const> __i)
2151 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2152 : _M_end(std::move(__i._M_end))
2155 constexpr sentinel_t<_Base>
2159 template<bool _Const2>
2160 requires sentinel_for<sentinel_t<_Base>,
2161 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
2162 friend constexpr bool
2163 operator==(const _Iterator<_Const2>& __x, const _Sentinel& __y)
2164 { return __y.__equal(__x); }
2166 template<bool _Const2,
2167 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
2168 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2169 friend constexpr range_difference_t<_Base2>
2170 operator-(const _Iterator<_Const2>& __x, const _Sentinel& __y)
2171 { return -__y.__distance_from(__x); }
2173 template<bool _Const2,
2174 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
2175 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2176 friend constexpr range_difference_t<_Base2>
2177 operator-(const _Sentinel& __y, const _Iterator<_Const2>& __x)
2178 { return __y.__distance_from(__x); }
2180 friend _Sentinel<!_Const>;
2183 _Vp _M_base = _Vp();
2184 [[no_unique_address]] __detail::__box<_Fp> _M_fun;
2187 transform_view() requires (default_initializable<_Vp>
2188 && default_initializable<_Fp>)
2192 transform_view(_Vp __base, _Fp __fun)
2193 : _M_base(std::move(__base)), _M_fun(std::move(__fun))
2197 base() const& requires copy_constructible<_Vp>
2198 { return _M_base ; }
2202 { return std::move(_M_base); }
2204 constexpr _Iterator<false>
2206 { return _Iterator<false>{this, ranges::begin(_M_base)}; }
2208 constexpr _Iterator<true>
2210 requires range<const _Vp>
2211 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
2212 { return _Iterator<true>{this, ranges::begin(_M_base)}; }
2214 constexpr _Sentinel<false>
2216 { return _Sentinel<false>{ranges::end(_M_base)}; }
2218 constexpr _Iterator<false>
2219 end() requires common_range<_Vp>
2220 { return _Iterator<false>{this, ranges::end(_M_base)}; }
2222 constexpr _Sentinel<true>
2224 requires range<const _Vp>
2225 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
2226 { return _Sentinel<true>{ranges::end(_M_base)}; }
2228 constexpr _Iterator<true>
2230 requires common_range<const _Vp>
2231 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
2232 { return _Iterator<true>{this, ranges::end(_M_base)}; }
2235 size() requires sized_range<_Vp>
2236 { return ranges::size(_M_base); }
2239 size() const requires sized_range<const _Vp>
2240 { return ranges::size(_M_base); }
2243 template<typename _Range, typename _Fp>
2244 transform_view(_Range&&, _Fp) -> transform_view<views::all_t<_Range>, _Fp>;
2250 template<typename _Range, typename _Fp>
2251 concept __can_transform_view
2252 = requires { transform_view(std::declval<_Range>(), std::declval<_Fp>()); };
2253 } // namespace __detail
2255 struct _Transform : __adaptor::_RangeAdaptor<_Transform>
2257 template<viewable_range _Range, typename _Fp>
2258 requires __detail::__can_transform_view<_Range, _Fp>
2260 operator() [[nodiscard]] (_Range&& __r, _Fp&& __f) const
2262 return transform_view(std::forward<_Range>(__r), std::forward<_Fp>(__f));
2265 using _RangeAdaptor<_Transform>::operator();
2266 static constexpr int _S_arity = 2;
2267 static constexpr bool _S_has_simple_extra_args = true;
2270 inline constexpr _Transform transform;
2271 } // namespace views
2274 class take_view : public view_interface<take_view<_Vp>>
2277 template<bool _Const>
2278 using _CI = counted_iterator<
2279 iterator_t<__detail::__maybe_const_t<_Const, _Vp>>>;
2281 template<bool _Const>
2285 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2286 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2289 _Sentinel() = default;
2292 _Sentinel(sentinel_t<_Base> __end)
2297 _Sentinel(_Sentinel<!_Const> __s)
2298 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2299 : _M_end(std::move(__s._M_end))
2302 constexpr sentinel_t<_Base>
2306 friend constexpr bool
2307 operator==(const _CI<_Const>& __y, const _Sentinel& __x)
2308 { return __y.count() == 0 || __y.base() == __x._M_end; }
2310 template<bool _OtherConst = !_Const,
2311 typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
2312 requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2313 friend constexpr bool
2314 operator==(const _CI<_OtherConst>& __y, const _Sentinel& __x)
2315 { return __y.count() == 0 || __y.base() == __x._M_end; }
2317 friend _Sentinel<!_Const>;
2320 _Vp _M_base = _Vp();
2321 range_difference_t<_Vp> _M_count = 0;
2324 take_view() requires default_initializable<_Vp> = default;
2327 take_view(_Vp __base, range_difference_t<_Vp> __count)
2328 : _M_base(std::move(__base)), _M_count(std::move(__count))
2332 base() const& requires copy_constructible<_Vp>
2337 { return std::move(_M_base); }
2340 begin() requires (!__detail::__simple_view<_Vp>)
2342 if constexpr (sized_range<_Vp>)
2344 if constexpr (random_access_range<_Vp>)
2345 return ranges::begin(_M_base);
2349 return counted_iterator(ranges::begin(_M_base), __sz);
2353 return counted_iterator(ranges::begin(_M_base), _M_count);
2357 begin() const requires range<const _Vp>
2359 if constexpr (sized_range<const _Vp>)
2361 if constexpr (random_access_range<const _Vp>)
2362 return ranges::begin(_M_base);
2366 return counted_iterator(ranges::begin(_M_base), __sz);
2370 return counted_iterator(ranges::begin(_M_base), _M_count);
2374 end() requires (!__detail::__simple_view<_Vp>)
2376 if constexpr (sized_range<_Vp>)
2378 if constexpr (random_access_range<_Vp>)
2379 return ranges::begin(_M_base) + size();
2381 return default_sentinel;
2384 return _Sentinel<false>{ranges::end(_M_base)};
2388 end() const requires range<const _Vp>
2390 if constexpr (sized_range<const _Vp>)
2392 if constexpr (random_access_range<const _Vp>)
2393 return ranges::begin(_M_base) + size();
2395 return default_sentinel;
2398 return _Sentinel<true>{ranges::end(_M_base)};
2402 size() requires sized_range<_Vp>
2404 auto __n = ranges::size(_M_base);
2405 return std::min(__n, static_cast<decltype(__n)>(_M_count));
2409 size() const requires sized_range<const _Vp>
2411 auto __n = ranges::size(_M_base);
2412 return std::min(__n, static_cast<decltype(__n)>(_M_count));
2416 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2417 // 3447. Deduction guides for take_view and drop_view have different
2419 template<typename _Range>
2420 take_view(_Range&&, range_difference_t<_Range>)
2421 -> take_view<views::all_t<_Range>>;
2423 template<typename _Tp>
2424 inline constexpr bool enable_borrowed_range<take_view<_Tp>>
2425 = enable_borrowed_range<_Tp>;
2431 template<typename _Range>
2432 inline constexpr bool __is_empty_view = false;
2434 template<typename _Tp>
2435 inline constexpr bool __is_empty_view<empty_view<_Tp>> = true;
2437 template<typename _Range>
2438 inline constexpr bool __is_basic_string_view = false;
2440 template<typename _CharT, typename _Traits>
2441 inline constexpr bool __is_basic_string_view<basic_string_view<_CharT, _Traits>>
2444 using ranges::__detail::__is_subrange;
2446 template<typename _Range>
2447 inline constexpr bool __is_iota_view = false;
2449 template<typename _Winc, typename _Bound>
2450 inline constexpr bool __is_iota_view<iota_view<_Winc, _Bound>> = true;
2452 template<typename _Range>
2453 inline constexpr bool __is_repeat_view = false;
2455 template<typename _Range>
2457 __take_of_repeat_view(_Range&&, range_difference_t<_Range>); // defined later
2459 template<typename _Range, typename _Dp>
2460 concept __can_take_view
2461 = requires { take_view(std::declval<_Range>(), std::declval<_Dp>()); };
2462 } // namespace __detail
2464 struct _Take : __adaptor::_RangeAdaptor<_Take>
2466 template<viewable_range _Range, typename _Dp = range_difference_t<_Range>>
2467 requires __detail::__can_take_view<_Range, _Dp>
2469 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n) const
2471 using _Tp = remove_cvref_t<_Range>;
2472 if constexpr (__detail::__is_empty_view<_Tp>)
2474 else if constexpr (random_access_range<_Tp>
2476 && (std::__detail::__is_span<_Tp>
2477 || __detail::__is_basic_string_view<_Tp>
2478 || __detail::__is_subrange<_Tp>
2479 || __detail::__is_iota_view<_Tp>))
2481 __n = std::min<_Dp>(ranges::distance(__r), __n);
2482 auto __begin = ranges::begin(__r);
2483 auto __end = __begin + __n;
2484 if constexpr (std::__detail::__is_span<_Tp>)
2485 return span<typename _Tp::element_type>(__begin, __end);
2486 else if constexpr (__detail::__is_basic_string_view<_Tp>)
2487 return _Tp(__begin, __end);
2488 else if constexpr (__detail::__is_subrange<_Tp>)
2489 return subrange<iterator_t<_Tp>>(__begin, __end);
2491 return iota_view(*__begin, *__end);
2493 else if constexpr (__detail::__is_repeat_view<_Tp>)
2494 return __detail::__take_of_repeat_view(std::forward<_Range>(__r), __n);
2496 return take_view(std::forward<_Range>(__r), __n);
2499 using _RangeAdaptor<_Take>::operator();
2500 static constexpr int _S_arity = 2;
2501 // The count argument of views::take is not always simple -- it can be
2502 // e.g. a move-only class that's implicitly convertible to the difference
2503 // type. But an integer-like count argument is surely simple.
2504 template<typename _Tp>
2505 static constexpr bool _S_has_simple_extra_args
2506 = ranges::__detail::__is_integer_like<_Tp>;
2509 inline constexpr _Take take;
2510 } // namespace views
2512 template<view _Vp, typename _Pred>
2513 requires input_range<_Vp> && is_object_v<_Pred>
2514 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2515 class take_while_view : public view_interface<take_while_view<_Vp, _Pred>>
2517 template<bool _Const>
2521 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2523 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2524 const _Pred* _M_pred = nullptr;
2527 _Sentinel() = default;
2530 _Sentinel(sentinel_t<_Base> __end, const _Pred* __pred)
2531 : _M_end(__end), _M_pred(__pred)
2535 _Sentinel(_Sentinel<!_Const> __s)
2536 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2537 : _M_end(__s._M_end), _M_pred(__s._M_pred)
2540 constexpr sentinel_t<_Base>
2541 base() const { return _M_end; }
2543 friend constexpr bool
2544 operator==(const iterator_t<_Base>& __x, const _Sentinel& __y)
2545 { return __y._M_end == __x || !std::__invoke(*__y._M_pred, *__x); }
2547 template<bool _OtherConst = !_Const,
2548 typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
2549 requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2550 friend constexpr bool
2551 operator==(const iterator_t<_Base2>& __x, const _Sentinel& __y)
2552 { return __y._M_end == __x || !std::__invoke(*__y._M_pred, *__x); }
2554 friend _Sentinel<!_Const>;
2557 _Vp _M_base = _Vp();
2558 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
2561 take_while_view() requires (default_initializable<_Vp>
2562 && default_initializable<_Pred>)
2566 take_while_view(_Vp __base, _Pred __pred)
2567 : _M_base(std::move(__base)), _M_pred(std::move(__pred))
2571 base() const& requires copy_constructible<_Vp>
2576 { return std::move(_M_base); }
2578 constexpr const _Pred&
2580 { return *_M_pred; }
2583 begin() requires (!__detail::__simple_view<_Vp>)
2584 { return ranges::begin(_M_base); }
2587 begin() const requires range<const _Vp>
2588 && indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
2589 { return ranges::begin(_M_base); }
2592 end() requires (!__detail::__simple_view<_Vp>)
2593 { return _Sentinel<false>(ranges::end(_M_base),
2594 std::__addressof(*_M_pred)); }
2597 end() const requires range<const _Vp>
2598 && indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
2599 { return _Sentinel<true>(ranges::end(_M_base),
2600 std::__addressof(*_M_pred)); }
2603 template<typename _Range, typename _Pred>
2604 take_while_view(_Range&&, _Pred)
2605 -> take_while_view<views::all_t<_Range>, _Pred>;
2611 template<typename _Range, typename _Pred>
2612 concept __can_take_while_view
2613 = requires { take_while_view(std::declval<_Range>(), std::declval<_Pred>()); };
2614 } // namespace __detail
2616 struct _TakeWhile : __adaptor::_RangeAdaptor<_TakeWhile>
2618 template<viewable_range _Range, typename _Pred>
2619 requires __detail::__can_take_while_view<_Range, _Pred>
2621 operator() [[nodiscard]] (_Range&& __r, _Pred&& __p) const
2623 return take_while_view(std::forward<_Range>(__r), std::forward<_Pred>(__p));
2626 using _RangeAdaptor<_TakeWhile>::operator();
2627 static constexpr int _S_arity = 2;
2628 static constexpr bool _S_has_simple_extra_args = true;
2631 inline constexpr _TakeWhile take_while;
2632 } // namespace views
2635 class drop_view : public view_interface<drop_view<_Vp>>
2638 _Vp _M_base = _Vp();
2639 range_difference_t<_Vp> _M_count = 0;
2641 // ranges::next(begin(base), count, end(base)) is O(1) if _Vp satisfies
2642 // both random_access_range and sized_range. Otherwise, cache its result.
2643 static constexpr bool _S_needs_cached_begin
2644 = !(random_access_range<const _Vp> && sized_range<const _Vp>);
2645 [[no_unique_address]]
2646 __detail::__maybe_present_t<_S_needs_cached_begin,
2647 __detail::_CachedPosition<_Vp>>
2651 drop_view() requires default_initializable<_Vp> = default;
2654 drop_view(_Vp __base, range_difference_t<_Vp> __count)
2655 : _M_base(std::move(__base)), _M_count(__count)
2656 { __glibcxx_assert(__count >= 0); }
2659 base() const& requires copy_constructible<_Vp>
2664 { return std::move(_M_base); }
2666 // This overload is disabled for simple views with constant-time begin().
2669 requires (!(__detail::__simple_view<_Vp>
2670 && random_access_range<const _Vp>
2671 && sized_range<const _Vp>))
2673 if constexpr (_S_needs_cached_begin)
2674 if (_M_cached_begin._M_has_value())
2675 return _M_cached_begin._M_get(_M_base);
2677 auto __it = ranges::next(ranges::begin(_M_base),
2678 _M_count, ranges::end(_M_base));
2679 if constexpr (_S_needs_cached_begin)
2680 _M_cached_begin._M_set(_M_base, __it);
2684 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2685 // 3482. drop_view's const begin should additionally require sized_range
2688 requires random_access_range<const _Vp> && sized_range<const _Vp>
2690 return ranges::begin(_M_base) + ranges::min(ranges::distance(_M_base),
2695 end() requires (!__detail::__simple_view<_Vp>)
2696 { return ranges::end(_M_base); }
2699 end() const requires range<const _Vp>
2700 { return ranges::end(_M_base); }
2703 size() requires sized_range<_Vp>
2705 const auto __s = ranges::size(_M_base);
2706 const auto __c = static_cast<decltype(__s)>(_M_count);
2707 return __s < __c ? 0 : __s - __c;
2711 size() const requires sized_range<const _Vp>
2713 const auto __s = ranges::size(_M_base);
2714 const auto __c = static_cast<decltype(__s)>(_M_count);
2715 return __s < __c ? 0 : __s - __c;
2719 template<typename _Range>
2720 drop_view(_Range&&, range_difference_t<_Range>)
2721 -> drop_view<views::all_t<_Range>>;
2723 template<typename _Tp>
2724 inline constexpr bool enable_borrowed_range<drop_view<_Tp>>
2725 = enable_borrowed_range<_Tp>;
2731 template<typename _Range>
2733 __drop_of_repeat_view(_Range&&, range_difference_t<_Range>); // defined later
2735 template<typename _Range, typename _Dp>
2736 concept __can_drop_view
2737 = requires { drop_view(std::declval<_Range>(), std::declval<_Dp>()); };
2738 } // namespace __detail
2740 struct _Drop : __adaptor::_RangeAdaptor<_Drop>
2742 template<viewable_range _Range, typename _Dp = range_difference_t<_Range>>
2743 requires __detail::__can_drop_view<_Range, _Dp>
2745 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n) const
2747 using _Tp = remove_cvref_t<_Range>;
2748 if constexpr (__detail::__is_empty_view<_Tp>)
2750 else if constexpr (random_access_range<_Tp>
2752 && (std::__detail::__is_span<_Tp>
2753 || __detail::__is_basic_string_view<_Tp>
2754 || __detail::__is_iota_view<_Tp>
2755 || __detail::__is_subrange<_Tp>))
2757 __n = std::min<_Dp>(ranges::distance(__r), __n);
2758 auto __begin = ranges::begin(__r) + __n;
2759 auto __end = ranges::end(__r);
2760 if constexpr (std::__detail::__is_span<_Tp>)
2761 return span<typename _Tp::element_type>(__begin, __end);
2762 else if constexpr (__detail::__is_subrange<_Tp>)
2764 if constexpr (_Tp::_S_store_size)
2766 using ranges::__detail::__to_unsigned_like;
2767 auto __m = ranges::distance(__r) - __n;
2768 return _Tp(__begin, __end, __to_unsigned_like(__m));
2771 return _Tp(__begin, __end);
2774 return _Tp(__begin, __end);
2776 else if constexpr (__detail::__is_repeat_view<_Tp>)
2777 return __detail::__drop_of_repeat_view(std::forward<_Range>(__r), __n);
2779 return drop_view(std::forward<_Range>(__r), __n);
2782 using _RangeAdaptor<_Drop>::operator();
2783 static constexpr int _S_arity = 2;
2784 template<typename _Tp>
2785 static constexpr bool _S_has_simple_extra_args
2786 = _Take::_S_has_simple_extra_args<_Tp>;
2789 inline constexpr _Drop drop;
2790 } // namespace views
2792 template<view _Vp, typename _Pred>
2793 requires input_range<_Vp> && is_object_v<_Pred>
2794 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2795 class drop_while_view : public view_interface<drop_while_view<_Vp, _Pred>>
2798 _Vp _M_base = _Vp();
2799 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
2800 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
2803 drop_while_view() requires (default_initializable<_Vp>
2804 && default_initializable<_Pred>)
2808 drop_while_view(_Vp __base, _Pred __pred)
2809 : _M_base(std::move(__base)), _M_pred(std::move(__pred))
2813 base() const& requires copy_constructible<_Vp>
2818 { return std::move(_M_base); }
2820 constexpr const _Pred&
2822 { return *_M_pred; }
2827 if (_M_cached_begin._M_has_value())
2828 return _M_cached_begin._M_get(_M_base);
2830 __glibcxx_assert(_M_pred.has_value());
2831 auto __it = ranges::find_if_not(ranges::begin(_M_base),
2832 ranges::end(_M_base),
2833 std::cref(*_M_pred));
2834 _M_cached_begin._M_set(_M_base, __it);
2840 { return ranges::end(_M_base); }
2843 template<typename _Range, typename _Pred>
2844 drop_while_view(_Range&&, _Pred)
2845 -> drop_while_view<views::all_t<_Range>, _Pred>;
2847 template<typename _Tp, typename _Pred>
2848 inline constexpr bool enable_borrowed_range<drop_while_view<_Tp, _Pred>>
2849 = enable_borrowed_range<_Tp>;
2855 template<typename _Range, typename _Pred>
2856 concept __can_drop_while_view
2857 = requires { drop_while_view(std::declval<_Range>(), std::declval<_Pred>()); };
2858 } // namespace __detail
2860 struct _DropWhile : __adaptor::_RangeAdaptor<_DropWhile>
2862 template<viewable_range _Range, typename _Pred>
2863 requires __detail::__can_drop_while_view<_Range, _Pred>
2865 operator() [[nodiscard]] (_Range&& __r, _Pred&& __p) const
2867 return drop_while_view(std::forward<_Range>(__r),
2868 std::forward<_Pred>(__p));
2871 using _RangeAdaptor<_DropWhile>::operator();
2872 static constexpr int _S_arity = 2;
2873 static constexpr bool _S_has_simple_extra_args = true;
2876 inline constexpr _DropWhile drop_while;
2877 } // namespace views
2881 template<typename _Tp>
2883 __as_lvalue(_Tp&& __t)
2884 { return static_cast<_Tp&>(__t); }
2885 } // namespace __detail
2887 template<input_range _Vp>
2888 requires view<_Vp> && input_range<range_reference_t<_Vp>>
2889 class join_view : public view_interface<join_view<_Vp>>
2892 using _InnerRange = range_reference_t<_Vp>;
2894 template<bool _Const>
2895 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2897 template<bool _Const>
2898 using _Outer_iter = iterator_t<_Base<_Const>>;
2900 template<bool _Const>
2901 using _Inner_iter = iterator_t<range_reference_t<_Base<_Const>>>;
2903 template<bool _Const>
2904 static constexpr bool _S_ref_is_glvalue
2905 = is_reference_v<range_reference_t<_Base<_Const>>>;
2907 template<bool _Const>
2911 template<bool _Const>
2912 requires _S_ref_is_glvalue<_Const>
2913 && forward_range<_Base<_Const>>
2914 && forward_range<range_reference_t<_Base<_Const>>>
2915 struct __iter_cat<_Const>
2918 static constexpr auto
2921 using _Outer_iter = join_view::_Outer_iter<_Const>;
2922 using _Inner_iter = join_view::_Inner_iter<_Const>;
2923 using _OuterCat = typename iterator_traits<_Outer_iter>::iterator_category;
2924 using _InnerCat = typename iterator_traits<_Inner_iter>::iterator_category;
2925 if constexpr (derived_from<_OuterCat, bidirectional_iterator_tag>
2926 && derived_from<_InnerCat, bidirectional_iterator_tag>
2927 && common_range<range_reference_t<_Base<_Const>>>)
2928 return bidirectional_iterator_tag{};
2929 else if constexpr (derived_from<_OuterCat, forward_iterator_tag>
2930 && derived_from<_InnerCat, forward_iterator_tag>)
2931 return forward_iterator_tag{};
2933 return input_iterator_tag{};
2936 using iterator_category = decltype(_S_iter_cat());
2939 template<bool _Const>
2942 template<bool _Const>
2943 struct _Iterator : __iter_cat<_Const>
2946 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
2947 using _Base = join_view::_Base<_Const>;
2951 static constexpr bool _S_ref_is_glvalue
2952 = join_view::_S_ref_is_glvalue<_Const>;
2957 auto __update_inner = [this] (const iterator_t<_Base>& __x) -> auto&& {
2958 if constexpr (_S_ref_is_glvalue)
2961 return _M_parent->_M_inner._M_emplace_deref(__x);
2964 _Outer_iter& __outer = _M_get_outer();
2965 for (; __outer != ranges::end(_M_parent->_M_base); ++__outer)
2967 auto&& __inner = __update_inner(__outer);
2968 _M_inner = ranges::begin(__inner);
2969 if (_M_inner != ranges::end(__inner))
2973 if constexpr (_S_ref_is_glvalue)
2977 static constexpr auto
2980 if constexpr (_S_ref_is_glvalue
2981 && bidirectional_range<_Base>
2982 && bidirectional_range<range_reference_t<_Base>>
2983 && common_range<range_reference_t<_Base>>)
2984 return bidirectional_iterator_tag{};
2985 else if constexpr (_S_ref_is_glvalue
2986 && forward_range<_Base>
2987 && forward_range<range_reference_t<_Base>>)
2988 return forward_iterator_tag{};
2990 return input_iterator_tag{};
2993 using _Outer_iter = join_view::_Outer_iter<_Const>;
2994 using _Inner_iter = join_view::_Inner_iter<_Const>;
2996 constexpr _Outer_iter&
2999 if constexpr (forward_range<_Base>)
3002 return *_M_parent->_M_outer;
3005 constexpr const _Outer_iter&
3006 _M_get_outer() const
3008 if constexpr (forward_range<_Base>)
3011 return *_M_parent->_M_outer;
3015 _Iterator(_Parent* __parent, _Outer_iter __outer) requires forward_range<_Base>
3016 : _M_outer(std::move(__outer)), _M_parent(__parent)
3020 _Iterator(_Parent* __parent) requires (!forward_range<_Base>)
3021 : _M_parent(__parent)
3024 [[no_unique_address]]
3025 __detail::__maybe_present_t<forward_range<_Base>, _Outer_iter> _M_outer
3026 = decltype(_M_outer)();
3027 optional<_Inner_iter> _M_inner;
3028 _Parent* _M_parent = nullptr;
3031 using iterator_concept = decltype(_S_iter_concept());
3032 // iterator_category defined in __join_view_iter_cat
3033 using value_type = range_value_t<range_reference_t<_Base>>;
3034 using difference_type
3035 = common_type_t<range_difference_t<_Base>,
3036 range_difference_t<range_reference_t<_Base>>>;
3038 _Iterator() = default;
3041 _Iterator(_Iterator<!_Const> __i)
3043 && convertible_to<iterator_t<_Vp>, _Outer_iter>
3044 && convertible_to<iterator_t<_InnerRange>, _Inner_iter>
3045 : _M_outer(std::move(__i._M_outer)), _M_inner(std::move(__i._M_inner)),
3046 _M_parent(__i._M_parent)
3049 constexpr decltype(auto)
3051 { return **_M_inner; }
3053 // _GLIBCXX_RESOLVE_LIB_DEFECTS
3054 // 3500. join_view::iterator::operator->() is bogus
3055 constexpr _Inner_iter
3057 requires __detail::__has_arrow<_Inner_iter>
3058 && copyable<_Inner_iter>
3059 { return *_M_inner; }
3061 constexpr _Iterator&
3064 auto&& __inner_range = [this] () -> auto&& {
3065 if constexpr (_S_ref_is_glvalue)
3066 return *_M_get_outer();
3068 return *_M_parent->_M_inner;
3070 if (++*_M_inner == ranges::end(__inner_range))
3084 requires _S_ref_is_glvalue && forward_range<_Base>
3085 && forward_range<range_reference_t<_Base>>
3092 constexpr _Iterator&
3094 requires _S_ref_is_glvalue && bidirectional_range<_Base>
3095 && bidirectional_range<range_reference_t<_Base>>
3096 && common_range<range_reference_t<_Base>>
3098 if (_M_outer == ranges::end(_M_parent->_M_base))
3099 _M_inner = ranges::end(__detail::__as_lvalue(*--_M_outer));
3100 while (*_M_inner == ranges::begin(__detail::__as_lvalue(*_M_outer)))
3101 *_M_inner = ranges::end(__detail::__as_lvalue(*--_M_outer));
3108 requires _S_ref_is_glvalue && bidirectional_range<_Base>
3109 && bidirectional_range<range_reference_t<_Base>>
3110 && common_range<range_reference_t<_Base>>
3117 friend constexpr bool
3118 operator==(const _Iterator& __x, const _Iterator& __y)
3119 requires _S_ref_is_glvalue
3120 && forward_range<_Base>
3121 && equality_comparable<_Inner_iter>
3123 return (__x._M_outer == __y._M_outer
3124 && __x._M_inner == __y._M_inner);
3127 friend constexpr decltype(auto)
3128 iter_move(const _Iterator& __i)
3129 noexcept(noexcept(ranges::iter_move(*__i._M_inner)))
3130 { return ranges::iter_move(*__i._M_inner); }
3132 friend constexpr void
3133 iter_swap(const _Iterator& __x, const _Iterator& __y)
3134 noexcept(noexcept(ranges::iter_swap(*__x._M_inner, *__y._M_inner)))
3135 requires indirectly_swappable<_Inner_iter>
3136 { return ranges::iter_swap(*__x._M_inner, *__y._M_inner); }
3138 friend _Iterator<!_Const>;
3139 template<bool> friend struct _Sentinel;
3142 template<bool _Const>
3146 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
3147 using _Base = join_view::_Base<_Const>;
3149 template<bool _Const2>
3151 __equal(const _Iterator<_Const2>& __i) const
3152 { return __i._M_get_outer() == _M_end; }
3154 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
3157 _Sentinel() = default;
3160 _Sentinel(_Parent* __parent)
3161 : _M_end(ranges::end(__parent->_M_base))
3165 _Sentinel(_Sentinel<!_Const> __s)
3166 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
3167 : _M_end(std::move(__s._M_end))
3170 template<bool _Const2>
3171 requires sentinel_for<sentinel_t<_Base>,
3172 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
3173 friend constexpr bool
3174 operator==(const _Iterator<_Const2>& __x, const _Sentinel& __y)
3175 { return __y.__equal(__x); }
3177 friend _Sentinel<!_Const>;
3180 _Vp _M_base = _Vp();
3181 [[no_unique_address]]
3182 __detail::__maybe_present_t<!forward_range<_Vp>,
3183 __detail::__non_propagating_cache<iterator_t<_Vp>>> _M_outer;
3184 [[no_unique_address]]
3185 __detail::__non_propagating_cache<remove_cv_t<_InnerRange>> _M_inner;
3188 join_view() requires default_initializable<_Vp> = default;
3191 join_view(_Vp __base)
3192 : _M_base(std::move(__base))
3196 base() const& requires copy_constructible<_Vp>
3201 { return std::move(_M_base); }
3206 if constexpr (forward_range<_Vp>)
3208 constexpr bool __use_const
3209 = (__detail::__simple_view<_Vp>
3210 && is_reference_v<range_reference_t<_Vp>>);
3211 return _Iterator<__use_const>{this, ranges::begin(_M_base)};
3215 _M_outer = ranges::begin(_M_base);
3216 return _Iterator<false>{this};
3222 requires forward_range<const _Vp>
3223 && is_reference_v<range_reference_t<const _Vp>>
3224 && input_range<range_reference_t<const _Vp>>
3226 return _Iterator<true>{this, ranges::begin(_M_base)};
3232 if constexpr (forward_range<_Vp> && is_reference_v<_InnerRange>
3233 && forward_range<_InnerRange>
3234 && common_range<_Vp> && common_range<_InnerRange>)
3235 return _Iterator<__detail::__simple_view<_Vp>>{this,
3236 ranges::end(_M_base)};
3238 return _Sentinel<__detail::__simple_view<_Vp>>{this};
3243 requires forward_range<const _Vp>
3244 && is_reference_v<range_reference_t<const _Vp>>
3245 && input_range<range_reference_t<const _Vp>>
3247 if constexpr (is_reference_v<range_reference_t<const _Vp>>
3248 && forward_range<range_reference_t<const _Vp>>
3249 && common_range<const _Vp>
3250 && common_range<range_reference_t<const _Vp>>)
3251 return _Iterator<true>{this, ranges::end(_M_base)};
3253 return _Sentinel<true>{this};
3257 template<typename _Range>
3258 explicit join_view(_Range&&) -> join_view<views::all_t<_Range>>;
3264 template<typename _Range>
3265 concept __can_join_view
3266 = requires { join_view<all_t<_Range>>{std::declval<_Range>()}; };
3267 } // namespace __detail
3269 struct _Join : __adaptor::_RangeAdaptorClosure<_Join>
3271 template<viewable_range _Range>
3272 requires __detail::__can_join_view<_Range>
3274 operator() [[nodiscard]] (_Range&& __r) const
3276 // _GLIBCXX_RESOLVE_LIB_DEFECTS
3277 // 3474. Nesting join_views is broken because of CTAD
3278 return join_view<all_t<_Range>>{std::forward<_Range>(__r)};
3281 static constexpr bool _S_has_simple_call_op = true;
3284 inline constexpr _Join join;
3285 } // namespace views
3290 struct __require_constant;
3292 template<typename _Range>
3293 concept __tiny_range = sized_range<_Range>
3295 { typename __require_constant<remove_reference_t<_Range>::size()>; }
3296 && (remove_reference_t<_Range>::size() <= 1);
3298 template<typename _Base>
3299 struct __lazy_split_view_outer_iter_cat
3302 template<forward_range _Base>
3303 struct __lazy_split_view_outer_iter_cat<_Base>
3304 { using iterator_category = input_iterator_tag; };
3306 template<typename _Base>
3307 struct __lazy_split_view_inner_iter_cat
3310 template<forward_range _Base>
3311 struct __lazy_split_view_inner_iter_cat<_Base>
3314 static constexpr auto
3317 using _Cat = typename iterator_traits<iterator_t<_Base>>::iterator_category;
3318 if constexpr (derived_from<_Cat, forward_iterator_tag>)
3319 return forward_iterator_tag{};
3324 using iterator_category = decltype(_S_iter_cat());
3328 template<input_range _Vp, forward_range _Pattern>
3329 requires view<_Vp> && view<_Pattern>
3330 && indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
3332 && (forward_range<_Vp> || __detail::__tiny_range<_Pattern>)
3333 class lazy_split_view : public view_interface<lazy_split_view<_Vp, _Pattern>>
3336 template<bool _Const>
3337 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
3339 template<bool _Const>
3342 template<bool _Const>
3344 : __detail::__lazy_split_view_outer_iter_cat<_Base<_Const>>
3347 using _Parent = __detail::__maybe_const_t<_Const, lazy_split_view>;
3348 using _Base = lazy_split_view::_Base<_Const>;
3352 { return __current() == ranges::end(_M_parent->_M_base) && !_M_trailing_empty; }
3354 // [range.lazy.split.outer] p1
3355 // Many of the following specifications refer to the notional member
3356 // current of outer-iterator. current is equivalent to current_ if
3357 // V models forward_range, and parent_->current_ otherwise.
3359 __current() noexcept
3361 if constexpr (forward_range<_Vp>)
3364 return *_M_parent->_M_current;
3368 __current() const noexcept
3370 if constexpr (forward_range<_Vp>)
3373 return *_M_parent->_M_current;
3376 _Parent* _M_parent = nullptr;
3378 [[no_unique_address]]
3379 __detail::__maybe_present_t<forward_range<_Vp>,
3380 iterator_t<_Base>> _M_current
3381 = decltype(_M_current)();
3382 bool _M_trailing_empty = false;
3385 using iterator_concept = __conditional_t<forward_range<_Base>,
3386 forward_iterator_tag,
3387 input_iterator_tag>;
3388 // iterator_category defined in __lazy_split_view_outer_iter_cat
3389 using difference_type = range_difference_t<_Base>;
3391 struct value_type : view_interface<value_type>
3394 _OuterIter _M_i = _OuterIter();
3396 // _GLIBCXX_RESOLVE_LIB_DEFECTS
3397 // 4013. lazy_split_view::outer-iterator::value_type should not
3398 // provide default constructor
3400 value_type(_OuterIter __i)
3401 : _M_i(std::move(__i))
3407 constexpr _InnerIter<_Const>
3409 { return _InnerIter<_Const>{_M_i}; }
3411 constexpr default_sentinel_t
3412 end() const noexcept
3413 { return default_sentinel; }
3416 _OuterIter() = default;
3419 _OuterIter(_Parent* __parent) requires (!forward_range<_Base>)
3420 : _M_parent(__parent)
3424 _OuterIter(_Parent* __parent, iterator_t<_Base> __current)
3425 requires forward_range<_Base>
3426 : _M_parent(__parent),
3427 _M_current(std::move(__current))
3431 _OuterIter(_OuterIter<!_Const> __i)
3433 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
3434 : _M_parent(__i._M_parent), _M_current(std::move(__i._M_current)),
3435 _M_trailing_empty(__i._M_trailing_empty)
3438 constexpr value_type
3440 { return value_type{*this}; }
3442 constexpr _OuterIter&
3445 // _GLIBCXX_RESOLVE_LIB_DEFECTS
3446 // 3505. lazy_split_view::outer-iterator::operator++ misspecified
3447 const auto __end = ranges::end(_M_parent->_M_base);
3448 if (__current() == __end)
3450 _M_trailing_empty = false;
3453 const auto [__pbegin, __pend] = subrange{_M_parent->_M_pattern};
3454 if (__pbegin == __pend)
3456 else if constexpr (__detail::__tiny_range<_Pattern>)
3458 __current() = ranges::find(std::move(__current()), __end,
3460 if (__current() != __end)
3463 if (__current() == __end)
3464 _M_trailing_empty = true;
3471 = ranges::mismatch(__current(), __end, __pbegin, __pend);
3475 if (__current() == __end)
3476 _M_trailing_empty = true;
3479 } while (++__current() != __end);
3483 constexpr decltype(auto)
3486 if constexpr (forward_range<_Base>)
3496 friend constexpr bool
3497 operator==(const _OuterIter& __x, const _OuterIter& __y)
3498 requires forward_range<_Base>
3500 return __x._M_current == __y._M_current
3501 && __x._M_trailing_empty == __y._M_trailing_empty;
3504 friend constexpr bool
3505 operator==(const _OuterIter& __x, default_sentinel_t)
3506 { return __x.__at_end(); };
3508 friend _OuterIter<!_Const>;
3509 friend _InnerIter<_Const>;
3512 template<bool _Const>
3514 : __detail::__lazy_split_view_inner_iter_cat<_Base<_Const>>
3517 using _Base = lazy_split_view::_Base<_Const>;
3522 auto [__pcur, __pend] = subrange{_M_i._M_parent->_M_pattern};
3523 auto __end = ranges::end(_M_i._M_parent->_M_base);
3524 if constexpr (__detail::__tiny_range<_Pattern>)
3526 const auto& __cur = _M_i_current();
3529 if (__pcur == __pend)
3530 return _M_incremented;
3531 return *__cur == *__pcur;
3535 auto __cur = _M_i_current();
3538 if (__pcur == __pend)
3539 return _M_incremented;
3542 if (*__cur != *__pcur)
3544 if (++__pcur == __pend)
3546 } while (++__cur != __end);
3552 _M_i_current() noexcept
3553 { return _M_i.__current(); }
3556 _M_i_current() const noexcept
3557 { return _M_i.__current(); }
3559 _OuterIter<_Const> _M_i = _OuterIter<_Const>();
3560 bool _M_incremented = false;
3563 using iterator_concept
3564 = typename _OuterIter<_Const>::iterator_concept;
3565 // iterator_category defined in __lazy_split_view_inner_iter_cat
3566 using value_type = range_value_t<_Base>;
3567 using difference_type = range_difference_t<_Base>;
3569 _InnerIter() = default;
3572 _InnerIter(_OuterIter<_Const> __i)
3573 : _M_i(std::move(__i))
3576 constexpr const iterator_t<_Base>&
3577 base() const& noexcept
3578 { return _M_i_current(); }
3580 constexpr iterator_t<_Base>
3581 base() && requires forward_range<_Vp>
3582 { return std::move(_M_i_current()); }
3584 constexpr decltype(auto)
3586 { return *_M_i_current(); }
3588 constexpr _InnerIter&
3591 _M_incremented = true;
3592 if constexpr (!forward_range<_Base>)
3593 if constexpr (_Pattern::size() == 0)
3599 constexpr decltype(auto)
3602 if constexpr (forward_range<_Base>)
3612 friend constexpr bool
3613 operator==(const _InnerIter& __x, const _InnerIter& __y)
3614 requires forward_range<_Base>
3615 { return __x._M_i == __y._M_i; }
3617 friend constexpr bool
3618 operator==(const _InnerIter& __x, default_sentinel_t)
3619 { return __x.__at_end(); }
3621 friend constexpr decltype(auto)
3622 iter_move(const _InnerIter& __i)
3623 noexcept(noexcept(ranges::iter_move(__i._M_i_current())))
3624 { return ranges::iter_move(__i._M_i_current()); }
3626 friend constexpr void
3627 iter_swap(const _InnerIter& __x, const _InnerIter& __y)
3628 noexcept(noexcept(ranges::iter_swap(__x._M_i_current(),
3629 __y._M_i_current())))
3630 requires indirectly_swappable<iterator_t<_Base>>
3631 { ranges::iter_swap(__x._M_i_current(), __y._M_i_current()); }
3634 _Vp _M_base = _Vp();
3635 _Pattern _M_pattern = _Pattern();
3636 [[no_unique_address]]
3637 __detail::__maybe_present_t<!forward_range<_Vp>,
3638 __detail::__non_propagating_cache<iterator_t<_Vp>>> _M_current;
3642 lazy_split_view() requires (default_initializable<_Vp>
3643 && default_initializable<_Pattern>)
3647 lazy_split_view(_Vp __base, _Pattern __pattern)
3648 : _M_base(std::move(__base)), _M_pattern(std::move(__pattern))
3651 template<input_range _Range>
3652 requires constructible_from<_Vp, views::all_t<_Range>>
3653 && constructible_from<_Pattern, single_view<range_value_t<_Range>>>
3655 lazy_split_view(_Range&& __r, range_value_t<_Range> __e)
3656 : _M_base(views::all(std::forward<_Range>(__r))),
3657 _M_pattern(views::single(std::move(__e)))
3661 base() const& requires copy_constructible<_Vp>
3666 { return std::move(_M_base); }
3671 if constexpr (forward_range<_Vp>)
3673 constexpr bool __simple
3674 = __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
3675 return _OuterIter<__simple>{this, ranges::begin(_M_base)};
3679 _M_current = ranges::begin(_M_base);
3680 return _OuterIter<false>{this};
3685 begin() const requires forward_range<_Vp> && forward_range<const _Vp>
3687 return _OuterIter<true>{this, ranges::begin(_M_base)};
3691 end() requires forward_range<_Vp> && common_range<_Vp>
3693 constexpr bool __simple
3694 = __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
3695 return _OuterIter<__simple>{this, ranges::end(_M_base)};
3701 if constexpr (forward_range<_Vp>
3702 && forward_range<const _Vp>
3703 && common_range<const _Vp>)
3704 return _OuterIter<true>{this, ranges::end(_M_base)};
3706 return default_sentinel;
3710 template<typename _Range, typename _Pattern>
3711 lazy_split_view(_Range&&, _Pattern&&)
3712 -> lazy_split_view<views::all_t<_Range>, views::all_t<_Pattern>>;
3714 template<input_range _Range>
3715 lazy_split_view(_Range&&, range_value_t<_Range>)
3716 -> lazy_split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
3722 template<typename _Range, typename _Pattern>
3723 concept __can_lazy_split_view
3724 = requires { lazy_split_view(std::declval<_Range>(), std::declval<_Pattern>()); };
3725 } // namespace __detail
3727 struct _LazySplit : __adaptor::_RangeAdaptor<_LazySplit>
3729 template<viewable_range _Range, typename _Pattern>
3730 requires __detail::__can_lazy_split_view<_Range, _Pattern>
3732 operator() [[nodiscard]] (_Range&& __r, _Pattern&& __f) const
3734 return lazy_split_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
3737 using _RangeAdaptor<_LazySplit>::operator();
3738 static constexpr int _S_arity = 2;
3739 // The pattern argument of views::lazy_split is not always simple -- it can be
3740 // a non-view range, the value category of which affects whether the call
3741 // is well-formed. But a scalar or a view pattern argument is surely
3743 template<typename _Pattern>
3744 static constexpr bool _S_has_simple_extra_args
3745 = is_scalar_v<_Pattern> || (view<_Pattern>
3746 && copy_constructible<_Pattern>);
3749 inline constexpr _LazySplit lazy_split;
3750 } // namespace views
3752 template<forward_range _Vp, forward_range _Pattern>
3753 requires view<_Vp> && view<_Pattern>
3754 && indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
3756 class split_view : public view_interface<split_view<_Vp, _Pattern>>
3759 _Vp _M_base = _Vp();
3760 _Pattern _M_pattern = _Pattern();
3761 __detail::__non_propagating_cache<subrange<iterator_t<_Vp>>> _M_cached_begin;
3767 split_view() requires (default_initializable<_Vp>
3768 && default_initializable<_Pattern>)
3772 split_view(_Vp __base, _Pattern __pattern)
3773 : _M_base(std::move(__base)), _M_pattern(std::move(__pattern))
3776 template<forward_range _Range>
3777 requires constructible_from<_Vp, views::all_t<_Range>>
3778 && constructible_from<_Pattern, single_view<range_value_t<_Range>>>
3780 split_view(_Range&& __r, range_value_t<_Range> __e)
3781 : _M_base(views::all(std::forward<_Range>(__r))),
3782 _M_pattern(views::single(std::move(__e)))
3786 base() const& requires copy_constructible<_Vp>
3791 { return std::move(_M_base); }
3796 if (!_M_cached_begin)
3797 _M_cached_begin = _M_find_next(ranges::begin(_M_base));
3798 return {this, ranges::begin(_M_base), *_M_cached_begin};
3804 if constexpr (common_range<_Vp>)
3805 return _Iterator{this, ranges::end(_M_base), {}};
3807 return _Sentinel{this};
3810 constexpr subrange<iterator_t<_Vp>>
3811 _M_find_next(iterator_t<_Vp> __it)
3813 auto [__b, __e] = ranges::search(subrange(__it, ranges::end(_M_base)), _M_pattern);
3814 if (__b != ranges::end(_M_base) && ranges::empty(_M_pattern))
3826 split_view* _M_parent = nullptr;
3827 iterator_t<_Vp> _M_cur = iterator_t<_Vp>();
3828 subrange<iterator_t<_Vp>> _M_next = subrange<iterator_t<_Vp>>();
3829 bool _M_trailing_empty = false;
3831 friend struct _Sentinel;
3834 using iterator_concept = forward_iterator_tag;
3835 using iterator_category = input_iterator_tag;
3836 using value_type = subrange<iterator_t<_Vp>>;
3837 using difference_type = range_difference_t<_Vp>;
3839 _Iterator() = default;
3842 _Iterator(split_view* __parent,
3843 iterator_t<_Vp> __current,
3844 subrange<iterator_t<_Vp>> __next)
3845 : _M_parent(__parent),
3846 _M_cur(std::move(__current)),
3847 _M_next(std::move(__next))
3850 constexpr iterator_t<_Vp>
3854 constexpr value_type
3856 { return {_M_cur, _M_next.begin()}; }
3858 constexpr _Iterator&
3861 _M_cur = _M_next.begin();
3862 if (_M_cur != ranges::end(_M_parent->_M_base))
3864 _M_cur = _M_next.end();
3865 if (_M_cur == ranges::end(_M_parent->_M_base))
3867 _M_trailing_empty = true;
3868 _M_next = {_M_cur, _M_cur};
3871 _M_next = _M_parent->_M_find_next(_M_cur);
3874 _M_trailing_empty = false;
3886 friend constexpr bool
3887 operator==(const _Iterator& __x, const _Iterator& __y)
3889 return __x._M_cur == __y._M_cur
3890 && __x._M_trailing_empty == __y._M_trailing_empty;
3897 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
3900 _M_equal(const _Iterator& __x) const
3901 { return __x._M_cur == _M_end && !__x._M_trailing_empty; }
3904 _Sentinel() = default;
3907 _Sentinel(split_view* __parent)
3908 : _M_end(ranges::end(__parent->_M_base))
3911 friend constexpr bool
3912 operator==(const _Iterator& __x, const _Sentinel& __y)
3913 { return __y._M_equal(__x); }
3917 template<typename _Range, typename _Pattern>
3918 split_view(_Range&&, _Pattern&&)
3919 -> split_view<views::all_t<_Range>, views::all_t<_Pattern>>;
3921 template<forward_range _Range>
3922 split_view(_Range&&, range_value_t<_Range>)
3923 -> split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
3929 template<typename _Range, typename _Pattern>
3930 concept __can_split_view
3931 = requires { split_view(std::declval<_Range>(), std::declval<_Pattern>()); };
3932 } // namespace __detail
3934 struct _Split : __adaptor::_RangeAdaptor<_Split>
3936 template<viewable_range _Range, typename _Pattern>
3937 requires __detail::__can_split_view<_Range, _Pattern>
3939 operator() [[nodiscard]] (_Range&& __r, _Pattern&& __f) const
3941 return split_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
3944 using _RangeAdaptor<_Split>::operator();
3945 static constexpr int _S_arity = 2;
3946 template<typename _Pattern>
3947 static constexpr bool _S_has_simple_extra_args
3948 = _LazySplit::_S_has_simple_extra_args<_Pattern>;
3951 inline constexpr _Split split;
3952 } // namespace views
3958 template<input_or_output_iterator _Iter>
3960 operator() [[nodiscard]] (_Iter __i, iter_difference_t<_Iter> __n) const
3962 if constexpr (contiguous_iterator<_Iter>)
3963 return span(std::to_address(__i), __n);
3964 else if constexpr (random_access_iterator<_Iter>)
3965 return subrange(__i, __i + __n);
3967 return subrange(counted_iterator(std::move(__i), __n),
3972 inline constexpr _Counted counted{};
3973 } // namespace views
3976 requires (!common_range<_Vp>) && copyable<iterator_t<_Vp>>
3977 class common_view : public view_interface<common_view<_Vp>>
3980 _Vp _M_base = _Vp();
3983 common_view() requires default_initializable<_Vp> = default;
3986 common_view(_Vp __r)
3987 : _M_base(std::move(__r))
3991 base() const& requires copy_constructible<_Vp>
3996 { return std::move(_M_base); }
3998 // _GLIBCXX_RESOLVE_LIB_DEFECTS
3999 // 4012. common_view::begin/end are missing the simple-view check
4001 begin() requires (!__detail::__simple_view<_Vp>)
4003 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
4004 return ranges::begin(_M_base);
4006 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
4007 (ranges::begin(_M_base));
4011 begin() const requires range<const _Vp>
4013 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
4014 return ranges::begin(_M_base);
4016 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
4017 (ranges::begin(_M_base));
4021 end() requires (!__detail::__simple_view<_Vp>)
4023 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
4024 return ranges::begin(_M_base) + ranges::size(_M_base);
4026 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
4027 (ranges::end(_M_base));
4031 end() const requires range<const _Vp>
4033 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
4034 return ranges::begin(_M_base) + ranges::size(_M_base);
4036 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
4037 (ranges::end(_M_base));
4041 size() requires sized_range<_Vp>
4042 { return ranges::size(_M_base); }
4045 size() const requires sized_range<const _Vp>
4046 { return ranges::size(_M_base); }
4049 template<typename _Range>
4050 common_view(_Range&&) -> common_view<views::all_t<_Range>>;
4052 template<typename _Tp>
4053 inline constexpr bool enable_borrowed_range<common_view<_Tp>>
4054 = enable_borrowed_range<_Tp>;
4060 template<typename _Range>
4061 concept __already_common = common_range<_Range>
4062 && requires { views::all(std::declval<_Range>()); };
4064 template<typename _Range>
4065 concept __can_common_view
4066 = requires { common_view{std::declval<_Range>()}; };
4067 } // namespace __detail
4069 struct _Common : __adaptor::_RangeAdaptorClosure<_Common>
4071 template<viewable_range _Range>
4072 requires __detail::__already_common<_Range>
4073 || __detail::__can_common_view<_Range>
4075 operator() [[nodiscard]] (_Range&& __r) const
4077 if constexpr (__detail::__already_common<_Range>)
4078 return views::all(std::forward<_Range>(__r));
4080 return common_view{std::forward<_Range>(__r)};
4083 static constexpr bool _S_has_simple_call_op = true;
4086 inline constexpr _Common common;
4087 } // namespace views
4090 requires bidirectional_range<_Vp>
4091 class reverse_view : public view_interface<reverse_view<_Vp>>
4094 static constexpr bool _S_needs_cached_begin
4095 = !common_range<_Vp> && !(random_access_range<_Vp>
4096 && sized_sentinel_for<sentinel_t<_Vp>,
4099 _Vp _M_base = _Vp();
4100 [[no_unique_address]]
4101 __detail::__maybe_present_t<_S_needs_cached_begin,
4102 __detail::_CachedPosition<_Vp>>
4106 reverse_view() requires default_initializable<_Vp> = default;
4109 reverse_view(_Vp __r)
4110 : _M_base(std::move(__r))
4114 base() const& requires copy_constructible<_Vp>
4119 { return std::move(_M_base); }
4121 constexpr reverse_iterator<iterator_t<_Vp>>
4124 if constexpr (_S_needs_cached_begin)
4125 if (_M_cached_begin._M_has_value())
4126 return std::make_reverse_iterator(_M_cached_begin._M_get(_M_base));
4128 auto __it = ranges::next(ranges::begin(_M_base), ranges::end(_M_base));
4129 if constexpr (_S_needs_cached_begin)
4130 _M_cached_begin._M_set(_M_base, __it);
4131 return std::make_reverse_iterator(std::move(__it));
4135 begin() requires common_range<_Vp>
4136 { return std::make_reverse_iterator(ranges::end(_M_base)); }
4139 begin() const requires common_range<const _Vp>
4140 { return std::make_reverse_iterator(ranges::end(_M_base)); }
4142 constexpr reverse_iterator<iterator_t<_Vp>>
4144 { return std::make_reverse_iterator(ranges::begin(_M_base)); }
4147 end() const requires common_range<const _Vp>
4148 { return std::make_reverse_iterator(ranges::begin(_M_base)); }
4151 size() requires sized_range<_Vp>
4152 { return ranges::size(_M_base); }
4155 size() const requires sized_range<const _Vp>
4156 { return ranges::size(_M_base); }
4159 template<typename _Range>
4160 reverse_view(_Range&&) -> reverse_view<views::all_t<_Range>>;
4162 template<typename _Tp>
4163 inline constexpr bool enable_borrowed_range<reverse_view<_Tp>>
4164 = enable_borrowed_range<_Tp>;
4171 inline constexpr bool __is_reversible_subrange = false;
4173 template<typename _Iter, subrange_kind _Kind>
4174 inline constexpr bool
4175 __is_reversible_subrange<subrange<reverse_iterator<_Iter>,
4176 reverse_iterator<_Iter>,
4180 inline constexpr bool __is_reverse_view = false;
4182 template<typename _Vp>
4183 inline constexpr bool __is_reverse_view<reverse_view<_Vp>> = true;
4185 template<typename _Range>
4186 concept __can_reverse_view
4187 = requires { reverse_view{std::declval<_Range>()}; };
4188 } // namespace __detail
4190 struct _Reverse : __adaptor::_RangeAdaptorClosure<_Reverse>
4192 template<viewable_range _Range>
4193 requires __detail::__is_reverse_view<remove_cvref_t<_Range>>
4194 || __detail::__is_reversible_subrange<remove_cvref_t<_Range>>
4195 || __detail::__can_reverse_view<_Range>
4197 operator() [[nodiscard]] (_Range&& __r) const
4199 using _Tp = remove_cvref_t<_Range>;
4200 if constexpr (__detail::__is_reverse_view<_Tp>)
4201 return std::forward<_Range>(__r).base();
4202 else if constexpr (__detail::__is_reversible_subrange<_Tp>)
4204 using _Iter = decltype(ranges::begin(__r).base());
4205 if constexpr (sized_range<_Tp>)
4206 return subrange<_Iter, _Iter, subrange_kind::sized>
4207 {__r.end().base(), __r.begin().base(), __r.size()};
4209 return subrange<_Iter, _Iter, subrange_kind::unsized>
4210 {__r.end().base(), __r.begin().base()};
4213 return reverse_view{std::forward<_Range>(__r)};
4216 static constexpr bool _S_has_simple_call_op = true;
4219 inline constexpr _Reverse reverse;
4220 } // namespace views
4224#if __cpp_lib_tuple_like // >= C++23
4225 template<typename _Tp, size_t _Nm>
4226 concept __has_tuple_element = __tuple_like<_Tp> && _Nm < tuple_size_v<_Tp>;
4228 template<typename _Tp, size_t _Nm>
4229 concept __has_tuple_element = requires(_Tp __t)
4231 typename tuple_size<_Tp>::type;
4232 requires _Nm < tuple_size_v<_Tp>;
4233 typename tuple_element_t<_Nm, _Tp>;
4234 { std::get<_Nm>(__t) }
4235 -> convertible_to<const tuple_element_t<_Nm, _Tp>&>;
4239 template<typename _Tp, size_t _Nm>
4240 concept __returnable_element
4241 = is_reference_v<_Tp> || move_constructible<tuple_element_t<_Nm, _Tp>>;
4244 template<input_range _Vp, size_t _Nm>
4246 && __detail::__has_tuple_element<range_value_t<_Vp>, _Nm>
4247 && __detail::__has_tuple_element<remove_reference_t<range_reference_t<_Vp>>,
4249 && __detail::__returnable_element<range_reference_t<_Vp>, _Nm>
4250 class elements_view : public view_interface<elements_view<_Vp, _Nm>>
4253 elements_view() requires default_initializable<_Vp> = default;
4256 elements_view(_Vp __base)
4257 : _M_base(std::move(__base))
4261 base() const& requires copy_constructible<_Vp>
4266 { return std::move(_M_base); }
4269 begin() requires (!__detail::__simple_view<_Vp>)
4270 { return _Iterator<false>(ranges::begin(_M_base)); }
4273 begin() const requires range<const _Vp>
4274 { return _Iterator<true>(ranges::begin(_M_base)); }
4277 end() requires (!__detail::__simple_view<_Vp> && !common_range<_Vp>)
4278 { return _Sentinel<false>{ranges::end(_M_base)}; }
4281 end() requires (!__detail::__simple_view<_Vp> && common_range<_Vp>)
4282 { return _Iterator<false>{ranges::end(_M_base)}; }
4285 end() const requires range<const _Vp>
4286 { return _Sentinel<true>{ranges::end(_M_base)}; }
4289 end() const requires common_range<const _Vp>
4290 { return _Iterator<true>{ranges::end(_M_base)}; }
4293 size() requires sized_range<_Vp>
4294 { return ranges::size(_M_base); }
4297 size() const requires sized_range<const _Vp>
4298 { return ranges::size(_M_base); }
4301 template<bool _Const>
4302 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
4304 template<bool _Const>
4308 template<bool _Const>
4309 requires forward_range<_Base<_Const>>
4310 struct __iter_cat<_Const>
4313 static auto _S_iter_cat()
4315 using _Base = elements_view::_Base<_Const>;
4316 using _Cat = typename iterator_traits<iterator_t<_Base>>::iterator_category;
4317 using _Res = decltype((std::get<_Nm>(*std::declval<iterator_t<_Base>>())));
4318 if constexpr (!is_lvalue_reference_v<_Res>)
4319 return input_iterator_tag{};
4320 else if constexpr (derived_from<_Cat, random_access_iterator_tag>)
4321 return random_access_iterator_tag{};
4326 using iterator_category = decltype(_S_iter_cat());
4329 template<bool _Const>
4332 template<bool _Const>
4333 struct _Iterator : __iter_cat<_Const>
4336 using _Base = elements_view::_Base<_Const>;
4338 iterator_t<_Base> _M_current = iterator_t<_Base>();
4340 static constexpr decltype(auto)
4341 _S_get_element(const iterator_t<_Base>& __i)
4343 if constexpr (is_reference_v<range_reference_t<_Base>>)
4344 return std::get<_Nm>(*__i);
4347 using _Et = remove_cv_t<tuple_element_t<_Nm, range_reference_t<_Base>>>;
4348 return static_cast<_Et>(std::get<_Nm>(*__i));
4355 if constexpr (random_access_range<_Base>)
4356 return random_access_iterator_tag{};
4357 else if constexpr (bidirectional_range<_Base>)
4358 return bidirectional_iterator_tag{};
4359 else if constexpr (forward_range<_Base>)
4360 return forward_iterator_tag{};
4362 return input_iterator_tag{};
4365 friend _Iterator<!_Const>;
4368 using iterator_concept = decltype(_S_iter_concept());
4369 // iterator_category defined in elements_view::__iter_cat
4371 = remove_cvref_t<tuple_element_t<_Nm, range_value_t<_Base>>>;
4372 using difference_type = range_difference_t<_Base>;
4374 _Iterator() requires default_initializable<iterator_t<_Base>> = default;
4377 _Iterator(iterator_t<_Base> __current)
4378 : _M_current(std::move(__current))
4382 _Iterator(_Iterator<!_Const> __i)
4383 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
4384 : _M_current(std::move(__i._M_current))
4387 constexpr const iterator_t<_Base>&
4388 base() const& noexcept
4389 { return _M_current; }
4391 constexpr iterator_t<_Base>
4393 { return std::move(_M_current); }
4395 constexpr decltype(auto)
4397 { return _S_get_element(_M_current); }
4399 constexpr _Iterator&
4411 operator++(int) requires forward_range<_Base>
4418 constexpr _Iterator&
4419 operator--() requires bidirectional_range<_Base>
4426 operator--(int) requires bidirectional_range<_Base>
4433 constexpr _Iterator&
4434 operator+=(difference_type __n)
4435 requires random_access_range<_Base>
4441 constexpr _Iterator&
4442 operator-=(difference_type __n)
4443 requires random_access_range<_Base>
4449 constexpr decltype(auto)
4450 operator[](difference_type __n) const
4451 requires random_access_range<_Base>
4452 { return _S_get_element(_M_current + __n); }
4454 friend constexpr bool
4455 operator==(const _Iterator& __x, const _Iterator& __y)
4456 requires equality_comparable<iterator_t<_Base>>
4457 { return __x._M_current == __y._M_current; }
4459 friend constexpr bool
4460 operator<(const _Iterator& __x, const _Iterator& __y)
4461 requires random_access_range<_Base>
4462 { return __x._M_current < __y._M_current; }
4464 friend constexpr bool
4465 operator>(const _Iterator& __x, const _Iterator& __y)
4466 requires random_access_range<_Base>
4467 { return __y._M_current < __x._M_current; }
4469 friend constexpr bool
4470 operator<=(const _Iterator& __x, const _Iterator& __y)
4471 requires random_access_range<_Base>
4472 { return !(__y._M_current > __x._M_current); }
4474 friend constexpr bool
4475 operator>=(const _Iterator& __x, const _Iterator& __y)
4476 requires random_access_range<_Base>
4477 { return !(__x._M_current > __y._M_current); }
4479#ifdef __cpp_lib_three_way_comparison
4480 friend constexpr auto
4481 operator<=>(const _Iterator& __x, const _Iterator& __y)
4482 requires random_access_range<_Base>
4483 && three_way_comparable<iterator_t<_Base>>
4484 { return __x._M_current <=> __y._M_current; }
4487 friend constexpr _Iterator
4488 operator+(const _Iterator& __x, difference_type __y)
4489 requires random_access_range<_Base>
4490 { return _Iterator{__x} += __y; }
4492 friend constexpr _Iterator
4493 operator+(difference_type __x, const _Iterator& __y)
4494 requires random_access_range<_Base>
4495 { return __y + __x; }
4497 friend constexpr _Iterator
4498 operator-(const _Iterator& __x, difference_type __y)
4499 requires random_access_range<_Base>
4500 { return _Iterator{__x} -= __y; }
4502 // _GLIBCXX_RESOLVE_LIB_DEFECTS
4503 // 3483. transform_view::iterator's difference is overconstrained
4504 friend constexpr difference_type
4505 operator-(const _Iterator& __x, const _Iterator& __y)
4506 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
4507 { return __x._M_current - __y._M_current; }
4509 template <bool> friend struct _Sentinel;
4512 template<bool _Const>
4516 template<bool _Const2>
4518 _M_equal(const _Iterator<_Const2>& __x) const
4519 { return __x._M_current == _M_end; }
4521 template<bool _Const2>
4523 _M_distance_from(const _Iterator<_Const2>& __i) const
4524 { return _M_end - __i._M_current; }
4526 using _Base = elements_view::_Base<_Const>;
4527 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
4530 _Sentinel() = default;
4533 _Sentinel(sentinel_t<_Base> __end)
4534 : _M_end(std::move(__end))
4538 _Sentinel(_Sentinel<!_Const> __other)
4540 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
4541 : _M_end(std::move(__other._M_end))
4544 constexpr sentinel_t<_Base>
4548 template<bool _Const2>
4549 requires sentinel_for<sentinel_t<_Base>,
4550 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
4551 friend constexpr bool
4552 operator==(const _Iterator<_Const2>& __x, const _Sentinel& __y)
4553 { return __y._M_equal(__x); }
4555 template<bool _Const2,
4556 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
4557 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
4558 friend constexpr range_difference_t<_Base2>
4559 operator-(const _Iterator<_Const2>& __x, const _Sentinel& __y)
4560 { return -__y._M_distance_from(__x); }
4562 template<bool _Const2,
4563 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
4564 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
4565 friend constexpr range_difference_t<_Base2>
4566 operator-(const _Sentinel& __x, const _Iterator<_Const2>& __y)
4567 { return __x._M_distance_from(__y); }
4569 friend _Sentinel<!_Const>;
4572 _Vp _M_base = _Vp();
4575 template<typename _Tp, size_t _Nm>
4576 inline constexpr bool enable_borrowed_range<elements_view<_Tp, _Nm>>
4577 = enable_borrowed_range<_Tp>;
4579 // _GLIBCXX_RESOLVE_LIB_DEFECTS
4580 // 3563. keys_view example is broken
4581 template<typename _Range>
4582 using keys_view = elements_view<_Range, 0>;
4584 template<typename _Range>
4585 using values_view = elements_view<_Range, 1>;
4591 template<size_t _Nm, typename _Range>
4592 concept __can_elements_view
4593 = requires { elements_view<all_t<_Range>, _Nm>{std::declval<_Range>()}; };
4594 } // namespace __detail
4596 template<size_t _Nm>
4597 struct _Elements : __adaptor::_RangeAdaptorClosure<_Elements<_Nm>>
4599 template<viewable_range _Range>
4600 requires __detail::__can_elements_view<_Nm, _Range>
4602 operator() [[nodiscard]] (_Range&& __r) const
4604 return elements_view<all_t<_Range>, _Nm>{std::forward<_Range>(__r)};
4607 static constexpr bool _S_has_simple_call_op = true;
4610 template<size_t _Nm>
4611 inline constexpr _Elements<_Nm> elements;
4612 inline constexpr auto keys = elements<0>;
4613 inline constexpr auto values = elements<1>;
4614 } // namespace views
4616#ifdef __cpp_lib_ranges_zip // C++ >= 23
4619 template<typename... _Rs>
4620 concept __zip_is_common = (sizeof...(_Rs) == 1 && (common_range<_Rs> && ...))
4621 || (!(bidirectional_range<_Rs> && ...) && (common_range<_Rs> && ...))
4622 || ((random_access_range<_Rs> && ...) && (sized_range<_Rs> && ...));
4624 template<typename _Fp, typename _Tuple>
4626 __tuple_transform(_Fp&& __f, _Tuple&& __tuple)
4628 return std::apply([&]<typename... _Ts>(_Ts&&... __elts) {
4629 return tuple<invoke_result_t<_Fp&, _Ts>...>
4630 (std::__invoke(__f, std::forward<_Ts>(__elts))...);
4631 }, std::forward<_Tuple>(__tuple));
4634 template<typename _Fp, typename _Tuple>
4636 __tuple_for_each(_Fp&& __f, _Tuple&& __tuple)
4638 std::apply([&]<typename... _Ts>(_Ts&&... __elts) {
4639 (std::__invoke(__f, std::forward<_Ts>(__elts)), ...);
4640 }, std::forward<_Tuple>(__tuple));
4642 } // namespace __detail
4644 template<input_range... _Vs>
4645 requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0)
4646 class zip_view : public view_interface<zip_view<_Vs...>>
4648 tuple<_Vs...> _M_views;
4650 template<bool> class _Iterator;
4651 template<bool> class _Sentinel;
4654 zip_view() = default;
4657 zip_view(_Vs... __views)
4658 : _M_views(std::move(__views)...)
4662 begin() requires (!(__detail::__simple_view<_Vs> && ...))
4663 { return _Iterator<false>(__detail::__tuple_transform(ranges::begin, _M_views)); }
4666 begin() const requires (range<const _Vs> && ...)
4667 { return _Iterator<true>(__detail::__tuple_transform(ranges::begin, _M_views)); }
4670 end() requires (!(__detail::__simple_view<_Vs> && ...))
4672 if constexpr (!__detail::__zip_is_common<_Vs...>)
4673 return _Sentinel<false>(__detail::__tuple_transform(ranges::end, _M_views));
4674 else if constexpr ((random_access_range<_Vs> && ...))
4675 return begin() + iter_difference_t<_Iterator<false>>(size());
4677 return _Iterator<false>(__detail::__tuple_transform(ranges::end, _M_views));
4681 end() const requires (range<const _Vs> && ...)
4683 if constexpr (!__detail::__zip_is_common<const _Vs...>)
4684 return _Sentinel<true>(__detail::__tuple_transform(ranges::end, _M_views));
4685 else if constexpr ((random_access_range<const _Vs> && ...))
4686 return begin() + iter_difference_t<_Iterator<true>>(size());
4688 return _Iterator<true>(__detail::__tuple_transform(ranges::end, _M_views));
4692 size() requires (sized_range<_Vs> && ...)
4694 return std::apply([](auto... sizes) {
4695 using _CT = __detail::__make_unsigned_like_t<common_type_t<decltype(sizes)...>>;
4696 return ranges::min({_CT(sizes)...});
4697 }, __detail::__tuple_transform(ranges::size, _M_views));
4701 size() const requires (sized_range<const _Vs> && ...)
4703 return std::apply([](auto... sizes) {
4704 using _CT = __detail::__make_unsigned_like_t<common_type_t<decltype(sizes)...>>;
4705 return ranges::min({_CT(sizes)...});
4706 }, __detail::__tuple_transform(ranges::size, _M_views));
4710 template<typename... _Rs>
4711 zip_view(_Rs&&...) -> zip_view<views::all_t<_Rs>...>;
4713 template<typename... _Views>
4714 inline constexpr bool enable_borrowed_range<zip_view<_Views...>>
4715 = (enable_borrowed_range<_Views> && ...);
4719 template<bool _Const, typename... _Vs>
4720 concept __all_random_access
4721 = (random_access_range<__maybe_const_t<_Const, _Vs>> && ...);
4723 template<bool _Const, typename... _Vs>
4724 concept __all_bidirectional
4725 = (bidirectional_range<__maybe_const_t<_Const, _Vs>> && ...);
4727 template<bool _Const, typename... _Vs>
4728 concept __all_forward
4729 = (forward_range<__maybe_const_t<_Const, _Vs>> && ...);
4731 template<bool _Const, typename... _Views>
4732 struct __zip_view_iter_cat
4735 template<bool _Const, typename... _Views>
4736 requires __all_forward<_Const, _Views...>
4737 struct __zip_view_iter_cat<_Const, _Views...>
4738 { using iterator_category = input_iterator_tag; };
4739 } // namespace __detail
4741 template<input_range... _Vs>
4742 requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0)
4743 template<bool _Const>
4744 class zip_view<_Vs...>::_Iterator
4745 : public __detail::__zip_view_iter_cat<_Const, _Vs...>
4747#ifdef _GLIBCXX_CLANG // LLVM-61763 workaround
4750 tuple<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>...> _M_current;
4753 _Iterator(decltype(_M_current) __current)
4754 : _M_current(std::move(__current))
4760 if constexpr (__detail::__all_random_access<_Const, _Vs...>)
4761 return random_access_iterator_tag{};
4762 else if constexpr (__detail::__all_bidirectional<_Const, _Vs...>)
4763 return bidirectional_iterator_tag{};
4764 else if constexpr (__detail::__all_forward<_Const, _Vs...>)
4765 return forward_iterator_tag{};
4767 return input_iterator_tag{};
4770#ifndef _GLIBCXX_CLANG // LLVM-61763 workaround
4771 template<move_constructible _Fp, input_range... _Ws>
4772 requires (view<_Ws> && ...) && (sizeof...(_Ws) > 0) && is_object_v<_Fp>
4773 && regular_invocable<_Fp&, range_reference_t<_Ws>...>
4774 && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Ws>...>>
4775 friend class zip_transform_view;
4779 // iterator_category defined in __zip_view_iter_cat
4780 using iterator_concept = decltype(_S_iter_concept());
4782 = tuple<range_value_t<__detail::__maybe_const_t<_Const, _Vs>>...>;
4783 using difference_type
4784 = common_type_t<range_difference_t<__detail::__maybe_const_t<_Const, _Vs>>...>;
4786 _Iterator() = default;
4789 _Iterator(_Iterator<!_Const> __i)
4791 && (convertible_to<iterator_t<_Vs>,
4792 iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4793 : _M_current(std::move(__i._M_current))
4799 auto __f = [](auto& __i) -> decltype(auto) {
4802 return __detail::__tuple_transform(__f, _M_current);
4805 constexpr _Iterator&
4808 __detail::__tuple_for_each([](auto& __i) { ++__i; }, _M_current);
4818 requires __detail::__all_forward<_Const, _Vs...>
4825 constexpr _Iterator&
4827 requires __detail::__all_bidirectional<_Const, _Vs...>
4829 __detail::__tuple_for_each([](auto& __i) { --__i; }, _M_current);
4835 requires __detail::__all_bidirectional<_Const, _Vs...>
4842 constexpr _Iterator&
4843 operator+=(difference_type __x)
4844 requires __detail::__all_random_access<_Const, _Vs...>
4846 auto __f = [&]<typename _It>(_It& __i) {
4847 __i += iter_difference_t<_It>(__x);
4849 __detail::__tuple_for_each(__f, _M_current);
4853 constexpr _Iterator&
4854 operator-=(difference_type __x)
4855 requires __detail::__all_random_access<_Const, _Vs...>
4857 auto __f = [&]<typename _It>(_It& __i) {
4858 __i -= iter_difference_t<_It>(__x);
4860 __detail::__tuple_for_each(__f, _M_current);
4865 operator[](difference_type __n) const
4866 requires __detail::__all_random_access<_Const, _Vs...>
4868 auto __f = [&]<typename _It>(_It& __i) -> decltype(auto) {
4869 return __i[iter_difference_t<_It>(__n)];
4871 return __detail::__tuple_transform(__f, _M_current);
4874 friend constexpr bool
4875 operator==(const _Iterator& __x, const _Iterator& __y)
4876 requires (equality_comparable<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4878 if constexpr (__detail::__all_bidirectional<_Const, _Vs...>)
4879 return __x._M_current == __y._M_current;
4881 return [&]<size_t... _Is>(index_sequence<_Is...>) {
4882 return ((std::get<_Is>(__x._M_current) == std::get<_Is>(__y._M_current)) || ...);
4883 }(make_index_sequence<sizeof...(_Vs)>{});
4886 friend constexpr auto
4887 operator<=>(const _Iterator& __x, const _Iterator& __y)
4888 requires __detail::__all_random_access<_Const, _Vs...>
4889 { return __x._M_current <=> __y._M_current; }
4891 friend constexpr _Iterator
4892 operator+(const _Iterator& __i, difference_type __n)
4893 requires __detail::__all_random_access<_Const, _Vs...>
4900 friend constexpr _Iterator
4901 operator+(difference_type __n, const _Iterator& __i)
4902 requires __detail::__all_random_access<_Const, _Vs...>
4909 friend constexpr _Iterator
4910 operator-(const _Iterator& __i, difference_type __n)
4911 requires __detail::__all_random_access<_Const, _Vs...>
4918 friend constexpr difference_type
4919 operator-(const _Iterator& __x, const _Iterator& __y)
4920 requires (sized_sentinel_for<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>,
4921 iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4923 return [&]<size_t... _Is>(index_sequence<_Is...>) {
4924 return ranges::min({difference_type(std::get<_Is>(__x._M_current)
4925 - std::get<_Is>(__y._M_current))...},
4927 [](difference_type __i) {
4928 return __detail::__to_unsigned_like(__i < 0 ? -__i : __i);
4930 }(make_index_sequence<sizeof...(_Vs)>{});
4933 friend constexpr auto
4934 iter_move(const _Iterator& __i)
4935 { return __detail::__tuple_transform(ranges::iter_move, __i._M_current); }
4937 friend constexpr void
4938 iter_swap(const _Iterator& __l, const _Iterator& __r)
4939 requires (indirectly_swappable<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4941 [&]<size_t... _Is>(index_sequence<_Is...>) {
4942 (ranges::iter_swap(std::get<_Is>(__l._M_current), std::get<_Is>(__r._M_current)), ...);
4943 }(make_index_sequence<sizeof...(_Vs)>{});
4946 friend class zip_view;
4949 template<input_range... _Vs>
4950 requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0)
4951 template<bool _Const>
4952 class zip_view<_Vs...>::_Sentinel
4954 tuple<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>...> _M_end;
4957 _Sentinel(decltype(_M_end) __end)
4961 friend class zip_view;
4964 _Sentinel() = default;
4967 _Sentinel(_Sentinel<!_Const> __i)
4969 && (convertible_to<sentinel_t<_Vs>,
4970 sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4971 : _M_end(std::move(__i._M_end))
4974 template<bool _OtherConst>
4975 requires (sentinel_for<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>,
4976 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vs>>> && ...)
4977 friend constexpr bool
4978 operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
4980 return [&]<size_t... _Is>(index_sequence<_Is...>) {
4981 return ((std::get<_Is>(__x._M_current) == std::get<_Is>(__y._M_end)) || ...);
4982 }(make_index_sequence<sizeof...(_Vs)>{});
4985 template<bool _OtherConst>
4986 requires (sized_sentinel_for<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>,
4987 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vs>>> && ...)
4988 friend constexpr auto
4989 operator-(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
4992 = common_type_t<range_difference_t<__detail::__maybe_const_t<_OtherConst, _Vs>>...>;
4993 return [&]<size_t... _Is>(index_sequence<_Is...>) {
4994 return ranges::min({_Ret(std::get<_Is>(__x._M_current) - std::get<_Is>(__y._M_end))...},
4997 return __detail::__to_unsigned_like(__i < 0 ? -__i : __i);
4999 }(make_index_sequence<sizeof...(_Vs)>{});
5002 template<bool _OtherConst>
5003 requires (sized_sentinel_for<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>,
5004 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vs>>> && ...)
5005 friend constexpr auto
5006 operator-(const _Sentinel& __y, const _Iterator<_OtherConst>& __x)
5007 { return -(__x - __y); }
5014 template<typename... _Ts>
5015 concept __can_zip_view
5016 = requires { zip_view<all_t<_Ts>...>(std::declval<_Ts>()...); };
5021 template<typename... _Ts>
5022 requires (sizeof...(_Ts) == 0 || __detail::__can_zip_view<_Ts...>)
5024 operator() [[nodiscard]] (_Ts&&... __ts) const
5026 if constexpr (sizeof...(_Ts) == 0)
5027 return views::empty<tuple<>>;
5029 return zip_view<all_t<_Ts>...>(std::forward<_Ts>(__ts)...);
5033 inline constexpr _Zip zip;
5038 template<typename _Range, bool _Const>
5039 using __range_iter_cat
5040 = typename iterator_traits<iterator_t<__maybe_const_t<_Const, _Range>>>::iterator_category;
5043 template<move_constructible _Fp, input_range... _Vs>
5044 requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0) && is_object_v<_Fp>
5045 && regular_invocable<_Fp&, range_reference_t<_Vs>...>
5046 && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Vs>...>>
5047 class zip_transform_view : public view_interface<zip_transform_view<_Fp, _Vs...>>
5049 [[no_unique_address]] __detail::__box<_Fp> _M_fun;
5050 zip_view<_Vs...> _M_zip;
5052 using _InnerView = zip_view<_Vs...>;
5054 template<bool _Const>
5055 using __ziperator = iterator_t<__detail::__maybe_const_t<_Const, _InnerView>>;
5057 template<bool _Const>
5058 using __zentinel = sentinel_t<__detail::__maybe_const_t<_Const, _InnerView>>;
5060 template<bool _Const>
5061 using _Base = __detail::__maybe_const_t<_Const, _InnerView>;
5063 template<bool _Const>
5067 template<bool _Const>
5068 requires forward_range<_Base<_Const>>
5069 struct __iter_cat<_Const>
5075 using __detail::__maybe_const_t;
5076 using __detail::__range_iter_cat;
5077 using _Res = invoke_result_t<__maybe_const_t<_Const, _Fp>&,
5078 range_reference_t<__maybe_const_t<_Const, _Vs>>...>;
5079 // _GLIBCXX_RESOLVE_LIB_DEFECTS
5080 // 3798. Rvalue reference and iterator_category
5081 if constexpr (!is_reference_v<_Res>)
5082 return input_iterator_tag{};
5083 else if constexpr ((derived_from<__range_iter_cat<_Vs, _Const>,
5084 random_access_iterator_tag> && ...))
5085 return random_access_iterator_tag{};
5086 else if constexpr ((derived_from<__range_iter_cat<_Vs, _Const>,
5087 bidirectional_iterator_tag> && ...))
5088 return bidirectional_iterator_tag{};
5089 else if constexpr ((derived_from<__range_iter_cat<_Vs, _Const>,
5090 forward_iterator_tag> && ...))
5091 return forward_iterator_tag{};
5093 return input_iterator_tag{};
5096 using iterator_category = decltype(_S_iter_cat());
5099 template<bool> class _Iterator;
5100 template<bool> class _Sentinel;
5103 zip_transform_view() = default;
5106 zip_transform_view(_Fp __fun, _Vs... __views)
5107 : _M_fun(std::move(__fun)), _M_zip(std::move(__views)...)
5112 { return _Iterator<false>(*this, _M_zip.begin()); }
5116 requires range<const _InnerView>
5117 && regular_invocable<const _Fp&, range_reference_t<const _Vs>...>
5118 { return _Iterator<true>(*this, _M_zip.begin()); }
5123 if constexpr (common_range<_InnerView>)
5124 return _Iterator<false>(*this, _M_zip.end());
5126 return _Sentinel<false>(_M_zip.end());
5131 requires range<const _InnerView>
5132 && regular_invocable<const _Fp&, range_reference_t<const _Vs>...>
5134 if constexpr (common_range<const _InnerView>)
5135 return _Iterator<true>(*this, _M_zip.end());
5137 return _Sentinel<true>(_M_zip.end());
5141 size() requires sized_range<_InnerView>
5142 { return _M_zip.size(); }
5145 size() const requires sized_range<const _InnerView>
5146 { return _M_zip.size(); }
5149 template<class _Fp, class... Rs>
5150 zip_transform_view(_Fp, Rs&&...) -> zip_transform_view<_Fp, views::all_t<Rs>...>;
5152 template<move_constructible _Fp, input_range... _Vs>
5153 requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0) && is_object_v<_Fp>
5154 && regular_invocable<_Fp&, range_reference_t<_Vs>...>
5155 && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Vs>...>>
5156 template<bool _Const>
5157 class zip_transform_view<_Fp, _Vs...>::_Iterator : public __iter_cat<_Const>
5159 using _Parent = __detail::__maybe_const_t<_Const, zip_transform_view>;
5161 _Parent* _M_parent = nullptr;
5162 __ziperator<_Const> _M_inner;
5165 _Iterator(_Parent& __parent, __ziperator<_Const> __inner)
5166 : _M_parent(std::__addressof(__parent)), _M_inner(std::move(__inner))
5169 friend class zip_transform_view;
5172 // iterator_category defined in zip_transform_view::__iter_cat
5173 using iterator_concept = typename __ziperator<_Const>::iterator_concept;
5175 = remove_cvref_t<invoke_result_t<__detail::__maybe_const_t<_Const, _Fp>&,
5176 range_reference_t<__detail::__maybe_const_t<_Const, _Vs>>...>>;
5177 using difference_type = range_difference_t<_Base<_Const>>;
5179 _Iterator() = default;
5182 _Iterator(_Iterator<!_Const> __i)
5183 requires _Const && convertible_to<__ziperator<false>, __ziperator<_Const>>
5184 : _M_parent(__i._M_parent), _M_inner(std::move(__i._M_inner))
5187 constexpr decltype(auto)
5190 return std::apply([&](const auto&... __iters) -> decltype(auto) {
5191 return std::__invoke(*_M_parent->_M_fun, *__iters...);
5192 }, _M_inner._M_current);
5195 constexpr _Iterator&
5207 operator++(int) requires forward_range<_Base<_Const>>
5214 constexpr _Iterator&
5215 operator--() requires bidirectional_range<_Base<_Const>>
5222 operator--(int) requires bidirectional_range<_Base<_Const>>
5229 constexpr _Iterator&
5230 operator+=(difference_type __x) requires random_access_range<_Base<_Const>>
5236 constexpr _Iterator&
5237 operator-=(difference_type __x) requires random_access_range<_Base<_Const>>
5243 constexpr decltype(auto)
5244 operator[](difference_type __n) const requires random_access_range<_Base<_Const>>
5246 return std::apply([&]<typename... _Is>(const _Is&... __iters) -> decltype(auto) {
5247 return std::__invoke(*_M_parent->_M_fun, __iters[iter_difference_t<_Is>(__n)]...);
5248 }, _M_inner._M_current);
5251 friend constexpr bool
5252 operator==(const _Iterator& __x, const _Iterator& __y)
5253 requires equality_comparable<__ziperator<_Const>>
5254 { return __x._M_inner == __y._M_inner; }
5256 friend constexpr auto
5257 operator<=>(const _Iterator& __x, const _Iterator& __y)
5258 requires random_access_range<_Base<_Const>>
5259 { return __x._M_inner <=> __y._M_inner; }
5261 friend constexpr _Iterator
5262 operator+(const _Iterator& __i, difference_type __n)
5263 requires random_access_range<_Base<_Const>>
5264 { return _Iterator(*__i._M_parent, __i._M_inner + __n); }
5266 friend constexpr _Iterator
5267 operator+(difference_type __n, const _Iterator& __i)
5268 requires random_access_range<_Base<_Const>>
5269 { return _Iterator(*__i._M_parent, __i._M_inner + __n); }
5271 friend constexpr _Iterator
5272 operator-(const _Iterator& __i, difference_type __n)
5273 requires random_access_range<_Base<_Const>>
5274 { return _Iterator(*__i._M_parent, __i._M_inner - __n); }
5276 friend constexpr difference_type
5277 operator-(const _Iterator& __x, const _Iterator& __y)
5278 requires sized_sentinel_for<__ziperator<_Const>, __ziperator<_Const>>
5279 { return __x._M_inner - __y._M_inner; }
5282 template<move_constructible _Fp, input_range... _Vs>
5283 requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0) && is_object_v<_Fp>
5284 && regular_invocable<_Fp&, range_reference_t<_Vs>...>
5285 && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Vs>...>>
5286 template<bool _Const>
5287 class zip_transform_view<_Fp, _Vs...>::_Sentinel
5289 __zentinel<_Const> _M_inner;
5292 _Sentinel(__zentinel<_Const> __inner)
5296 friend class zip_transform_view;
5299 _Sentinel() = default;
5302 _Sentinel(_Sentinel<!_Const> __i)
5303 requires _Const && convertible_to<__zentinel<false>, __zentinel<_Const>>
5304 : _M_inner(std::move(__i._M_inner))
5307 template<bool _OtherConst>
5308 requires sentinel_for<__zentinel<_Const>, __ziperator<_OtherConst>>
5309 friend constexpr bool
5310 operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
5311 { return __x._M_inner == __y._M_inner; }
5313 template<bool _OtherConst>
5314 requires sized_sentinel_for<__zentinel<_Const>, __ziperator<_OtherConst>>
5315 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
5316 operator-(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
5317 { return __x._M_inner - __y._M_inner; }
5319 template<bool _OtherConst>
5320 requires sized_sentinel_for<__zentinel<_Const>, __ziperator<_OtherConst>>
5321 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
5322 operator-(const _Sentinel& __x, const _Iterator<_OtherConst>& __y)
5323 { return __x._M_inner - __y._M_inner; }
5330 template<typename _Fp, typename... _Ts>
5331 concept __can_zip_transform_view
5332 = requires { zip_transform_view(std::declval<_Fp>(), std::declval<_Ts>()...); };
5335 struct _ZipTransform
5337 template<typename _Fp>
5338 requires move_constructible<decay_t<_Fp>> && regular_invocable<decay_t<_Fp>&>
5339 && is_object_v<decay_t<invoke_result_t<decay_t<_Fp>&>>>
5341 operator() [[nodiscard]] (_Fp&&) const
5343 return views::empty<decay_t<invoke_result_t<decay_t<_Fp>&>>>;
5346 template<typename _Fp, typename... _Ts>
5347 requires (sizeof...(_Ts) != 0) && __detail::__can_zip_transform_view<_Fp, _Ts...>
5349 operator() [[nodiscard]] (_Fp&& __f, _Ts&&... __ts) const
5351 return zip_transform_view(std::forward<_Fp>(__f), std::forward<_Ts>(__ts)...);
5355 inline constexpr _ZipTransform zip_transform;
5358 template<forward_range _Vp, size_t _Nm>
5359 requires view<_Vp> && (_Nm > 0)
5360 class adjacent_view : public view_interface<adjacent_view<_Vp, _Nm>>
5362 _Vp _M_base = _Vp();
5364 template<bool> class _Iterator;
5365 template<bool> class _Sentinel;
5367 struct __as_sentinel
5371 adjacent_view() requires default_initializable<_Vp> = default;
5374 adjacent_view(_Vp __base)
5375 : _M_base(std::move(__base))
5378 // _GLIBCXX_RESOLVE_LIB_DEFECTS
5379 // 3848. adjacent_view, adjacent_transform_view and slide_view missing base accessor
5381 base() const & requires copy_constructible<_Vp>
5386 { return std::move(_M_base); }
5389 begin() requires (!__detail::__simple_view<_Vp>)
5390 { return _Iterator<false>(ranges::begin(_M_base), ranges::end(_M_base)); }
5393 begin() const requires range<const _Vp>
5394 { return _Iterator<true>(ranges::begin(_M_base), ranges::end(_M_base)); }
5397 end() requires (!__detail::__simple_view<_Vp>)
5399 if constexpr (common_range<_Vp>)
5400 return _Iterator<false>(__as_sentinel{}, ranges::begin(_M_base), ranges::end(_M_base));
5402 return _Sentinel<false>(ranges::end(_M_base));
5406 end() const requires range<const _Vp>
5408 if constexpr (common_range<const _Vp>)
5409 return _Iterator<true>(__as_sentinel{}, ranges::begin(_M_base), ranges::end(_M_base));
5411 return _Sentinel<true>(ranges::end(_M_base));
5415 size() requires sized_range<_Vp>
5417 using _ST = decltype(ranges::size(_M_base));
5418 using _CT = common_type_t<_ST, size_t>;
5419 auto __sz = static_cast<_CT>(ranges::size(_M_base));
5420 __sz -= std::min<_CT>(__sz, _Nm - 1);
5421 return static_cast<_ST>(__sz);
5425 size() const requires sized_range<const _Vp>
5427 using _ST = decltype(ranges::size(_M_base));
5428 using _CT = common_type_t<_ST, size_t>;
5429 auto __sz = static_cast<_CT>(ranges::size(_M_base));
5430 __sz -= std::min<_CT>(__sz, _Nm - 1);
5431 return static_cast<_ST>(__sz);
5435 template<typename _Vp, size_t _Nm>
5436 inline constexpr bool enable_borrowed_range<adjacent_view<_Vp, _Nm>>
5437 = enable_borrowed_range<_Vp>;
5441 // Yields tuple<_Tp, ..., _Tp> with _Nm elements.
5442 template<typename _Tp, size_t _Nm>
5443 using __repeated_tuple = decltype(std::tuple_cat(std::declval<array<_Tp, _Nm>>()));
5445 // For a functor F that is callable with N arguments, the expression
5446 // declval<__unarize<F, N>>(x) is equivalent to declval<F>(x, ..., x).
5447 template<typename _Fp, size_t _Nm>
5450 template<typename... _Ts>
5451 static invoke_result_t<_Fp, _Ts...>
5452 __tuple_apply(const tuple<_Ts...>&); // not defined
5454 template<typename _Tp>
5455 decltype(__tuple_apply(std::declval<__repeated_tuple<_Tp, _Nm>>()))
5456 operator()(_Tp&&); // not defined
5460 template<forward_range _Vp, size_t _Nm>
5461 requires view<_Vp> && (_Nm > 0)
5462 template<bool _Const>
5463 class adjacent_view<_Vp, _Nm>::_Iterator
5465#ifdef _GLIBCXX_CLANG // LLVM-61763 workaround
5468 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
5469 array<iterator_t<_Base>, _Nm> _M_current = array<iterator_t<_Base>, _Nm>();
5472 _Iterator(iterator_t<_Base> __first, sentinel_t<_Base> __last)
5474 for (auto& __i : _M_current)
5477 ranges::advance(__first, 1, __last);
5482 _Iterator(__as_sentinel, iterator_t<_Base> __first, iterator_t<_Base> __last)
5484 if constexpr (!bidirectional_range<_Base>)
5485 for (auto& __it : _M_current)
5488 for (size_t __i = 0; __i < _Nm; ++__i)
5490 _M_current[_Nm - 1 - __i] = __last;
5491 ranges::advance(__last, -1, __first);
5498 if constexpr (random_access_range<_Base>)
5499 return random_access_iterator_tag{};
5500 else if constexpr (bidirectional_range<_Base>)
5501 return bidirectional_iterator_tag{};
5503 return forward_iterator_tag{};
5506 friend class adjacent_view;
5508#ifndef _GLIBCXX_CLANG // LLVM-61763 workaround
5509 template<forward_range _Wp, move_constructible _Fp, size_t _Mm>
5510 requires view<_Wp> && (_Mm > 0) && is_object_v<_Fp>
5511 && regular_invocable<__detail::__unarize<_Fp&, _Mm>, range_reference_t<_Wp>>
5512 && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Mm>,
5513 range_reference_t<_Wp>>>
5514 friend class adjacent_transform_view;
5518 using iterator_category = input_iterator_tag;
5519 using iterator_concept = decltype(_S_iter_concept());
5520 using value_type = conditional_t<_Nm == 2,
5521 pair<range_value_t<_Base>, range_value_t<_Base>>,
5522 __detail::__repeated_tuple<range_value_t<_Base>, _Nm>>;
5523 using difference_type = range_difference_t<_Base>;
5525 _Iterator() = default;
5528 _Iterator(_Iterator<!_Const> __i)
5529 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
5531 for (size_t __j = 0; __j < _Nm; ++__j)
5532 _M_current[__j] = std::move(__i._M_current[__j]);
5538 auto __f = [](auto& __i) -> decltype(auto) { return *__i; };
5539 return __detail::__tuple_transform(__f, _M_current);
5542 constexpr _Iterator&
5545 for (auto& __i : _M_current)
5558 constexpr _Iterator&
5559 operator--() requires bidirectional_range<_Base>
5561 for (auto& __i : _M_current)
5567 operator--(int) requires bidirectional_range<_Base>
5574 constexpr _Iterator&
5575 operator+=(difference_type __x)
5576 requires random_access_range<_Base>
5578 for (auto& __i : _M_current)
5583 constexpr _Iterator&
5584 operator-=(difference_type __x)
5585 requires random_access_range<_Base>
5587 for (auto& __i : _M_current)
5593 operator[](difference_type __n) const
5594 requires random_access_range<_Base>
5596 auto __f = [&](auto& __i) -> decltype(auto) { return __i[__n]; };
5597 return __detail::__tuple_transform(__f, _M_current);
5600 friend constexpr bool
5601 operator==(const _Iterator& __x, const _Iterator& __y)
5602 { return __x._M_current.back() == __y._M_current.back(); }
5604 friend constexpr bool
5605 operator<(const _Iterator& __x, const _Iterator& __y)
5606 requires random_access_range<_Base>
5607 { return __x._M_current.back() < __y._M_current.back(); }
5609 friend constexpr bool
5610 operator>(const _Iterator& __x, const _Iterator& __y)
5611 requires random_access_range<_Base>
5612 { return __y < __x; }
5614 friend constexpr bool
5615 operator<=(const _Iterator& __x, const _Iterator& __y)
5616 requires random_access_range<_Base>
5617 { return !(__y < __x); }
5619 friend constexpr bool
5620 operator>=(const _Iterator& __x, const _Iterator& __y)
5621 requires random_access_range<_Base>
5622 { return !(__x < __y); }
5624 friend constexpr auto
5625 operator<=>(const _Iterator& __x, const _Iterator& __y)
5626 requires random_access_range<_Base>
5627 && three_way_comparable<iterator_t<_Base>>
5628 { return __x._M_current.back() <=> __y._M_current.back(); }
5630 friend constexpr _Iterator
5631 operator+(const _Iterator& __i, difference_type __n)
5632 requires random_access_range<_Base>
5639 friend constexpr _Iterator
5640 operator+(difference_type __n, const _Iterator& __i)
5641 requires random_access_range<_Base>
5648 friend constexpr _Iterator
5649 operator-(const _Iterator& __i, difference_type __n)
5650 requires random_access_range<_Base>
5657 friend constexpr difference_type
5658 operator-(const _Iterator& __x, const _Iterator& __y)
5659 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
5660 { return __x._M_current.back() - __y._M_current.back(); }
5662 friend constexpr auto
5663 iter_move(const _Iterator& __i)
5664 { return __detail::__tuple_transform(ranges::iter_move, __i._M_current); }
5666 friend constexpr void
5667 iter_swap(const _Iterator& __l, const _Iterator& __r)
5668 requires indirectly_swappable<iterator_t<_Base>>
5670 for (size_t __i = 0; __i < _Nm; __i++)
5671 ranges::iter_swap(__l._M_current[__i], __r._M_current[__i]);
5675 template<forward_range _Vp, size_t _Nm>
5676 requires view<_Vp> && (_Nm > 0)
5677 template<bool _Const>
5678 class adjacent_view<_Vp, _Nm>::_Sentinel
5680 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
5682 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
5685 _Sentinel(sentinel_t<_Base> __end)
5689 friend class adjacent_view;
5692 _Sentinel() = default;
5695 _Sentinel(_Sentinel<!_Const> __i)
5696 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
5697 : _M_end(std::move(__i._M_end))
5700 template<bool _OtherConst>
5701 requires sentinel_for<sentinel_t<_Base>,
5702 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
5703 friend constexpr bool
5704 operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
5705 { return __x._M_current.back() == __y._M_end; }
5707 template<bool _OtherConst>
5708 requires sized_sentinel_for<sentinel_t<_Base>,
5709 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
5710 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _Vp>>
5711 operator-(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
5712 { return __x._M_current.back() - __y._M_end; }
5714 template<bool _OtherConst>
5715 requires sized_sentinel_for<sentinel_t<_Base>,
5716 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
5717 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _Vp>>
5718 operator-(const _Sentinel& __y, const _Iterator<_OtherConst>& __x)
5719 { return __y._M_end - __x._M_current.back(); }
5726 template<size_t _Nm, typename _Range>
5727 concept __can_adjacent_view
5728 = requires { adjacent_view<all_t<_Range>, _Nm>(std::declval<_Range>()); };
5731 template<size_t _Nm>
5732 struct _Adjacent : __adaptor::_RangeAdaptorClosure<_Adjacent<_Nm>>
5734 template<viewable_range _Range>
5735 requires (_Nm == 0) || __detail::__can_adjacent_view<_Nm, _Range>
5737 operator() [[nodiscard]] (_Range&& __r) const
5739 if constexpr (_Nm == 0)
5740 return views::empty<tuple<>>;
5742 return adjacent_view<all_t<_Range>, _Nm>(std::forward<_Range>(__r));
5746 template<size_t _Nm>
5747 inline constexpr _Adjacent<_Nm> adjacent;
5749 inline constexpr auto pairwise = adjacent<2>;
5752 template<forward_range _Vp, move_constructible _Fp, size_t _Nm>
5753 requires view<_Vp> && (_Nm > 0) && is_object_v<_Fp>
5754 && regular_invocable<__detail::__unarize<_Fp&, _Nm>, range_reference_t<_Vp>>
5755 && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Nm>,
5756 range_reference_t<_Vp>>>
5757 class adjacent_transform_view : public view_interface<adjacent_transform_view<_Vp, _Fp, _Nm>>
5759 [[no_unique_address]] __detail::__box<_Fp> _M_fun;
5760 adjacent_view<_Vp, _Nm> _M_inner;
5762 using _InnerView = adjacent_view<_Vp, _Nm>;
5764 template<bool _Const>
5765 using _InnerIter = iterator_t<__detail::__maybe_const_t<_Const, _InnerView>>;
5767 template<bool _Const>
5768 using _InnerSent = sentinel_t<__detail::__maybe_const_t<_Const, _InnerView>>;
5770 template<bool> class _Iterator;
5771 template<bool> class _Sentinel;
5774 adjacent_transform_view() = default;
5777 adjacent_transform_view(_Vp __base, _Fp __fun)
5778 : _M_fun(std::move(__fun)), _M_inner(std::move(__base))
5781 // _GLIBCXX_RESOLVE_LIB_DEFECTS
5782 // 3848. adjacent_view, adjacent_transform_view and slide_view missing base accessor
5783 // 3947. Unexpected constraints on adjacent_transform_view::base()
5785 base() const & requires copy_constructible<_Vp>
5786 { return _M_inner.base(); }
5790 { return std::move(_M_inner.base()); }
5794 { return _Iterator<false>(*this, _M_inner.begin()); }
5798 requires range<const _InnerView>
5799 && regular_invocable<__detail::__unarize<const _Fp&, _Nm>,
5800 range_reference_t<const _Vp>>
5801 { return _Iterator<true>(*this, _M_inner.begin()); }
5806 if constexpr (common_range<_InnerView>)
5807 return _Iterator<false>(*this, _M_inner.end());
5809 return _Sentinel<false>(_M_inner.end());
5814 requires range<const _InnerView>
5815 && regular_invocable<__detail::__unarize<const _Fp&, _Nm>,
5816 range_reference_t<const _Vp>>
5818 if constexpr (common_range<const _InnerView>)
5819 return _Iterator<true>(*this, _M_inner.end());
5821 return _Sentinel<true>(_M_inner.end());
5825 size() requires sized_range<_InnerView>
5826 { return _M_inner.size(); }
5829 size() const requires sized_range<const _InnerView>
5830 { return _M_inner.size(); }
5833 template<forward_range _Vp, move_constructible _Fp, size_t _Nm>
5834 requires view<_Vp> && (_Nm > 0) && is_object_v<_Fp>
5835 && regular_invocable<__detail::__unarize<_Fp&, _Nm>, range_reference_t<_Vp>>
5836 && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Nm>,
5837 range_reference_t<_Vp>>>
5838 template<bool _Const>
5839 class adjacent_transform_view<_Vp, _Fp, _Nm>::_Iterator
5841 using _Parent = __detail::__maybe_const_t<_Const, adjacent_transform_view>;
5842 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
5844 _Parent* _M_parent = nullptr;
5845 _InnerIter<_Const> _M_inner;
5848 _Iterator(_Parent& __parent, _InnerIter<_Const> __inner)
5849 : _M_parent(std::__addressof(__parent)), _M_inner(std::move(__inner))
5855 using __detail::__maybe_const_t;
5856 using __detail::__unarize;
5857 using _Res = invoke_result_t<__unarize<__maybe_const_t<_Const, _Fp>&, _Nm>,
5858 range_reference_t<_Base>>;
5859 using _Cat = typename iterator_traits<iterator_t<_Base>>::iterator_category;
5860 // _GLIBCXX_RESOLVE_LIB_DEFECTS
5861 // 3798. Rvalue reference and iterator_category
5862 if constexpr (!is_reference_v<_Res>)
5863 return input_iterator_tag{};
5864 else if constexpr (derived_from<_Cat, random_access_iterator_tag>)
5865 return random_access_iterator_tag{};
5866 else if constexpr (derived_from<_Cat, bidirectional_iterator_tag>)
5867 return bidirectional_iterator_tag{};
5868 else if constexpr (derived_from<_Cat, forward_iterator_tag>)
5869 return forward_iterator_tag{};
5871 return input_iterator_tag{};
5874 friend class adjacent_transform_view;
5877 using iterator_category = decltype(_S_iter_cat());
5878 using iterator_concept = typename _InnerIter<_Const>::iterator_concept;
5880 = remove_cvref_t<invoke_result_t
5881 <__detail::__unarize<__detail::__maybe_const_t<_Const, _Fp>&, _Nm>,
5882 range_reference_t<_Base>>>;
5883 using difference_type = range_difference_t<_Base>;
5885 _Iterator() = default;
5888 _Iterator(_Iterator<!_Const> __i)
5889 requires _Const && convertible_to<_InnerIter<false>, _InnerIter<_Const>>
5890 : _M_parent(__i._M_parent), _M_inner(std::move(__i._M_inner))
5893 constexpr decltype(auto)
5896 return std::apply([&](const auto&... __iters) -> decltype(auto) {
5897 return std::__invoke(*_M_parent->_M_fun, *__iters...);
5898 }, _M_inner._M_current);
5901 constexpr _Iterator&
5916 constexpr _Iterator&
5917 operator--() requires bidirectional_range<_Base>
5924 operator--(int) requires bidirectional_range<_Base>
5931 constexpr _Iterator&
5932 operator+=(difference_type __x) requires random_access_range<_Base>
5938 constexpr _Iterator&
5939 operator-=(difference_type __x) requires random_access_range<_Base>
5945 constexpr decltype(auto)
5946 operator[](difference_type __n) const requires random_access_range<_Base>
5948 return std::apply([&](const auto&... __iters) -> decltype(auto) {
5949 return std::__invoke(*_M_parent->_M_fun, __iters[__n]...);
5950 }, _M_inner._M_current);
5953 friend constexpr bool
5954 operator==(const _Iterator& __x, const _Iterator& __y)
5955 { return __x._M_inner == __y._M_inner; }
5957 friend constexpr bool
5958 operator<(const _Iterator& __x, const _Iterator& __y)
5959 requires random_access_range<_Base>
5960 { return __x._M_inner < __y._M_inner; }
5962 friend constexpr bool
5963 operator>(const _Iterator& __x, const _Iterator& __y)
5964 requires random_access_range<_Base>
5965 { return __x._M_inner > __y._M_inner; }
5967 friend constexpr bool
5968 operator<=(const _Iterator& __x, const _Iterator& __y)
5969 requires random_access_range<_Base>
5970 { return __x._M_inner <= __y._M_inner; }
5972 friend constexpr bool
5973 operator>=(const _Iterator& __x, const _Iterator& __y)
5974 requires random_access_range<_Base>
5975 { return __x._M_inner >= __y._M_inner; }
5977 friend constexpr auto
5978 operator<=>(const _Iterator& __x, const _Iterator& __y)
5979 requires random_access_range<_Base> &&
5980 three_way_comparable<_InnerIter<_Const>>
5981 { return __x._M_inner <=> __y._M_inner; }
5983 friend constexpr _Iterator
5984 operator+(const _Iterator& __i, difference_type __n)
5985 requires random_access_range<_Base>
5986 { return _Iterator(*__i._M_parent, __i._M_inner + __n); }
5988 friend constexpr _Iterator
5989 operator+(difference_type __n, const _Iterator& __i)
5990 requires random_access_range<_Base>
5991 { return _Iterator(*__i._M_parent, __i._M_inner + __n); }
5993 friend constexpr _Iterator
5994 operator-(const _Iterator& __i, difference_type __n)
5995 requires random_access_range<_Base>
5996 { return _Iterator(*__i._M_parent, __i._M_inner - __n); }
5998 friend constexpr difference_type
5999 operator-(const _Iterator& __x, const _Iterator& __y)
6000 requires sized_sentinel_for<_InnerIter<_Const>, _InnerIter<_Const>>
6001 { return __x._M_inner - __y._M_inner; }
6004 template<forward_range _Vp, move_constructible _Fp, size_t _Nm>
6005 requires view<_Vp> && (_Nm > 0) && is_object_v<_Fp>
6006 && regular_invocable<__detail::__unarize<_Fp&, _Nm>, range_reference_t<_Vp>>
6007 && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Nm>,
6008 range_reference_t<_Vp>>>
6009 template<bool _Const>
6010 class adjacent_transform_view<_Vp, _Fp, _Nm>::_Sentinel
6012 _InnerSent<_Const> _M_inner;
6015 _Sentinel(_InnerSent<_Const> __inner)
6019 friend class adjacent_transform_view;
6022 _Sentinel() = default;
6025 _Sentinel(_Sentinel<!_Const> __i)
6026 requires _Const && convertible_to<_InnerSent<false>, _InnerSent<_Const>>
6027 : _M_inner(std::move(__i._M_inner))
6030 template<bool _OtherConst>
6031 requires sentinel_for<_InnerSent<_Const>, _InnerIter<_OtherConst>>
6032 friend constexpr bool
6033 operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
6034 { return __x._M_inner == __y._M_inner; }
6036 template<bool _OtherConst>
6037 requires sized_sentinel_for<_InnerSent<_Const>, _InnerIter<_OtherConst>>
6038 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
6039 operator-(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
6040 { return __x._M_inner - __y._M_inner; }
6042 template<bool _OtherConst>
6043 requires sized_sentinel_for<_InnerSent<_Const>, _InnerIter<_OtherConst>>
6044 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
6045 operator-(const _Sentinel& __x, const _Iterator<_OtherConst>& __y)
6046 { return __x._M_inner - __y._M_inner; }
6053 template<size_t _Nm, typename _Range, typename _Fp>
6054 concept __can_adjacent_transform_view
6055 = requires { adjacent_transform_view<all_t<_Range>, decay_t<_Fp>, _Nm>
6056 (std::declval<_Range>(), std::declval<_Fp>()); };
6059 template<size_t _Nm>
6060 struct _AdjacentTransform : __adaptor::_RangeAdaptor<_AdjacentTransform<_Nm>>
6062 template<viewable_range _Range, typename _Fp>
6063 requires (_Nm == 0) || __detail::__can_adjacent_transform_view<_Nm, _Range, _Fp>
6065 operator() [[nodiscard]] (_Range&& __r, _Fp&& __f) const
6067 if constexpr (_Nm == 0)
6068 return zip_transform(std::forward<_Fp>(__f));
6070 return adjacent_transform_view<all_t<_Range>, decay_t<_Fp>, _Nm>
6071 (std::forward<_Range>(__r), std::forward<_Fp>(__f));
6074 using __adaptor::_RangeAdaptor<_AdjacentTransform>::operator();
6075 static constexpr int _S_arity = 2;
6076 static constexpr bool _S_has_simple_extra_args = true;
6079 template<size_t _Nm>
6080 inline constexpr _AdjacentTransform<_Nm> adjacent_transform;
6082 inline constexpr auto pairwise_transform = adjacent_transform<2>;
6084#endif // __cpp_lib_ranges_zip
6086#ifdef __cpp_lib_ranges_chunk // C++ >= 23
6089 template<typename _Tp>
6090 constexpr _Tp __div_ceil(_Tp __num, _Tp __denom)
6092 _Tp __r = __num / __denom;
6093 if (__num % __denom)
6100 requires input_range<_Vp>
6101 class chunk_view : public view_interface<chunk_view<_Vp>>
6104 range_difference_t<_Vp> _M_n;
6105 range_difference_t<_Vp> _M_remainder = 0;
6106 __detail::__non_propagating_cache<iterator_t<_Vp>> _M_current;
6113 chunk_view(_Vp __base, range_difference_t<_Vp> __n)
6114 : _M_base(std::move(__base)), _M_n(__n)
6115 { __glibcxx_assert(__n >= 0); }
6118 base() const & requires copy_constructible<_Vp>
6123 { return std::move(_M_base); }
6125 constexpr _OuterIter
6128 _M_current = ranges::begin(_M_base);
6129 _M_remainder = _M_n;
6130 return _OuterIter(*this);
6133 constexpr default_sentinel_t
6134 end() const noexcept
6135 { return default_sentinel; }
6138 size() requires sized_range<_Vp>
6140 return __detail::__to_unsigned_like(__detail::__div_ceil
6141 (ranges::distance(_M_base), _M_n));
6145 size() const requires sized_range<const _Vp>
6147 return __detail::__to_unsigned_like(__detail::__div_ceil
6148 (ranges::distance(_M_base), _M_n));
6152 template<typename _Range>
6153 chunk_view(_Range&&, range_difference_t<_Range>) -> chunk_view<views::all_t<_Range>>;
6156 requires input_range<_Vp>
6157 class chunk_view<_Vp>::_OuterIter
6159 chunk_view* _M_parent;
6162 _OuterIter(chunk_view& __parent) noexcept
6163 : _M_parent(std::__addressof(__parent))
6169 using iterator_concept = input_iterator_tag;
6170 using difference_type = range_difference_t<_Vp>;
6174 _OuterIter(_OuterIter&&) = default;
6175 _OuterIter& operator=(_OuterIter&&) = default;
6177 constexpr value_type
6180 __glibcxx_assert(*this != default_sentinel);
6181 return value_type(*_M_parent);
6184 constexpr _OuterIter&
6187 __glibcxx_assert(*this != default_sentinel);
6188 ranges::advance(*_M_parent->_M_current, _M_parent->_M_remainder,
6189 ranges::end(_M_parent->_M_base));
6190 _M_parent->_M_remainder = _M_parent->_M_n;
6198 friend constexpr bool
6199 operator==(const _OuterIter& __x, default_sentinel_t)
6201 return *__x._M_parent->_M_current == ranges::end(__x._M_parent->_M_base)
6202 && __x._M_parent->_M_remainder != 0;
6205 friend constexpr difference_type
6206 operator-(default_sentinel_t, const _OuterIter& __x)
6207 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6209 const auto __dist = ranges::end(__x._M_parent->_M_base) - *__x._M_parent->_M_current;
6211 if (__dist < __x._M_parent->_M_remainder)
6212 return __dist == 0 ? 0 : 1;
6214 return 1 + __detail::__div_ceil(__dist - __x._M_parent->_M_remainder,
6215 __x._M_parent->_M_n);
6218 friend constexpr difference_type
6219 operator-(const _OuterIter& __x, default_sentinel_t __y)
6220 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6221 { return -(__y - __x); }
6225 requires input_range<_Vp>
6226 struct chunk_view<_Vp>::_OuterIter::value_type : view_interface<value_type>
6229 chunk_view* _M_parent;
6232 value_type(chunk_view& __parent) noexcept
6233 : _M_parent(std::__addressof(__parent))
6239 constexpr _InnerIter
6240 begin() const noexcept
6241 { return _InnerIter(*_M_parent); }
6243 constexpr default_sentinel_t
6244 end() const noexcept
6245 { return default_sentinel; }
6249 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6251 return __detail::__to_unsigned_like
6252 (ranges::min(_M_parent->_M_remainder,
6253 ranges::end(_M_parent->_M_base) - *_M_parent->_M_current));
6258 requires input_range<_Vp>
6259 class chunk_view<_Vp>::_InnerIter
6261 chunk_view* _M_parent;
6264 _InnerIter(chunk_view& __parent) noexcept
6265 : _M_parent(std::__addressof(__parent))
6268 friend _OuterIter::value_type;
6271 using iterator_concept = input_iterator_tag;
6272 using difference_type = range_difference_t<_Vp>;
6273 using value_type = range_value_t<_Vp>;
6275 _InnerIter(_InnerIter&&) = default;
6276 _InnerIter& operator=(_InnerIter&&) = default;
6278 constexpr const iterator_t<_Vp>&
6280 { return *_M_parent->_M_current; }
6282 constexpr range_reference_t<_Vp>
6285 __glibcxx_assert(*this != default_sentinel);
6286 return **_M_parent->_M_current;
6289 constexpr _InnerIter&
6292 __glibcxx_assert(*this != default_sentinel);
6293 ++*_M_parent->_M_current;
6294 if (*_M_parent->_M_current == ranges::end(_M_parent->_M_base))
6295 _M_parent->_M_remainder = 0;
6297 --_M_parent->_M_remainder;
6305 friend constexpr bool
6306 operator==(const _InnerIter& __x, default_sentinel_t) noexcept
6307 { return __x._M_parent->_M_remainder == 0; }
6309 friend constexpr difference_type
6310 operator-(default_sentinel_t, const _InnerIter& __x)
6311 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6313 return ranges::min(__x._M_parent->_M_remainder,
6314 ranges::end(__x._M_parent->_M_base) - *__x._M_parent->_M_current);
6317 friend constexpr difference_type
6318 operator-(const _InnerIter& __x, default_sentinel_t __y)
6319 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6320 { return -(__y - __x); }
6322 // _GLIBCXX_RESOLVE_LIB_DEFECTS
6323 // 3851. chunk_view::inner-iterator missing custom iter_move and iter_swap
6324 friend constexpr range_rvalue_reference_t<_Vp>
6325 iter_move(const _InnerIter& __i)
6326 noexcept(noexcept(ranges::iter_move(*__i._M_parent->_M_current)))
6327 { return ranges::iter_move(*__i._M_parent->_M_current); }
6329 friend constexpr void
6330 iter_swap(const _InnerIter& __x, const _InnerIter& __y)
6331 noexcept(noexcept(ranges::iter_swap(*__x._M_parent->_M_current,
6332 *__x._M_parent->_M_current)))
6333 requires indirectly_swappable<iterator_t<_Vp>>
6334 { return ranges::iter_swap(*__x._M_parent->_M_current, *__y._M_parent->_M_current); }
6338 requires forward_range<_Vp>
6339 class chunk_view<_Vp> : public view_interface<chunk_view<_Vp>>
6342 range_difference_t<_Vp> _M_n;
6343 template<bool> class _Iterator;
6347 chunk_view(_Vp __base, range_difference_t<_Vp> __n)
6348 : _M_base(std::move(__base)), _M_n(__n)
6349 { __glibcxx_assert(__n > 0); }
6352 base() const & requires copy_constructible<_Vp>
6357 { return std::move(_M_base); }
6360 begin() requires (!__detail::__simple_view<_Vp>)
6361 { return _Iterator<false>(this, ranges::begin(_M_base)); }
6364 begin() const requires forward_range<const _Vp>
6365 { return _Iterator<true>(this, ranges::begin(_M_base)); }
6368 end() requires (!__detail::__simple_view<_Vp>)
6370 if constexpr (common_range<_Vp> && sized_range<_Vp>)
6372 auto __missing = (_M_n - ranges::distance(_M_base) % _M_n) % _M_n;
6373 return _Iterator<false>(this, ranges::end(_M_base), __missing);
6375 else if constexpr (common_range<_Vp> && !bidirectional_range<_Vp>)
6376 return _Iterator<false>(this, ranges::end(_M_base));
6378 return default_sentinel;
6382 end() const requires forward_range<const _Vp>
6384 if constexpr (common_range<const _Vp> && sized_range<const _Vp>)
6386 auto __missing = (_M_n - ranges::distance(_M_base) % _M_n) % _M_n;
6387 return _Iterator<true>(this, ranges::end(_M_base), __missing);
6389 else if constexpr (common_range<const _Vp> && !bidirectional_range<const _Vp>)
6390 return _Iterator<true>(this, ranges::end(_M_base));
6392 return default_sentinel;
6396 size() requires sized_range<_Vp>
6398 return __detail::__to_unsigned_like(__detail::__div_ceil
6399 (ranges::distance(_M_base), _M_n));
6403 size() const requires sized_range<const _Vp>
6405 return __detail::__to_unsigned_like(__detail::__div_ceil
6406 (ranges::distance(_M_base), _M_n));
6410 template<typename _Vp>
6411 inline constexpr bool enable_borrowed_range<chunk_view<_Vp>>
6412 = forward_range<_Vp> && enable_borrowed_range<_Vp>;
6415 requires forward_range<_Vp>
6416 template<bool _Const>
6417 class chunk_view<_Vp>::_Iterator
6419 using _Parent = __detail::__maybe_const_t<_Const, chunk_view>;
6420 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
6422 iterator_t<_Base> _M_current = iterator_t<_Base>();
6423 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
6424 range_difference_t<_Base> _M_n = 0;
6425 range_difference_t<_Base> _M_missing = 0;
6428 _Iterator(_Parent* __parent, iterator_t<_Base> __current,
6429 range_difference_t<_Base> __missing = 0)
6430 : _M_current(__current), _M_end(ranges::end(__parent->_M_base)),
6431 _M_n(__parent->_M_n), _M_missing(__missing)
6437 if constexpr (random_access_range<_Base>)
6438 return random_access_iterator_tag{};
6439 else if constexpr (bidirectional_range<_Base>)
6440 return bidirectional_iterator_tag{};
6442 return forward_iterator_tag{};
6448 using iterator_category = input_iterator_tag;
6449 using iterator_concept = decltype(_S_iter_cat());
6450 using value_type = decltype(views::take(subrange(_M_current, _M_end), _M_n));
6451 using difference_type = range_difference_t<_Base>;
6453 _Iterator() = default;
6455 constexpr _Iterator(_Iterator<!_Const> __i)
6457 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
6458 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
6459 : _M_current(std::move(__i._M_current)), _M_end(std::move(__i._M_end)),
6460 _M_n(__i._M_n), _M_missing(__i._M_missing)
6463 constexpr iterator_t<_Base>
6465 { return _M_current; }
6467 constexpr value_type
6470 __glibcxx_assert(_M_current != _M_end);
6471 return views::take(subrange(_M_current, _M_end), _M_n);
6474 constexpr _Iterator&
6477 __glibcxx_assert(_M_current != _M_end);
6478 _M_missing = ranges::advance(_M_current, _M_n, _M_end);
6490 constexpr _Iterator&
6491 operator--() requires bidirectional_range<_Base>
6493 ranges::advance(_M_current, _M_missing - _M_n);
6499 operator--(int) requires bidirectional_range<_Base>
6506 constexpr _Iterator&
6507 operator+=(difference_type __x)
6508 requires random_access_range<_Base>
6512 __glibcxx_assert(ranges::distance(_M_current, _M_end) > _M_n * (__x - 1));
6513 _M_missing = ranges::advance(_M_current, _M_n * __x, _M_end);
6517 ranges::advance(_M_current, _M_n * __x + _M_missing);
6523 constexpr _Iterator&
6524 operator-=(difference_type __x)
6525 requires random_access_range<_Base>
6526 { return *this += -__x; }
6528 constexpr value_type
6529 operator[](difference_type __n) const
6530 requires random_access_range<_Base>
6531 { return *(*this + __n); }
6533 friend constexpr bool
6534 operator==(const _Iterator& __x, const _Iterator& __y)
6535 { return __x._M_current == __y._M_current; }
6537 friend constexpr bool
6538 operator==(const _Iterator& __x, default_sentinel_t)
6539 { return __x._M_current == __x._M_end; }
6541 friend constexpr bool
6542 operator<(const _Iterator& __x, const _Iterator& __y)
6543 requires random_access_range<_Base>
6544 { return __x._M_current > __y._M_current; }
6546 friend constexpr bool
6547 operator>(const _Iterator& __x, const _Iterator& __y)
6548 requires random_access_range<_Base>
6549 { return __y < __x; }
6551 friend constexpr bool
6552 operator<=(const _Iterator& __x, const _Iterator& __y)
6553 requires random_access_range<_Base>
6554 { return !(__y < __x); }
6556 friend constexpr bool
6557 operator>=(const _Iterator& __x, const _Iterator& __y)
6558 requires random_access_range<_Base>
6559 { return !(__x < __y); }
6561 friend constexpr auto
6562 operator<=>(const _Iterator& __x, const _Iterator& __y)
6563 requires random_access_range<_Base>
6564 && three_way_comparable<iterator_t<_Base>>
6565 { return __x._M_current <=> __y._M_current; }
6567 friend constexpr _Iterator
6568 operator+(const _Iterator& __i, difference_type __n)
6569 requires random_access_range<_Base>
6576 friend constexpr _Iterator
6577 operator+(difference_type __n, const _Iterator& __i)
6578 requires random_access_range<_Base>
6585 friend constexpr _Iterator
6586 operator-(const _Iterator& __i, difference_type __n)
6587 requires random_access_range<_Base>
6594 friend constexpr difference_type
6595 operator-(const _Iterator& __x, const _Iterator& __y)
6596 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
6598 return (__x._M_current - __y._M_current
6599 + __x._M_missing - __y._M_missing) / __x._M_n;
6602 friend constexpr difference_type
6603 operator-(default_sentinel_t, const _Iterator& __x)
6604 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
6605 { return __detail::__div_ceil(__x._M_end - __x._M_current, __x._M_n); }
6607 friend constexpr difference_type
6608 operator-(const _Iterator& __x, default_sentinel_t __y)
6609 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
6610 { return -(__y - __x); }
6617 template<typename _Range, typename _Dp>
6618 concept __can_chunk_view
6619 = requires { chunk_view(std::declval<_Range>(), std::declval<_Dp>()); };
6622 struct _Chunk : __adaptor::_RangeAdaptor<_Chunk>
6624 template<viewable_range _Range, typename _Dp = range_difference_t<_Range>>
6625 requires __detail::__can_chunk_view<_Range, _Dp>
6627 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n) const
6628 { return chunk_view(std::forward<_Range>(__r), __n); }
6630 using __adaptor::_RangeAdaptor<_Chunk>::operator();
6631 static constexpr int _S_arity = 2;
6632 static constexpr bool _S_has_simple_extra_args = true;
6635 inline constexpr _Chunk chunk;
6637#endif // __cpp_lib_ranges_chunk
6639#ifdef __cpp_lib_ranges_slide // C++ >= 23
6642 template<typename _Vp>
6643 concept __slide_caches_nothing = random_access_range<_Vp> && sized_range<_Vp>;
6645 template<typename _Vp>
6646 concept __slide_caches_last
6647 = !__slide_caches_nothing<_Vp> && bidirectional_range<_Vp> && common_range<_Vp>;
6649 template<typename _Vp>
6650 concept __slide_caches_first
6651 = !__slide_caches_nothing<_Vp> && !__slide_caches_last<_Vp>;
6654 template<forward_range _Vp>
6656 class slide_view : public view_interface<slide_view<_Vp>>
6659 range_difference_t<_Vp> _M_n;
6660 [[no_unique_address]]
6661 __detail::__maybe_present_t<__detail::__slide_caches_first<_Vp>,
6662 __detail::_CachedPosition<_Vp>, 0> _M_cached_begin;
6663 [[no_unique_address]]
6664 __detail::__maybe_present_t<__detail::__slide_caches_last<_Vp>,
6665 __detail::_CachedPosition<_Vp>, 1> _M_cached_end;
6667 template<bool> class _Iterator;
6672 slide_view(_Vp __base, range_difference_t<_Vp> __n)
6673 : _M_base(std::move(__base)), _M_n(__n)
6674 { __glibcxx_assert(__n > 0); }
6676 // _GLIBCXX_RESOLVE_LIB_DEFECTS
6677 // 3848. adjacent_view, adjacent_transform_view and slide_view missing base accessor
6679 base() const & requires copy_constructible<_Vp>
6684 { return std::move(_M_base); }
6687 begin() requires (!(__detail::__simple_view<_Vp>
6688 && __detail::__slide_caches_nothing<const _Vp>))
6690 if constexpr (__detail::__slide_caches_first<_Vp>)
6692 iterator_t<_Vp> __it;
6693 if (_M_cached_begin._M_has_value())
6694 __it = _M_cached_begin._M_get(_M_base);
6697 __it = ranges::next(ranges::begin(_M_base), _M_n - 1, ranges::end(_M_base));
6698 _M_cached_begin._M_set(_M_base, __it);
6700 return _Iterator<false>(ranges::begin(_M_base), std::move(__it), _M_n);
6703 return _Iterator<false>(ranges::begin(_M_base), _M_n);
6707 begin() const requires __detail::__slide_caches_nothing<const _Vp>
6708 { return _Iterator<true>(ranges::begin(_M_base), _M_n); }
6711 end() requires (!(__detail::__simple_view<_Vp>
6712 && __detail::__slide_caches_nothing<const _Vp>))
6714 if constexpr (__detail::__slide_caches_nothing<_Vp>)
6715 return _Iterator<false>(ranges::begin(_M_base) + range_difference_t<_Vp>(size()),
6717 else if constexpr (__detail::__slide_caches_last<_Vp>)
6719 iterator_t<_Vp> __it;
6720 if (_M_cached_end._M_has_value())
6721 __it = _M_cached_end._M_get(_M_base);
6724 __it = ranges::prev(ranges::end(_M_base), _M_n - 1, ranges::begin(_M_base));
6725 _M_cached_end._M_set(_M_base, __it);
6727 return _Iterator<false>(std::move(__it), _M_n);
6729 else if constexpr (common_range<_Vp>)
6730 return _Iterator<false>(ranges::end(_M_base), ranges::end(_M_base), _M_n);
6732 return _Sentinel(ranges::end(_M_base));
6736 end() const requires __detail::__slide_caches_nothing<const _Vp>
6737 { return begin() + range_difference_t<const _Vp>(size()); }
6740 size() requires sized_range<_Vp>
6742 auto __sz = ranges::distance(_M_base) - _M_n + 1;
6745 return __detail::__to_unsigned_like(__sz);
6749 size() const requires sized_range<const _Vp>
6751 auto __sz = ranges::distance(_M_base) - _M_n + 1;
6754 return __detail::__to_unsigned_like(__sz);
6758 template<typename _Range>
6759 slide_view(_Range&&, range_difference_t<_Range>) -> slide_view<views::all_t<_Range>>;
6761 template<typename _Vp>
6762 inline constexpr bool enable_borrowed_range<slide_view<_Vp>>
6763 = enable_borrowed_range<_Vp>;
6765 template<forward_range _Vp>
6767 template<bool _Const>
6768 class slide_view<_Vp>::_Iterator
6770 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
6771 static constexpr bool _S_last_elt_present
6772 = __detail::__slide_caches_first<_Base>;
6774 iterator_t<_Base> _M_current = iterator_t<_Base>();
6775 [[no_unique_address]]
6776 __detail::__maybe_present_t<_S_last_elt_present, iterator_t<_Base>>
6777 _M_last_elt = decltype(_M_last_elt)();
6778 range_difference_t<_Base> _M_n = 0;
6781 _Iterator(iterator_t<_Base> __current, range_difference_t<_Base> __n)
6782 requires (!_S_last_elt_present)
6783 : _M_current(__current), _M_n(__n)
6787 _Iterator(iterator_t<_Base> __current, iterator_t<_Base> __last_elt,
6788 range_difference_t<_Base> __n)
6789 requires _S_last_elt_present
6790 : _M_current(__current), _M_last_elt(__last_elt), _M_n(__n)
6796 if constexpr (random_access_range<_Base>)
6797 return random_access_iterator_tag{};
6798 else if constexpr (bidirectional_range<_Base>)
6799 return bidirectional_iterator_tag{};
6801 return forward_iterator_tag{};
6805 friend slide_view::_Sentinel;
6808 using iterator_category = input_iterator_tag;
6809 using iterator_concept = decltype(_S_iter_concept());
6810 using value_type = decltype(views::counted(_M_current, _M_n));
6811 using difference_type = range_difference_t<_Base>;
6813 _Iterator() = default;
6816 _Iterator(_Iterator<!_Const> __i)
6817 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
6818 : _M_current(std::move(__i._M_current)), _M_n(__i._M_n)
6823 { return views::counted(_M_current, _M_n); }
6825 constexpr _Iterator&
6829 if constexpr (_S_last_elt_present)
6842 constexpr _Iterator&
6843 operator--() requires bidirectional_range<_Base>
6846 if constexpr (_S_last_elt_present)
6852 operator--(int) requires bidirectional_range<_Base>
6859 constexpr _Iterator&
6860 operator+=(difference_type __x)
6861 requires random_access_range<_Base>
6864 if constexpr (_S_last_elt_present)
6869 constexpr _Iterator&
6870 operator-=(difference_type __x)
6871 requires random_access_range<_Base>
6874 if constexpr (_S_last_elt_present)
6880 operator[](difference_type __n) const
6881 requires random_access_range<_Base>
6882 { return views::counted(_M_current + __n, _M_n); }
6884 friend constexpr bool
6885 operator==(const _Iterator& __x, const _Iterator& __y)
6887 if constexpr (_S_last_elt_present)
6888 return __x._M_last_elt == __y._M_last_elt;
6890 return __x._M_current == __y._M_current;
6893 friend constexpr bool
6894 operator<(const _Iterator& __x, const _Iterator& __y)
6895 requires random_access_range<_Base>
6896 { return __x._M_current < __y._M_current; }
6898 friend constexpr bool
6899 operator>(const _Iterator& __x, const _Iterator& __y)
6900 requires random_access_range<_Base>
6901 { return __y < __x; }
6903 friend constexpr bool
6904 operator<=(const _Iterator& __x, const _Iterator& __y)
6905 requires random_access_range<_Base>
6906 { return !(__y < __x); }
6908 friend constexpr bool
6909 operator>=(const _Iterator& __x, const _Iterator& __y)
6910 requires random_access_range<_Base>
6911 { return !(__x < __y); }
6913 friend constexpr auto
6914 operator<=>(const _Iterator& __x, const _Iterator& __y)
6915 requires random_access_range<_Base>
6916 && three_way_comparable<iterator_t<_Base>>
6917 { return __x._M_current <=> __y._M_current; }
6919 friend constexpr _Iterator
6920 operator+(const _Iterator& __i, difference_type __n)
6921 requires random_access_range<_Base>
6928 friend constexpr _Iterator
6929 operator+(difference_type __n, const _Iterator& __i)
6930 requires random_access_range<_Base>
6937 friend constexpr _Iterator
6938 operator-(const _Iterator& __i, difference_type __n)
6939 requires random_access_range<_Base>
6946 friend constexpr difference_type
6947 operator-(const _Iterator& __x, const _Iterator& __y)
6948 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
6950 if constexpr (_S_last_elt_present)
6951 return __x._M_last_elt - __y._M_last_elt;
6953 return __x._M_current - __y._M_current;
6957 template<forward_range _Vp>
6959 class slide_view<_Vp>::_Sentinel
6961 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
6964 _Sentinel(sentinel_t<_Vp> __end)
6971 _Sentinel() = default;
6973 friend constexpr bool
6974 operator==(const _Iterator<false>& __x, const _Sentinel& __y)
6975 { return __x._M_last_elt == __y._M_end; }
6977 friend constexpr range_difference_t<_Vp>
6978 operator-(const _Iterator<false>& __x, const _Sentinel& __y)
6979 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6980 { return __x._M_last_elt - __y._M_end; }
6982 friend constexpr range_difference_t<_Vp>
6983 operator-(const _Sentinel& __y, const _Iterator<false>& __x)
6984 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6985 { return __y._M_end -__x._M_last_elt; }
6992 template<typename _Range, typename _Dp>
6993 concept __can_slide_view
6994 = requires { slide_view(std::declval<_Range>(), std::declval<_Dp>()); };
6997 struct _Slide : __adaptor::_RangeAdaptor<_Slide>
6999 template<viewable_range _Range, typename _Dp = range_difference_t<_Range>>
7000 requires __detail::__can_slide_view<_Range, _Dp>
7002 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n) const
7003 { return slide_view(std::forward<_Range>(__r), __n); }
7005 using __adaptor::_RangeAdaptor<_Slide>::operator();
7006 static constexpr int _S_arity = 2;
7007 static constexpr bool _S_has_simple_extra_args = true;
7010 inline constexpr _Slide slide;
7012#endif // __cpp_lib_ranges_slide
7014#ifdef __cpp_lib_ranges_chunk_by // C++ >= 23
7015 template<forward_range _Vp,
7016 indirect_binary_predicate<iterator_t<_Vp>, iterator_t<_Vp>> _Pred>
7017 requires view<_Vp> && is_object_v<_Pred>
7018 class chunk_by_view : public view_interface<chunk_by_view<_Vp, _Pred>>
7020 _Vp _M_base = _Vp();
7021 __detail::__box<_Pred> _M_pred;
7022 __detail::_CachedPosition<_Vp> _M_cached_begin;
7024 constexpr iterator_t<_Vp>
7025 _M_find_next(iterator_t<_Vp> __current)
7027 __glibcxx_assert(_M_pred.has_value());
7028 auto __pred = [this]<typename _Tp, typename _Up>(_Tp&& __x, _Up&& __y) {
7029 return !bool((*_M_pred)(std::forward<_Tp>(__x), std::forward<_Up>(__y)));
7031 auto __it = ranges::adjacent_find(__current, ranges::end(_M_base), __pred);
7032 return ranges::next(__it, 1, ranges::end(_M_base));
7035 constexpr iterator_t<_Vp>
7036 _M_find_prev(iterator_t<_Vp> __current) requires bidirectional_range<_Vp>
7038 __glibcxx_assert(_M_pred.has_value());
7039 auto __pred = [this]<typename _Tp, typename _Up>(_Tp&& __x, _Up&& __y) {
7040 return !bool((*_M_pred)(std::forward<_Up>(__y), std::forward<_Tp>(__x)));
7042 auto __rbegin = std::make_reverse_iterator(__current);
7043 auto __rend = std::make_reverse_iterator(ranges::begin(_M_base));
7044 __glibcxx_assert(__rbegin != __rend);
7045 auto __it = ranges::adjacent_find(__rbegin, __rend, __pred).base();
7046 return ranges::prev(__it, 1, ranges::begin(_M_base));
7052 chunk_by_view() requires (default_initializable<_Vp>
7053 && default_initializable<_Pred>)
7057 chunk_by_view(_Vp __base, _Pred __pred)
7058 : _M_base(std::move(__base)), _M_pred(std::move(__pred))
7062 base() const & requires copy_constructible<_Vp>
7067 { return std::move(_M_base); }
7069 constexpr const _Pred&
7071 { return *_M_pred; }
7076 __glibcxx_assert(_M_pred.has_value());
7077 iterator_t<_Vp> __it;
7078 if (_M_cached_begin._M_has_value())
7079 __it = _M_cached_begin._M_get(_M_base);
7082 __it = _M_find_next(ranges::begin(_M_base));
7083 _M_cached_begin._M_set(_M_base, __it);
7085 return _Iterator(*this, ranges::begin(_M_base), __it);
7091 if constexpr (common_range<_Vp>)
7092 return _Iterator(*this, ranges::end(_M_base), ranges::end(_M_base));
7094 return default_sentinel;
7098 template<typename _Range, typename _Pred>
7099 chunk_by_view(_Range&&, _Pred) -> chunk_by_view<views::all_t<_Range>, _Pred>;
7101 template<forward_range _Vp,
7102 indirect_binary_predicate<iterator_t<_Vp>, iterator_t<_Vp>> _Pred>
7103 requires view<_Vp> && is_object_v<_Pred>
7104 class chunk_by_view<_Vp, _Pred>::_Iterator
7106 chunk_by_view* _M_parent = nullptr;
7107 iterator_t<_Vp> _M_current = iterator_t<_Vp>();
7108 iterator_t<_Vp> _M_next = iterator_t<_Vp>();
7111 _Iterator(chunk_by_view& __parent, iterator_t<_Vp> __current, iterator_t<_Vp> __next)
7112 : _M_parent(std::__addressof(__parent)), _M_current(__current), _M_next(__next)
7118 if constexpr (bidirectional_range<_Vp>)
7119 return bidirectional_iterator_tag{};
7121 return forward_iterator_tag{};
7124 friend chunk_by_view;
7127 using value_type = subrange<iterator_t<_Vp>>;
7128 using difference_type = range_difference_t<_Vp>;
7129 using iterator_category = input_iterator_tag;
7130 using iterator_concept = decltype(_S_iter_concept());
7132 _Iterator() = default;
7134 constexpr value_type
7137 __glibcxx_assert(_M_current != _M_next);
7138 return ranges::subrange(_M_current, _M_next);
7141 constexpr _Iterator&
7144 __glibcxx_assert(_M_current != _M_next);
7145 _M_current = _M_next;
7146 _M_next = _M_parent->_M_find_next(_M_current);
7158 constexpr _Iterator&
7159 operator--() requires bidirectional_range<_Vp>
7161 _M_next = _M_current;
7162 _M_current = _M_parent->_M_find_prev(_M_next);
7167 operator--(int) requires bidirectional_range<_Vp>
7174 friend constexpr bool
7175 operator==(const _Iterator& __x, const _Iterator& __y)
7176 { return __x._M_current == __y._M_current; }
7178 friend constexpr bool
7179 operator==(const _Iterator& __x, default_sentinel_t)
7180 { return __x._M_current == __x._M_next; }
7187 template<typename _Range, typename _Pred>
7188 concept __can_chunk_by_view
7189 = requires { chunk_by_view(std::declval<_Range>(), std::declval<_Pred>()); };
7192 struct _ChunkBy : __adaptor::_RangeAdaptor<_ChunkBy>
7194 template<viewable_range _Range, typename _Pred>
7195 requires __detail::__can_chunk_by_view<_Range, _Pred>
7197 operator() [[nodiscard]] (_Range&& __r, _Pred&& __pred) const
7198 { return chunk_by_view(std::forward<_Range>(__r), std::forward<_Pred>(__pred)); }
7200 using __adaptor::_RangeAdaptor<_ChunkBy>::operator();
7201 static constexpr int _S_arity = 2;
7202 static constexpr bool _S_has_simple_extra_args = true;
7205 inline constexpr _ChunkBy chunk_by;
7207#endif // __cpp_lib_ranges_chunk_by
7209#ifdef __cpp_lib_ranges_join_with // C++ >= 23
7212 template<typename _Range, typename _Pattern>
7213 concept __compatible_joinable_ranges
7214 = common_with<range_value_t<_Range>, range_value_t<_Pattern>>
7215 && common_reference_with<range_reference_t<_Range>,
7216 range_reference_t<_Pattern>>
7217 && common_reference_with<range_rvalue_reference_t<_Range>,
7218 range_rvalue_reference_t<_Pattern>>;
7220 template<typename _Range>
7221 concept __bidirectional_common = bidirectional_range<_Range> && common_range<_Range>;
7224 template<input_range _Vp, forward_range _Pattern>
7225 requires view<_Vp> && view<_Pattern>
7226 && input_range<range_reference_t<_Vp>>
7227 && __detail::__compatible_joinable_ranges<range_reference_t<_Vp>, _Pattern>
7228 class join_with_view : public view_interface<join_with_view<_Vp, _Pattern>>
7230 using _InnerRange = range_reference_t<_Vp>;
7232 _Vp _M_base = _Vp();
7233 [[no_unique_address]]
7234 __detail::__maybe_present_t<!forward_range<_Vp>,
7235 __detail::__non_propagating_cache<iterator_t<_Vp>>> _M_outer_it;
7236 __detail::__non_propagating_cache<remove_cv_t<_InnerRange>> _M_inner;
7237 _Pattern _M_pattern = _Pattern();
7239 template<bool _Const> using _Base = __detail::__maybe_const_t<_Const, _Vp>;
7240 template<bool _Const> using _InnerBase = range_reference_t<_Base<_Const>>;
7241 template<bool _Const> using _PatternBase = __detail::__maybe_const_t<_Const, _Pattern>;
7243 template<bool _Const> using _OuterIter = iterator_t<_Base<_Const>>;
7244 template<bool _Const> using _InnerIter = iterator_t<_InnerBase<_Const>>;
7245 template<bool _Const> using _PatternIter = iterator_t<_PatternBase<_Const>>;
7247 template<bool _Const>
7248 static constexpr bool _S_ref_is_glvalue = is_reference_v<_InnerBase<_Const>>;
7250 template<bool _Const>
7254 template<bool _Const>
7255 requires _S_ref_is_glvalue<_Const>
7256 && forward_range<_Base<_Const>>
7257 && forward_range<_InnerBase<_Const>>
7258 struct __iter_cat<_Const>
7264 using _OuterIter = join_with_view::_OuterIter<_Const>;
7265 using _InnerIter = join_with_view::_InnerIter<_Const>;
7266 using _PatternIter = join_with_view::_PatternIter<_Const>;
7267 using _OuterCat = typename iterator_traits<_OuterIter>::iterator_category;
7268 using _InnerCat = typename iterator_traits<_InnerIter>::iterator_category;
7269 using _PatternCat = typename iterator_traits<_PatternIter>::iterator_category;
7270 // _GLIBCXX_RESOLVE_LIB_DEFECTS
7271 // 3798. Rvalue reference and iterator_category
7272 if constexpr (!is_reference_v<common_reference_t<iter_reference_t<_InnerIter>,
7273 iter_reference_t<_PatternIter>>>)
7274 return input_iterator_tag{};
7275 else if constexpr (derived_from<_OuterCat, bidirectional_iterator_tag>
7276 && derived_from<_InnerCat, bidirectional_iterator_tag>
7277 && derived_from<_PatternCat, bidirectional_iterator_tag>
7278 && common_range<_InnerBase<_Const>>
7279 && common_range<_PatternBase<_Const>>)
7280 return bidirectional_iterator_tag{};
7281 else if constexpr (derived_from<_OuterCat, forward_iterator_tag>
7282 && derived_from<_InnerCat, forward_iterator_tag>
7283 && derived_from<_PatternCat, forward_iterator_tag>)
7284 return forward_iterator_tag{};
7286 return input_iterator_tag{};
7289 using iterator_category = decltype(_S_iter_cat());
7292 template<bool> class _Iterator;
7293 template<bool> class _Sentinel;
7296 join_with_view() requires (default_initializable<_Vp>
7297 && default_initializable<_Pattern>)
7301 join_with_view(_Vp __base, _Pattern __pattern)
7302 : _M_base(std::move(__base)), _M_pattern(std::move(__pattern))
7305 template<input_range _Range>
7306 requires constructible_from<_Vp, views::all_t<_Range>>
7307 && constructible_from<_Pattern, single_view<range_value_t<_InnerRange>>>
7309 join_with_view(_Range&& __r, range_value_t<_InnerRange> __e)
7310 : _M_base(views::all(std::forward<_Range>(__r))),
7311 _M_pattern(views::single(std::move(__e)))
7315 base() const& requires copy_constructible<_Vp>
7320 { return std::move(_M_base); }
7325 if constexpr (forward_range<_Vp>)
7327 constexpr bool __use_const = is_reference_v<_InnerRange>
7328 && __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
7329 return _Iterator<__use_const>{*this, ranges::begin(_M_base)};
7333 _M_outer_it = ranges::begin(_M_base);
7334 return _Iterator<false>{*this};
7340 requires forward_range<const _Vp>
7341 && forward_range<const _Pattern>
7342 && is_reference_v<range_reference_t<const _Vp>>
7343 && input_range<range_reference_t<const _Vp>>
7344 { return _Iterator<true>{*this, ranges::begin(_M_base)}; }
7349 constexpr bool __use_const
7350 = __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
7351 if constexpr (is_reference_v<_InnerRange>
7352 && forward_range<_Vp> && common_range<_Vp>
7353 && forward_range<_InnerRange> && common_range<_InnerRange>)
7354 return _Iterator<__use_const>{*this, ranges::end(_M_base)};
7356 return _Sentinel<__use_const>{*this};
7361 requires forward_range<const _Vp>
7362 && forward_range<const _Pattern>
7363 && is_reference_v<range_reference_t<const _Vp>>
7364 && input_range<range_reference_t<const _Vp>>
7366 using _InnerConstRange = range_reference_t<const _Vp>;
7367 if constexpr (forward_range<_InnerConstRange>
7368 && common_range<const _Vp>
7369 && common_range<_InnerConstRange>)
7370 return _Iterator<true>{*this, ranges::end(_M_base)};
7372 return _Sentinel<true>{*this};
7376 template<typename _Range, typename _Pattern>
7377 join_with_view(_Range&&, _Pattern&&)
7378 -> join_with_view<views::all_t<_Range>, views::all_t<_Pattern>>;
7380 template<input_range _Range>
7381 join_with_view(_Range&&, range_value_t<range_reference_t<_Range>>)
7382 -> join_with_view<views::all_t<_Range>,
7383 single_view<range_value_t<range_reference_t<_Range>>>>;
7385 template<input_range _Vp, forward_range _Pattern>
7386 requires view<_Vp> && view<_Pattern>
7387 && input_range<range_reference_t<_Vp>>
7388 && __detail::__compatible_joinable_ranges<range_reference_t<_Vp>, _Pattern>
7389 template<bool _Const>
7390 class join_with_view<_Vp, _Pattern>::_Iterator : public __iter_cat<_Const>
7392 using _Parent = __detail::__maybe_const_t<_Const, join_with_view>;
7393 using _Base = join_with_view::_Base<_Const>;
7394 using _InnerBase = join_with_view::_InnerBase<_Const>;
7395 using _PatternBase = join_with_view::_PatternBase<_Const>;
7397 using _OuterIter = join_with_view::_OuterIter<_Const>;
7398 using _InnerIter = join_with_view::_InnerIter<_Const>;
7399 using _PatternIter = join_with_view::_PatternIter<_Const>;
7401 static constexpr bool _S_ref_is_glvalue = join_with_view::_S_ref_is_glvalue<_Const>;
7403 _Parent* _M_parent = nullptr;
7404 [[no_unique_address]]
7405 __detail::__maybe_present_t<forward_range<_Base>, _OuterIter> _M_outer_it
7406 = decltype(_M_outer_it)();
7407 variant<_PatternIter, _InnerIter> _M_inner_it;
7409 constexpr _OuterIter&
7412 if constexpr (forward_range<_Base>)
7415 return *_M_parent->_M_outer_it;
7418 constexpr const _OuterIter&
7419 _M_get_outer() const
7421 if constexpr (forward_range<_Base>)
7424 return *_M_parent->_M_outer_it;
7428 _Iterator(_Parent& __parent, _OuterIter __outer)
7429 requires forward_range<_Base>
7430 : _M_parent(std::__addressof(__parent)), _M_outer_it(std::move(__outer))
7432 if (_M_get_outer() != ranges::end(_M_parent->_M_base))
7434 auto&& __inner = _M_update_inner();
7435 _M_inner_it.template emplace<1>(ranges::begin(__inner));
7441 _Iterator(_Parent& __parent)
7442 requires (!forward_range<_Base>)
7443 : _M_parent(std::__addressof(__parent))
7445 if (_M_get_outer() != ranges::end(_M_parent->_M_base))
7447 auto&& __inner = _M_update_inner();
7448 _M_inner_it.template emplace<1>(ranges::begin(__inner));
7456 _OuterIter& __outer = _M_get_outer();
7457 if constexpr (_S_ref_is_glvalue)
7458 return __detail::__as_lvalue(*__outer);
7460 return _M_parent->_M_inner._M_emplace_deref(__outer);
7466 if constexpr (_S_ref_is_glvalue)
7467 return __detail::__as_lvalue(*_M_get_outer());
7469 return *_M_parent->_M_inner;
7477 if (_M_inner_it.index() == 0)
7479 if (std::get<0>(_M_inner_it) != ranges::end(_M_parent->_M_pattern))
7482 auto&& __inner = _M_update_inner();
7483 _M_inner_it.template emplace<1>(ranges::begin(__inner));
7487 auto&& __inner = _M_get_inner();
7488 if (std::get<1>(_M_inner_it) != ranges::end(__inner))
7491 if (++_M_get_outer() == ranges::end(_M_parent->_M_base))
7493 if constexpr (_S_ref_is_glvalue)
7494 _M_inner_it.template emplace<0>();
7498 _M_inner_it.template emplace<0>(ranges::begin(_M_parent->_M_pattern));
7506 if constexpr (_S_ref_is_glvalue
7507 && bidirectional_range<_Base>
7508 && __detail::__bidirectional_common<_InnerBase>
7509 && __detail::__bidirectional_common<_PatternBase>)
7510 return bidirectional_iterator_tag{};
7511 else if constexpr (_S_ref_is_glvalue
7512 && forward_range<_Base>
7513 && forward_range<_InnerBase>)
7514 return forward_iterator_tag{};
7516 return input_iterator_tag{};
7519 friend join_with_view;
7522 using iterator_concept = decltype(_S_iter_concept());
7523 // iterator_category defined in join_with_view::__iter_cat
7524 using value_type = common_type_t<iter_value_t<_InnerIter>,
7525 iter_value_t<_PatternIter>>;
7526 using difference_type = common_type_t<iter_difference_t<_OuterIter>,
7527 iter_difference_t<_InnerIter>,
7528 iter_difference_t<_PatternIter>>;
7530 _Iterator() = default;
7533 _Iterator(_Iterator<!_Const> __i)
7535 && convertible_to<iterator_t<_Vp>, _OuterIter>
7536 && convertible_to<iterator_t<_InnerRange>, _InnerIter>
7537 && convertible_to<iterator_t<_Pattern>, _PatternIter>
7538 : _M_parent(__i._M_parent),
7539 _M_outer_it(std::move(__i._M_outer_it))
7541 if (__i._M_inner_it.index() == 0)
7542 _M_inner_it.template emplace<0>(std::get<0>(std::move(__i._M_inner_it)));
7544 _M_inner_it.template emplace<1>(std::get<1>(std::move(__i._M_inner_it)));
7547 constexpr common_reference_t<iter_reference_t<_InnerIter>,
7548 iter_reference_t<_PatternIter>>
7551 if (_M_inner_it.index() == 0)
7552 return *std::get<0>(_M_inner_it);
7554 return *std::get<1>(_M_inner_it);
7557 constexpr _Iterator&
7560 if (_M_inner_it.index() == 0)
7561 ++std::get<0>(_M_inner_it);
7563 ++std::get<1>(_M_inner_it);
7574 requires _S_ref_is_glvalue
7575 && forward_iterator<_OuterIter> && forward_iterator<_InnerIter>
7577 _Iterator __tmp = *this;
7582 constexpr _Iterator&
7584 requires _S_ref_is_glvalue
7585 && bidirectional_range<_Base>
7586 && __detail::__bidirectional_common<_InnerBase>
7587 && __detail::__bidirectional_common<_PatternBase>
7589 if (_M_outer_it == ranges::end(_M_parent->_M_base))
7591 auto&& __inner = *--_M_outer_it;
7592 _M_inner_it.template emplace<1>(ranges::end(__inner));
7597 if (_M_inner_it.index() == 0)
7599 auto& __it = std::get<0>(_M_inner_it);
7600 if (__it == ranges::begin(_M_parent->_M_pattern))
7602 auto&& __inner = *--_M_outer_it;
7603 _M_inner_it.template emplace<1>(ranges::end(__inner));
7610 auto& __it = std::get<1>(_M_inner_it);
7611 auto&& __inner = *_M_outer_it;
7612 if (__it == ranges::begin(__inner))
7613 _M_inner_it.template emplace<0>(ranges::end(_M_parent->_M_pattern));
7619 if (_M_inner_it.index() == 0)
7620 --std::get<0>(_M_inner_it);
7622 --std::get<1>(_M_inner_it);
7628 requires _S_ref_is_glvalue && bidirectional_range<_Base>
7629 && __detail::__bidirectional_common<_InnerBase>
7630 && __detail::__bidirectional_common<_PatternBase>
7632 _Iterator __tmp = *this;
7637 friend constexpr bool
7638 operator==(const _Iterator& __x, const _Iterator& __y)
7639 requires _S_ref_is_glvalue
7640 && forward_range<_Base> && equality_comparable<_InnerIter>
7641 { return __x._M_outer_it == __y._M_outer_it && __x._M_inner_it ==__y._M_inner_it; }
7643 friend constexpr common_reference_t<iter_rvalue_reference_t<_InnerIter>,
7644 iter_rvalue_reference_t<_PatternIter>>
7645 iter_move(const _Iterator& __x)
7647 if (__x._M_inner_it.index() == 0)
7648 return ranges::iter_move(std::get<0>(__x._M_inner_it));
7650 return ranges::iter_move(std::get<1>(__x._M_inner_it));
7653 friend constexpr void
7654 iter_swap(const _Iterator& __x, const _Iterator& __y)
7655 requires indirectly_swappable<_InnerIter, _PatternIter>
7657 if (__x._M_inner_it.index() == 0)
7659 if (__y._M_inner_it.index() == 0)
7660 ranges::iter_swap(std::get<0>(__x._M_inner_it), std::get<0>(__y._M_inner_it));
7662 ranges::iter_swap(std::get<0>(__x._M_inner_it), std::get<1>(__y._M_inner_it));
7666 if (__y._M_inner_it.index() == 0)
7667 ranges::iter_swap(std::get<1>(__x._M_inner_it), std::get<0>(__y._M_inner_it));
7669 ranges::iter_swap(std::get<1>(__x._M_inner_it), std::get<1>(__y._M_inner_it));
7674 template<input_range _Vp, forward_range _Pattern>
7675 requires view<_Vp> && view<_Pattern>
7676 && input_range<range_reference_t<_Vp>>
7677 && __detail::__compatible_joinable_ranges<range_reference_t<_Vp>, _Pattern>
7678 template<bool _Const>
7679 class join_with_view<_Vp, _Pattern>::_Sentinel
7681 using _Parent = __detail::__maybe_const_t<_Const, join_with_view>;
7682 using _Base = join_with_view::_Base<_Const>;
7684 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
7687 _Sentinel(_Parent& __parent)
7688 : _M_end(ranges::end(__parent._M_base))
7691 friend join_with_view;
7694 _Sentinel() = default;
7697 _Sentinel(_Sentinel<!_Const> __s)
7698 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
7699 : _M_end(std::move(__s._M_end))
7702 template<bool _OtherConst>
7703 requires sentinel_for<sentinel_t<_Base>,
7704 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
7705 friend constexpr bool
7706 operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
7707 { return __x._M_get_outer() == __y._M_end; }
7714 template<typename _Range, typename _Pattern>
7715 concept __can_join_with_view
7716 = requires { join_with_view(std::declval<_Range>(), std::declval<_Pattern>()); };
7717 } // namespace __detail
7719 struct _JoinWith : __adaptor::_RangeAdaptor<_JoinWith>
7721 template<viewable_range _Range, typename _Pattern>
7722 requires __detail::__can_join_with_view<_Range, _Pattern>
7724 operator() [[nodiscard]] (_Range&& __r, _Pattern&& __f) const
7726 return join_with_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
7729 using _RangeAdaptor<_JoinWith>::operator();
7730 static constexpr int _S_arity = 2;
7731 template<typename _Pattern>
7732 static constexpr bool _S_has_simple_extra_args
7733 = _LazySplit::_S_has_simple_extra_args<_Pattern>;
7736 inline constexpr _JoinWith join_with;
7737 } // namespace views
7738#endif // __cpp_lib_ranges_join_with
7740#ifdef __cpp_lib_ranges_repeat // C++ >= 23
7741 template<move_constructible _Tp, semiregular _Bound = unreachable_sentinel_t>
7742 requires is_object_v<_Tp> && same_as<_Tp, remove_cv_t<_Tp>>
7743 && (__detail::__is_integer_like<_Bound> || same_as<_Bound, unreachable_sentinel_t>)
7744 class repeat_view : public view_interface<repeat_view<_Tp, _Bound>>
7746 __detail::__box<_Tp> _M_value;
7747 [[no_unique_address]] _Bound _M_bound = _Bound();
7751 template<typename _Range>
7752 friend constexpr auto
7753 views::__detail::__take_of_repeat_view(_Range&&, range_difference_t<_Range>);
7755 template<typename _Range>
7756 friend constexpr auto
7757 views::__detail::__drop_of_repeat_view(_Range&&, range_difference_t<_Range>);
7760 repeat_view() requires default_initializable<_Tp> = default;
7763 repeat_view(const _Tp& __value, _Bound __bound = _Bound())
7764 requires copy_constructible<_Tp>
7765 : _M_value(__value), _M_bound(__bound)
7767 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7768 __glibcxx_assert(__bound >= 0);
7772 repeat_view(_Tp&& __value, _Bound __bound = _Bound())
7773 : _M_value(std::move(__value)), _M_bound(__bound)
7776 template<typename... _Args, typename... _BoundArgs>
7777 requires constructible_from<_Tp, _Args...>
7778 && constructible_from<_Bound, _BoundArgs...>
7780 repeat_view(piecewise_construct_t,
7781 tuple<_Args...> __args,
7782 tuple<_BoundArgs...> __bound_args = tuple<>{})
7783 : _M_value(std::make_from_tuple<_Tp>(std::move(__args))),
7784 _M_bound(std::make_from_tuple<_Bound>(std::move(__bound_args)))
7789 { return _Iterator(std::__addressof(*_M_value)); }
7792 end() const requires (!same_as<_Bound, unreachable_sentinel_t>)
7793 { return _Iterator(std::__addressof(*_M_value), _M_bound); }
7795 constexpr unreachable_sentinel_t
7796 end() const noexcept
7797 { return unreachable_sentinel; }
7800 size() const requires (!same_as<_Bound, unreachable_sentinel_t>)
7801 { return __detail::__to_unsigned_like(_M_bound); }
7804 // _GLIBCXX_RESOLVE_LIB_DEFECTS
7805 // 4053. Unary call to std::views::repeat does not decay the argument
7806 template<typename _Tp, typename _Bound = unreachable_sentinel_t>
7807 repeat_view(_Tp, _Bound = _Bound()) -> repeat_view<_Tp, _Bound>;
7809 template<move_constructible _Tp, semiregular _Bound>
7810 requires is_object_v<_Tp> && same_as<_Tp, remove_cv_t<_Tp>>
7811 && (__detail::__is_integer_like<_Bound> || same_as<_Bound, unreachable_sentinel_t>)
7812 class repeat_view<_Tp, _Bound>::_Iterator
7815 = __conditional_t<same_as<_Bound, unreachable_sentinel_t>, ptrdiff_t, _Bound>;
7817 const _Tp* _M_value = nullptr;
7818 __index_type _M_current = __index_type();
7821 _Iterator(const _Tp* __value, __index_type __bound = __index_type())
7822 : _M_value(__value), _M_current(__bound)
7824 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7825 __glibcxx_assert(__bound >= 0);
7831 using iterator_concept = random_access_iterator_tag;
7832 using iterator_category = random_access_iterator_tag;
7833 using value_type = _Tp;
7834 using difference_type = __conditional_t<__detail::__is_signed_integer_like<__index_type>,
7836 __detail::__iota_diff_t<__index_type>>;
7838 _Iterator() = default;
7840 constexpr const _Tp&
7841 operator*() const noexcept
7842 { return *_M_value; }
7844 constexpr _Iterator&
7859 constexpr _Iterator&
7862 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7863 __glibcxx_assert(_M_current > 0);
7876 constexpr _Iterator&
7877 operator+=(difference_type __n)
7879 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7880 __glibcxx_assert(_M_current + __n >= 0);
7885 constexpr _Iterator&
7886 operator-=(difference_type __n)
7888 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7889 __glibcxx_assert(_M_current - __n >= 0);
7894 constexpr const _Tp&
7895 operator[](difference_type __n) const noexcept
7896 { return *(*this + __n); }
7898 friend constexpr bool
7899 operator==(const _Iterator& __x, const _Iterator& __y)
7900 { return __x._M_current == __y._M_current; }
7902 friend constexpr auto
7903 operator<=>(const _Iterator& __x, const _Iterator& __y)
7904 { return __x._M_current <=> __y._M_current; }
7906 friend constexpr _Iterator
7907 operator+(_Iterator __i, difference_type __n)
7913 friend constexpr _Iterator
7914 operator+(difference_type __n, _Iterator __i)
7915 { return __i + __n; }
7917 friend constexpr _Iterator
7918 operator-(_Iterator __i, difference_type __n)
7924 friend constexpr difference_type
7925 operator-(const _Iterator& __x, const _Iterator& __y)
7927 return (static_cast<difference_type>(__x._M_current)
7928 - static_cast<difference_type>(__y._M_current));
7936 template<typename _Tp, typename _Bound>
7937 inline constexpr bool __is_repeat_view<repeat_view<_Tp, _Bound>> = true;
7939 template<typename _Tp>
7940 concept __can_repeat_view
7941 = requires { repeat_view(std::declval<_Tp>()); };
7943 template<typename _Tp, typename _Bound>
7944 concept __can_bounded_repeat_view
7945 = requires { repeat_view(std::declval<_Tp>(), std::declval<_Bound>()); };
7950 template<typename _Tp>
7951 requires __detail::__can_repeat_view<_Tp>
7953 operator() [[nodiscard]] (_Tp&& __value) const
7955 // _GLIBCXX_RESOLVE_LIB_DEFECTS
7956 // 4054. Repeating a repeat_view should repeat the view
7957 return repeat_view<decay_t<_Tp>>(std::forward<_Tp>(__value));
7960 template<typename _Tp, typename _Bound>
7961 requires __detail::__can_bounded_repeat_view<_Tp, _Bound>
7963 operator() [[nodiscard]] (_Tp&& __value, _Bound __bound) const
7964 { return repeat_view(std::forward<_Tp>(__value), __bound); }
7967 inline constexpr _Repeat repeat;
7971 template<typename _Range>
7973 __take_of_repeat_view(_Range&& __r, range_difference_t<_Range> __n)
7975 using _Tp = remove_cvref_t<_Range>;
7976 static_assert(__is_repeat_view<_Tp>);
7977 if constexpr (sized_range<_Tp>)
7978 return views::repeat(*std::forward<_Range>(__r)._M_value,
7979 std::min(ranges::distance(__r), __n));
7981 return views::repeat(*std::forward<_Range>(__r)._M_value, __n);
7984 template<typename _Range>
7986 __drop_of_repeat_view(_Range&& __r, range_difference_t<_Range> __n)
7988 using _Tp = remove_cvref_t<_Range>;
7989 static_assert(__is_repeat_view<_Tp>);
7990 if constexpr (sized_range<_Tp>)
7992 auto __sz = ranges::distance(__r);
7993 return views::repeat(*std::forward<_Range>(__r)._M_value,
7994 __sz - std::min(__sz, __n));
8001#endif // __cpp_lib_ranges_repeat
8003#ifdef __cpp_lib_ranges_stride // C++ >= 23
8004 template<input_range _Vp>
8006 class stride_view : public view_interface<stride_view<_Vp>>
8009 range_difference_t<_Vp> _M_stride;
8011 template<bool _Const> using _Base = __detail::__maybe_const_t<_Const, _Vp>;
8013 template<bool _Const>
8017 template<bool _Const>
8018 requires forward_range<_Base<_Const>>
8019 struct __iter_cat<_Const>
8025 using _Cat = typename iterator_traits<iterator_t<_Base<_Const>>>::iterator_category;
8026 if constexpr (derived_from<_Cat, random_access_iterator_tag>)
8027 return random_access_iterator_tag{};
8032 using iterator_category = decltype(_S_iter_cat());
8035 template<bool> class _Iterator;
8039 stride_view(_Vp __base, range_difference_t<_Vp> __stride)
8040 : _M_base(std::move(__base)), _M_stride(__stride)
8041 { __glibcxx_assert(__stride > 0); }
8044 base() const& requires copy_constructible<_Vp>
8049 { return std::move(_M_base); }
8051 constexpr range_difference_t<_Vp>
8052 stride() const noexcept
8053 { return _M_stride; }
8056 begin() requires (!__detail::__simple_view<_Vp>)
8057 { return _Iterator<false>(this, ranges::begin(_M_base)); }
8060 begin() const requires range<const _Vp>
8061 { return _Iterator<true>(this, ranges::begin(_M_base)); }
8064 end() requires (!__detail::__simple_view<_Vp>)
8066 if constexpr (common_range<_Vp> && sized_range<_Vp> && forward_range<_Vp>)
8068 auto __missing = (_M_stride - ranges::distance(_M_base) % _M_stride) % _M_stride;
8069 return _Iterator<false>(this, ranges::end(_M_base), __missing);
8071 else if constexpr (common_range<_Vp> && !bidirectional_range<_Vp>)
8072 return _Iterator<false>(this, ranges::end(_M_base));
8074 return default_sentinel;
8078 end() const requires range<const _Vp>
8080 if constexpr (common_range<const _Vp> && sized_range<const _Vp>
8081 && forward_range<const _Vp>)
8083 auto __missing = (_M_stride - ranges::distance(_M_base) % _M_stride) % _M_stride;
8084 return _Iterator<true>(this, ranges::end(_M_base), __missing);
8086 else if constexpr (common_range<const _Vp> && !bidirectional_range<const _Vp>)
8087 return _Iterator<true>(this, ranges::end(_M_base));
8089 return default_sentinel;
8093 size() requires sized_range<_Vp>
8095 return __detail::__to_unsigned_like
8096 (__detail::__div_ceil(ranges::distance(_M_base), _M_stride));
8100 size() const requires sized_range<const _Vp>
8102 return __detail::__to_unsigned_like
8103 (__detail::__div_ceil(ranges::distance(_M_base), _M_stride));
8107 template<typename _Range>
8108 stride_view(_Range&&, range_difference_t<_Range>) -> stride_view<views::all_t<_Range>>;
8110 template<typename _Vp>
8111 inline constexpr bool enable_borrowed_range<stride_view<_Vp>>
8112 = enable_borrowed_range<_Vp>;
8114 template<input_range _Vp>
8116 template<bool _Const>
8117 class stride_view<_Vp>::_Iterator : public __iter_cat<_Const>
8119 using _Parent = __detail::__maybe_const_t<_Const, stride_view>;
8120 using _Base = stride_view::_Base<_Const>;
8122 iterator_t<_Base> _M_current = iterator_t<_Base>();
8123 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
8124 range_difference_t<_Base> _M_stride = 0;
8125 range_difference_t<_Base> _M_missing = 0;
8128 _Iterator(_Parent* __parent, iterator_t<_Base> __current,
8129 range_difference_t<_Base> __missing = 0)
8130 : _M_current(std::move(__current)), _M_end(ranges::end(__parent->_M_base)),
8131 _M_stride(__parent->_M_stride), _M_missing(__missing)
8137 if constexpr (random_access_range<_Base>)
8138 return random_access_iterator_tag{};
8139 else if constexpr (bidirectional_range<_Base>)
8140 return bidirectional_iterator_tag{};
8141 else if constexpr (forward_range<_Base>)
8142 return forward_iterator_tag{};
8144 return input_iterator_tag{};
8150 using difference_type = range_difference_t<_Base>;
8151 using value_type = range_value_t<_Base>;
8152 using iterator_concept = decltype(_S_iter_concept());
8153 // iterator_category defined in stride_view::__iter_cat
8155 _Iterator() requires default_initializable<iterator_t<_Base>> = default;
8158 _Iterator(_Iterator<!_Const> __other)
8160 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
8161 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
8162 : _M_current(std::move(__other._M_current)), _M_end(std::move(__other._M_end)),
8163 _M_stride(__other._M_stride), _M_missing(__other._M_missing)
8166 constexpr iterator_t<_Base>
8168 { return std::move(_M_current); }
8170 constexpr const iterator_t<_Base>&
8171 base() const & noexcept
8172 { return _M_current; }
8174 constexpr decltype(auto)
8176 { return *_M_current; }
8178 constexpr _Iterator&
8181 __glibcxx_assert(_M_current != _M_end);
8182 _M_missing = ranges::advance(_M_current, _M_stride, _M_end);
8191 operator++(int) requires forward_range<_Base>
8198 constexpr _Iterator&
8199 operator--() requires bidirectional_range<_Base>
8201 ranges::advance(_M_current, _M_missing - _M_stride);
8207 operator--(int) requires bidirectional_range<_Base>
8214 constexpr _Iterator&
8215 operator+=(difference_type __n) requires random_access_range<_Base>
8219 __glibcxx_assert(ranges::distance(_M_current, _M_end) > _M_stride * (__n - 1));
8220 _M_missing = ranges::advance(_M_current, _M_stride * __n, _M_end);
8224 ranges::advance(_M_current, _M_stride * __n + _M_missing);
8230 constexpr _Iterator&
8231 operator-=(difference_type __n) requires random_access_range<_Base>
8232 { return *this += -__n; }
8234 constexpr decltype(auto) operator[](difference_type __n) const
8235 requires random_access_range<_Base>
8236 { return *(*this + __n); }
8238 friend constexpr bool
8239 operator==(const _Iterator& __x, default_sentinel_t)
8240 { return __x._M_current == __x._M_end; }
8242 friend constexpr bool
8243 operator==(const _Iterator& __x, const _Iterator& __y)
8244 requires equality_comparable<iterator_t<_Base>>
8245 { return __x._M_current == __y._M_current; }
8247 friend constexpr bool
8248 operator<(const _Iterator& __x, const _Iterator& __y)
8249 requires random_access_range<_Base>
8250 { return __x._M_current < __y._M_current; }
8252 friend constexpr bool
8253 operator>(const _Iterator& __x, const _Iterator& __y)
8254 requires random_access_range<_Base>
8255 { return __y._M_current < __x._M_current; }
8257 friend constexpr bool
8258 operator<=(const _Iterator& __x, const _Iterator& __y)
8259 requires random_access_range<_Base>
8260 { return !(__y._M_current < __x._M_current); }
8262 friend constexpr bool
8263 operator>=(const _Iterator& __x, const _Iterator& __y)
8264 requires random_access_range<_Base>
8265 { return !(__x._M_current < __y._M_current); }
8267 friend constexpr auto
8268 operator<=>(const _Iterator& __x, const _Iterator& __y)
8269 requires random_access_range<_Base> && three_way_comparable<iterator_t<_Base>>
8270 { return __x._M_current <=> __y._M_current; }
8272 friend constexpr _Iterator
8273 operator+(const _Iterator& __i, difference_type __n)
8274 requires random_access_range<_Base>
8281 friend constexpr _Iterator
8282 operator+(difference_type __n, const _Iterator& __i)
8283 requires random_access_range<_Base>
8284 { return __i + __n; }
8286 friend constexpr _Iterator
8287 operator-(const _Iterator& __i, difference_type __n)
8288 requires random_access_range<_Base>
8295 friend constexpr difference_type
8296 operator-(const _Iterator& __x, const _Iterator& __y)
8297 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
8299 auto __n = __x._M_current - __y._M_current;
8300 if constexpr (forward_range<_Base>)
8301 return (__n + __x._M_missing - __y._M_missing) / __x._M_stride;
8303 return -__detail::__div_ceil(-__n, __x._M_stride);
8305 return __detail::__div_ceil(__n, __x._M_stride);
8308 friend constexpr difference_type
8309 operator-(default_sentinel_t, const _Iterator& __x)
8310 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
8311 { return __detail::__div_ceil(__x._M_end - __x._M_current, __x._M_stride); }
8313 friend constexpr difference_type
8314 operator-(const _Iterator& __x, default_sentinel_t __y)
8315 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
8316 { return -(__y - __x); }
8318 friend constexpr range_rvalue_reference_t<_Base>
8319 iter_move(const _Iterator& __i)
8320 noexcept(noexcept(ranges::iter_move(__i._M_current)))
8321 { return ranges::iter_move(__i._M_current); }
8323 friend constexpr void
8324 iter_swap(const _Iterator& __x, const _Iterator& __y)
8325 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
8326 requires indirectly_swappable<iterator_t<_Base>>
8327 { ranges::iter_swap(__x._M_current, __y._M_current); }
8334 template<typename _Range, typename _Dp>
8335 concept __can_stride_view
8336 = requires { stride_view(std::declval<_Range>(), std::declval<_Dp>()); };
8339 struct _Stride : __adaptor::_RangeAdaptor<_Stride>
8341 template<viewable_range _Range, typename _Dp = range_difference_t<_Range>>
8342 requires __detail::__can_stride_view<_Range, _Dp>
8344 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n) const
8345 { return stride_view(std::forward<_Range>(__r), __n); }
8347 using __adaptor::_RangeAdaptor<_Stride>::operator();
8348 static constexpr int _S_arity = 2;
8349 static constexpr bool _S_has_simple_extra_args = true;
8352 inline constexpr _Stride stride;
8354#endif // __cpp_lib_ranges_stride
8356#ifdef __cpp_lib_ranges_cartesian_product // C++ >= 23
8359 template<bool _Const, typename _First, typename... _Vs>
8360 concept __cartesian_product_is_random_access
8361 = (random_access_range<__maybe_const_t<_Const, _First>>
8363 && (random_access_range<__maybe_const_t<_Const, _Vs>>
8364 && sized_range<__maybe_const_t<_Const, _Vs>>));
8366 template<typename _Range>
8367 concept __cartesian_product_common_arg
8368 = common_range<_Range> || (sized_range<_Range> && random_access_range<_Range>);
8370 template<bool _Const, typename _First, typename... _Vs>
8371 concept __cartesian_product_is_bidirectional
8372 = (bidirectional_range<__maybe_const_t<_Const, _First>>
8374 && (bidirectional_range<__maybe_const_t<_Const, _Vs>>
8375 && __cartesian_product_common_arg<__maybe_const_t<_Const, _Vs>>));
8377 template<typename _First, typename... _Vs>
8378 concept __cartesian_product_is_common = __cartesian_product_common_arg<_First>;
8380 template<typename... _Vs>
8381 concept __cartesian_product_is_sized = (sized_range<_Vs> && ...);
8383 template<bool _Const, template<typename> class FirstSent, typename _First, typename... _Vs>
8384 concept __cartesian_is_sized_sentinel
8385 = (sized_sentinel_for<FirstSent<__maybe_const_t<_Const, _First>>,
8386 iterator_t<__maybe_const_t<_Const, _First>>>
8388 && (sized_range<__maybe_const_t<_Const, _Vs>>
8389 && sized_sentinel_for<iterator_t<__maybe_const_t<_Const, _Vs>>,
8390 iterator_t<__maybe_const_t<_Const, _Vs>>>));
8392 template<__cartesian_product_common_arg _Range>
8394 __cartesian_common_arg_end(_Range& __r)
8396 if constexpr (common_range<_Range>)
8397 return ranges::end(__r);
8399 return ranges::begin(__r) + ranges::distance(__r);
8401 } // namespace __detail
8403 template<input_range _First, forward_range... _Vs>
8404 requires (view<_First> && ... && view<_Vs>)
8405 class cartesian_product_view : public view_interface<cartesian_product_view<_First, _Vs...>>
8407 tuple<_First, _Vs...> _M_bases;
8409 template<bool> class _Iterator;
8412 _S_difference_type()
8414 // TODO: Implement the recommended practice of using the smallest
8415 // sufficiently wide type according to the maximum sizes of the
8416 // underlying ranges?
8417 return common_type_t<ptrdiff_t,
8418 range_difference_t<_First>,
8419 range_difference_t<_Vs>...>{};
8423 cartesian_product_view() = default;
8426 cartesian_product_view(_First __first, _Vs... __rest)
8427 : _M_bases(std::move(__first), std::move(__rest)...)
8430 constexpr _Iterator<false>
8431 begin() requires (!__detail::__simple_view<_First> || ... || !__detail::__simple_view<_Vs>)
8432 { return _Iterator<false>(*this, __detail::__tuple_transform(ranges::begin, _M_bases)); }
8434 constexpr _Iterator<true>
8435 begin() const requires (range<const _First> && ... && range<const _Vs>)
8436 { return _Iterator<true>(*this, __detail::__tuple_transform(ranges::begin, _M_bases)); }
8438 constexpr _Iterator<false>
8439 end() requires ((!__detail::__simple_view<_First> || ... || !__detail::__simple_view<_Vs>)
8440 && __detail::__cartesian_product_is_common<_First, _Vs...>)
8442 auto __its = [this]<size_t... _Is>(index_sequence<_Is...>) {
8443 using _Ret = tuple<iterator_t<_First>, iterator_t<_Vs>...>;
8444 bool __empty_tail = (ranges::empty(std::get<1 + _Is>(_M_bases)) || ...);
8445 auto& __first = std::get<0>(_M_bases);
8446 return _Ret{(__empty_tail
8447 ? ranges::begin(__first)
8448 : __detail::__cartesian_common_arg_end(__first)),
8449 ranges::begin(std::get<1 + _Is>(_M_bases))...};
8450 }(make_index_sequence<sizeof...(_Vs)>{});
8452 return _Iterator<false>{*this, std::move(__its)};
8455 constexpr _Iterator<true>
8456 end() const requires __detail::__cartesian_product_is_common<const _First, const _Vs...>
8458 auto __its = [this]<size_t... _Is>(index_sequence<_Is...>) {
8459 using _Ret = tuple<iterator_t<const _First>, iterator_t<const _Vs>...>;
8460 bool __empty_tail = (ranges::empty(std::get<1 + _Is>(_M_bases)) || ...);
8461 auto& __first = std::get<0>(_M_bases);
8462 return _Ret{(__empty_tail
8463 ? ranges::begin(__first)
8464 : __detail::__cartesian_common_arg_end(__first)),
8465 ranges::begin(std::get<1 + _Is>(_M_bases))...};
8466 }(make_index_sequence<sizeof...(_Vs)>{});
8468 return _Iterator<true>{*this, std::move(__its)};
8471 constexpr default_sentinel_t
8472 end() const noexcept
8473 { return default_sentinel; }
8476 size() requires __detail::__cartesian_product_is_sized<_First, _Vs...>
8478 using _ST = __detail::__make_unsigned_like_t<decltype(_S_difference_type())>;
8479 return [&]<size_t... _Is>(index_sequence<_Is...>) {
8480 auto __size = static_cast<_ST>(1);
8481#ifdef _GLIBCXX_ASSERTIONS
8482 if constexpr (integral<_ST>)
8485 = (__builtin_mul_overflow(__size,
8486 static_cast<_ST>(ranges::size(std::get<_Is>(_M_bases))),
8489 __glibcxx_assert(!__overflow);
8493 __size = (static_cast<_ST>(ranges::size(std::get<_Is>(_M_bases))) * ...);
8495 }(make_index_sequence<1 + sizeof...(_Vs)>{});
8499 size() const requires __detail::__cartesian_product_is_sized<const _First, const _Vs...>
8501 using _ST = __detail::__make_unsigned_like_t<decltype(_S_difference_type())>;
8502 return [&]<size_t... _Is>(index_sequence<_Is...>) {
8503 auto __size = static_cast<_ST>(1);
8504#ifdef _GLIBCXX_ASSERTIONS
8505 if constexpr (integral<_ST>)
8508 = (__builtin_mul_overflow(__size,
8509 static_cast<_ST>(ranges::size(std::get<_Is>(_M_bases))),
8512 __glibcxx_assert(!__overflow);
8516 __size = (static_cast<_ST>(ranges::size(std::get<_Is>(_M_bases))) * ...);
8518 }(make_index_sequence<1 + sizeof...(_Vs)>{});
8522 template<typename... _Vs>
8523 cartesian_product_view(_Vs&&...) -> cartesian_product_view<views::all_t<_Vs>...>;
8525 template<input_range _First, forward_range... _Vs>
8526 requires (view<_First> && ... && view<_Vs>)
8527 template<bool _Const>
8528 class cartesian_product_view<_First, _Vs...>::_Iterator
8530 using _Parent = __maybe_const_t<_Const, cartesian_product_view>;
8531 _Parent* _M_parent = nullptr;
8532 tuple<iterator_t<__maybe_const_t<_Const, _First>>,
8533 iterator_t<__maybe_const_t<_Const, _Vs>>...> _M_current;
8536 _Iterator(_Parent& __parent, decltype(_M_current) __current)
8537 : _M_parent(std::__addressof(__parent)),
8538 _M_current(std::move(__current))
8544 if constexpr (__detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>)
8545 return random_access_iterator_tag{};
8546 else if constexpr (__detail::__cartesian_product_is_bidirectional<_Const, _First, _Vs...>)
8547 return bidirectional_iterator_tag{};
8548 else if constexpr (forward_range<__maybe_const_t<_Const, _First>>)
8549 return forward_iterator_tag{};
8551 return input_iterator_tag{};
8554 friend cartesian_product_view;
8557 using iterator_category = input_iterator_tag;
8558 using iterator_concept = decltype(_S_iter_concept());
8560 = tuple<range_value_t<__maybe_const_t<_Const, _First>>,
8561 range_value_t<__maybe_const_t<_Const, _Vs>>...>;
8563 = tuple<range_reference_t<__maybe_const_t<_Const, _First>>,
8564 range_reference_t<__maybe_const_t<_Const, _Vs>>...>;
8565 using difference_type = decltype(cartesian_product_view::_S_difference_type());
8567 _Iterator() = default;
8570 _Iterator(_Iterator<!_Const> __i)
8572 && (convertible_to<iterator_t<_First>, iterator_t<const _First>>
8573 && ... && convertible_to<iterator_t<_Vs>, iterator_t<const _Vs>>)
8574 : _M_parent(std::__addressof(__i._M_parent)),
8575 _M_current(std::move(__i._M_current))
8581 auto __f = [](auto& __i) -> decltype(auto) {
8584 return __detail::__tuple_transform(__f, _M_current);
8587 constexpr _Iterator&
8599 operator++(int) requires forward_range<__maybe_const_t<_Const, _First>>
8606 constexpr _Iterator&
8608 requires __detail::__cartesian_product_is_bidirectional<_Const, _First, _Vs...>
8616 requires __detail::__cartesian_product_is_bidirectional<_Const, _First, _Vs...>
8623 constexpr _Iterator&
8624 operator+=(difference_type __x)
8625 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8631 constexpr _Iterator&
8632 operator-=(difference_type __x)
8633 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8634 { return *this += -__x; }
8637 operator[](difference_type __n) const
8638 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8639 { return *((*this) + __n); }
8641 friend constexpr bool
8642 operator==(const _Iterator& __x, const _Iterator& __y)
8643 requires equality_comparable<iterator_t<__maybe_const_t<_Const, _First>>>
8644 { return __x._M_current == __y._M_current; }
8646 friend constexpr bool
8647 operator==(const _Iterator& __x, default_sentinel_t)
8649 return [&]<size_t... _Is>(index_sequence<_Is...>) {
8650 return ((std::get<_Is>(__x._M_current)
8651 == ranges::end(std::get<_Is>(__x._M_parent->_M_bases)))
8653 }(make_index_sequence<1 + sizeof...(_Vs)>{});
8656 friend constexpr auto
8657 operator<=>(const _Iterator& __x, const _Iterator& __y)
8658 requires __detail::__all_random_access<_Const, _First, _Vs...>
8659 { return __x._M_current <=> __y._M_current; }
8661 friend constexpr _Iterator
8662 operator+(_Iterator __x, difference_type __y)
8663 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8664 { return __x += __y; }
8666 friend constexpr _Iterator
8667 operator+(difference_type __x, _Iterator __y)
8668 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8669 { return __y += __x; }
8671 friend constexpr _Iterator
8672 operator-(_Iterator __x, difference_type __y)
8673 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8674 { return __x -= __y; }
8676 friend constexpr difference_type
8677 operator-(const _Iterator& __x, const _Iterator& __y)
8678 requires __detail::__cartesian_is_sized_sentinel<_Const, iterator_t, _First, _Vs...>
8679 { return __x._M_distance_from(__y._M_current); }
8681 friend constexpr difference_type
8682 operator-(const _Iterator& __i, default_sentinel_t)
8683 requires __detail::__cartesian_is_sized_sentinel<_Const, sentinel_t, _First, _Vs...>
8685 tuple __end_tuple = [&]<size_t... _Is>(index_sequence<_Is...>) {
8686 return tuple{ranges::end(std::get<0>(__i._M_parent->_M_bases)),
8687 ranges::begin(std::get<1 + _Is>(__i._M_parent->_M_bases))...};
8688 }(make_index_sequence<sizeof...(_Vs)>{});
8689 return __i._M_distance_from(__end_tuple);
8692 friend constexpr difference_type
8693 operator-(default_sentinel_t, const _Iterator& __i)
8694 requires __detail::__cartesian_is_sized_sentinel<_Const, sentinel_t, _First, _Vs...>
8695 { return -(__i - default_sentinel); }
8697 friend constexpr auto
8698 iter_move(const _Iterator& __i)
8699 { return __detail::__tuple_transform(ranges::iter_move, __i._M_current); }
8701 friend constexpr void
8702 iter_swap(const _Iterator& __l, const _Iterator& __r)
8703 requires (indirectly_swappable<iterator_t<__maybe_const_t<_Const, _First>>>
8705 && indirectly_swappable<iterator_t<__maybe_const_t<_Const, _Vs>>>)
8707 [&]<size_t... _Is>(index_sequence<_Is...>) {
8708 (ranges::iter_swap(std::get<_Is>(__l._M_current), std::get<_Is>(__r._M_current)), ...);
8709 }(make_index_sequence<1 + sizeof...(_Vs)>{});
8713 template<size_t _Nm = sizeof...(_Vs)>
8717 auto& __it = std::get<_Nm>(_M_current);
8719 if constexpr (_Nm > 0)
8720 if (__it == ranges::end(std::get<_Nm>(_M_parent->_M_bases)))
8722 __it = ranges::begin(std::get<_Nm>(_M_parent->_M_bases));
8727 template<size_t _Nm = sizeof...(_Vs)>
8731 auto& __it = std::get<_Nm>(_M_current);
8732 if constexpr (_Nm > 0)
8733 if (__it == ranges::begin(std::get<_Nm>(_M_parent->_M_bases)))
8735 __it = __detail::__cartesian_common_arg_end(std::get<_Nm>(_M_parent->_M_bases));
8741 template<size_t _Nm = sizeof...(_Vs)>
8743 _M_advance(difference_type __x)
8744 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8752 // Constant time iterator advancement.
8753 auto& __r = std::get<_Nm>(_M_parent->_M_bases);
8754 auto& __it = std::get<_Nm>(_M_current);
8755 if constexpr (_Nm == 0)
8757#ifdef _GLIBCXX_ASSERTIONS
8758 if constexpr (sized_range<__maybe_const_t<_Const, _First>>)
8760 auto __size = ranges::ssize(__r);
8761 auto __begin = ranges::begin(__r);
8762 auto __offset = __it - __begin;
8763 __glibcxx_assert(__offset + __x >= 0 && __offset + __x <= __size);
8770 auto __size = ranges::ssize(__r);
8771 auto __begin = ranges::begin(__r);
8772 auto __offset = __it - __begin;
8774 __x = __offset / __size;
8778 __offset = __size + __offset;
8781 __it = __begin + __offset;
8782 _M_advance<_Nm - 1>(__x);
8787 template<typename _Tuple>
8788 constexpr difference_type
8789 _M_distance_from(const _Tuple& __t) const
8791 return [&]<size_t... _Is>(index_sequence<_Is...>) {
8792 auto __sum = static_cast<difference_type>(0);
8793#ifdef _GLIBCXX_ASSERTIONS
8794 if constexpr (integral<difference_type>)
8797 = (__builtin_add_overflow(__sum, _M_scaled_distance<_Is>(__t), &__sum)
8799 __glibcxx_assert(!__overflow);
8803 __sum = (_M_scaled_distance<_Is>(__t) + ...);
8805 }(make_index_sequence<1 + sizeof...(_Vs)>{});
8808 template<size_t _Nm, typename _Tuple>
8809 constexpr difference_type
8810 _M_scaled_distance(const _Tuple& __t) const
8812 auto __dist = static_cast<difference_type>(std::get<_Nm>(_M_current)
8813 - std::get<_Nm>(__t));
8814#ifdef _GLIBCXX_ASSERTIONS
8815 if constexpr (integral<difference_type>)
8817 bool __overflow = __builtin_mul_overflow(__dist, _M_scaled_size<_Nm+1>(), &__dist);
8818 __glibcxx_assert(!__overflow);
8822 __dist *= _M_scaled_size<_Nm+1>();
8826 template<size_t _Nm>
8827 constexpr difference_type
8828 _M_scaled_size() const
8830 if constexpr (_Nm <= sizeof...(_Vs))
8832 auto __size = static_cast<difference_type>(ranges::size
8833 (std::get<_Nm>(_M_parent->_M_bases)));
8834#ifdef _GLIBCXX_ASSERTIONS
8835 if constexpr (integral<difference_type>)
8837 bool __overflow = __builtin_mul_overflow(__size, _M_scaled_size<_Nm+1>(), &__size);
8838 __glibcxx_assert(!__overflow);
8842 __size *= _M_scaled_size<_Nm+1>();
8846 return static_cast<difference_type>(1);
8854 template<typename... _Ts>
8855 concept __can_cartesian_product_view
8856 = requires { cartesian_product_view<all_t<_Ts>...>(std::declval<_Ts>()...); };
8859 struct _CartesianProduct
8861 template<typename... _Ts>
8862 requires (sizeof...(_Ts) == 0 || __detail::__can_cartesian_product_view<_Ts...>)
8864 operator() [[nodiscard]] (_Ts&&... __ts) const
8866 if constexpr (sizeof...(_Ts) == 0)
8867 return views::single(tuple{});
8869 return cartesian_product_view<all_t<_Ts>...>(std::forward<_Ts>(__ts)...);
8873 inline constexpr _CartesianProduct cartesian_product;
8875#endif // __cpp_lib_ranges_cartesian_product
8877#ifdef __cpp_lib_ranges_as_rvalue // C++ >= 23
8878 template<input_range _Vp>
8880 class as_rvalue_view : public view_interface<as_rvalue_view<_Vp>>
8882 _Vp _M_base = _Vp();
8885 as_rvalue_view() requires default_initializable<_Vp> = default;
8888 as_rvalue_view(_Vp __base)
8889 : _M_base(std::move(__base))
8893 base() const& requires copy_constructible<_Vp>
8898 { return std::move(_M_base); }
8901 begin() requires (!__detail::__simple_view<_Vp>)
8902 { return move_iterator(ranges::begin(_M_base)); }
8905 begin() const requires range<const _Vp>
8906 { return move_iterator(ranges::begin(_M_base)); }
8909 end() requires (!__detail::__simple_view<_Vp>)
8911 if constexpr (common_range<_Vp>)
8912 return move_iterator(ranges::end(_M_base));
8914 return move_sentinel(ranges::end(_M_base));
8918 end() const requires range<const _Vp>
8920 if constexpr (common_range<const _Vp>)
8921 return move_iterator(ranges::end(_M_base));
8923 return move_sentinel(ranges::end(_M_base));
8927 size() requires sized_range<_Vp>
8928 { return ranges::size(_M_base); }
8931 size() const requires sized_range<const _Vp>
8932 { return ranges::size(_M_base); }
8935 template<typename _Range>
8936 as_rvalue_view(_Range&&) -> as_rvalue_view<views::all_t<_Range>>;
8938 template<typename _Tp>
8939 inline constexpr bool enable_borrowed_range<as_rvalue_view<_Tp>>
8940 = enable_borrowed_range<_Tp>;
8946 template<typename _Tp>
8947 concept __can_as_rvalue_view = requires { as_rvalue_view(std::declval<_Tp>()); };
8950 struct _AsRvalue : __adaptor::_RangeAdaptorClosure<_AsRvalue>
8952 template<viewable_range _Range>
8953 requires __detail::__can_as_rvalue_view<_Range>
8955 operator() [[nodiscard]] (_Range&& __r) const
8957 if constexpr (same_as<range_rvalue_reference_t<_Range>,
8958 range_reference_t<_Range>>)
8959 return views::all(std::forward<_Range>(__r));
8961 return as_rvalue_view(std::forward<_Range>(__r));
8965 inline constexpr _AsRvalue as_rvalue;
8967#endif // __cpp_lib_as_rvalue
8969#ifdef __cpp_lib_ranges_enumerate // C++ >= 23
8972 template<typename _Range>
8973 concept __range_with_movable_reference = input_range<_Range>
8974 && move_constructible<range_reference_t<_Range>>
8975 && move_constructible<range_rvalue_reference_t<_Range>>;
8979 requires __detail::__range_with_movable_reference<_Vp>
8980 class enumerate_view : public view_interface<enumerate_view<_Vp>>
8982 _Vp _M_base = _Vp();
8984 template<bool _Const> class _Iterator;
8985 template<bool _Const> class _Sentinel;
8988 enumerate_view() requires default_initializable<_Vp> = default;
8991 enumerate_view(_Vp __base)
8992 : _M_base(std::move(__base))
8996 begin() requires (!__detail::__simple_view<_Vp>)
8997 { return _Iterator<false>(ranges::begin(_M_base), 0); }
9000 begin() const requires __detail::__range_with_movable_reference<const _Vp>
9001 { return _Iterator<true>(ranges::begin(_M_base), 0); }
9004 end() requires (!__detail::__simple_view<_Vp>)
9006 if constexpr (common_range<_Vp> && sized_range<_Vp>)
9007 return _Iterator<false>(ranges::end(_M_base), ranges::distance(_M_base));
9009 return _Sentinel<false>(ranges::end(_M_base));
9013 end() const requires __detail::__range_with_movable_reference<const _Vp>
9015 if constexpr (common_range<const _Vp> && sized_range<const _Vp>)
9016 return _Iterator<true>(ranges::end(_M_base), ranges::distance(_M_base));
9018 return _Sentinel<true>(ranges::end(_M_base));
9022 size() requires sized_range<_Vp>
9023 { return ranges::size(_M_base); }
9026 size() const requires sized_range<const _Vp>
9027 { return ranges::size(_M_base); }
9030 base() const & requires copy_constructible<_Vp>
9035 { return std::move(_M_base); }
9038 template<typename _Range>
9039 enumerate_view(_Range&&) -> enumerate_view<views::all_t<_Range>>;
9041 template<typename _Tp>
9042 inline constexpr bool enable_borrowed_range<enumerate_view<_Tp>>
9043 = enable_borrowed_range<_Tp>;
9046 requires __detail::__range_with_movable_reference<_Vp>
9047 template<bool _Const>
9048 class enumerate_view<_Vp>::_Iterator
9050 using _Base = __maybe_const_t<_Const, _Vp>;
9055 if constexpr (random_access_range<_Base>)
9056 return random_access_iterator_tag{};
9057 else if constexpr (bidirectional_range<_Base>)
9058 return bidirectional_iterator_tag{};
9059 else if constexpr (forward_range<_Base>)
9060 return forward_iterator_tag{};
9062 return input_iterator_tag{};
9065 friend enumerate_view;
9068 using iterator_category = input_iterator_tag;
9069 using iterator_concept = decltype(_S_iter_concept());
9070 using difference_type = range_difference_t<_Base>;
9071 using value_type = tuple<difference_type, range_value_t<_Base>>;
9074 using __reference_type = tuple<difference_type, range_reference_t<_Base>>;
9076 iterator_t<_Base> _M_current = iterator_t<_Base>();
9077 difference_type _M_pos = 0;
9080 _Iterator(iterator_t<_Base> __current, difference_type __pos)
9081 : _M_current(std::move(__current)), _M_pos(__pos)
9085 _Iterator() requires default_initializable<iterator_t<_Base>> = default;
9088 _Iterator(_Iterator<!_Const> __i)
9089 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
9090 : _M_current(std::move(__i._M_current)), _M_pos(__i._M_pos)
9093 constexpr const iterator_t<_Base> &
9094 base() const & noexcept
9095 { return _M_current; }
9097 constexpr iterator_t<_Base>
9099 { return std::move(_M_current); }
9101 constexpr difference_type
9102 index() const noexcept
9107 { return __reference_type(_M_pos, *_M_current); }
9109 constexpr _Iterator&
9122 operator++(int) requires forward_range<_Base>
9129 constexpr _Iterator&
9130 operator--() requires bidirectional_range<_Base>
9138 operator--(int) requires bidirectional_range<_Base>
9145 constexpr _Iterator&
9146 operator+=(difference_type __n) requires random_access_range<_Base>
9153 constexpr _Iterator&
9154 operator-=(difference_type __n) requires random_access_range<_Base>
9162 operator[](difference_type __n) const requires random_access_range<_Base>
9163 { return __reference_type(_M_pos + __n, _M_current[__n]); }
9165 friend constexpr bool
9166 operator==(const _Iterator& __x, const _Iterator& __y) noexcept
9167 { return __x._M_pos == __y._M_pos; }
9169 friend constexpr strong_ordering
9170 operator<=>(const _Iterator& __x, const _Iterator& __y) noexcept
9171 { return __x._M_pos <=> __y._M_pos; }
9173 friend constexpr _Iterator
9174 operator+(const _Iterator& __x, difference_type __y)
9175 requires random_access_range<_Base>
9176 { return (auto(__x) += __y); }
9178 friend constexpr _Iterator
9179 operator+(difference_type __x, const _Iterator& __y)
9180 requires random_access_range<_Base>
9181 { return auto(__y) += __x; }
9183 friend constexpr _Iterator
9184 operator-(const _Iterator& __x, difference_type __y)
9185 requires random_access_range<_Base>
9186 { return auto(__x) -= __y; }
9188 friend constexpr difference_type
9189 operator-(const _Iterator& __x, const _Iterator& __y) noexcept
9190 { return __x._M_pos - __y._M_pos; }
9192 friend constexpr auto
9193 iter_move(const _Iterator& __i)
9194 noexcept(noexcept(ranges::iter_move(__i._M_current))
9195 && is_nothrow_move_constructible_v<range_rvalue_reference_t<_Base>>)
9197 return tuple<difference_type, range_rvalue_reference_t<_Base>>
9198 (__i._M_pos, ranges::iter_move(__i._M_current));
9203 requires __detail::__range_with_movable_reference<_Vp>
9204 template<bool _Const>
9205 class enumerate_view<_Vp>::_Sentinel
9207 using _Base = __maybe_const_t<_Const, _Vp>;
9209 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
9212 _Sentinel(sentinel_t<_Base> __end)
9213 : _M_end(std::move(__end))
9216 friend enumerate_view;
9219 _Sentinel() = default;
9222 _Sentinel(_Sentinel<!_Const> __other)
9223 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
9224 : _M_end(std::move(__other._M_end))
9227 constexpr sentinel_t<_Base>
9231 template<bool _OtherConst>
9232 requires sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const_t<_OtherConst, _Vp>>>
9233 friend constexpr bool
9234 operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
9235 { return __x._M_current == __y._M_end; }
9237 template<bool _OtherConst>
9238 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const_t<_OtherConst, _Vp>>>
9239 friend constexpr range_difference_t<__maybe_const_t<_OtherConst, _Vp>>
9240 operator-(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
9241 { return __x._M_current - __y._M_end; }
9243 template<bool _OtherConst>
9244 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const_t<_OtherConst, _Vp>>>
9245 friend constexpr range_difference_t<__maybe_const_t<_OtherConst, _Vp>>
9246 operator-(const _Sentinel& __x, const _Iterator<_OtherConst>& __y)
9247 { return __x._M_end - __y._M_current; }
9254 template<typename _Tp>
9255 concept __can_enumerate_view
9256 = requires { enumerate_view<all_t<_Tp>>(std::declval<_Tp>()); };
9259 struct _Enumerate : __adaptor::_RangeAdaptorClosure<_Enumerate>
9261 template<viewable_range _Range>
9262 requires __detail::__can_enumerate_view<_Range>
9264 operator() [[nodiscard]] (_Range&& __r) const
9265 { return enumerate_view<all_t<_Range>>(std::forward<_Range>(__r)); }
9268 inline constexpr _Enumerate enumerate;
9270#endif // __cpp_lib_ranges_enumerate
9272#ifdef __cpp_lib_ranges_as_const // C++ >= 23
9274 requires input_range<_Vp>
9275 class as_const_view : public view_interface<as_const_view<_Vp>>
9277 _Vp _M_base = _Vp();
9280 as_const_view() requires default_initializable<_Vp> = default;
9283 as_const_view(_Vp __base)
9284 noexcept(is_nothrow_move_constructible_v<_Vp>)
9285 : _M_base(std::move(__base))
9290 noexcept(is_nothrow_copy_constructible_v<_Vp>)
9291 requires copy_constructible<_Vp>
9296 noexcept(is_nothrow_move_constructible_v<_Vp>)
9297 { return std::move(_M_base); }
9300 begin() requires (!__detail::__simple_view<_Vp>)
9301 { return ranges::cbegin(_M_base); }
9304 begin() const requires range<const _Vp>
9305 { return ranges::cbegin(_M_base); }
9308 end() requires (!__detail::__simple_view<_Vp>)
9309 { return ranges::cend(_M_base); }
9312 end() const requires range<const _Vp>
9313 { return ranges::cend(_M_base); }
9316 size() requires sized_range<_Vp>
9317 { return ranges::size(_M_base); }
9320 size() const requires sized_range<const _Vp>
9321 { return ranges::size(_M_base); }
9324 template<typename _Range>
9325 as_const_view(_Range&&) -> as_const_view<views::all_t<_Range>>;
9327 template<typename _Tp>
9328 inline constexpr bool enable_borrowed_range<as_const_view<_Tp>>
9329 = enable_borrowed_range<_Tp>;
9335 template<typename _Tp>
9336 inline constexpr bool __is_constable_ref_view = false;
9338 template<typename _Range>
9339 inline constexpr bool __is_constable_ref_view<ref_view<_Range>>
9340 = constant_range<const _Range>;
9342 template<typename _Range>
9343 concept __can_as_const_view = requires { as_const_view(std::declval<_Range>()); };
9346 struct _AsConst : __adaptor::_RangeAdaptorClosure<_AsConst>
9348 template<viewable_range _Range>
9350 operator()(_Range&& __r) const
9351 noexcept(noexcept(as_const_view(std::declval<_Range>())))
9352 requires __detail::__can_as_const_view<_Range>
9354 using _Tp = remove_cvref_t<_Range>;
9355 using element_type = remove_reference_t<range_reference_t<_Range>>;
9356 if constexpr (constant_range<views::all_t<_Range>>)
9357 return views::all(std::forward<_Range>(__r));
9358 else if constexpr (__detail::__is_empty_view<_Tp>)
9359 return views::empty<const element_type>;
9360 else if constexpr (std::__detail::__is_span<_Tp>)
9361 return span<const element_type, _Tp::extent>(std::forward<_Range>(__r));
9362 else if constexpr (__detail::__is_constable_ref_view<_Tp>)
9363 return ref_view(std::as_const(std::forward<_Range>(__r).base()));
9364 else if constexpr (is_lvalue_reference_v<_Range>
9365 && constant_range<const _Tp>
9367 return ref_view(static_cast<const _Tp&>(__r));
9369 return as_const_view(std::forward<_Range>(__r));
9373 inline constexpr _AsConst as_const;
9375#endif // __cpp_lib_as_const
9376} // namespace ranges
9378 namespace views = ranges::views;
9380#if __cpp_lib_ranges_to_container // C++ >= 23
9383/// @cond undocumented
9386 template<typename _Container>
9387 constexpr bool __reservable_container
9388 = sized_range<_Container>
9389 && requires(_Container& __c, range_size_t<_Container> __n) {
9391 { __c.capacity() } -> same_as<decltype(__n)>;
9392 { __c.max_size() } -> same_as<decltype(__n)>;
9395 template<typename _Cont, typename _Range>
9396 constexpr bool __toable = requires {
9397 requires (!input_range<_Cont>
9398 || convertible_to<range_reference_t<_Range>,
9399 range_value_t<_Cont>>);
9401} // namespace __detail
9404 /// Convert a range to a container.
9406 * @tparam _Cont A container type.
9407 * @param __r A range that models the `input_range` concept.
9408 * @param __args... Arguments to pass to the container constructor.
9411 * This function converts a range to the `_Cont` type.
9413 * For example, `std::ranges::to<std::vector<int>>(some_view)`
9414 * will convert the view to `std::vector<int>`.
9416 * Additional constructor arguments for the container can be supplied after
9417 * the input range argument, e.g.
9418 * `std::ranges::to<std::vector<int, Alloc<int>>>(a_range, an_allocator)`.
9420 template<typename _Cont, input_range _Rg, typename... _Args>
9421 requires (!view<_Cont>)
9423 to [[nodiscard]] (_Rg&& __r, _Args&&... __args)
9425 static_assert(!is_const_v<_Cont> && !is_volatile_v<_Cont>);
9426 static_assert(is_class_v<_Cont> || is_union_v<_Cont>);
9428 if constexpr (__detail::__toable<_Cont, _Rg>)
9430 if constexpr (constructible_from<_Cont, _Rg, _Args...>)
9431 return _Cont(std::forward<_Rg>(__r),
9432 std::forward<_Args>(__args)...);
9433 else if constexpr (constructible_from<_Cont, from_range_t, _Rg, _Args...>)
9434 return _Cont(from_range, std::forward<_Rg>(__r),
9435 std::forward<_Args>(__args)...);
9436 else if constexpr (requires { requires common_range<_Rg>;
9437 typename __iter_category_t<iterator_t<_Rg>>;
9438 requires derived_from<__iter_category_t<iterator_t<_Rg>>,
9439 input_iterator_tag>;
9440 requires constructible_from<_Cont, iterator_t<_Rg>,
9441 sentinel_t<_Rg>, _Args...>;
9443 return _Cont(ranges::begin(__r), ranges::end(__r),
9444 std::forward<_Args>(__args)...);
9447 static_assert(constructible_from<_Cont, _Args...>);
9448 _Cont __c(std::forward<_Args>(__args)...);
9449 if constexpr (sized_range<_Rg>
9450 && __detail::__reservable_container<_Cont>)
9451 __c.reserve(static_cast<range_size_t<_Cont>>(ranges::size(__r)));
9452 // _GLIBCXX_RESOLVE_LIB_DEFECTS
9453 // 4016. container-insertable checks do not match what
9454 // container-inserter does
9455 auto __it = ranges::begin(__r);
9456 const auto __sent = ranges::end(__r);
9457 while (__it != __sent)
9459 if constexpr (requires { __c.emplace_back(*__it); })
9460 __c.emplace_back(*__it);
9461 else if constexpr (requires { __c.push_back(*__it); })
9462 __c.push_back(*__it);
9463 else if constexpr (requires { __c.emplace(__c.end(), *__it); })
9464 __c.emplace(__c.end(), *__it);
9466 __c.insert(__c.end(), *__it);
9474 static_assert(input_range<range_reference_t<_Rg>>);
9475 // _GLIBCXX_RESOLVE_LIB_DEFECTS
9476 // 3984. ranges::to's recursion branch may be ill-formed
9477 return ranges::to<_Cont>(ref_view(__r) | views::transform(
9478 []<typename _Elt>(_Elt&& __elem) {
9479 using _ValT = range_value_t<_Cont>;
9480 return ranges::to<_ValT>(std::forward<_Elt>(__elem));
9481 }), std::forward<_Args>(__args)...);
9485/// @cond undocumented
9488 template<typename _Rg>
9491 using iterator_category = input_iterator_tag;
9492 using value_type = range_value_t<_Rg>;
9493 using difference_type = ptrdiff_t;
9494 using pointer = add_pointer_t<range_reference_t<_Rg>>;
9495 using reference = range_reference_t<_Rg>;
9496 reference operator*() const;
9497 pointer operator->() const;
9498 _InputIter& operator++();
9499 _InputIter operator++(int);
9500 bool operator==(const _InputIter&) const;
9503 template<template<typename...> typename _Cont, input_range _Rg,
9506 = decltype(_Cont(std::declval<_Rg>(), std::declval<_Args>()...));
9508 template<template<typename...> typename _Cont, input_range _Rg,
9511 = decltype(_Cont(from_range, std::declval<_Rg>(),
9512 std::declval<_Args>()...));
9514 template<template<typename...> typename _Cont, input_range _Rg,
9517 = decltype(_Cont(std::declval<_InputIter<_Rg>>(),
9518 std::declval<_InputIter<_Rg>>(),
9519 std::declval<_Args>()...));
9521} // namespace __detail
9524 template<template<typename...> typename _Cont, input_range _Rg,
9527 to [[nodiscard]] (_Rg&& __r, _Args&&... __args)
9529 using __detail::_DeduceExpr1;
9530 using __detail::_DeduceExpr2;
9531 using __detail::_DeduceExpr3;
9532 if constexpr (requires { typename _DeduceExpr1<_Cont, _Rg, _Args...>; })
9533 return ranges::to<_DeduceExpr1<_Cont, _Rg, _Args...>>(
9534 std::forward<_Rg>(__r), std::forward<_Args>(__args)...);
9535 else if constexpr (requires { typename _DeduceExpr2<_Cont, _Rg, _Args...>; })
9536 return ranges::to<_DeduceExpr2<_Cont, _Rg, _Args...>>(
9537 std::forward<_Rg>(__r), std::forward<_Args>(__args)...);
9538 else if constexpr (requires { typename _DeduceExpr3<_Cont, _Rg, _Args...>; })
9539 return ranges::to<_DeduceExpr3<_Cont, _Rg, _Args...>>(
9540 std::forward<_Rg>(__r), std::forward<_Args>(__args)...);
9542 static_assert(false); // Cannot deduce container specialization.
9545/// @cond undocumented
9548 template<typename _Cont>
9551 template<typename _Range, typename... _Args>
9552 requires requires { ranges::to<_Cont>(std::declval<_Range>(),
9553 std::declval<_Args>()...); }
9555 operator()(_Range&& __r, _Args&&... __args) const
9557 return ranges::to<_Cont>(std::forward<_Range>(__r),
9558 std::forward<_Args>(__args)...);
9561} // namespace __detail
9564 /// ranges::to adaptor for converting a range to a container type
9566 * @tparam _Cont A container type.
9567 * @param __args... Arguments to pass to the container constructor.
9570 * This range adaptor returns a range adaptor closure object that converts
9571 * a range to the `_Cont` type.
9573 * For example, `some_view | std::ranges::to<std::vector<int>>()`
9574 * will convert the view to `std::vector<int>`.
9576 * Additional constructor arguments for the container can be supplied, e.g.
9577 * `r | std::ranges::to<std::vector<int, Alloc<int>>>(an_allocator)`.
9579 template<typename _Cont, typename... _Args>
9580 requires (!view<_Cont>)
9582 to [[nodiscard]] (_Args&&... __args)
9584 static_assert(!is_const_v<_Cont> && !is_volatile_v<_Cont>);
9585 static_assert(is_class_v<_Cont> || is_union_v<_Cont>);
9587 using __detail::_To;
9588 using views::__adaptor::_Partial;
9589 return _Partial<_To<_Cont>, decay_t<_Args>...>{0, std::forward<_Args>(__args)...};
9592/// @cond undocumented
9595 template<template<typename...> typename _Cont>
9598 template<typename _Range, typename... _Args>
9599 requires requires { ranges::to<_Cont>(std::declval<_Range>(),
9600 std::declval<_Args>()...); }
9602 operator()(_Range&& __r, _Args&&... __args) const
9604 return ranges::to<_Cont>(std::forward<_Range>(__r),
9605 std::forward<_Args>(__args)...);
9608} // namespace __detail
9611 /// ranges::to adaptor for converting a range to a deduced container type.
9613 * @tparam _Cont A container template.
9614 * @param __args... Arguments to pass to the container constructor.
9617 * This range adaptor returns a range adaptor closure object that converts
9618 * a range to a specialization of the `_Cont` class template. The specific
9619 * specialization of `_Cont` to be used is deduced automatically.
9621 * For example, `some_view | std::ranges::to<std::vector>(Alloc<int>{})`
9622 * will convert the view to `std::vector<T, Alloc<T>>`, where `T` is the
9623 * view's value type, i.e. `std::ranges::range_value_t<decltype(some_view)>`.
9625 * Additional constructor arguments for the container can be supplied, e.g.
9626 * `r | std::ranges::to<std::vector>(an_allocator)`.
9628 template<template<typename...> typename _Cont, typename... _Args>
9630 to [[nodiscard]] (_Args&&... __args)
9632 using __detail::_To2;
9633 using views::__adaptor::_Partial;
9634 return _Partial<_To2<_Cont>, decay_t<_Args>...>{0, std::forward<_Args>(__args)...};
9637} // namespace ranges
9638#endif // __cpp_lib_ranges_to_container
9640#if __cpp_lib_ranges_concat // C++ >= C++26
9645 template<typename... _Rs>
9646 using __concat_reference_t = common_reference_t<range_reference_t<_Rs>...>;
9648 template<typename... _Rs>
9649 using __concat_value_t = common_type_t<range_value_t<_Rs>...>;
9651 template<typename... _Rs>
9652 using __concat_rvalue_reference_t
9653 = common_reference_t<range_rvalue_reference_t<_Rs>...>;
9655 template<typename _Ref, typename _RRef, typename _It>
9656 concept __concat_indirectly_readable_impl = requires(const _It __it) {
9657 { *__it } -> convertible_to<_Ref>;
9658 { ranges::iter_move(__it) } -> convertible_to<_RRef>;
9661 template<typename... _Rs>
9662 concept __concat_indirectly_readable
9663 = common_reference_with<__concat_reference_t<_Rs...>&&, __concat_value_t<_Rs...>&>
9664 && common_reference_with<__concat_reference_t<_Rs...>&&,
9665 __concat_rvalue_reference_t<_Rs...>&&>
9666 && common_reference_with<__concat_rvalue_reference_t<_Rs...>&&,
9667 __concat_value_t<_Rs...> const&>
9668 && (__concat_indirectly_readable_impl<__concat_reference_t<_Rs...>,
9669 __concat_rvalue_reference_t<_Rs...>,
9673 template<typename... _Rs>
9674 concept __concatable = requires {
9675 typename __concat_reference_t<_Rs...>;
9676 typename __concat_value_t<_Rs...>;
9677 typename __concat_rvalue_reference_t<_Rs...>;
9678 } && __concat_indirectly_readable<_Rs...>;
9680 template<bool _Const, typename _Range, typename... _Rs>
9681 struct __all_but_last_common
9683 static inline constexpr bool value
9684 = requires { requires (common_range<__maybe_const_t<_Const, _Range>>
9685 && __all_but_last_common<_Const, _Rs...>::value); };
9688 template<bool _Const, typename _Range>
9689 struct __all_but_last_common<_Const, _Range>
9690 { static inline constexpr bool value = true; };
9692 template<bool _Const, typename... _Rs>
9693 concept __concat_is_random_access = __all_random_access<_Const, _Rs...>
9694 && __all_but_last_common<_Const, _Rs...>::value;
9696 template<bool _Const, typename... _Rs>
9697 concept __concat_is_bidirectional = __all_bidirectional<_Const, _Rs...>
9698 && __all_but_last_common<_Const, _Rs...>::value;
9700 template<typename _Range, typename... _Rs>
9701 struct __all_but_first_sized
9702 { static inline constexpr bool value = (sized_range<_Rs> && ...); };
9703 } // namespace __detail
9705 template<input_range... _Vs>
9706 requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0) && __detail::__concatable<_Vs...>
9707 class concat_view : public view_interface<concat_view<_Vs...>>
9709 tuple<_Vs...> _M_views;
9711 template<bool _Const> class _Iterator;
9714 constexpr concat_view() = default;
9717 concat_view(_Vs... __views)
9718 : _M_views(std::move(__views)...)
9721 constexpr _Iterator<false>
9722 begin() requires (!(__detail::__simple_view<_Vs> && ...))
9724 _Iterator<false> __it(this, in_place_index<0>, ranges::begin(std::get<0>(_M_views)));
9725 __it.template _M_satisfy<0>();
9729 constexpr _Iterator<true>
9730 begin() const requires (range<const _Vs> && ...) && __detail::__concatable<const _Vs...>
9732 _Iterator<true> __it(this, in_place_index<0>, ranges::begin(std::get<0>(_M_views)));
9733 __it.template _M_satisfy<0>();
9738 end() requires (!(__detail::__simple_view<_Vs> && ...))
9740 constexpr auto __n = sizeof...(_Vs);
9741 if constexpr (__detail::__all_forward<false, _Vs...>
9742 && common_range<_Vs...[__n - 1]>)
9743 return _Iterator<false>(this, in_place_index<__n - 1>,
9744 ranges::end(std::get<__n - 1>(_M_views)));
9746 return default_sentinel;
9750 end() const requires (range<const _Vs> && ...) && __detail::__concatable<const _Vs...>
9752 constexpr auto __n = sizeof...(_Vs);
9753 if constexpr (__detail::__all_forward<true, _Vs...>
9754 && common_range<const _Vs...[__n - 1]>)
9755 return _Iterator<true>(this, in_place_index<__n - 1>,
9756 ranges::end(std::get<__n - 1>(_M_views)));
9758 return default_sentinel;
9762 size() requires (sized_range<_Vs>&&...)
9764 return std::apply([](auto... __sizes) {
9765 using _CT = __detail::__make_unsigned_like_t<common_type_t<decltype(__sizes)...>>;
9766 return (_CT(__sizes) + ...);
9767 }, __detail::__tuple_transform(ranges::size, _M_views));
9771 size() const requires (sized_range<const _Vs>&&...)
9773 return std::apply([](auto... __sizes) {
9774 using _CT = __detail::__make_unsigned_like_t<common_type_t<decltype(__sizes)...>>;
9775 return (_CT(__sizes) + ...);
9776 }, __detail::__tuple_transform(ranges::size, _M_views));
9780 template<typename... _Rs>
9781 concat_view(_Rs&&...) -> concat_view<views::all_t<_Rs>...>;
9785 template<bool _Const, typename... _Vs>
9786 struct __concat_view_iter_cat
9789 template<bool _Const, typename... _Vs>
9790 requires __detail::__all_forward<_Const, _Vs...>
9791 struct __concat_view_iter_cat<_Const, _Vs...>
9796 if constexpr (!is_reference_v<__concat_reference_t<__maybe_const_t<_Const, _Vs>...>>)
9797 return input_iterator_tag{};
9799 return []<typename... _Cats>(_Cats... __cats) {
9800 if constexpr ((derived_from<_Cats, random_access_iterator_tag> && ...)
9801 && __concat_is_random_access<_Const, _Vs...>)
9802 return random_access_iterator_tag{};
9803 else if constexpr ((derived_from<_Cats, bidirectional_iterator_tag> && ...)
9804 && __concat_is_bidirectional<_Const, _Vs...>)
9805 return bidirectional_iterator_tag{};
9806 else if constexpr ((derived_from<_Cats, forward_iterator_tag> && ...))
9807 return forward_iterator_tag{};
9809 return input_iterator_tag{};
9810 }(typename iterator_traits<iterator_t<__maybe_const_t<_Const, _Vs>>>
9811 ::iterator_category{}...);
9816 template<input_range... _Vs>
9817 requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0) && __detail::__concatable<_Vs...>
9818 template<bool _Const>
9819 class concat_view<_Vs...>::_Iterator
9820 : public __detail::__concat_view_iter_cat<_Const, _Vs...>
9825 if constexpr (__detail::__concat_is_random_access<_Const, _Vs...>)
9826 return random_access_iterator_tag{};
9827 else if constexpr (__detail::__concat_is_bidirectional<_Const, _Vs...>)
9828 return bidirectional_iterator_tag{};
9829 else if constexpr (__detail::__all_forward<_Const, _Vs...>)
9830 return forward_iterator_tag{};
9832 return input_iterator_tag{};
9836 friend _Iterator<!_Const>;
9839 // iterator_category defined in __concat_view_iter_cat
9840 using iterator_concept = decltype(_S_iter_concept());
9841 using value_type = __detail::__concat_value_t<__maybe_const_t<_Const, _Vs>...>;
9842 using difference_type = common_type_t<range_difference_t<__maybe_const_t<_Const, _Vs>>...>;
9845 using __base_iter = variant<iterator_t<__maybe_const_t<_Const, _Vs>>...>;
9847 __maybe_const_t<_Const, concat_view>* _M_parent = nullptr;
9850 template<size_t _Nm>
9854 if constexpr (_Nm < (sizeof...(_Vs) - 1))
9856 if (std::get<_Nm>(_M_it) == ranges::end(std::get<_Nm>(_M_parent->_M_views)))
9858 _M_it.template emplace<_Nm + 1>(ranges::begin
9859 (std::get<_Nm + 1>(_M_parent->_M_views)));
9860 _M_satisfy<_Nm + 1>();
9865 template<size_t _Nm>
9869 if constexpr (_Nm == 0)
9870 --std::get<0>(_M_it);
9873 if (std::get<_Nm>(_M_it) == ranges::begin(std::get<_Nm>(_M_parent->_M_views)))
9875 _M_it.template emplace<_Nm - 1>(ranges::end
9876 (std::get<_Nm - 1>(_M_parent->_M_views)));
9880 --std::get<_Nm>(_M_it);
9884 template<size_t _Nm>
9886 _M_advance_fwd(difference_type __offset, difference_type __steps)
9888 using _Dt = iter_difference_t<variant_alternative_t<_Nm, __base_iter>>;
9889 if constexpr (_Nm == sizeof...(_Vs) - 1)
9890 std::get<_Nm>(_M_it) += static_cast<_Dt>(__steps);
9893 auto __n_size = ranges::distance(std::get<_Nm>(_M_parent->_M_views));
9894 if (__offset + __steps < __n_size)
9895 std::get<_Nm>(_M_it) += static_cast<_Dt>(__steps);
9898 _M_it.template emplace<_Nm + 1>(ranges::begin
9899 (std::get<_Nm + 1>(_M_parent->_M_views)));
9900 _M_advance_fwd<_Nm + 1>(0, __offset + __steps - __n_size);
9905 template<size_t _Nm>
9907 _M_advance_bwd(difference_type __offset, difference_type __steps)
9909 using _Dt = iter_difference_t<variant_alternative_t<_Nm, __base_iter>>;
9910 if constexpr (_Nm == 0)
9911 std::get<_Nm>(_M_it) -= static_cast<_Dt>(__steps);
9913 if (__offset >= __steps)
9914 std::get<_Nm>(_M_it) -= static_cast<_Dt>(__steps);
9917 auto __prev_size = ranges::distance(std::get<_Nm - 1>(_M_parent->_M_views));
9918 _M_it.template emplace<_Nm - 1>(ranges::end
9919 (std::get<_Nm - 1>(_M_parent->_M_views)));
9920 _M_advance_bwd<_Nm - 1>(__prev_size, __steps - __offset);
9925 // Invoke the function object __f, which has a call operator with a size_t
9926 // template parameter (corresponding to an index into the pack of views),
9927 // using the runtime value of __index as the template argument.
9928 template<typename _Fp>
9929 static constexpr auto
9930 _S_invoke_with_runtime_index(_Fp&& __f, size_t __index)
9932 return [&__f, __index]<size_t _Idx>(this auto&& __self) {
9933 if (_Idx == __index)
9934 return __f.template operator()<_Idx>();
9935 if constexpr (_Idx + 1 < sizeof...(_Vs))
9936 return __self.template operator()<_Idx + 1>();
9937 __builtin_unreachable();
9938 }.template operator()<0>();
9941 template<typename _Fp>
9943 _M_invoke_with_runtime_index(_Fp&& __f)
9944 { return _S_invoke_with_runtime_index(std::forward<_Fp>(__f), _M_it.index()); }
9946 template<typename... _Args>
9948 _Iterator(__maybe_const_t<_Const, concat_view>* __parent, _Args&&... __args)
9949 requires constructible_from<__base_iter, _Args&&...>
9950 : _M_parent(__parent), _M_it(std::forward<_Args>(__args)...)
9954 _Iterator() = default;
9957 _Iterator(_Iterator<!_Const> __it)
9958 requires _Const && (convertible_to<iterator_t<_Vs>, iterator_t<const _Vs>> && ...)
9959 : _M_parent(__it._M_parent),
9960 _M_it(_S_invoke_with_runtime_index([this, &__it]<size_t _Idx>() {
9961 return __base_iter(in_place_index<_Idx>,
9962 std::get<_Idx>(std::move(__it._M_it)));
9963 }, __it._M_it.index()))
9966 constexpr decltype(auto)
9969 __glibcxx_assert(!_M_it.valueless_by_exception());
9970 using reference = __detail::__concat_reference_t<__maybe_const_t<_Const, _Vs>...>;
9971 return std::visit([](auto&& __it) -> reference { return *__it; }, _M_it);
9974 constexpr _Iterator&
9977 _M_invoke_with_runtime_index([this]<size_t _Idx>() {
9978 ++std::get<_Idx>(_M_it);
9990 requires __detail::__all_forward<_Const, _Vs...>
9997 constexpr _Iterator&
9999 requires __detail::__concat_is_bidirectional<_Const, _Vs...>
10001 __glibcxx_assert(!_M_it.valueless_by_exception());
10002 _M_invoke_with_runtime_index([this]<size_t _Idx>() {
10008 constexpr _Iterator
10010 requires __detail::__concat_is_bidirectional<_Const, _Vs...>
10012 auto __tmp = *this;
10017 constexpr _Iterator&
10018 operator+=(difference_type __n)
10019 requires __detail::__concat_is_random_access<_Const, _Vs...>
10021 __glibcxx_assert(!_M_it.valueless_by_exception());
10022 _M_invoke_with_runtime_index([this, __n]<size_t _Idx>() {
10023 auto __begin = ranges::begin(std::get<_Idx>(_M_parent->_M_views));
10025 _M_advance_fwd<_Idx>(std::get<_Idx>(_M_it) - __begin, __n);
10027 _M_advance_bwd<_Idx>(std::get<_Idx>(_M_it) - __begin, -__n);
10032 constexpr _Iterator&
10033 operator-=(difference_type __n)
10034 requires __detail::__concat_is_random_access<_Const, _Vs...>
10040 constexpr decltype(auto)
10041 operator[](difference_type __n) const
10042 requires __detail::__concat_is_random_access<_Const, _Vs...>
10043 { return *((*this) + __n); }
10045 friend constexpr bool
10046 operator==(const _Iterator& __x, const _Iterator& __y)
10047 requires (equality_comparable<iterator_t<__maybe_const_t<_Const, _Vs>>> && ...)
10049 __glibcxx_assert(!__x._M_it.valueless_by_exception());
10050 __glibcxx_assert(!__y._M_it.valueless_by_exception());
10051 return __x._M_it == __y._M_it;
10054 friend constexpr bool
10055 operator==(const _Iterator& __it, default_sentinel_t)
10057 __glibcxx_assert(!__it._M_it.valueless_by_exception());
10058 constexpr auto __last_idx = sizeof...(_Vs) - 1;
10059 return (__it._M_it.index() == __last_idx
10060 && (std::get<__last_idx>(__it._M_it)
10061 == ranges::end(std::get<__last_idx>(__it._M_parent->_M_views))));
10064 friend constexpr bool
10065 operator<(const _Iterator& __x, const _Iterator& __y)
10066 requires __detail::__all_random_access<_Const, _Vs...>
10067 { return __x._M_it < __y._M_it; }
10069 friend constexpr bool
10070 operator>(const _Iterator& __x, const _Iterator& __y)
10071 requires __detail::__all_random_access<_Const, _Vs...>
10072 { return __x._M_it > __y._M_it; }
10074 friend constexpr bool
10075 operator<=(const _Iterator& __x, const _Iterator& __y)
10076 requires __detail::__all_random_access<_Const, _Vs...>
10077 { return __x._M_it <= __y._M_it; }
10079 friend constexpr bool
10080 operator>=(const _Iterator& __x, const _Iterator& __y)
10081 requires __detail::__all_random_access<_Const, _Vs...>
10082 { return __x._M_it >= __y._M_it; }
10084 friend constexpr auto
10085 operator<=>(const _Iterator& __x, const _Iterator& __y)
10086 requires __detail::__all_random_access<_Const, _Vs...>
10087 && (three_way_comparable<iterator_t<__maybe_const_t<_Const, _Vs>>> && ...)
10088 { return __x._M_it <=> __y._M_it; }
10090 friend constexpr _Iterator
10091 operator+(const _Iterator& __it, difference_type __n)
10092 requires __detail::__concat_is_random_access<_Const, _Vs...>
10093 { return auto(__it) += __n; }
10095 friend constexpr _Iterator
10096 operator+(difference_type __n, const _Iterator& __it)
10097 requires __detail::__concat_is_random_access<_Const, _Vs...>
10098 { return __it + __n; }
10100 friend constexpr _Iterator
10101 operator-(const _Iterator& __it, difference_type __n)
10102 requires __detail::__concat_is_random_access<_Const, _Vs...>
10103 { return auto(__it) -= __n; }
10105 friend constexpr difference_type
10106 operator-(const _Iterator& __x, const _Iterator& __y)
10107 requires __detail::__concat_is_random_access<_Const, _Vs...>
10109 return _S_invoke_with_runtime_index([&]<size_t _Ix>() -> difference_type {
10110 return _S_invoke_with_runtime_index([&]<size_t _Iy>() -> difference_type {
10111 if constexpr (_Ix > _Iy)
10113 auto __dy = ranges::distance(std::get<_Iy>(__y._M_it),
10114 ranges::end(std::get<_Iy>(__y._M_parent
10116 auto __dx = ranges::distance(ranges::begin(std::get<_Ix>(__x._M_parent
10118 std::get<_Ix>(__x._M_it));
10119 difference_type __s = 0;
10120 [&]<size_t _Idx = _Iy + 1>(this auto&& __self) {
10121 if constexpr (_Idx < _Ix)
10123 __s += ranges::size(std::get<_Idx>(__x._M_parent->_M_views));
10124 __self.template operator()<_Idx + 1>();
10127 return __dy + __s + __dx;
10129 else if constexpr (_Ix < _Iy)
10130 return -(__y - __x);
10132 return std::get<_Ix>(__x._M_it) - std::get<_Iy>(__y._M_it);
10133 }, __y._M_it.index());
10134 }, __x._M_it.index());
10137 friend constexpr difference_type
10138 operator-(const _Iterator& __x, default_sentinel_t)
10139 requires (sized_sentinel_for<sentinel_t<__maybe_const_t<_Const, _Vs>>,
10140 iterator_t<__maybe_const_t<_Const, _Vs>>> && ...)
10141 && __detail::__all_but_first_sized<__maybe_const_t<_Const, _Vs>...>::value
10143 return _S_invoke_with_runtime_index([&]<size_t _Ix>() -> difference_type {
10144 auto __dx = ranges::distance(std::get<_Ix>(__x._M_it),
10145 ranges::end(std::get<_Ix>(__x._M_parent->_M_views)));
10146 difference_type __s = 0;
10147 [&]<size_t _Idx = _Ix + 1>(this auto&& __self) {
10148 if constexpr (_Idx < sizeof...(_Vs))
10150 __s += ranges::size(std::get<_Idx>(__x._M_parent->_M_views));
10151 __self.template operator()<_Idx + 1>();
10154 return -(__dx + __s);
10155 }, __x._M_it.index());
10158 friend constexpr difference_type
10159 operator-(default_sentinel_t, const _Iterator& __x)
10160 requires (sized_sentinel_for<sentinel_t<__maybe_const_t<_Const, _Vs>>,
10161 iterator_t<__maybe_const_t<_Const, _Vs>>> && ...)
10162 && __detail::__all_but_first_sized<__maybe_const_t<_Const, _Vs>...>::value
10163 { return -(__x - default_sentinel); }
10165 friend constexpr decltype(auto)
10166 iter_move(const _Iterator& __it)
10168 using _Res = __detail::__concat_rvalue_reference_t<__maybe_const_t<_Const, _Vs>...>;
10169 return std::visit([](const auto& __i) -> _Res {
10170 return ranges::iter_move(__i);
10174 friend constexpr void
10175 iter_swap(const _Iterator& __x, const _Iterator& __y)
10176 requires swappable_with<iter_reference_t<_Iterator>, iter_reference_t<_Iterator>>
10177 && (... && indirectly_swappable<iterator_t<__maybe_const_t<_Const, _Vs>>>)
10179 std::visit([&]<typename _Tp, typename _Up>(const _Tp& __it1, const _Up& __it2) {
10180 if constexpr (is_same_v<_Tp, _Up>)
10181 ranges::iter_swap(__it1, __it2);
10183 ranges::swap(*__it1, *__it2);
10184 }, __x._M_it, __y._M_it);
10192 template<typename... _Ts>
10193 concept __can_concat_view = requires { concat_view(std::declval<_Ts>()...); };
10198 template<typename... _Ts>
10199 requires __detail::__can_concat_view<_Ts...>
10201 operator() [[nodiscard]] (_Ts&&... __ts) const
10202 { return concat_view(std::forward<_Ts>(__ts)...); }
10204 template<input_range _Range>
10206 operator() [[nodiscard]] (_Range&& __t) const
10207 { return views::all(std::forward<_Range>(__t)); }
10210 inline constexpr _Concat concat;
10213} // namespace ranges
10214#endif // __cpp_lib_ranges_concat
10216#if __cpp_lib_ranges_cache_latest // C++ >= 26
10219 template<input_range _Vp>
10221 class cache_latest_view : public view_interface<cache_latest_view<_Vp>>
10223 _Vp _M_base = _Vp();
10225 using __cache_t = __conditional_t<is_reference_v<range_reference_t<_Vp>>,
10226 add_pointer_t<range_reference_t<_Vp>>,
10227 range_reference_t<_Vp>>;
10228 __detail::__non_propagating_cache<__cache_t> _M_cache;
10234 cache_latest_view() requires default_initializable<_Vp> = default;
10237 cache_latest_view(_Vp __base)
10238 : _M_base(std::move(__base))
10242 base() const & requires copy_constructible<_Vp>
10243 { return _M_base; }
10247 { return std::move(_M_base); }
10251 { return _Iterator(*this); }
10255 { return _Sentinel(*this); }
10258 size() requires sized_range<_Vp>
10259 { return ranges::size(_M_base); }
10262 size() const requires sized_range<const _Vp>
10263 { return ranges::size(_M_base); }
10266 template<typename _Range>
10267 cache_latest_view(_Range&&) -> cache_latest_view<views::all_t<_Range>>;
10269 template<input_range _Vp>
10271 class cache_latest_view<_Vp>::_Iterator
10273 cache_latest_view* _M_parent;
10274 iterator_t<_Vp> _M_current;
10277 _Iterator(cache_latest_view& __parent)
10278 : _M_parent(std::__addressof(__parent)),
10279 _M_current(ranges::begin(__parent._M_base))
10282 friend class cache_latest_view;
10285 using difference_type = range_difference_t<_Vp>;
10286 using value_type = range_value_t<_Vp>;
10287 using iterator_concept = input_iterator_tag;
10289 _Iterator(_Iterator&&) = default;
10292 operator=(_Iterator&&) = default;
10294 constexpr iterator_t<_Vp>
10296 { return std::move(_M_current); }
10298 constexpr const iterator_t<_Vp>&
10299 base() const & noexcept
10300 { return _M_current; }
10302 constexpr range_reference_t<_Vp>&
10305 if constexpr (is_reference_v<range_reference_t<_Vp>>)
10307 if (!_M_parent->_M_cache)
10308 _M_parent->_M_cache = std::__addressof(__detail::__as_lvalue(*_M_current));
10309 return **_M_parent->_M_cache;
10313 if (!_M_parent->_M_cache)
10314 _M_parent->_M_cache._M_emplace_deref(_M_current);
10315 return *_M_parent->_M_cache;
10319 constexpr _Iterator&
10322 _M_parent->_M_cache._M_reset();
10331 friend constexpr range_rvalue_reference_t<_Vp>
10332 iter_move(const _Iterator& __i)
10333 noexcept(noexcept(ranges::iter_move(__i._M_current)))
10334 { return ranges::iter_move(__i._M_current); }
10336 friend constexpr void
10337 iter_swap(const _Iterator& __x, const _Iterator& __y)
10338 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
10339 requires indirectly_swappable<iterator_t<_Vp>>
10340 { ranges::iter_swap(__x._M_current, __y._M_current); }
10343 template<input_range _Vp>
10345 class cache_latest_view<_Vp>::_Sentinel
10347 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
10350 _Sentinel(cache_latest_view& __parent)
10351 : _M_end(ranges::end(__parent._M_base))
10354 friend class cache_latest_view;
10357 _Sentinel() = default;
10359 constexpr sentinel_t<_Vp>
10363 friend constexpr bool
10364 operator==(const _Iterator& __x, const _Sentinel& __y)
10365 { return __x._M_current == __y._M_end; }
10367 friend constexpr range_difference_t<_Vp>
10368 operator-(const _Iterator& __x, const _Sentinel& __y)
10369 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
10370 { return __x._M_current - __y._M_end; }
10372 friend constexpr range_difference_t<_Vp>
10373 operator-(const _Sentinel& __x, const _Iterator& __y)
10374 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
10375 { return __x._M_end - __y._M_current; }
10382 template<typename _Tp>
10383 concept __can_cache_latest = requires { cache_latest_view(std::declval<_Tp>()); };
10386 struct _CacheLatest : __adaptor::_RangeAdaptorClosure<_CacheLatest>
10388 template<viewable_range _Range>
10389 requires __detail::__can_cache_latest<_Range>
10391 operator() [[nodiscard]] (_Range&& __r) const
10392 { return cache_latest_view(std::forward<_Range>(__r)); }
10394 static constexpr bool _S_has_simple_call_op = true;
10397 inline constexpr _CacheLatest cache_latest;
10399} // namespace ranges
10400#endif // __cpp_lib_ranges_cache_latest
10402#if __cpp_lib_ranges_to_input // C++ >= 26
10405 template<input_range _Vp>
10407 class to_input_view : public view_interface<to_input_view<_Vp>>
10409 _Vp _M_base = _Vp();
10411 template<bool _Const>
10415 to_input_view() requires default_initializable<_Vp> = default;
10418 to_input_view(_Vp __base)
10419 : _M_base(std::move(__base))
10423 base() const & requires copy_constructible<_Vp>
10424 { return _M_base; }
10428 { return std::move(_M_base); }
10431 begin() requires (!__detail::__simple_view<_Vp>)
10432 { return _Iterator<false>(ranges::begin(_M_base)); }
10435 begin() const requires range<const _Vp>
10436 { return _Iterator<true>(ranges::begin(_M_base)); }
10439 end() requires (!__detail::__simple_view<_Vp>)
10440 { return ranges::end(_M_base); }
10443 end() const requires range<const _Vp>
10444 { return ranges::end(_M_base); }
10447 size() requires sized_range<_Vp>
10448 { return ranges::size(_M_base); }
10451 size() const requires sized_range<const _Vp>
10452 { return ranges::size(_M_base); }
10455 template<typename _Range>
10456 to_input_view(_Range&&) -> to_input_view<views::all_t<_Range>>;
10458 template<input_range _Vp>
10460 template<bool _Const>
10461 class to_input_view<_Vp>::_Iterator
10463 using _Base = __maybe_const_t<_Const, _Vp>;
10465 iterator_t<_Base> _M_current = iterator_t<_Base>();
10468 _Iterator(iterator_t<_Base> __current)
10469 : _M_current(std::move(__current))
10472 friend to_input_view;
10473 friend _Iterator<!_Const>;
10476 using difference_type = range_difference_t<_Base>;
10477 using value_type = range_value_t<_Base>;
10478 using iterator_concept = input_iterator_tag;
10480 _Iterator() requires default_initializable<iterator_t<_Base>> = default;
10482 _Iterator(_Iterator&&) = default;
10483 _Iterator& operator=(_Iterator&&) = default;
10486 _Iterator(_Iterator<!_Const> __i)
10487 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
10488 : _M_current(std::move(__i._M_current))
10491 constexpr iterator_t<_Base>
10493 { return std::move(_M_current); }
10495 constexpr const iterator_t<_Base>&
10496 base() const & noexcept
10497 { return _M_current; }
10499 constexpr decltype(auto)
10501 { return *_M_current; }
10503 constexpr _Iterator&
10514 friend constexpr bool
10515 operator==(const _Iterator& __x, const sentinel_t<_Base>& __y)
10516 { return __x._M_current == __y; }
10518 friend constexpr difference_type
10519 operator-(const sentinel_t<_Base>& __y, const _Iterator& __x)
10520 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
10521 { return __y - __x._M_current; }
10523 friend constexpr difference_type
10524 operator-(const _Iterator& __x, const sentinel_t<_Base>& __y)
10525 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
10526 { return __x._M_current - __y; }
10528 friend constexpr range_rvalue_reference_t<_Base>
10529 iter_move(const _Iterator& __i)
10530 noexcept(noexcept(ranges::iter_move(__i._M_current)))
10531 { return ranges::iter_move(__i._M_current); }
10533 friend constexpr void
10534 iter_swap(const _Iterator& __x, const _Iterator& __y)
10535 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
10536 requires indirectly_swappable<iterator_t<_Base>>
10537 { ranges::iter_swap(__x._M_current, __y._M_current); }
10544 template<typename _Tp>
10545 concept __can_to_input = requires { to_input_view(std::declval<_Tp>()); };
10548 struct _ToInput : __adaptor::_RangeAdaptorClosure<_ToInput>
10550 template<viewable_range _Range>
10551 requires __detail::__can_to_input<_Range>
10553 operator() [[nodiscard]] (_Range&& __r) const
10555 if constexpr (input_range<_Range>
10556 && !common_range<_Range>
10557 && !forward_range<_Range>)
10558 return views::all(std::forward<_Range>(__r));
10560 return to_input_view(std::forward<_Range>(__r));
10563 static constexpr bool _S_has_simple_call_op = true;
10566 inline constexpr _ToInput to_input;
10568} // namespace ranges
10569#endif // __cpp_lib_ranges_to_input
10571_GLIBCXX_END_NAMESPACE_VERSION
10573#endif // library concepts
10575#endif /* _GLIBCXX_RANGES */