libstdc++
ranges
Go to the documentation of this file.
1// <ranges> -*- C++ -*-
2
3// Copyright (C) 2019-2024 Free Software Foundation, Inc.
4//
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)
9// any later version.
10
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.
15
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.
19
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/>.
24
25/** @file include/ranges
26 * This is a Standard C++ Library header.
27 * @ingroup concepts
28 */
29
30#ifndef _GLIBCXX_RANGES
31#define _GLIBCXX_RANGES 1
32
33#if __cplusplus > 201703L
34
35#pragma GCC system_header
36
37#include <concepts>
38
39#if __cpp_lib_concepts
40
41#include <compare>
42#include <initializer_list>
43#include <iterator>
44#include <optional>
45#include <span>
46#include <string_view>
47#include <tuple>
48#if __cplusplus > 202002L
49#include <variant>
50#endif
51#include <bits/ranges_util.h>
52#include <bits/refwrap.h>
53
54#define __glibcxx_want_ranges
55#define __glibcxx_want_ranges_as_const
56#define __glibcxx_want_ranges_as_rvalue
57#define __glibcxx_want_ranges_cartesian_product
58#define __glibcxx_want_ranges_chunk
59#define __glibcxx_want_ranges_chunk_by
60#define __glibcxx_want_ranges_enumerate
61#define __glibcxx_want_ranges_iota
62#define __glibcxx_want_ranges_join_with
63#define __glibcxx_want_ranges_repeat
64#define __glibcxx_want_ranges_slide
65#define __glibcxx_want_ranges_stride
66#define __glibcxx_want_ranges_to_container
67#define __glibcxx_want_ranges_zip
68#include <bits/version.h>
69
70#ifdef __glibcxx_generator // C++ >= 23 && __glibcxx_coroutine
71# include <bits/elements_of.h>
72#endif
73
74/**
75 * @defgroup ranges Ranges
76 *
77 * Components for dealing with ranges of elements.
78 */
79
80namespace std _GLIBCXX_VISIBILITY(default)
81{
82_GLIBCXX_BEGIN_NAMESPACE_VERSION
83namespace ranges
84{
85 // [range.access] customization point objects
86 // [range.req] range and view concepts
87 // [range.dangling] dangling iterator handling
88 // Defined in <bits/ranges_base.h>
89
90 // [view.interface] View interface
91 // [range.subrange] Sub-ranges
92 // Defined in <bits/ranges_util.h>
93
94 // C++20 24.6 [range.factories] Range factories
95
96 /// A view that contains no elements.
97 template<typename _Tp> requires is_object_v<_Tp>
98 class empty_view
99 : public view_interface<empty_view<_Tp>>
100 {
101 public:
102 static constexpr _Tp* begin() noexcept { return nullptr; }
103 static constexpr _Tp* end() noexcept { return nullptr; }
104 static constexpr _Tp* data() noexcept { return nullptr; }
105 static constexpr size_t size() noexcept { return 0; }
106 static constexpr bool empty() noexcept { return true; }
107 };
108
109 template<typename _Tp>
110 inline constexpr bool enable_borrowed_range<empty_view<_Tp>> = true;
111
112 namespace __detail
113 {
114#if __cpp_lib_ranges >= 202207L // C++ >= 23
115 // P2494R2 Relaxing range adaptors to allow for move only types
116 template<typename _Tp>
117 concept __boxable = move_constructible<_Tp> && is_object_v<_Tp>;
118#else
119 template<typename _Tp>
120 concept __boxable = copy_constructible<_Tp> && is_object_v<_Tp>;
121#endif
122
123 template<__boxable _Tp>
124 struct __box : std::optional<_Tp>
125 {
126 using std::optional<_Tp>::optional;
127
128 constexpr
129 __box()
130 noexcept(is_nothrow_default_constructible_v<_Tp>)
131 requires default_initializable<_Tp>
132 : std::optional<_Tp>{std::in_place}
133 { }
134
135 __box(const __box&) = default;
136 __box(__box&&) = default;
137
138 using std::optional<_Tp>::operator=;
139
140 // _GLIBCXX_RESOLVE_LIB_DEFECTS
141 // 3477. Simplify constraints for semiregular-box
142 // 3572. copyable-box should be fully constexpr
143 constexpr __box&
144 operator=(const __box& __that)
145 noexcept(is_nothrow_copy_constructible_v<_Tp>)
146 requires (!copyable<_Tp>) && copy_constructible<_Tp>
147 {
148 if (this != std::__addressof(__that))
149 {
150 if ((bool)__that)
151 this->emplace(*__that);
152 else
153 this->reset();
154 }
155 return *this;
156 }
157
158 constexpr __box&
159 operator=(__box&& __that)
160 noexcept(is_nothrow_move_constructible_v<_Tp>)
161 requires (!movable<_Tp>)
162 {
163 if (this != std::__addressof(__that))
164 {
165 if ((bool)__that)
166 this->emplace(std::move(*__that));
167 else
168 this->reset();
169 }
170 return *this;
171 }
172 };
173
174 template<typename _Tp>
175 concept __boxable_copyable
176 = copy_constructible<_Tp>
177 && (copyable<_Tp> || (is_nothrow_move_constructible_v<_Tp>
178 && is_nothrow_copy_constructible_v<_Tp>));
179 template<typename _Tp>
180 concept __boxable_movable
181 = (!copy_constructible<_Tp>)
182 && (movable<_Tp> || is_nothrow_move_constructible_v<_Tp>);
183
184 // For types which are already copyable (or since C++23, movable)
185 // this specialization of the box wrapper stores the object directly
186 // without going through std::optional. It provides just the subset of
187 // the primary template's API that we currently use.
188 template<__boxable _Tp>
189 requires __boxable_copyable<_Tp> || __boxable_movable<_Tp>
190 struct __box<_Tp>
191 {
192 private:
193 [[no_unique_address]] _Tp _M_value = _Tp();
194
195 public:
196 __box() requires default_initializable<_Tp> = default;
197
198 constexpr explicit
199 __box(const _Tp& __t)
200 noexcept(is_nothrow_copy_constructible_v<_Tp>)
201 requires copy_constructible<_Tp>
202 : _M_value(__t)
203 { }
204
205 constexpr explicit
206 __box(_Tp&& __t)
207 noexcept(is_nothrow_move_constructible_v<_Tp>)
208 : _M_value(std::move(__t))
209 { }
210
211 template<typename... _Args>
212 requires constructible_from<_Tp, _Args...>
213 constexpr explicit
214 __box(in_place_t, _Args&&... __args)
215 noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
216 : _M_value(std::forward<_Args>(__args)...)
217 { }
218
219 __box(const __box&) = default;
220 __box(__box&&) = default;
221 __box& operator=(const __box&) requires copyable<_Tp> = default;
222 __box& operator=(__box&&) requires movable<_Tp> = default;
223
224 // When _Tp is nothrow_copy_constructible but not copy_assignable,
225 // copy assignment is implemented via destroy-then-copy-construct.
226 constexpr __box&
227 operator=(const __box& __that) noexcept
228 requires (!copyable<_Tp>) && copy_constructible<_Tp>
229 {
230 static_assert(is_nothrow_copy_constructible_v<_Tp>);
231 if (this != std::__addressof(__that))
232 {
233 _M_value.~_Tp();
234 std::construct_at(std::__addressof(_M_value), *__that);
235 }
236 return *this;
237 }
238
239 // Likewise for move assignment.
240 constexpr __box&
241 operator=(__box&& __that) noexcept
242 requires (!movable<_Tp>)
243 {
244 static_assert(is_nothrow_move_constructible_v<_Tp>);
245 if (this != std::__addressof(__that))
246 {
247 _M_value.~_Tp();
248 std::construct_at(std::__addressof(_M_value), std::move(*__that));
249 }
250 return *this;
251 }
252
253 constexpr bool
254 has_value() const noexcept
255 { return true; };
256
257 constexpr _Tp&
258 operator*() & noexcept
259 { return _M_value; }
260
261 constexpr const _Tp&
262 operator*() const & noexcept
263 { return _M_value; }
264
265 constexpr _Tp&&
266 operator*() && noexcept
267 { return std::move(_M_value); }
268
269 constexpr const _Tp&&
270 operator*() const && noexcept
271 { return std::move(_M_value); }
272
273 constexpr _Tp*
274 operator->() noexcept
275 { return std::__addressof(_M_value); }
276
277 constexpr const _Tp*
278 operator->() const noexcept
279 { return std::__addressof(_M_value); }
280 };
281 } // namespace __detail
282
283 /// A view that contains exactly one element.
284#if __cpp_lib_ranges >= 202207L // C++ >= 23
285 template<move_constructible _Tp>
286#else
287 template<copy_constructible _Tp>
288#endif
289 requires is_object_v<_Tp>
290 class single_view : public view_interface<single_view<_Tp>>
291 {
292 public:
293 single_view() requires default_initializable<_Tp> = default;
294
295 constexpr explicit
296 single_view(const _Tp& __t)
297 noexcept(is_nothrow_copy_constructible_v<_Tp>)
298 requires copy_constructible<_Tp>
299 : _M_value(__t)
300 { }
301
302 constexpr explicit
303 single_view(_Tp&& __t)
304 noexcept(is_nothrow_move_constructible_v<_Tp>)
305 : _M_value(std::move(__t))
306 { }
307
308 // _GLIBCXX_RESOLVE_LIB_DEFECTS
309 // 3428. single_view's in place constructor should be explicit
310 template<typename... _Args>
311 requires constructible_from<_Tp, _Args...>
312 constexpr explicit
313 single_view(in_place_t, _Args&&... __args)
314 noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
315 : _M_value{in_place, std::forward<_Args>(__args)...}
316 { }
317
318 constexpr _Tp*
319 begin() noexcept
320 { return data(); }
321
322 constexpr const _Tp*
323 begin() const noexcept
324 { return data(); }
325
326 constexpr _Tp*
327 end() noexcept
328 { return data() + 1; }
329
330 constexpr const _Tp*
331 end() const noexcept
332 { return data() + 1; }
333
334 // _GLIBCXX_RESOLVE_LIB_DEFECTS
335 // 4035. single_view should provide empty
336 static constexpr bool
337 empty() noexcept
338 { return false; }
339
340 static constexpr size_t
341 size() noexcept
342 { return 1; }
343
344 constexpr _Tp*
345 data() noexcept
346 { return _M_value.operator->(); }
347
348 constexpr const _Tp*
349 data() const noexcept
350 { return _M_value.operator->(); }
351
352 private:
353 [[no_unique_address]] __detail::__box<_Tp> _M_value;
354 };
355
356 template<typename _Tp>
357 single_view(_Tp) -> single_view<_Tp>;
358
359 namespace __detail
360 {
361 template<typename _Wp>
362 constexpr auto __to_signed_like(_Wp __w) noexcept
363 {
364 if constexpr (!integral<_Wp>)
365 return iter_difference_t<_Wp>();
366 else if constexpr (sizeof(iter_difference_t<_Wp>) > sizeof(_Wp))
367 return iter_difference_t<_Wp>(__w);
368 else if constexpr (sizeof(ptrdiff_t) > sizeof(_Wp))
369 return ptrdiff_t(__w);
370 else if constexpr (sizeof(long long) > sizeof(_Wp))
371 return (long long)(__w);
372#ifdef __SIZEOF_INT128__
373 else if constexpr (__SIZEOF_INT128__ > sizeof(_Wp))
374 return __int128(__w);
375#endif
376 else
377 return __max_diff_type(__w);
378 }
379
380 template<typename _Wp>
381 using __iota_diff_t = decltype(__to_signed_like(std::declval<_Wp>()));
382
383 template<typename _It>
384 concept __decrementable = incrementable<_It>
385 && requires(_It __i)
386 {
387 { --__i } -> same_as<_It&>;
388 { __i-- } -> same_as<_It>;
389 };
390
391 template<typename _It>
392 concept __advanceable = __decrementable<_It> && totally_ordered<_It>
393 && requires( _It __i, const _It __j, const __iota_diff_t<_It> __n)
394 {
395 { __i += __n } -> same_as<_It&>;
396 { __i -= __n } -> same_as<_It&>;
397 _It(__j + __n);
398 _It(__n + __j);
399 _It(__j - __n);
400 { __j - __j } -> convertible_to<__iota_diff_t<_It>>;
401 };
402
403 template<typename _Winc>
404 struct __iota_view_iter_cat
405 { };
406
407 template<incrementable _Winc>
408 struct __iota_view_iter_cat<_Winc>
409 { using iterator_category = input_iterator_tag; };
410 } // namespace __detail
411
412 template<weakly_incrementable _Winc,
413 semiregular _Bound = unreachable_sentinel_t>
414 requires std::__detail::__weakly_eq_cmp_with<_Winc, _Bound>
415 && copyable<_Winc>
416 class iota_view : public view_interface<iota_view<_Winc, _Bound>>
417 {
418 private:
419 struct _Sentinel;
420
421 struct _Iterator : __detail::__iota_view_iter_cat<_Winc>
422 {
423 private:
424 static auto
425 _S_iter_concept()
426 {
427 using namespace __detail;
428 if constexpr (__advanceable<_Winc>)
429 return random_access_iterator_tag{};
430 else if constexpr (__decrementable<_Winc>)
431 return bidirectional_iterator_tag{};
432 else if constexpr (incrementable<_Winc>)
433 return forward_iterator_tag{};
434 else
435 return input_iterator_tag{};
436 }
437
438 public:
439 using iterator_concept = decltype(_S_iter_concept());
440 // iterator_category defined in __iota_view_iter_cat
441 using value_type = _Winc;
442 using difference_type = __detail::__iota_diff_t<_Winc>;
443
444 _Iterator() requires default_initializable<_Winc> = default;
445
446 constexpr explicit
447 _Iterator(_Winc __value)
448 : _M_value(__value) { }
449
450 constexpr _Winc
451 operator*() const noexcept(is_nothrow_copy_constructible_v<_Winc>)
452 { return _M_value; }
453
454 constexpr _Iterator&
455 operator++()
456 {
457 ++_M_value;
458 return *this;
459 }
460
461 constexpr void
462 operator++(int)
463 { ++*this; }
464
465 constexpr _Iterator
466 operator++(int) requires incrementable<_Winc>
467 {
468 auto __tmp = *this;
469 ++*this;
470 return __tmp;
471 }
472
473 constexpr _Iterator&
474 operator--() requires __detail::__decrementable<_Winc>
475 {
476 --_M_value;
477 return *this;
478 }
479
480 constexpr _Iterator
481 operator--(int) requires __detail::__decrementable<_Winc>
482 {
483 auto __tmp = *this;
484 --*this;
485 return __tmp;
486 }
487
488 constexpr _Iterator&
489 operator+=(difference_type __n) requires __detail::__advanceable<_Winc>
490 {
491 using __detail::__is_integer_like;
492 using __detail::__is_signed_integer_like;
493 if constexpr (__is_integer_like<_Winc>
494 && !__is_signed_integer_like<_Winc>)
495 {
496 if (__n >= difference_type(0))
497 _M_value += static_cast<_Winc>(__n);
498 else
499 _M_value -= static_cast<_Winc>(-__n);
500 }
501 else
502 _M_value += __n;
503 return *this;
504 }
505
506 constexpr _Iterator&
507 operator-=(difference_type __n) requires __detail::__advanceable<_Winc>
508 {
509 using __detail::__is_integer_like;
510 using __detail::__is_signed_integer_like;
511 if constexpr (__is_integer_like<_Winc>
512 && !__is_signed_integer_like<_Winc>)
513 {
514 if (__n >= difference_type(0))
515 _M_value -= static_cast<_Winc>(__n);
516 else
517 _M_value += static_cast<_Winc>(-__n);
518 }
519 else
520 _M_value -= __n;
521 return *this;
522 }
523
524 constexpr _Winc
525 operator[](difference_type __n) const
526 requires __detail::__advanceable<_Winc>
527 { return _Winc(_M_value + __n); }
528
529 friend constexpr bool
530 operator==(const _Iterator& __x, const _Iterator& __y)
531 requires equality_comparable<_Winc>
532 { return __x._M_value == __y._M_value; }
533
534 friend constexpr bool
535 operator<(const _Iterator& __x, const _Iterator& __y)
536 requires totally_ordered<_Winc>
537 { return __x._M_value < __y._M_value; }
538
539 friend constexpr bool
540 operator>(const _Iterator& __x, const _Iterator& __y)
541 requires totally_ordered<_Winc>
542 { return __y < __x; }
543
544 friend constexpr bool
545 operator<=(const _Iterator& __x, const _Iterator& __y)
546 requires totally_ordered<_Winc>
547 { return !(__y < __x); }
548
549 friend constexpr bool
550 operator>=(const _Iterator& __x, const _Iterator& __y)
551 requires totally_ordered<_Winc>
552 { return !(__x < __y); }
553
554#ifdef __cpp_lib_three_way_comparison
555 friend constexpr auto
556 operator<=>(const _Iterator& __x, const _Iterator& __y)
557 requires totally_ordered<_Winc> && three_way_comparable<_Winc>
558 { return __x._M_value <=> __y._M_value; }
559#endif
560
561 friend constexpr _Iterator
562 operator+(_Iterator __i, difference_type __n)
563 requires __detail::__advanceable<_Winc>
564 {
565 __i += __n;
566 return __i;
567 }
568
569 friend constexpr _Iterator
570 operator+(difference_type __n, _Iterator __i)
571 requires __detail::__advanceable<_Winc>
572 { return __i += __n; }
573
574 friend constexpr _Iterator
575 operator-(_Iterator __i, difference_type __n)
576 requires __detail::__advanceable<_Winc>
577 {
578 __i -= __n;
579 return __i;
580 }
581
582 friend constexpr difference_type
583 operator-(const _Iterator& __x, const _Iterator& __y)
584 requires __detail::__advanceable<_Winc>
585 {
586 using __detail::__is_integer_like;
587 using __detail::__is_signed_integer_like;
588 using _Dt = difference_type;
589 if constexpr (__is_integer_like<_Winc>)
590 {
591 if constexpr (__is_signed_integer_like<_Winc>)
592 return _Dt(_Dt(__x._M_value) - _Dt(__y._M_value));
593 else
594 return (__y._M_value > __x._M_value)
595 ? _Dt(-_Dt(__y._M_value - __x._M_value))
596 : _Dt(__x._M_value - __y._M_value);
597 }
598 else
599 return __x._M_value - __y._M_value;
600 }
601
602 private:
603 _Winc _M_value = _Winc();
604
605 friend iota_view;
606 friend _Sentinel;
607 };
608
609 struct _Sentinel
610 {
611 private:
612 constexpr bool
613 _M_equal(const _Iterator& __x) const
614 { return __x._M_value == _M_bound; }
615
616 constexpr auto
617 _M_distance_from(const _Iterator& __x) const
618 { return _M_bound - __x._M_value; }
619
620 _Bound _M_bound = _Bound();
621
622 public:
623 _Sentinel() = default;
624
625 constexpr explicit
626 _Sentinel(_Bound __bound)
627 : _M_bound(__bound) { }
628
629 friend constexpr bool
630 operator==(const _Iterator& __x, const _Sentinel& __y)
631 { return __y._M_equal(__x); }
632
633 friend constexpr iter_difference_t<_Winc>
634 operator-(const _Iterator& __x, const _Sentinel& __y)
635 requires sized_sentinel_for<_Bound, _Winc>
636 { return -__y._M_distance_from(__x); }
637
638 friend constexpr iter_difference_t<_Winc>
639 operator-(const _Sentinel& __x, const _Iterator& __y)
640 requires sized_sentinel_for<_Bound, _Winc>
641 { return __x._M_distance_from(__y); }
642
643 friend iota_view;
644 };
645
646 _Winc _M_value = _Winc();
647 [[no_unique_address]] _Bound _M_bound = _Bound();
648
649 public:
650 iota_view() requires default_initializable<_Winc> = default;
651
652 constexpr explicit
653 iota_view(_Winc __value)
654 : _M_value(__value)
655 { }
656
657 constexpr
658 iota_view(type_identity_t<_Winc> __value,
659 type_identity_t<_Bound> __bound)
660 : _M_value(__value), _M_bound(__bound)
661 {
662 if constexpr (totally_ordered_with<_Winc, _Bound>)
663 __glibcxx_assert( bool(__value <= __bound) );
664 }
665
666 constexpr
667 iota_view(_Iterator __first, _Iterator __last)
668 requires same_as<_Winc, _Bound>
669 : iota_view(__first._M_value, __last._M_value)
670 { }
671
672 constexpr
673 iota_view(_Iterator __first, unreachable_sentinel_t __last)
674 requires same_as<_Bound, unreachable_sentinel_t>
675 : iota_view(__first._M_value, __last)
676 { }
677
678 constexpr
679 iota_view(_Iterator __first, _Sentinel __last)
680 requires (!same_as<_Winc, _Bound>) && (!same_as<_Bound, unreachable_sentinel_t>)
681 : iota_view(__first._M_value, __last._M_bound)
682 { }
683
684 constexpr _Iterator
685 begin() const { return _Iterator{_M_value}; }
686
687 constexpr auto
688 end() const
689 {
690 if constexpr (same_as<_Bound, unreachable_sentinel_t>)
691 return unreachable_sentinel;
692 else
693 return _Sentinel{_M_bound};
694 }
695
696 constexpr _Iterator
697 end() const requires same_as<_Winc, _Bound>
698 { return _Iterator{_M_bound}; }
699
700 // _GLIBCXX_RESOLVE_LIB_DEFECTS
701 // 4001. iota_view should provide empty
702 constexpr bool
703 empty() const
704 { return _M_value == _M_bound; }
705
706 constexpr auto
707 size() const
708 requires (same_as<_Winc, _Bound> && __detail::__advanceable<_Winc>)
709 || (integral<_Winc> && integral<_Bound>)
710 || sized_sentinel_for<_Bound, _Winc>
711 {
712 using __detail::__is_integer_like;
713 using __detail::__to_unsigned_like;
714 if constexpr (integral<_Winc> && integral<_Bound>)
715 {
716 using _Up = make_unsigned_t<decltype(_M_bound - _M_value)>;
717 return _Up(_M_bound) - _Up(_M_value);
718 }
719 else if constexpr (__is_integer_like<_Winc>)
720 return __to_unsigned_like(_M_bound) - __to_unsigned_like(_M_value);
721 else
722 return __to_unsigned_like(_M_bound - _M_value);
723 }
724 };
725
726 template<typename _Winc, typename _Bound>
727 requires (!__detail::__is_integer_like<_Winc>
728 || !__detail::__is_integer_like<_Bound>
729 || (__detail::__is_signed_integer_like<_Winc>
730 == __detail::__is_signed_integer_like<_Bound>))
731 iota_view(_Winc, _Bound) -> iota_view<_Winc, _Bound>;
732
733 template<typename _Winc, typename _Bound>
734 inline constexpr bool
735 enable_borrowed_range<iota_view<_Winc, _Bound>> = true;
736
737namespace views
738{
739 template<typename _Tp>
740 inline constexpr empty_view<_Tp> empty{};
741
742 namespace __detail
743 {
744 template<typename _Tp>
745 concept __can_single_view
746 = requires { single_view<decay_t<_Tp>>(std::declval<_Tp>()); };
747 } // namespace __detail
748
749 struct _Single
750 {
751 template<__detail::__can_single_view _Tp>
752 constexpr auto
753 operator() [[nodiscard]] (_Tp&& __e) const
754 noexcept(noexcept(single_view<decay_t<_Tp>>(std::forward<_Tp>(__e))))
755 { return single_view<decay_t<_Tp>>(std::forward<_Tp>(__e)); }
756 };
757
758 inline constexpr _Single single{};
759
760 namespace __detail
761 {
762 template<typename... _Args>
763 concept __can_iota_view = requires { iota_view(std::declval<_Args>()...); };
764 } // namespace __detail
765
766 struct _Iota
767 {
768 template<__detail::__can_iota_view _Tp>
769 constexpr auto
770 operator() [[nodiscard]] (_Tp&& __e) const
771 { return iota_view(std::forward<_Tp>(__e)); }
772
773 template<typename _Tp, typename _Up>
774 requires __detail::__can_iota_view<_Tp, _Up>
775 constexpr auto
776 operator() [[nodiscard]] (_Tp&& __e, _Up&& __f) const
777 { return iota_view(std::forward<_Tp>(__e), std::forward<_Up>(__f)); }
778 };
779
780 inline constexpr _Iota iota{};
781} // namespace views
782
783#if _GLIBCXX_HOSTED
784 namespace __detail
785 {
786 template<typename _Val, typename _CharT, typename _Traits>
787 concept __stream_extractable
788 = requires(basic_istream<_CharT, _Traits>& is, _Val& t) { is >> t; };
789 } // namespace __detail
790
791 template<movable _Val, typename _CharT,
792 typename _Traits = char_traits<_CharT>>
793 requires default_initializable<_Val>
794 && __detail::__stream_extractable<_Val, _CharT, _Traits>
795 class basic_istream_view
796 : public view_interface<basic_istream_view<_Val, _CharT, _Traits>>
797 {
798 public:
799 constexpr explicit
800 basic_istream_view(basic_istream<_CharT, _Traits>& __stream)
801 : _M_stream(std::__addressof(__stream))
802 { }
803
804 constexpr auto
805 begin()
806 {
807 *_M_stream >> _M_object;
808 return _Iterator{this};
809 }
810
811 constexpr default_sentinel_t
812 end() const noexcept
813 { return default_sentinel; }
814
815 private:
816 basic_istream<_CharT, _Traits>* _M_stream;
817 _Val _M_object = _Val();
818
819 struct _Iterator
820 {
821 public:
822 using iterator_concept = input_iterator_tag;
823 using difference_type = ptrdiff_t;
824 using value_type = _Val;
825
826 constexpr explicit
827 _Iterator(basic_istream_view* __parent) noexcept
828 : _M_parent(__parent)
829 { }
830
831 _Iterator(const _Iterator&) = delete;
832 _Iterator(_Iterator&&) = default;
833 _Iterator& operator=(const _Iterator&) = delete;
834 _Iterator& operator=(_Iterator&&) = default;
835
836 _Iterator&
837 operator++()
838 {
839 *_M_parent->_M_stream >> _M_parent->_M_object;
840 return *this;
841 }
842
843 void
844 operator++(int)
845 { ++*this; }
846
847 _Val&
848 operator*() const
849 { return _M_parent->_M_object; }
850
851 friend bool
852 operator==(const _Iterator& __x, default_sentinel_t)
853 { return __x._M_at_end(); }
854
855 private:
856 basic_istream_view* _M_parent;
857
858 bool
859 _M_at_end() const
860 { return !*_M_parent->_M_stream; }
861 };
862
863 friend _Iterator;
864 };
865
866 template<typename _Val>
867 using istream_view = basic_istream_view<_Val, char>;
868
869 template<typename _Val>
870 using wistream_view = basic_istream_view<_Val, wchar_t>;
871
872namespace views
873{
874 namespace __detail
875 {
876 template<typename _Tp, typename _Up>
877 concept __can_istream_view = requires (_Up __e) {
878 basic_istream_view<_Tp, typename _Up::char_type, typename _Up::traits_type>(__e);
879 };
880 } // namespace __detail
881
882 template<typename _Tp>
883 struct _Istream
884 {
885 template<typename _CharT, typename _Traits>
886 constexpr auto
887 operator() [[nodiscard]] (basic_istream<_CharT, _Traits>& __e) const
888 requires __detail::__can_istream_view<_Tp, remove_reference_t<decltype(__e)>>
889 { return basic_istream_view<_Tp, _CharT, _Traits>(__e); }
890 };
891
892 template<typename _Tp>
893 inline constexpr _Istream<_Tp> istream;
894}
895#endif // HOSTED
896
897 // C++20 24.7 [range.adaptors] Range adaptors
898
899namespace __detail
900{
901 template<typename _Tp, int _Disc>
902 struct _Absent { };
903
904 // Alias for a type that is conditionally present
905 // (and is an empty type otherwise).
906 // Data members using this alias should use [[no_unique_address]] so that
907 // they take no space when not needed.
908 // The optional template parameter _Disc is for discriminating two otherwise
909 // equivalent absent types so that even they can overlap.
910 template<bool _Present, typename _Tp, int _Disc = 0>
911 using __maybe_present_t = __conditional_t<_Present, _Tp, _Absent<_Tp, _Disc>>;
912
913 // Alias for a type that is conditionally const.
914 template<bool _Const, typename _Tp>
915 using __maybe_const_t = __conditional_t<_Const, const _Tp, _Tp>;
916
917} // namespace __detail
918
919// Shorthand for __detail::__maybe_const_t.
920using __detail::__maybe_const_t;
921
922namespace views::__adaptor
923{
924 // True if the range adaptor _Adaptor can be applied with _Args.
925 template<typename _Adaptor, typename... _Args>
926 concept __adaptor_invocable
927 = requires { std::declval<_Adaptor>()(declval<_Args>()...); };
928
929 // True if the range adaptor non-closure _Adaptor can be partially applied
930 // with _Args.
931 template<typename _Adaptor, typename... _Args>
932 concept __adaptor_partial_app_viable = (_Adaptor::_S_arity > 1)
933 && (sizeof...(_Args) == _Adaptor::_S_arity - 1)
934 && (constructible_from<decay_t<_Args>, _Args> && ...);
935
936 template<typename _Adaptor, typename... _Args>
937 struct _Partial;
938
939 template<typename _Lhs, typename _Rhs>
940 struct _Pipe;
941
942 // The base class of every range adaptor closure.
943 //
944 // The derived class should define the optional static data member
945 // _S_has_simple_call_op to true if the behavior of this adaptor is
946 // independent of the constness/value category of the adaptor object.
947 template<typename _Derived>
948 struct _RangeAdaptorClosure
949 { };
950
951 template<typename _Tp, typename _Up>
952 requires (!same_as<_Tp, _RangeAdaptorClosure<_Up>>)
953 void __is_range_adaptor_closure_fn
954 (const _Tp&, const _RangeAdaptorClosure<_Up>&); // not defined
955
956 template<typename _Tp>
957 concept __is_range_adaptor_closure
958 = requires (_Tp __t) { __adaptor::__is_range_adaptor_closure_fn(__t, __t); };
959
960#pragma GCC diagnostic push
961#pragma GCC diagnostic ignored "-Wdangling-reference"
962 // range | adaptor is equivalent to adaptor(range).
963 template<typename _Self, typename _Range>
964 requires __is_range_adaptor_closure<_Self>
965 && __adaptor_invocable<_Self, _Range>
966 constexpr auto
967 operator|(_Range&& __r, _Self&& __self)
968 { return std::forward<_Self>(__self)(std::forward<_Range>(__r)); }
969
970 // Compose the adaptors __lhs and __rhs into a pipeline, returning
971 // another range adaptor closure object.
972 template<typename _Lhs, typename _Rhs>
973 requires __is_range_adaptor_closure<_Lhs>
974 && __is_range_adaptor_closure<_Rhs>
975 constexpr auto
976 operator|(_Lhs&& __lhs, _Rhs&& __rhs)
977 {
978 return _Pipe<decay_t<_Lhs>, decay_t<_Rhs>>{std::forward<_Lhs>(__lhs),
979 std::forward<_Rhs>(__rhs)};
980 }
981#pragma GCC diagnostic pop
982
983 // The base class of every range adaptor non-closure.
984 //
985 // The static data member _Derived::_S_arity must contain the total number of
986 // arguments that the adaptor takes, and the class _Derived must introduce
987 // _RangeAdaptor::operator() into the class scope via a using-declaration.
988 //
989 // The optional static data member _Derived::_S_has_simple_extra_args should
990 // be defined to true if the behavior of this adaptor is independent of the
991 // constness/value category of the extra arguments. This data member could
992 // also be defined as a variable template parameterized by the types of the
993 // extra arguments.
994 template<typename _Derived>
995 struct _RangeAdaptor
996 {
997 // Partially apply the arguments __args to the range adaptor _Derived,
998 // returning a range adaptor closure object.
999 template<typename... _Args>
1000 requires __adaptor_partial_app_viable<_Derived, _Args...>
1001 constexpr auto
1002 operator()(_Args&&... __args) const
1003 {
1004 return _Partial<_Derived, decay_t<_Args>...>{0, std::forward<_Args>(__args)...};
1005 }
1006 };
1007
1008 // True if the range adaptor closure _Adaptor has a simple operator(), i.e.
1009 // one that's not overloaded according to constness or value category of the
1010 // _Adaptor object.
1011 template<typename _Adaptor>
1012 concept __closure_has_simple_call_op = _Adaptor::_S_has_simple_call_op;
1013
1014 // True if the behavior of the range adaptor non-closure _Adaptor is
1015 // independent of the value category of its extra arguments _Args.
1016 template<typename _Adaptor, typename... _Args>
1017 concept __adaptor_has_simple_extra_args = _Adaptor::_S_has_simple_extra_args
1018 || _Adaptor::template _S_has_simple_extra_args<_Args...>;
1019
1020 // A range adaptor closure that represents partial application of
1021 // the range adaptor _Adaptor with arguments _Args.
1022 template<typename _Adaptor, typename... _Args>
1023 struct _Partial : _RangeAdaptorClosure<_Partial<_Adaptor, _Args...>>
1024 {
1025 tuple<_Args...> _M_args;
1026
1027 // First parameter is to ensure this constructor is never used
1028 // instead of the copy/move constructor.
1029 template<typename... _Ts>
1030 constexpr
1031 _Partial(int, _Ts&&... __args)
1032 : _M_args(std::forward<_Ts>(__args)...)
1033 { }
1034
1035 // Invoke _Adaptor with arguments __r, _M_args... according to the
1036 // value category of this _Partial object.
1037#if __cpp_explicit_this_parameter
1038 template<typename _Self, typename _Range>
1039 requires __adaptor_invocable<_Adaptor, _Range, __like_t<_Self, _Args>...>
1040 constexpr auto
1041 operator()(this _Self&& __self, _Range&& __r)
1042 {
1043 auto __forwarder = [&__r] (auto&&... __args) {
1044 return _Adaptor{}(std::forward<_Range>(__r),
1045 std::forward<decltype(__args)>(__args)...);
1046 };
1047 return std::apply(__forwarder, __like_t<_Self, _Partial>(__self)._M_args);
1048 }
1049#else
1050 template<typename _Range>
1051 requires __adaptor_invocable<_Adaptor, _Range, const _Args&...>
1052 constexpr auto
1053 operator()(_Range&& __r) const &
1054 {
1055 auto __forwarder = [&__r] (const auto&... __args) {
1056 return _Adaptor{}(std::forward<_Range>(__r), __args...);
1057 };
1058 return std::apply(__forwarder, _M_args);
1059 }
1060
1061 template<typename _Range>
1062 requires __adaptor_invocable<_Adaptor, _Range, _Args...>
1063 constexpr auto
1064 operator()(_Range&& __r) &&
1065 {
1066 auto __forwarder = [&__r] (auto&... __args) {
1067 return _Adaptor{}(std::forward<_Range>(__r), std::move(__args)...);
1068 };
1069 return std::apply(__forwarder, _M_args);
1070 }
1071
1072 template<typename _Range>
1073 constexpr auto
1074 operator()(_Range&& __r) const && = delete;
1075#endif
1076 };
1077
1078 // A lightweight specialization of the above primary template for
1079 // the common case where _Adaptor accepts a single extra argument.
1080 template<typename _Adaptor, typename _Arg>
1081 struct _Partial<_Adaptor, _Arg> : _RangeAdaptorClosure<_Partial<_Adaptor, _Arg>>
1082 {
1083 _Arg _M_arg;
1084
1085 template<typename _Tp>
1086 constexpr
1087 _Partial(int, _Tp&& __arg)
1088 : _M_arg(std::forward<_Tp>(__arg))
1089 { }
1090
1091#if __cpp_explicit_this_parameter
1092 template<typename _Self, typename _Range>
1093 requires __adaptor_invocable<_Adaptor, _Range, __like_t<_Self, _Arg>>
1094 constexpr auto
1095 operator()(this _Self&& __self, _Range&& __r)
1096 {
1097 return _Adaptor{}(std::forward<_Range>(__r),
1098 __like_t<_Self, _Partial>(__self)._M_arg);
1099 }
1100#else
1101 template<typename _Range>
1102 requires __adaptor_invocable<_Adaptor, _Range, const _Arg&>
1103 constexpr auto
1104 operator()(_Range&& __r) const &
1105 { return _Adaptor{}(std::forward<_Range>(__r), _M_arg); }
1106
1107 template<typename _Range>
1108 requires __adaptor_invocable<_Adaptor, _Range, _Arg>
1109 constexpr auto
1110 operator()(_Range&& __r) &&
1111 { return _Adaptor{}(std::forward<_Range>(__r), std::move(_M_arg)); }
1112
1113 template<typename _Range>
1114 constexpr auto
1115 operator()(_Range&& __r) const && = delete;
1116#endif
1117 };
1118
1119 // Partial specialization of the primary template for the case where the extra
1120 // arguments of the adaptor can always be safely and efficiently forwarded by
1121 // const reference. This lets us get away with a single operator() overload,
1122 // which makes overload resolution failure diagnostics more concise.
1123 template<typename _Adaptor, typename... _Args>
1124 requires __adaptor_has_simple_extra_args<_Adaptor, _Args...>
1125 && (is_trivially_copyable_v<_Args> && ...)
1126 struct _Partial<_Adaptor, _Args...> : _RangeAdaptorClosure<_Partial<_Adaptor, _Args...>>
1127 {
1128 tuple<_Args...> _M_args;
1129
1130 template<typename... _Ts>
1131 constexpr
1132 _Partial(int, _Ts&&... __args)
1133 : _M_args(std::forward<_Ts>(__args)...)
1134 { }
1135
1136 // Invoke _Adaptor with arguments __r, const _M_args&... regardless
1137 // of the value category of this _Partial object.
1138 template<typename _Range>
1139 requires __adaptor_invocable<_Adaptor, _Range, const _Args&...>
1140 constexpr auto
1141 operator()(_Range&& __r) const
1142 {
1143 auto __forwarder = [&__r] (const auto&... __args) {
1144 return _Adaptor{}(std::forward<_Range>(__r), __args...);
1145 };
1146 return std::apply(__forwarder, _M_args);
1147 }
1148
1149 static constexpr bool _S_has_simple_call_op = true;
1150 };
1151
1152 // A lightweight specialization of the above template for the common case
1153 // where _Adaptor accepts a single extra argument.
1154 template<typename _Adaptor, typename _Arg>
1155 requires __adaptor_has_simple_extra_args<_Adaptor, _Arg>
1156 && is_trivially_copyable_v<_Arg>
1157 struct _Partial<_Adaptor, _Arg> : _RangeAdaptorClosure<_Partial<_Adaptor, _Arg>>
1158 {
1159 _Arg _M_arg;
1160
1161 template<typename _Tp>
1162 constexpr
1163 _Partial(int, _Tp&& __arg)
1164 : _M_arg(std::forward<_Tp>(__arg))
1165 { }
1166
1167 template<typename _Range>
1168 requires __adaptor_invocable<_Adaptor, _Range, const _Arg&>
1169 constexpr auto
1170 operator()(_Range&& __r) const
1171 { return _Adaptor{}(std::forward<_Range>(__r), _M_arg); }
1172
1173 static constexpr bool _S_has_simple_call_op = true;
1174 };
1175
1176 template<typename _Lhs, typename _Rhs, typename _Range>
1177 concept __pipe_invocable
1178 = requires { std::declval<_Rhs>()(std::declval<_Lhs>()(std::declval<_Range>())); };
1179
1180 // A range adaptor closure that represents composition of the range
1181 // adaptor closures _Lhs and _Rhs.
1182 template<typename _Lhs, typename _Rhs>
1183 struct _Pipe : _RangeAdaptorClosure<_Pipe<_Lhs, _Rhs>>
1184 {
1185 [[no_unique_address]] _Lhs _M_lhs;
1186 [[no_unique_address]] _Rhs _M_rhs;
1187
1188 template<typename _Tp, typename _Up>
1189 constexpr
1190 _Pipe(_Tp&& __lhs, _Up&& __rhs)
1191 : _M_lhs(std::forward<_Tp>(__lhs)), _M_rhs(std::forward<_Up>(__rhs))
1192 { }
1193
1194 // Invoke _M_rhs(_M_lhs(__r)) according to the value category of this
1195 // range adaptor closure object.
1196#if __cpp_explicit_this_parameter
1197 template<typename _Self, typename _Range>
1198 requires __pipe_invocable<__like_t<_Self, _Lhs>, __like_t<_Self, _Rhs>, _Range>
1199 constexpr auto
1200 operator()(this _Self&& __self, _Range&& __r)
1201 {
1202 return (__like_t<_Self, _Pipe>(__self)._M_rhs
1203 (__like_t<_Self, _Pipe>(__self)._M_lhs
1204 (std::forward<_Range>(__r))));
1205 }
1206#else
1207 template<typename _Range>
1208 requires __pipe_invocable<const _Lhs&, const _Rhs&, _Range>
1209 constexpr auto
1210 operator()(_Range&& __r) const &
1211 { return _M_rhs(_M_lhs(std::forward<_Range>(__r))); }
1212
1213 template<typename _Range>
1214 requires __pipe_invocable<_Lhs, _Rhs, _Range>
1215 constexpr auto
1216 operator()(_Range&& __r) &&
1217 { return std::move(_M_rhs)(std::move(_M_lhs)(std::forward<_Range>(__r))); }
1218
1219 template<typename _Range>
1220 constexpr auto
1221 operator()(_Range&& __r) const && = delete;
1222#endif
1223 };
1224
1225 // A partial specialization of the above primary template for the case where
1226 // both adaptor operands have a simple operator(). This in turn lets us
1227 // implement composition using a single simple operator(), which makes
1228 // overload resolution failure diagnostics more concise.
1229 template<typename _Lhs, typename _Rhs>
1230 requires __closure_has_simple_call_op<_Lhs>
1231 && __closure_has_simple_call_op<_Rhs>
1232 struct _Pipe<_Lhs, _Rhs> : _RangeAdaptorClosure<_Pipe<_Lhs, _Rhs>>
1233 {
1234 [[no_unique_address]] _Lhs _M_lhs;
1235 [[no_unique_address]] _Rhs _M_rhs;
1236
1237 template<typename _Tp, typename _Up>
1238 constexpr
1239 _Pipe(_Tp&& __lhs, _Up&& __rhs)
1240 : _M_lhs(std::forward<_Tp>(__lhs)), _M_rhs(std::forward<_Up>(__rhs))
1241 { }
1242
1243 template<typename _Range>
1244 requires __pipe_invocable<const _Lhs&, const _Rhs&, _Range>
1245 constexpr auto
1246 operator()(_Range&& __r) const
1247 { return _M_rhs(_M_lhs(std::forward<_Range>(__r))); }
1248
1249 static constexpr bool _S_has_simple_call_op = true;
1250 };
1251} // namespace views::__adaptor
1252
1253#if __cpp_lib_ranges >= 202202L
1254 // P2387R3 Pipe support for user-defined range adaptors
1255 template<typename _Derived>
1256 requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
1257 class range_adaptor_closure
1258 : public views::__adaptor::_RangeAdaptorClosure<_Derived>
1259 { };
1260#endif
1261
1262 template<range _Range> requires is_object_v<_Range>
1263 class ref_view : public view_interface<ref_view<_Range>>
1264 {
1265 private:
1266 _Range* _M_r;
1267
1268 static void _S_fun(_Range&); // not defined
1269 static void _S_fun(_Range&&) = delete;
1270
1271 public:
1272 template<__detail::__different_from<ref_view> _Tp>
1273 requires convertible_to<_Tp, _Range&>
1274 && requires { _S_fun(declval<_Tp>()); }
1275 constexpr
1276 ref_view(_Tp&& __t)
1277 noexcept(noexcept(static_cast<_Range&>(std::declval<_Tp>())))
1278 : _M_r(std::__addressof(static_cast<_Range&>(std::forward<_Tp>(__t))))
1279 { }
1280
1281 constexpr _Range&
1282 base() const
1283 { return *_M_r; }
1284
1285 constexpr iterator_t<_Range>
1286 begin() const
1287 { return ranges::begin(*_M_r); }
1288
1289 constexpr sentinel_t<_Range>
1290 end() const
1291 { return ranges::end(*_M_r); }
1292
1293 constexpr bool
1294 empty() const requires requires { ranges::empty(*_M_r); }
1295 { return ranges::empty(*_M_r); }
1296
1297 constexpr auto
1298 size() const requires sized_range<_Range>
1299 { return ranges::size(*_M_r); }
1300
1301 constexpr auto
1302 data() const requires contiguous_range<_Range>
1303 { return ranges::data(*_M_r); }
1304 };
1305
1306 template<typename _Range>
1307 ref_view(_Range&) -> ref_view<_Range>;
1308
1309 template<typename _Tp>
1310 inline constexpr bool enable_borrowed_range<ref_view<_Tp>> = true;
1311
1312 template<range _Range>
1313 requires movable<_Range>
1314 && (!__detail::__is_initializer_list<remove_cv_t<_Range>>)
1315 class owning_view : public view_interface<owning_view<_Range>>
1316 {
1317 private:
1318 _Range _M_r = _Range();
1319
1320 public:
1321 owning_view() requires default_initializable<_Range> = default;
1322
1323 constexpr
1324 owning_view(_Range&& __t)
1325 noexcept(is_nothrow_move_constructible_v<_Range>)
1326 : _M_r(std::move(__t))
1327 { }
1328
1329 owning_view(owning_view&&) = default;
1330 owning_view& operator=(owning_view&&) = default;
1331
1332 constexpr _Range&
1333 base() & noexcept
1334 { return _M_r; }
1335
1336 constexpr const _Range&
1337 base() const& noexcept
1338 { return _M_r; }
1339
1340 constexpr _Range&&
1341 base() && noexcept
1342 { return std::move(_M_r); }
1343
1344 constexpr const _Range&&
1345 base() const&& noexcept
1346 { return std::move(_M_r); }
1347
1348 constexpr iterator_t<_Range>
1349 begin()
1350 { return ranges::begin(_M_r); }
1351
1352 constexpr sentinel_t<_Range>
1353 end()
1354 { return ranges::end(_M_r); }
1355
1356 constexpr auto
1357 begin() const requires range<const _Range>
1358 { return ranges::begin(_M_r); }
1359
1360 constexpr auto
1361 end() const requires range<const _Range>
1362 { return ranges::end(_M_r); }
1363
1364 constexpr bool
1365 empty() requires requires { ranges::empty(_M_r); }
1366 { return ranges::empty(_M_r); }
1367
1368 constexpr bool
1369 empty() const requires requires { ranges::empty(_M_r); }
1370 { return ranges::empty(_M_r); }
1371
1372 constexpr auto
1373 size() requires sized_range<_Range>
1374 { return ranges::size(_M_r); }
1375
1376 constexpr auto
1377 size() const requires sized_range<const _Range>
1378 { return ranges::size(_M_r); }
1379
1380 constexpr auto
1381 data() requires contiguous_range<_Range>
1382 { return ranges::data(_M_r); }
1383
1384 constexpr auto
1385 data() const requires contiguous_range<const _Range>
1386 { return ranges::data(_M_r); }
1387 };
1388
1389 template<typename _Tp>
1390 inline constexpr bool enable_borrowed_range<owning_view<_Tp>>
1391 = enable_borrowed_range<_Tp>;
1392
1393 namespace views
1394 {
1395 namespace __detail
1396 {
1397 template<typename _Range>
1398 concept __can_ref_view = requires { ref_view{std::declval<_Range>()}; };
1399
1400 template<typename _Range>
1401 concept __can_owning_view = requires { owning_view{std::declval<_Range>()}; };
1402 } // namespace __detail
1403
1404 struct _All : __adaptor::_RangeAdaptorClosure<_All>
1405 {
1406 template<typename _Range>
1407 static constexpr bool
1408 _S_noexcept()
1409 {
1410 if constexpr (view<decay_t<_Range>>)
1411 return is_nothrow_constructible_v<decay_t<_Range>, _Range>;
1412 else if constexpr (__detail::__can_ref_view<_Range>)
1413 return true;
1414 else
1415 return noexcept(owning_view{std::declval<_Range>()});
1416 }
1417
1418 template<viewable_range _Range>
1419 requires view<decay_t<_Range>>
1420 || __detail::__can_ref_view<_Range>
1421 || __detail::__can_owning_view<_Range>
1422 constexpr auto
1423 operator() [[nodiscard]] (_Range&& __r) const
1424 noexcept(_S_noexcept<_Range>())
1425 {
1426 if constexpr (view<decay_t<_Range>>)
1427 return std::forward<_Range>(__r);
1428 else if constexpr (__detail::__can_ref_view<_Range>)
1429 return ref_view{std::forward<_Range>(__r)};
1430 else
1431 return owning_view{std::forward<_Range>(__r)};
1432 }
1433
1434 static constexpr bool _S_has_simple_call_op = true;
1435 };
1436
1437 inline constexpr _All all;
1438
1439 template<viewable_range _Range>
1440 using all_t = decltype(all(std::declval<_Range>()));
1441 } // namespace views
1442
1443 namespace __detail
1444 {
1445 template<typename _Tp>
1446 struct __non_propagating_cache
1447 {
1448 // When _Tp is not an object type (e.g. is a reference type), we make
1449 // __non_propagating_cache<_Tp> empty rather than ill-formed so that
1450 // users can easily conditionally declare data members with this type
1451 // (such as join_view::_M_inner).
1452 };
1453
1454 template<typename _Tp>
1455 requires is_object_v<_Tp>
1456 struct __non_propagating_cache<_Tp>
1457 : protected _Optional_base<_Tp>
1458 {
1459 __non_propagating_cache() = default;
1460
1461 constexpr
1462 __non_propagating_cache(const __non_propagating_cache&) noexcept
1463 { }
1464
1465 constexpr
1466 __non_propagating_cache(__non_propagating_cache&& __other) noexcept
1467 { __other._M_reset(); }
1468
1469 constexpr __non_propagating_cache&
1470 operator=(const __non_propagating_cache& __other) noexcept
1471 {
1472 if (std::__addressof(__other) != this)
1473 this->_M_reset();
1474 return *this;
1475 }
1476
1477 constexpr __non_propagating_cache&
1478 operator=(__non_propagating_cache&& __other) noexcept
1479 {
1480 this->_M_reset();
1481 __other._M_reset();
1482 return *this;
1483 }
1484
1485 constexpr __non_propagating_cache&
1486 operator=(_Tp __val)
1487 {
1488 this->_M_reset();
1489 this->_M_payload._M_construct(std::move(__val));
1490 return *this;
1491 }
1492
1493 constexpr explicit
1494 operator bool() const noexcept
1495 { return this->_M_is_engaged(); }
1496
1497 constexpr _Tp&
1498 operator*() noexcept
1499 { return this->_M_get(); }
1500
1501 constexpr const _Tp&
1502 operator*() const noexcept
1503 { return this->_M_get(); }
1504
1505 template<typename _Iter>
1506 constexpr _Tp&
1507 _M_emplace_deref(const _Iter& __i)
1508 {
1509 this->_M_reset();
1510 auto __f = [] (auto& __x) { return *__x; };
1511 this->_M_payload._M_apply(_Optional_func{__f}, __i);
1512 return this->_M_get();
1513 }
1514 };
1515
1516 template<range _Range>
1517 struct _CachedPosition
1518 {
1519 constexpr bool
1520 _M_has_value() const
1521 { return false; }
1522
1523 constexpr iterator_t<_Range>
1524 _M_get(const _Range&) const
1525 {
1526 __glibcxx_assert(false);
1527 __builtin_unreachable();
1528 }
1529
1530 constexpr void
1531 _M_set(const _Range&, const iterator_t<_Range>&) const
1532 { }
1533 };
1534
1535 template<forward_range _Range>
1536 struct _CachedPosition<_Range>
1537 : protected __non_propagating_cache<iterator_t<_Range>>
1538 {
1539 constexpr bool
1540 _M_has_value() const
1541 { return this->_M_is_engaged(); }
1542
1543 constexpr iterator_t<_Range>
1544 _M_get(const _Range&) const
1545 {
1546 __glibcxx_assert(_M_has_value());
1547 return **this;
1548 }
1549
1550 constexpr void
1551 _M_set(const _Range&, const iterator_t<_Range>& __it)
1552 {
1553 __glibcxx_assert(!_M_has_value());
1554 std::construct_at(std::__addressof(this->_M_payload._M_payload),
1555 in_place, __it);
1556 this->_M_payload._M_engaged = true;
1557 }
1558 };
1559
1560 template<random_access_range _Range>
1561 requires (sizeof(range_difference_t<_Range>)
1562 <= sizeof(iterator_t<_Range>))
1563 struct _CachedPosition<_Range>
1564 {
1565 private:
1566 range_difference_t<_Range> _M_offset = -1;
1567
1568 public:
1569 _CachedPosition() = default;
1570
1571 constexpr
1572 _CachedPosition(const _CachedPosition&) = default;
1573
1574 constexpr
1575 _CachedPosition(_CachedPosition&& __other) noexcept
1576 { *this = std::move(__other); }
1577
1578 constexpr _CachedPosition&
1579 operator=(const _CachedPosition&) = default;
1580
1581 constexpr _CachedPosition&
1582 operator=(_CachedPosition&& __other) noexcept
1583 {
1584 // Propagate the cached offset, but invalidate the source.
1585 _M_offset = __other._M_offset;
1586 __other._M_offset = -1;
1587 return *this;
1588 }
1589
1590 constexpr bool
1591 _M_has_value() const
1592 { return _M_offset >= 0; }
1593
1594 constexpr iterator_t<_Range>
1595 _M_get(_Range& __r) const
1596 {
1597 __glibcxx_assert(_M_has_value());
1598 return ranges::begin(__r) + _M_offset;
1599 }
1600
1601 constexpr void
1602 _M_set(_Range& __r, const iterator_t<_Range>& __it)
1603 {
1604 __glibcxx_assert(!_M_has_value());
1605 _M_offset = __it - ranges::begin(__r);
1606 }
1607 };
1608 } // namespace __detail
1609
1610 namespace __detail
1611 {
1612 template<typename _Base>
1613 struct __filter_view_iter_cat
1614 { };
1615
1616 template<forward_range _Base>
1617 struct __filter_view_iter_cat<_Base>
1618 {
1619 private:
1620 static auto
1621 _S_iter_cat()
1622 {
1623 using _Cat = typename iterator_traits<iterator_t<_Base>>::iterator_category;
1624 if constexpr (derived_from<_Cat, bidirectional_iterator_tag>)
1625 return bidirectional_iterator_tag{};
1626 else if constexpr (derived_from<_Cat, forward_iterator_tag>)
1627 return forward_iterator_tag{};
1628 else
1629 return _Cat{};
1630 }
1631 public:
1632 using iterator_category = decltype(_S_iter_cat());
1633 };
1634 } // namespace __detail
1635
1636 template<input_range _Vp,
1637 indirect_unary_predicate<iterator_t<_Vp>> _Pred>
1638 requires view<_Vp> && is_object_v<_Pred>
1639 class filter_view : public view_interface<filter_view<_Vp, _Pred>>
1640 {
1641 private:
1642 struct _Sentinel;
1643
1644 struct _Iterator : __detail::__filter_view_iter_cat<_Vp>
1645 {
1646 private:
1647 static constexpr auto
1648 _S_iter_concept()
1649 {
1650 if constexpr (bidirectional_range<_Vp>)
1651 return bidirectional_iterator_tag{};
1652 else if constexpr (forward_range<_Vp>)
1653 return forward_iterator_tag{};
1654 else
1655 return input_iterator_tag{};
1656 }
1657
1658 friend filter_view;
1659
1660 using _Vp_iter = iterator_t<_Vp>;
1661
1662 _Vp_iter _M_current = _Vp_iter();
1663 filter_view* _M_parent = nullptr;
1664
1665 public:
1666 using iterator_concept = decltype(_S_iter_concept());
1667 // iterator_category defined in __filter_view_iter_cat
1668 using value_type = range_value_t<_Vp>;
1669 using difference_type = range_difference_t<_Vp>;
1670
1671 _Iterator() requires default_initializable<_Vp_iter> = default;
1672
1673 constexpr
1674 _Iterator(filter_view* __parent, _Vp_iter __current)
1675 : _M_current(std::move(__current)),
1676 _M_parent(__parent)
1677 { }
1678
1679 constexpr const _Vp_iter&
1680 base() const & noexcept
1681 { return _M_current; }
1682
1683 constexpr _Vp_iter
1684 base() &&
1685 { return std::move(_M_current); }
1686
1687 constexpr range_reference_t<_Vp>
1688 operator*() const
1689 { return *_M_current; }
1690
1691 constexpr _Vp_iter
1692 operator->() const
1693 requires __detail::__has_arrow<_Vp_iter>
1694 && copyable<_Vp_iter>
1695 { return _M_current; }
1696
1697 constexpr _Iterator&
1698 operator++()
1699 {
1700 _M_current = ranges::find_if(std::move(++_M_current),
1701 ranges::end(_M_parent->_M_base),
1702 std::ref(*_M_parent->_M_pred));
1703 return *this;
1704 }
1705
1706 constexpr void
1707 operator++(int)
1708 { ++*this; }
1709
1710 constexpr _Iterator
1711 operator++(int) requires forward_range<_Vp>
1712 {
1713 auto __tmp = *this;
1714 ++*this;
1715 return __tmp;
1716 }
1717
1718 constexpr _Iterator&
1719 operator--() requires bidirectional_range<_Vp>
1720 {
1721 do
1722 --_M_current;
1723 while (!std::__invoke(*_M_parent->_M_pred, *_M_current));
1724 return *this;
1725 }
1726
1727 constexpr _Iterator
1728 operator--(int) requires bidirectional_range<_Vp>
1729 {
1730 auto __tmp = *this;
1731 --*this;
1732 return __tmp;
1733 }
1734
1735 friend constexpr bool
1736 operator==(const _Iterator& __x, const _Iterator& __y)
1737 requires equality_comparable<_Vp_iter>
1738 { return __x._M_current == __y._M_current; }
1739
1740 friend constexpr range_rvalue_reference_t<_Vp>
1741 iter_move(const _Iterator& __i)
1742 noexcept(noexcept(ranges::iter_move(__i._M_current)))
1743 { return ranges::iter_move(__i._M_current); }
1744
1745 friend constexpr void
1746 iter_swap(const _Iterator& __x, const _Iterator& __y)
1747 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1748 requires indirectly_swappable<_Vp_iter>
1749 { ranges::iter_swap(__x._M_current, __y._M_current); }
1750 };
1751
1752 struct _Sentinel
1753 {
1754 private:
1755 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
1756
1757 constexpr bool
1758 __equal(const _Iterator& __i) const
1759 { return __i._M_current == _M_end; }
1760
1761 public:
1762 _Sentinel() = default;
1763
1764 constexpr explicit
1765 _Sentinel(filter_view* __parent)
1766 : _M_end(ranges::end(__parent->_M_base))
1767 { }
1768
1769 constexpr sentinel_t<_Vp>
1770 base() const
1771 { return _M_end; }
1772
1773 friend constexpr bool
1774 operator==(const _Iterator& __x, const _Sentinel& __y)
1775 { return __y.__equal(__x); }
1776 };
1777
1778 _Vp _M_base = _Vp();
1779 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
1780 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
1781
1782 public:
1783 filter_view() requires (default_initializable<_Vp>
1784 && default_initializable<_Pred>)
1785 = default;
1786
1787 constexpr
1788 filter_view(_Vp __base, _Pred __pred)
1789 : _M_base(std::move(__base)), _M_pred(std::move(__pred))
1790 { }
1791
1792 constexpr _Vp
1793 base() const& requires copy_constructible<_Vp>
1794 { return _M_base; }
1795
1796 constexpr _Vp
1797 base() &&
1798 { return std::move(_M_base); }
1799
1800 constexpr const _Pred&
1801 pred() const
1802 { return *_M_pred; }
1803
1804 constexpr _Iterator
1805 begin()
1806 {
1807 if (_M_cached_begin._M_has_value())
1808 return {this, _M_cached_begin._M_get(_M_base)};
1809
1810 __glibcxx_assert(_M_pred.has_value());
1811 auto __it = ranges::find_if(ranges::begin(_M_base),
1812 ranges::end(_M_base),
1813 std::ref(*_M_pred));
1814 _M_cached_begin._M_set(_M_base, __it);
1815 return {this, std::move(__it)};
1816 }
1817
1818 constexpr auto
1819 end()
1820 {
1821 if constexpr (common_range<_Vp>)
1822 return _Iterator{this, ranges::end(_M_base)};
1823 else
1824 return _Sentinel{this};
1825 }
1826 };
1827
1828 template<typename _Range, typename _Pred>
1829 filter_view(_Range&&, _Pred) -> filter_view<views::all_t<_Range>, _Pred>;
1830
1831 namespace views
1832 {
1833 namespace __detail
1834 {
1835 template<typename _Range, typename _Pred>
1836 concept __can_filter_view
1837 = requires { filter_view(std::declval<_Range>(), std::declval<_Pred>()); };
1838 } // namespace __detail
1839
1840 struct _Filter : __adaptor::_RangeAdaptor<_Filter>
1841 {
1842 template<viewable_range _Range, typename _Pred>
1843 requires __detail::__can_filter_view<_Range, _Pred>
1844 constexpr auto
1845 operator() [[nodiscard]] (_Range&& __r, _Pred&& __p) const
1846 {
1847 return filter_view(std::forward<_Range>(__r), std::forward<_Pred>(__p));
1848 }
1849
1850 using _RangeAdaptor<_Filter>::operator();
1851 static constexpr int _S_arity = 2;
1852 static constexpr bool _S_has_simple_extra_args = true;
1853 };
1854
1855 inline constexpr _Filter filter;
1856 } // namespace views
1857
1858#if __cpp_lib_ranges >= 202207L // C++ >= 23
1859 template<input_range _Vp, move_constructible _Fp>
1860#else
1861 template<input_range _Vp, copy_constructible _Fp>
1862#endif
1863 requires view<_Vp> && is_object_v<_Fp>
1864 && regular_invocable<_Fp&, range_reference_t<_Vp>>
1865 && std::__detail::__can_reference<invoke_result_t<_Fp&,
1866 range_reference_t<_Vp>>>
1867 class transform_view : public view_interface<transform_view<_Vp, _Fp>>
1868 {
1869 private:
1870 template<bool _Const>
1871 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
1872
1873 template<bool _Const>
1874 struct __iter_cat
1875 { };
1876
1877 template<bool _Const>
1878 requires forward_range<_Base<_Const>>
1879 struct __iter_cat<_Const>
1880 {
1881 private:
1882 static auto
1883 _S_iter_cat()
1884 {
1885 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1886 // 3564. transform_view::iterator<true>::value_type and
1887 // iterator_category should use const F&
1888 using _Base = transform_view::_Base<_Const>;
1889 using _Res = invoke_result_t<__maybe_const_t<_Const, _Fp>&,
1890 range_reference_t<_Base>>;
1891 if constexpr (is_lvalue_reference_v<_Res>)
1892 {
1893 using _Cat
1894 = typename iterator_traits<iterator_t<_Base>>::iterator_category;
1895 if constexpr (derived_from<_Cat, contiguous_iterator_tag>)
1896 return random_access_iterator_tag{};
1897 else
1898 return _Cat{};
1899 }
1900 else
1901 return input_iterator_tag{};
1902 }
1903 public:
1904 using iterator_category = decltype(_S_iter_cat());
1905 };
1906
1907 template<bool _Const>
1908 struct _Sentinel;
1909
1910 template<bool _Const>
1911 struct _Iterator : __iter_cat<_Const>
1912 {
1913 private:
1914 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
1915 using _Base = transform_view::_Base<_Const>;
1916
1917 static auto
1918 _S_iter_concept()
1919 {
1920 if constexpr (random_access_range<_Base>)
1921 return random_access_iterator_tag{};
1922 else if constexpr (bidirectional_range<_Base>)
1923 return bidirectional_iterator_tag{};
1924 else if constexpr (forward_range<_Base>)
1925 return forward_iterator_tag{};
1926 else
1927 return input_iterator_tag{};
1928 }
1929
1930 using _Base_iter = iterator_t<_Base>;
1931
1932 _Base_iter _M_current = _Base_iter();
1933 _Parent* _M_parent = nullptr;
1934
1935 public:
1936 using iterator_concept = decltype(_S_iter_concept());
1937 // iterator_category defined in __transform_view_iter_cat
1938 using value_type
1939 = remove_cvref_t<invoke_result_t<__maybe_const_t<_Const, _Fp>&,
1940 range_reference_t<_Base>>>;
1941 using difference_type = range_difference_t<_Base>;
1942
1943 _Iterator() requires default_initializable<_Base_iter> = default;
1944
1945 constexpr
1946 _Iterator(_Parent* __parent, _Base_iter __current)
1947 : _M_current(std::move(__current)),
1948 _M_parent(__parent)
1949 { }
1950
1951 constexpr
1952 _Iterator(_Iterator<!_Const> __i)
1953 requires _Const
1954 && convertible_to<iterator_t<_Vp>, _Base_iter>
1955 : _M_current(std::move(__i._M_current)), _M_parent(__i._M_parent)
1956 { }
1957
1958 constexpr const _Base_iter&
1959 base() const & noexcept
1960 { return _M_current; }
1961
1962 constexpr _Base_iter
1963 base() &&
1964 { return std::move(_M_current); }
1965
1966 constexpr decltype(auto)
1967 operator*() const
1968 noexcept(noexcept(std::__invoke(*_M_parent->_M_fun, *_M_current)))
1969 { return std::__invoke(*_M_parent->_M_fun, *_M_current); }
1970
1971 constexpr _Iterator&
1972 operator++()
1973 {
1974 ++_M_current;
1975 return *this;
1976 }
1977
1978 constexpr void
1979 operator++(int)
1980 { ++_M_current; }
1981
1982 constexpr _Iterator
1983 operator++(int) requires forward_range<_Base>
1984 {
1985 auto __tmp = *this;
1986 ++*this;
1987 return __tmp;
1988 }
1989
1990 constexpr _Iterator&
1991 operator--() requires bidirectional_range<_Base>
1992 {
1993 --_M_current;
1994 return *this;
1995 }
1996
1997 constexpr _Iterator
1998 operator--(int) requires bidirectional_range<_Base>
1999 {
2000 auto __tmp = *this;
2001 --*this;
2002 return __tmp;
2003 }
2004
2005 constexpr _Iterator&
2006 operator+=(difference_type __n) requires random_access_range<_Base>
2007 {
2008 _M_current += __n;
2009 return *this;
2010 }
2011
2012 constexpr _Iterator&
2013 operator-=(difference_type __n) requires random_access_range<_Base>
2014 {
2015 _M_current -= __n;
2016 return *this;
2017 }
2018
2019 constexpr decltype(auto)
2020 operator[](difference_type __n) const
2021 requires random_access_range<_Base>
2022 { return std::__invoke(*_M_parent->_M_fun, _M_current[__n]); }
2023
2024 friend constexpr bool
2025 operator==(const _Iterator& __x, const _Iterator& __y)
2026 requires equality_comparable<_Base_iter>
2027 { return __x._M_current == __y._M_current; }
2028
2029 friend constexpr bool
2030 operator<(const _Iterator& __x, const _Iterator& __y)
2031 requires random_access_range<_Base>
2032 { return __x._M_current < __y._M_current; }
2033
2034 friend constexpr bool
2035 operator>(const _Iterator& __x, const _Iterator& __y)
2036 requires random_access_range<_Base>
2037 { return __y < __x; }
2038
2039 friend constexpr bool
2040 operator<=(const _Iterator& __x, const _Iterator& __y)
2041 requires random_access_range<_Base>
2042 { return !(__y < __x); }
2043
2044 friend constexpr bool
2045 operator>=(const _Iterator& __x, const _Iterator& __y)
2046 requires random_access_range<_Base>
2047 { return !(__x < __y); }
2048
2049#ifdef __cpp_lib_three_way_comparison
2050 friend constexpr auto
2051 operator<=>(const _Iterator& __x, const _Iterator& __y)
2052 requires random_access_range<_Base>
2053 && three_way_comparable<_Base_iter>
2054 { return __x._M_current <=> __y._M_current; }
2055#endif
2056
2057 friend constexpr _Iterator
2058 operator+(_Iterator __i, difference_type __n)
2059 requires random_access_range<_Base>
2060 { return {__i._M_parent, __i._M_current + __n}; }
2061
2062 friend constexpr _Iterator
2063 operator+(difference_type __n, _Iterator __i)
2064 requires random_access_range<_Base>
2065 { return {__i._M_parent, __i._M_current + __n}; }
2066
2067 friend constexpr _Iterator
2068 operator-(_Iterator __i, difference_type __n)
2069 requires random_access_range<_Base>
2070 { return {__i._M_parent, __i._M_current - __n}; }
2071
2072 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2073 // 3483. transform_view::iterator's difference is overconstrained
2074 friend constexpr difference_type
2075 operator-(const _Iterator& __x, const _Iterator& __y)
2076 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
2077 { return __x._M_current - __y._M_current; }
2078
2079 friend constexpr decltype(auto)
2080 iter_move(const _Iterator& __i) noexcept(noexcept(*__i))
2081 {
2082 if constexpr (is_lvalue_reference_v<decltype(*__i)>)
2083 return std::move(*__i);
2084 else
2085 return *__i;
2086 }
2087
2088 friend _Iterator<!_Const>;
2089 template<bool> friend struct _Sentinel;
2090 };
2091
2092 template<bool _Const>
2093 struct _Sentinel
2094 {
2095 private:
2096 using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
2097 using _Base = transform_view::_Base<_Const>;
2098
2099 template<bool _Const2>
2100 constexpr auto
2101 __distance_from(const _Iterator<_Const2>& __i) const
2102 { return _M_end - __i._M_current; }
2103
2104 template<bool _Const2>
2105 constexpr bool
2106 __equal(const _Iterator<_Const2>& __i) const
2107 { return __i._M_current == _M_end; }
2108
2109 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2110
2111 public:
2112 _Sentinel() = default;
2113
2114 constexpr explicit
2115 _Sentinel(sentinel_t<_Base> __end)
2116 : _M_end(__end)
2117 { }
2118
2119 constexpr
2120 _Sentinel(_Sentinel<!_Const> __i)
2121 requires _Const
2122 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2123 : _M_end(std::move(__i._M_end))
2124 { }
2125
2126 constexpr sentinel_t<_Base>
2127 base() const
2128 { return _M_end; }
2129
2130 template<bool _Const2>
2131 requires sentinel_for<sentinel_t<_Base>,
2132 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
2133 friend constexpr bool
2134 operator==(const _Iterator<_Const2>& __x, const _Sentinel& __y)
2135 { return __y.__equal(__x); }
2136
2137 template<bool _Const2,
2138 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
2139 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2140 friend constexpr range_difference_t<_Base2>
2141 operator-(const _Iterator<_Const2>& __x, const _Sentinel& __y)
2142 { return -__y.__distance_from(__x); }
2143
2144 template<bool _Const2,
2145 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
2146 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2147 friend constexpr range_difference_t<_Base2>
2148 operator-(const _Sentinel& __y, const _Iterator<_Const2>& __x)
2149 { return __y.__distance_from(__x); }
2150
2151 friend _Sentinel<!_Const>;
2152 };
2153
2154 _Vp _M_base = _Vp();
2155 [[no_unique_address]] __detail::__box<_Fp> _M_fun;
2156
2157 public:
2158 transform_view() requires (default_initializable<_Vp>
2159 && default_initializable<_Fp>)
2160 = default;
2161
2162 constexpr
2163 transform_view(_Vp __base, _Fp __fun)
2164 : _M_base(std::move(__base)), _M_fun(std::move(__fun))
2165 { }
2166
2167 constexpr _Vp
2168 base() const& requires copy_constructible<_Vp>
2169 { return _M_base ; }
2170
2171 constexpr _Vp
2172 base() &&
2173 { return std::move(_M_base); }
2174
2175 constexpr _Iterator<false>
2176 begin()
2177 { return _Iterator<false>{this, ranges::begin(_M_base)}; }
2178
2179 constexpr _Iterator<true>
2180 begin() const
2181 requires range<const _Vp>
2182 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
2183 { return _Iterator<true>{this, ranges::begin(_M_base)}; }
2184
2185 constexpr _Sentinel<false>
2186 end()
2187 { return _Sentinel<false>{ranges::end(_M_base)}; }
2188
2189 constexpr _Iterator<false>
2190 end() requires common_range<_Vp>
2191 { return _Iterator<false>{this, ranges::end(_M_base)}; }
2192
2193 constexpr _Sentinel<true>
2194 end() const
2195 requires range<const _Vp>
2196 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
2197 { return _Sentinel<true>{ranges::end(_M_base)}; }
2198
2199 constexpr _Iterator<true>
2200 end() const
2201 requires common_range<const _Vp>
2202 && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
2203 { return _Iterator<true>{this, ranges::end(_M_base)}; }
2204
2205 constexpr auto
2206 size() requires sized_range<_Vp>
2207 { return ranges::size(_M_base); }
2208
2209 constexpr auto
2210 size() const requires sized_range<const _Vp>
2211 { return ranges::size(_M_base); }
2212 };
2213
2214 template<typename _Range, typename _Fp>
2215 transform_view(_Range&&, _Fp) -> transform_view<views::all_t<_Range>, _Fp>;
2216
2217 namespace views
2218 {
2219 namespace __detail
2220 {
2221 template<typename _Range, typename _Fp>
2222 concept __can_transform_view
2223 = requires { transform_view(std::declval<_Range>(), std::declval<_Fp>()); };
2224 } // namespace __detail
2225
2226 struct _Transform : __adaptor::_RangeAdaptor<_Transform>
2227 {
2228 template<viewable_range _Range, typename _Fp>
2229 requires __detail::__can_transform_view<_Range, _Fp>
2230 constexpr auto
2231 operator() [[nodiscard]] (_Range&& __r, _Fp&& __f) const
2232 {
2233 return transform_view(std::forward<_Range>(__r), std::forward<_Fp>(__f));
2234 }
2235
2236 using _RangeAdaptor<_Transform>::operator();
2237 static constexpr int _S_arity = 2;
2238 static constexpr bool _S_has_simple_extra_args = true;
2239 };
2240
2241 inline constexpr _Transform transform;
2242 } // namespace views
2243
2244 template<view _Vp>
2245 class take_view : public view_interface<take_view<_Vp>>
2246 {
2247 private:
2248 template<bool _Const>
2249 using _CI = counted_iterator<
2250 iterator_t<__detail::__maybe_const_t<_Const, _Vp>>>;
2251
2252 template<bool _Const>
2253 struct _Sentinel
2254 {
2255 private:
2256 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2257 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2258
2259 public:
2260 _Sentinel() = default;
2261
2262 constexpr explicit
2263 _Sentinel(sentinel_t<_Base> __end)
2264 : _M_end(__end)
2265 { }
2266
2267 constexpr
2268 _Sentinel(_Sentinel<!_Const> __s)
2269 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2270 : _M_end(std::move(__s._M_end))
2271 { }
2272
2273 constexpr sentinel_t<_Base>
2274 base() const
2275 { return _M_end; }
2276
2277 friend constexpr bool
2278 operator==(const _CI<_Const>& __y, const _Sentinel& __x)
2279 { return __y.count() == 0 || __y.base() == __x._M_end; }
2280
2281 template<bool _OtherConst = !_Const,
2282 typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
2283 requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2284 friend constexpr bool
2285 operator==(const _CI<_OtherConst>& __y, const _Sentinel& __x)
2286 { return __y.count() == 0 || __y.base() == __x._M_end; }
2287
2288 friend _Sentinel<!_Const>;
2289 };
2290
2291 _Vp _M_base = _Vp();
2292 range_difference_t<_Vp> _M_count = 0;
2293
2294 public:
2295 take_view() requires default_initializable<_Vp> = default;
2296
2297 constexpr
2298 take_view(_Vp __base, range_difference_t<_Vp> __count)
2299 : _M_base(std::move(__base)), _M_count(std::move(__count))
2300 { }
2301
2302 constexpr _Vp
2303 base() const& requires copy_constructible<_Vp>
2304 { return _M_base; }
2305
2306 constexpr _Vp
2307 base() &&
2308 { return std::move(_M_base); }
2309
2310 constexpr auto
2311 begin() requires (!__detail::__simple_view<_Vp>)
2312 {
2313 if constexpr (sized_range<_Vp>)
2314 {
2315 if constexpr (random_access_range<_Vp>)
2316 return ranges::begin(_M_base);
2317 else
2318 {
2319 auto __sz = size();
2320 return counted_iterator(ranges::begin(_M_base), __sz);
2321 }
2322 }
2323 else
2324 return counted_iterator(ranges::begin(_M_base), _M_count);
2325 }
2326
2327 constexpr auto
2328 begin() const requires range<const _Vp>
2329 {
2330 if constexpr (sized_range<const _Vp>)
2331 {
2332 if constexpr (random_access_range<const _Vp>)
2333 return ranges::begin(_M_base);
2334 else
2335 {
2336 auto __sz = size();
2337 return counted_iterator(ranges::begin(_M_base), __sz);
2338 }
2339 }
2340 else
2341 return counted_iterator(ranges::begin(_M_base), _M_count);
2342 }
2343
2344 constexpr auto
2345 end() requires (!__detail::__simple_view<_Vp>)
2346 {
2347 if constexpr (sized_range<_Vp>)
2348 {
2349 if constexpr (random_access_range<_Vp>)
2350 return ranges::begin(_M_base) + size();
2351 else
2352 return default_sentinel;
2353 }
2354 else
2355 return _Sentinel<false>{ranges::end(_M_base)};
2356 }
2357
2358 constexpr auto
2359 end() const requires range<const _Vp>
2360 {
2361 if constexpr (sized_range<const _Vp>)
2362 {
2363 if constexpr (random_access_range<const _Vp>)
2364 return ranges::begin(_M_base) + size();
2365 else
2366 return default_sentinel;
2367 }
2368 else
2369 return _Sentinel<true>{ranges::end(_M_base)};
2370 }
2371
2372 constexpr auto
2373 size() requires sized_range<_Vp>
2374 {
2375 auto __n = ranges::size(_M_base);
2376 return std::min(__n, static_cast<decltype(__n)>(_M_count));
2377 }
2378
2379 constexpr auto
2380 size() const requires sized_range<const _Vp>
2381 {
2382 auto __n = ranges::size(_M_base);
2383 return std::min(__n, static_cast<decltype(__n)>(_M_count));
2384 }
2385 };
2386
2387 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2388 // 3447. Deduction guides for take_view and drop_view have different
2389 // constraints
2390 template<typename _Range>
2391 take_view(_Range&&, range_difference_t<_Range>)
2392 -> take_view<views::all_t<_Range>>;
2393
2394 template<typename _Tp>
2395 inline constexpr bool enable_borrowed_range<take_view<_Tp>>
2396 = enable_borrowed_range<_Tp>;
2397
2398 namespace views
2399 {
2400 namespace __detail
2401 {
2402 template<typename _Range>
2403 inline constexpr bool __is_empty_view = false;
2404
2405 template<typename _Tp>
2406 inline constexpr bool __is_empty_view<empty_view<_Tp>> = true;
2407
2408 template<typename _Range>
2409 inline constexpr bool __is_basic_string_view = false;
2410
2411 template<typename _CharT, typename _Traits>
2412 inline constexpr bool __is_basic_string_view<basic_string_view<_CharT, _Traits>>
2413 = true;
2414
2415 using ranges::__detail::__is_subrange;
2416
2417 template<typename _Range>
2418 inline constexpr bool __is_iota_view = false;
2419
2420 template<typename _Winc, typename _Bound>
2421 inline constexpr bool __is_iota_view<iota_view<_Winc, _Bound>> = true;
2422
2423 template<typename _Range>
2424 inline constexpr bool __is_repeat_view = false;
2425
2426 template<typename _Range>
2427 constexpr auto
2428 __take_of_repeat_view(_Range&&, range_difference_t<_Range>); // defined later
2429
2430 template<typename _Range, typename _Dp>
2431 concept __can_take_view
2432 = requires { take_view(std::declval<_Range>(), std::declval<_Dp>()); };
2433 } // namespace __detail
2434
2435 struct _Take : __adaptor::_RangeAdaptor<_Take>
2436 {
2437 template<viewable_range _Range, typename _Dp = range_difference_t<_Range>>
2438 requires __detail::__can_take_view<_Range, _Dp>
2439 constexpr auto
2440 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n) const
2441 {
2442 using _Tp = remove_cvref_t<_Range>;
2443 if constexpr (__detail::__is_empty_view<_Tp>)
2444 return _Tp();
2445 else if constexpr (random_access_range<_Tp>
2446 && sized_range<_Tp>
2447 && (std::__detail::__is_span<_Tp>
2448 || __detail::__is_basic_string_view<_Tp>
2449 || __detail::__is_subrange<_Tp>
2450 || __detail::__is_iota_view<_Tp>))
2451 {
2452 __n = std::min<_Dp>(ranges::distance(__r), __n);
2453 auto __begin = ranges::begin(__r);
2454 auto __end = __begin + __n;
2455 if constexpr (std::__detail::__is_span<_Tp>)
2456 return span<typename _Tp::element_type>(__begin, __end);
2457 else if constexpr (__detail::__is_basic_string_view<_Tp>)
2458 return _Tp(__begin, __end);
2459 else if constexpr (__detail::__is_subrange<_Tp>)
2460 return subrange<iterator_t<_Tp>>(__begin, __end);
2461 else
2462 return iota_view(*__begin, *__end);
2463 }
2464 else if constexpr (__detail::__is_repeat_view<_Tp>)
2465 return __detail::__take_of_repeat_view(std::forward<_Range>(__r), __n);
2466 else
2467 return take_view(std::forward<_Range>(__r), __n);
2468 }
2469
2470 using _RangeAdaptor<_Take>::operator();
2471 static constexpr int _S_arity = 2;
2472 // The count argument of views::take is not always simple -- it can be
2473 // e.g. a move-only class that's implicitly convertible to the difference
2474 // type. But an integer-like count argument is surely simple.
2475 template<typename _Tp>
2476 static constexpr bool _S_has_simple_extra_args
2477 = ranges::__detail::__is_integer_like<_Tp>;
2478 };
2479
2480 inline constexpr _Take take;
2481 } // namespace views
2482
2483 template<view _Vp, typename _Pred>
2484 requires input_range<_Vp> && is_object_v<_Pred>
2485 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2486 class take_while_view : public view_interface<take_while_view<_Vp, _Pred>>
2487 {
2488 template<bool _Const>
2489 struct _Sentinel
2490 {
2491 private:
2492 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2493
2494 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2495 const _Pred* _M_pred = nullptr;
2496
2497 public:
2498 _Sentinel() = default;
2499
2500 constexpr explicit
2501 _Sentinel(sentinel_t<_Base> __end, const _Pred* __pred)
2502 : _M_end(__end), _M_pred(__pred)
2503 { }
2504
2505 constexpr
2506 _Sentinel(_Sentinel<!_Const> __s)
2507 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2508 : _M_end(__s._M_end), _M_pred(__s._M_pred)
2509 { }
2510
2511 constexpr sentinel_t<_Base>
2512 base() const { return _M_end; }
2513
2514 friend constexpr bool
2515 operator==(const iterator_t<_Base>& __x, const _Sentinel& __y)
2516 { return __y._M_end == __x || !std::__invoke(*__y._M_pred, *__x); }
2517
2518 template<bool _OtherConst = !_Const,
2519 typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
2520 requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2521 friend constexpr bool
2522 operator==(const iterator_t<_Base2>& __x, const _Sentinel& __y)
2523 { return __y._M_end == __x || !std::__invoke(*__y._M_pred, *__x); }
2524
2525 friend _Sentinel<!_Const>;
2526 };
2527
2528 _Vp _M_base = _Vp();
2529 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
2530
2531 public:
2532 take_while_view() requires (default_initializable<_Vp>
2533 && default_initializable<_Pred>)
2534 = default;
2535
2536 constexpr
2537 take_while_view(_Vp __base, _Pred __pred)
2538 : _M_base(std::move(__base)), _M_pred(std::move(__pred))
2539 { }
2540
2541 constexpr _Vp
2542 base() const& requires copy_constructible<_Vp>
2543 { return _M_base; }
2544
2545 constexpr _Vp
2546 base() &&
2547 { return std::move(_M_base); }
2548
2549 constexpr const _Pred&
2550 pred() const
2551 { return *_M_pred; }
2552
2553 constexpr auto
2554 begin() requires (!__detail::__simple_view<_Vp>)
2555 { return ranges::begin(_M_base); }
2556
2557 constexpr auto
2558 begin() const requires range<const _Vp>
2559 && indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
2560 { return ranges::begin(_M_base); }
2561
2562 constexpr auto
2563 end() requires (!__detail::__simple_view<_Vp>)
2564 { return _Sentinel<false>(ranges::end(_M_base),
2565 std::__addressof(*_M_pred)); }
2566
2567 constexpr auto
2568 end() const requires range<const _Vp>
2569 && indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
2570 { return _Sentinel<true>(ranges::end(_M_base),
2571 std::__addressof(*_M_pred)); }
2572 };
2573
2574 template<typename _Range, typename _Pred>
2575 take_while_view(_Range&&, _Pred)
2576 -> take_while_view<views::all_t<_Range>, _Pred>;
2577
2578 namespace views
2579 {
2580 namespace __detail
2581 {
2582 template<typename _Range, typename _Pred>
2583 concept __can_take_while_view
2584 = requires { take_while_view(std::declval<_Range>(), std::declval<_Pred>()); };
2585 } // namespace __detail
2586
2587 struct _TakeWhile : __adaptor::_RangeAdaptor<_TakeWhile>
2588 {
2589 template<viewable_range _Range, typename _Pred>
2590 requires __detail::__can_take_while_view<_Range, _Pred>
2591 constexpr auto
2592 operator() [[nodiscard]] (_Range&& __r, _Pred&& __p) const
2593 {
2594 return take_while_view(std::forward<_Range>(__r), std::forward<_Pred>(__p));
2595 }
2596
2597 using _RangeAdaptor<_TakeWhile>::operator();
2598 static constexpr int _S_arity = 2;
2599 static constexpr bool _S_has_simple_extra_args = true;
2600 };
2601
2602 inline constexpr _TakeWhile take_while;
2603 } // namespace views
2604
2605 template<view _Vp>
2606 class drop_view : public view_interface<drop_view<_Vp>>
2607 {
2608 private:
2609 _Vp _M_base = _Vp();
2610 range_difference_t<_Vp> _M_count = 0;
2611
2612 // ranges::next(begin(base), count, end(base)) is O(1) if _Vp satisfies
2613 // both random_access_range and sized_range. Otherwise, cache its result.
2614 static constexpr bool _S_needs_cached_begin
2615 = !(random_access_range<const _Vp> && sized_range<const _Vp>);
2616 [[no_unique_address]]
2617 __detail::__maybe_present_t<_S_needs_cached_begin,
2618 __detail::_CachedPosition<_Vp>>
2619 _M_cached_begin;
2620
2621 public:
2622 drop_view() requires default_initializable<_Vp> = default;
2623
2624 constexpr
2625 drop_view(_Vp __base, range_difference_t<_Vp> __count)
2626 : _M_base(std::move(__base)), _M_count(__count)
2627 { __glibcxx_assert(__count >= 0); }
2628
2629 constexpr _Vp
2630 base() const& requires copy_constructible<_Vp>
2631 { return _M_base; }
2632
2633 constexpr _Vp
2634 base() &&
2635 { return std::move(_M_base); }
2636
2637 // This overload is disabled for simple views with constant-time begin().
2638 constexpr auto
2639 begin()
2640 requires (!(__detail::__simple_view<_Vp>
2641 && random_access_range<const _Vp>
2642 && sized_range<const _Vp>))
2643 {
2644 if constexpr (_S_needs_cached_begin)
2645 if (_M_cached_begin._M_has_value())
2646 return _M_cached_begin._M_get(_M_base);
2647
2648 auto __it = ranges::next(ranges::begin(_M_base),
2649 _M_count, ranges::end(_M_base));
2650 if constexpr (_S_needs_cached_begin)
2651 _M_cached_begin._M_set(_M_base, __it);
2652 return __it;
2653 }
2654
2655 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2656 // 3482. drop_view's const begin should additionally require sized_range
2657 constexpr auto
2658 begin() const
2659 requires random_access_range<const _Vp> && sized_range<const _Vp>
2660 {
2661 return ranges::next(ranges::begin(_M_base), _M_count,
2662 ranges::end(_M_base));
2663 }
2664
2665 constexpr auto
2666 end() requires (!__detail::__simple_view<_Vp>)
2667 { return ranges::end(_M_base); }
2668
2669 constexpr auto
2670 end() const requires range<const _Vp>
2671 { return ranges::end(_M_base); }
2672
2673 constexpr auto
2674 size() requires sized_range<_Vp>
2675 {
2676 const auto __s = ranges::size(_M_base);
2677 const auto __c = static_cast<decltype(__s)>(_M_count);
2678 return __s < __c ? 0 : __s - __c;
2679 }
2680
2681 constexpr auto
2682 size() const requires sized_range<const _Vp>
2683 {
2684 const auto __s = ranges::size(_M_base);
2685 const auto __c = static_cast<decltype(__s)>(_M_count);
2686 return __s < __c ? 0 : __s - __c;
2687 }
2688 };
2689
2690 template<typename _Range>
2691 drop_view(_Range&&, range_difference_t<_Range>)
2692 -> drop_view<views::all_t<_Range>>;
2693
2694 template<typename _Tp>
2695 inline constexpr bool enable_borrowed_range<drop_view<_Tp>>
2696 = enable_borrowed_range<_Tp>;
2697
2698 namespace views
2699 {
2700 namespace __detail
2701 {
2702 template<typename _Range>
2703 constexpr auto
2704 __drop_of_repeat_view(_Range&&, range_difference_t<_Range>); // defined later
2705
2706 template<typename _Range, typename _Dp>
2707 concept __can_drop_view
2708 = requires { drop_view(std::declval<_Range>(), std::declval<_Dp>()); };
2709 } // namespace __detail
2710
2711 struct _Drop : __adaptor::_RangeAdaptor<_Drop>
2712 {
2713 template<viewable_range _Range, typename _Dp = range_difference_t<_Range>>
2714 requires __detail::__can_drop_view<_Range, _Dp>
2715 constexpr auto
2716 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n) const
2717 {
2718 using _Tp = remove_cvref_t<_Range>;
2719 if constexpr (__detail::__is_empty_view<_Tp>)
2720 return _Tp();
2721 else if constexpr (random_access_range<_Tp>
2722 && sized_range<_Tp>
2723 && (std::__detail::__is_span<_Tp>
2724 || __detail::__is_basic_string_view<_Tp>
2725 || __detail::__is_iota_view<_Tp>
2726 || __detail::__is_subrange<_Tp>))
2727 {
2728 __n = std::min<_Dp>(ranges::distance(__r), __n);
2729 auto __begin = ranges::begin(__r) + __n;
2730 auto __end = ranges::end(__r);
2731 if constexpr (std::__detail::__is_span<_Tp>)
2732 return span<typename _Tp::element_type>(__begin, __end);
2733 else if constexpr (__detail::__is_subrange<_Tp>)
2734 {
2735 if constexpr (_Tp::_S_store_size)
2736 {
2737 using ranges::__detail::__to_unsigned_like;
2738 auto __m = ranges::distance(__r) - __n;
2739 return _Tp(__begin, __end, __to_unsigned_like(__m));
2740 }
2741 else
2742 return _Tp(__begin, __end);
2743 }
2744 else
2745 return _Tp(__begin, __end);
2746 }
2747 else if constexpr (__detail::__is_repeat_view<_Tp>)
2748 return __detail::__drop_of_repeat_view(std::forward<_Range>(__r), __n);
2749 else
2750 return drop_view(std::forward<_Range>(__r), __n);
2751 }
2752
2753 using _RangeAdaptor<_Drop>::operator();
2754 static constexpr int _S_arity = 2;
2755 template<typename _Tp>
2756 static constexpr bool _S_has_simple_extra_args
2757 = _Take::_S_has_simple_extra_args<_Tp>;
2758 };
2759
2760 inline constexpr _Drop drop;
2761 } // namespace views
2762
2763 template<view _Vp, typename _Pred>
2764 requires input_range<_Vp> && is_object_v<_Pred>
2765 && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2766 class drop_while_view : public view_interface<drop_while_view<_Vp, _Pred>>
2767 {
2768 private:
2769 _Vp _M_base = _Vp();
2770 [[no_unique_address]] __detail::__box<_Pred> _M_pred;
2771 [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
2772
2773 public:
2774 drop_while_view() requires (default_initializable<_Vp>
2775 && default_initializable<_Pred>)
2776 = default;
2777
2778 constexpr
2779 drop_while_view(_Vp __base, _Pred __pred)
2780 : _M_base(std::move(__base)), _M_pred(std::move(__pred))
2781 { }
2782
2783 constexpr _Vp
2784 base() const& requires copy_constructible<_Vp>
2785 { return _M_base; }
2786
2787 constexpr _Vp
2788 base() &&
2789 { return std::move(_M_base); }
2790
2791 constexpr const _Pred&
2792 pred() const
2793 { return *_M_pred; }
2794
2795 constexpr auto
2796 begin()
2797 {
2798 if (_M_cached_begin._M_has_value())
2799 return _M_cached_begin._M_get(_M_base);
2800
2801 __glibcxx_assert(_M_pred.has_value());
2802 auto __it = ranges::find_if_not(ranges::begin(_M_base),
2803 ranges::end(_M_base),
2804 std::cref(*_M_pred));
2805 _M_cached_begin._M_set(_M_base, __it);
2806 return __it;
2807 }
2808
2809 constexpr auto
2810 end()
2811 { return ranges::end(_M_base); }
2812 };
2813
2814 template<typename _Range, typename _Pred>
2815 drop_while_view(_Range&&, _Pred)
2816 -> drop_while_view<views::all_t<_Range>, _Pred>;
2817
2818 template<typename _Tp, typename _Pred>
2819 inline constexpr bool enable_borrowed_range<drop_while_view<_Tp, _Pred>>
2820 = enable_borrowed_range<_Tp>;
2821
2822 namespace views
2823 {
2824 namespace __detail
2825 {
2826 template<typename _Range, typename _Pred>
2827 concept __can_drop_while_view
2828 = requires { drop_while_view(std::declval<_Range>(), std::declval<_Pred>()); };
2829 } // namespace __detail
2830
2831 struct _DropWhile : __adaptor::_RangeAdaptor<_DropWhile>
2832 {
2833 template<viewable_range _Range, typename _Pred>
2834 requires __detail::__can_drop_while_view<_Range, _Pred>
2835 constexpr auto
2836 operator() [[nodiscard]] (_Range&& __r, _Pred&& __p) const
2837 {
2838 return drop_while_view(std::forward<_Range>(__r),
2839 std::forward<_Pred>(__p));
2840 }
2841
2842 using _RangeAdaptor<_DropWhile>::operator();
2843 static constexpr int _S_arity = 2;
2844 static constexpr bool _S_has_simple_extra_args = true;
2845 };
2846
2847 inline constexpr _DropWhile drop_while;
2848 } // namespace views
2849
2850 namespace __detail
2851 {
2852 template<typename _Tp>
2853 constexpr _Tp&
2854 __as_lvalue(_Tp&& __t)
2855 { return static_cast<_Tp&>(__t); }
2856 } // namespace __detail
2857
2858 template<input_range _Vp>
2859 requires view<_Vp> && input_range<range_reference_t<_Vp>>
2860 class join_view : public view_interface<join_view<_Vp>>
2861 {
2862 private:
2863 using _InnerRange = range_reference_t<_Vp>;
2864
2865 template<bool _Const>
2866 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2867
2868 template<bool _Const>
2869 using _Outer_iter = iterator_t<_Base<_Const>>;
2870
2871 template<bool _Const>
2872 using _Inner_iter = iterator_t<range_reference_t<_Base<_Const>>>;
2873
2874 template<bool _Const>
2875 static constexpr bool _S_ref_is_glvalue
2876 = is_reference_v<range_reference_t<_Base<_Const>>>;
2877
2878 template<bool _Const>
2879 struct __iter_cat
2880 { };
2881
2882 template<bool _Const>
2883 requires _S_ref_is_glvalue<_Const>
2884 && forward_range<_Base<_Const>>
2885 && forward_range<range_reference_t<_Base<_Const>>>
2886 struct __iter_cat<_Const>
2887 {
2888 private:
2889 static constexpr auto
2890 _S_iter_cat()
2891 {
2892 using _Outer_iter = join_view::_Outer_iter<_Const>;
2893 using _Inner_iter = join_view::_Inner_iter<_Const>;
2894 using _OuterCat = typename iterator_traits<_Outer_iter>::iterator_category;
2895 using _InnerCat = typename iterator_traits<_Inner_iter>::iterator_category;
2896 if constexpr (derived_from<_OuterCat, bidirectional_iterator_tag>
2897 && derived_from<_InnerCat, bidirectional_iterator_tag>
2898 && common_range<range_reference_t<_Base<_Const>>>)
2899 return bidirectional_iterator_tag{};
2900 else if constexpr (derived_from<_OuterCat, forward_iterator_tag>
2901 && derived_from<_InnerCat, forward_iterator_tag>)
2902 return forward_iterator_tag{};
2903 else
2904 return input_iterator_tag{};
2905 }
2906 public:
2907 using iterator_category = decltype(_S_iter_cat());
2908 };
2909
2910 template<bool _Const>
2911 struct _Sentinel;
2912
2913 template<bool _Const>
2914 struct _Iterator : __iter_cat<_Const>
2915 {
2916 private:
2917 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
2918 using _Base = join_view::_Base<_Const>;
2919
2920 friend join_view;
2921
2922 static constexpr bool _S_ref_is_glvalue
2923 = join_view::_S_ref_is_glvalue<_Const>;
2924
2925 constexpr void
2926 _M_satisfy()
2927 {
2928 auto __update_inner = [this] (const iterator_t<_Base>& __x) -> auto&& {
2929 if constexpr (_S_ref_is_glvalue)
2930 return *__x;
2931 else
2932 return _M_parent->_M_inner._M_emplace_deref(__x);
2933 };
2934
2935 _Outer_iter& __outer = _M_get_outer();
2936 for (; __outer != ranges::end(_M_parent->_M_base); ++__outer)
2937 {
2938 auto&& __inner = __update_inner(__outer);
2939 _M_inner = ranges::begin(__inner);
2940 if (_M_inner != ranges::end(__inner))
2941 return;
2942 }
2943
2944 if constexpr (_S_ref_is_glvalue)
2945 _M_inner.reset();
2946 }
2947
2948 static constexpr auto
2949 _S_iter_concept()
2950 {
2951 if constexpr (_S_ref_is_glvalue
2952 && bidirectional_range<_Base>
2953 && bidirectional_range<range_reference_t<_Base>>
2954 && common_range<range_reference_t<_Base>>)
2955 return bidirectional_iterator_tag{};
2956 else if constexpr (_S_ref_is_glvalue
2957 && forward_range<_Base>
2958 && forward_range<range_reference_t<_Base>>)
2959 return forward_iterator_tag{};
2960 else
2961 return input_iterator_tag{};
2962 }
2963
2964 using _Outer_iter = join_view::_Outer_iter<_Const>;
2965 using _Inner_iter = join_view::_Inner_iter<_Const>;
2966
2967 constexpr _Outer_iter&
2968 _M_get_outer()
2969 {
2970 if constexpr (forward_range<_Base>)
2971 return _M_outer;
2972 else
2973 return *_M_parent->_M_outer;
2974 }
2975
2976 constexpr const _Outer_iter&
2977 _M_get_outer() const
2978 {
2979 if constexpr (forward_range<_Base>)
2980 return _M_outer;
2981 else
2982 return *_M_parent->_M_outer;
2983 }
2984
2985 constexpr
2986 _Iterator(_Parent* __parent, _Outer_iter __outer) requires forward_range<_Base>
2987 : _M_outer(std::move(__outer)), _M_parent(__parent)
2988 { _M_satisfy(); }
2989
2990 constexpr explicit
2991 _Iterator(_Parent* __parent) requires (!forward_range<_Base>)
2992 : _M_parent(__parent)
2993 { _M_satisfy(); }
2994
2995 [[no_unique_address]]
2996 __detail::__maybe_present_t<forward_range<_Base>, _Outer_iter> _M_outer;
2997 optional<_Inner_iter> _M_inner;
2998 _Parent* _M_parent = nullptr;
2999
3000 public:
3001 using iterator_concept = decltype(_S_iter_concept());
3002 // iterator_category defined in __join_view_iter_cat
3003 using value_type = range_value_t<range_reference_t<_Base>>;
3004 using difference_type
3005 = common_type_t<range_difference_t<_Base>,
3006 range_difference_t<range_reference_t<_Base>>>;
3007
3008 _Iterator() = default;
3009
3010 constexpr
3011 _Iterator(_Iterator<!_Const> __i)
3012 requires _Const
3013 && convertible_to<iterator_t<_Vp>, _Outer_iter>
3014 && convertible_to<iterator_t<_InnerRange>, _Inner_iter>
3015 : _M_outer(std::move(__i._M_outer)), _M_inner(std::move(__i._M_inner)),
3016 _M_parent(__i._M_parent)
3017 { }
3018
3019 constexpr decltype(auto)
3020 operator*() const
3021 { return **_M_inner; }
3022
3023 // _GLIBCXX_RESOLVE_LIB_DEFECTS
3024 // 3500. join_view::iterator::operator->() is bogus
3025 constexpr _Inner_iter
3026 operator->() const
3027 requires __detail::__has_arrow<_Inner_iter>
3028 && copyable<_Inner_iter>
3029 { return *_M_inner; }
3030
3031 constexpr _Iterator&
3032 operator++()
3033 {
3034 auto&& __inner_range = [this] () -> auto&& {
3035 if constexpr (_S_ref_is_glvalue)
3036 return *_M_get_outer();
3037 else
3038 return *_M_parent->_M_inner;
3039 }();
3040 if (++*_M_inner == ranges::end(__inner_range))
3041 {
3042 ++_M_get_outer();
3043 _M_satisfy();
3044 }
3045 return *this;
3046 }
3047
3048 constexpr void
3049 operator++(int)
3050 { ++*this; }
3051
3052 constexpr _Iterator
3053 operator++(int)
3054 requires _S_ref_is_glvalue && forward_range<_Base>
3055 && forward_range<range_reference_t<_Base>>
3056 {
3057 auto __tmp = *this;
3058 ++*this;
3059 return __tmp;
3060 }
3061
3062 constexpr _Iterator&
3063 operator--()
3064 requires _S_ref_is_glvalue && bidirectional_range<_Base>
3065 && bidirectional_range<range_reference_t<_Base>>
3066 && common_range<range_reference_t<_Base>>
3067 {
3068 if (_M_outer == ranges::end(_M_parent->_M_base))
3069 _M_inner = ranges::end(__detail::__as_lvalue(*--_M_outer));
3070 while (*_M_inner == ranges::begin(__detail::__as_lvalue(*_M_outer)))
3071 *_M_inner = ranges::end(__detail::__as_lvalue(*--_M_outer));
3072 --*_M_inner;
3073 return *this;
3074 }
3075
3076 constexpr _Iterator
3077 operator--(int)
3078 requires _S_ref_is_glvalue && bidirectional_range<_Base>
3079 && bidirectional_range<range_reference_t<_Base>>
3080 && common_range<range_reference_t<_Base>>
3081 {
3082 auto __tmp = *this;
3083 --*this;
3084 return __tmp;
3085 }
3086
3087 friend constexpr bool
3088 operator==(const _Iterator& __x, const _Iterator& __y)
3089 requires _S_ref_is_glvalue
3090 && forward_range<_Base>
3091 && equality_comparable<_Inner_iter>
3092 {
3093 return (__x._M_outer == __y._M_outer
3094 && __x._M_inner == __y._M_inner);
3095 }
3096
3097 friend constexpr decltype(auto)
3098 iter_move(const _Iterator& __i)
3099 noexcept(noexcept(ranges::iter_move(*__i._M_inner)))
3100 { return ranges::iter_move(*__i._M_inner); }
3101
3102 friend constexpr void
3103 iter_swap(const _Iterator& __x, const _Iterator& __y)
3104 noexcept(noexcept(ranges::iter_swap(*__x._M_inner, *__y._M_inner)))
3105 requires indirectly_swappable<_Inner_iter>
3106 { return ranges::iter_swap(*__x._M_inner, *__y._M_inner); }
3107
3108 friend _Iterator<!_Const>;
3109 template<bool> friend struct _Sentinel;
3110 };
3111
3112 template<bool _Const>
3113 struct _Sentinel
3114 {
3115 private:
3116 using _Parent = __detail::__maybe_const_t<_Const, join_view>;
3117 using _Base = join_view::_Base<_Const>;
3118
3119 template<bool _Const2>
3120 constexpr bool
3121 __equal(const _Iterator<_Const2>& __i) const
3122 { return __i._M_get_outer() == _M_end; }
3123
3124 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
3125
3126 public:
3127 _Sentinel() = default;
3128
3129 constexpr explicit
3130 _Sentinel(_Parent* __parent)
3131 : _M_end(ranges::end(__parent->_M_base))
3132 { }
3133
3134 constexpr
3135 _Sentinel(_Sentinel<!_Const> __s)
3136 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
3137 : _M_end(std::move(__s._M_end))
3138 { }
3139
3140 template<bool _Const2>
3141 requires sentinel_for<sentinel_t<_Base>,
3142 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
3143 friend constexpr bool
3144 operator==(const _Iterator<_Const2>& __x, const _Sentinel& __y)
3145 { return __y.__equal(__x); }
3146
3147 friend _Sentinel<!_Const>;
3148 };
3149
3150 _Vp _M_base = _Vp();
3151 [[no_unique_address]]
3152 __detail::__maybe_present_t<!forward_range<_Vp>,
3153 __detail::__non_propagating_cache<iterator_t<_Vp>>> _M_outer;
3154 [[no_unique_address]]
3155 __detail::__non_propagating_cache<remove_cv_t<_InnerRange>> _M_inner;
3156
3157 public:
3158 join_view() requires default_initializable<_Vp> = default;
3159
3160 constexpr explicit
3161 join_view(_Vp __base)
3162 : _M_base(std::move(__base))
3163 { }
3164
3165 constexpr _Vp
3166 base() const& requires copy_constructible<_Vp>
3167 { return _M_base; }
3168
3169 constexpr _Vp
3170 base() &&
3171 { return std::move(_M_base); }
3172
3173 constexpr auto
3174 begin()
3175 {
3176 if constexpr (forward_range<_Vp>)
3177 {
3178 constexpr bool __use_const
3179 = (__detail::__simple_view<_Vp>
3180 && is_reference_v<range_reference_t<_Vp>>);
3181 return _Iterator<__use_const>{this, ranges::begin(_M_base)};
3182 }
3183 else
3184 {
3185 _M_outer = ranges::begin(_M_base);
3186 return _Iterator<false>{this};
3187 }
3188 }
3189
3190 constexpr auto
3191 begin() const
3192 requires forward_range<const _Vp>
3193 && is_reference_v<range_reference_t<const _Vp>>
3194 && input_range<range_reference_t<const _Vp>>
3195 {
3196 return _Iterator<true>{this, ranges::begin(_M_base)};
3197 }
3198
3199 constexpr auto
3200 end()
3201 {
3202 if constexpr (forward_range<_Vp> && is_reference_v<_InnerRange>
3203 && forward_range<_InnerRange>
3204 && common_range<_Vp> && common_range<_InnerRange>)
3205 return _Iterator<__detail::__simple_view<_Vp>>{this,
3206 ranges::end(_M_base)};
3207 else
3208 return _Sentinel<__detail::__simple_view<_Vp>>{this};
3209 }
3210
3211 constexpr auto
3212 end() const
3213 requires forward_range<const _Vp>
3214 && is_reference_v<range_reference_t<const _Vp>>
3215 && input_range<range_reference_t<const _Vp>>
3216 {
3217 if constexpr (is_reference_v<range_reference_t<const _Vp>>
3218 && forward_range<range_reference_t<const _Vp>>
3219 && common_range<const _Vp>
3220 && common_range<range_reference_t<const _Vp>>)
3221 return _Iterator<true>{this, ranges::end(_M_base)};
3222 else
3223 return _Sentinel<true>{this};
3224 }
3225 };
3226
3227 template<typename _Range>
3228 explicit join_view(_Range&&) -> join_view<views::all_t<_Range>>;
3229
3230 namespace views
3231 {
3232 namespace __detail
3233 {
3234 template<typename _Range>
3235 concept __can_join_view
3236 = requires { join_view<all_t<_Range>>{std::declval<_Range>()}; };
3237 } // namespace __detail
3238
3239 struct _Join : __adaptor::_RangeAdaptorClosure<_Join>
3240 {
3241 template<viewable_range _Range>
3242 requires __detail::__can_join_view<_Range>
3243 constexpr auto
3244 operator() [[nodiscard]] (_Range&& __r) const
3245 {
3246 // _GLIBCXX_RESOLVE_LIB_DEFECTS
3247 // 3474. Nesting join_views is broken because of CTAD
3248 return join_view<all_t<_Range>>{std::forward<_Range>(__r)};
3249 }
3250
3251 static constexpr bool _S_has_simple_call_op = true;
3252 };
3253
3254 inline constexpr _Join join;
3255 } // namespace views
3256
3257 namespace __detail
3258 {
3259 template<auto>
3260 struct __require_constant;
3261
3262 template<typename _Range>
3263 concept __tiny_range = sized_range<_Range>
3264 && requires
3265 { typename __require_constant<remove_reference_t<_Range>::size()>; }
3266 && (remove_reference_t<_Range>::size() <= 1);
3267
3268 template<typename _Base>
3269 struct __lazy_split_view_outer_iter_cat
3270 { };
3271
3272 template<forward_range _Base>
3273 struct __lazy_split_view_outer_iter_cat<_Base>
3274 { using iterator_category = input_iterator_tag; };
3275
3276 template<typename _Base>
3277 struct __lazy_split_view_inner_iter_cat
3278 { };
3279
3280 template<forward_range _Base>
3281 struct __lazy_split_view_inner_iter_cat<_Base>
3282 {
3283 private:
3284 static constexpr auto
3285 _S_iter_cat()
3286 {
3287 using _Cat = typename iterator_traits<iterator_t<_Base>>::iterator_category;
3288 if constexpr (derived_from<_Cat, forward_iterator_tag>)
3289 return forward_iterator_tag{};
3290 else
3291 return _Cat{};
3292 }
3293 public:
3294 using iterator_category = decltype(_S_iter_cat());
3295 };
3296 }
3297
3298 template<input_range _Vp, forward_range _Pattern>
3299 requires view<_Vp> && view<_Pattern>
3300 && indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
3301 ranges::equal_to>
3302 && (forward_range<_Vp> || __detail::__tiny_range<_Pattern>)
3303 class lazy_split_view : public view_interface<lazy_split_view<_Vp, _Pattern>>
3304 {
3305 private:
3306 template<bool _Const>
3307 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
3308
3309 template<bool _Const>
3310 struct _InnerIter;
3311
3312 template<bool _Const>
3313 struct _OuterIter
3314 : __detail::__lazy_split_view_outer_iter_cat<_Base<_Const>>
3315 {
3316 private:
3317 using _Parent = __detail::__maybe_const_t<_Const, lazy_split_view>;
3318 using _Base = lazy_split_view::_Base<_Const>;
3319
3320 constexpr bool
3321 __at_end() const
3322 { return __current() == ranges::end(_M_parent->_M_base) && !_M_trailing_empty; }
3323
3324 // [range.lazy.split.outer] p1
3325 // Many of the following specifications refer to the notional member
3326 // current of outer-iterator. current is equivalent to current_ if
3327 // V models forward_range, and parent_->current_ otherwise.
3328 constexpr auto&
3329 __current() noexcept
3330 {
3331 if constexpr (forward_range<_Vp>)
3332 return _M_current;
3333 else
3334 return *_M_parent->_M_current;
3335 }
3336
3337 constexpr auto&
3338 __current() const noexcept
3339 {
3340 if constexpr (forward_range<_Vp>)
3341 return _M_current;
3342 else
3343 return *_M_parent->_M_current;
3344 }
3345
3346 _Parent* _M_parent = nullptr;
3347
3348 [[no_unique_address]]
3349 __detail::__maybe_present_t<forward_range<_Vp>,
3350 iterator_t<_Base>> _M_current;
3351 bool _M_trailing_empty = false;
3352
3353 public:
3354 using iterator_concept = __conditional_t<forward_range<_Base>,
3355 forward_iterator_tag,
3356 input_iterator_tag>;
3357 // iterator_category defined in __lazy_split_view_outer_iter_cat
3358 using difference_type = range_difference_t<_Base>;
3359
3360 struct value_type : view_interface<value_type>
3361 {
3362 private:
3363 _OuterIter _M_i = _OuterIter();
3364
3365 // _GLIBCXX_RESOLVE_LIB_DEFECTS
3366 // 4013. lazy_split_view::outer-iterator::value_type should not
3367 // provide default constructor
3368 constexpr explicit
3369 value_type(_OuterIter __i)
3370 : _M_i(std::move(__i))
3371 { }
3372
3373 friend _OuterIter;
3374
3375 public:
3376 constexpr _InnerIter<_Const>
3377 begin() const
3378 { return _InnerIter<_Const>{_M_i}; }
3379
3380 constexpr default_sentinel_t
3381 end() const noexcept
3382 { return default_sentinel; }
3383 };
3384
3385 _OuterIter() = default;
3386
3387 constexpr explicit
3388 _OuterIter(_Parent* __parent) requires (!forward_range<_Base>)
3389 : _M_parent(__parent)
3390 { }
3391
3392 constexpr
3393 _OuterIter(_Parent* __parent, iterator_t<_Base> __current)
3394 requires forward_range<_Base>
3395 : _M_parent(__parent),
3396 _M_current(std::move(__current))
3397 { }
3398
3399 constexpr
3400 _OuterIter(_OuterIter<!_Const> __i)
3401 requires _Const
3402 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
3403 : _M_parent(__i._M_parent), _M_current(std::move(__i._M_current)),
3404 _M_trailing_empty(__i._M_trailing_empty)
3405 { }
3406
3407 constexpr value_type
3408 operator*() const
3409 { return value_type{*this}; }
3410
3411 constexpr _OuterIter&
3412 operator++()
3413 {
3414 // _GLIBCXX_RESOLVE_LIB_DEFECTS
3415 // 3505. lazy_split_view::outer-iterator::operator++ misspecified
3416 const auto __end = ranges::end(_M_parent->_M_base);
3417 if (__current() == __end)
3418 {
3419 _M_trailing_empty = false;
3420 return *this;
3421 }
3422 const auto [__pbegin, __pend] = subrange{_M_parent->_M_pattern};
3423 if (__pbegin == __pend)
3424 ++__current();
3425 else if constexpr (__detail::__tiny_range<_Pattern>)
3426 {
3427 __current() = ranges::find(std::move(__current()), __end,
3428 *__pbegin);
3429 if (__current() != __end)
3430 {
3431 ++__current();
3432 if (__current() == __end)
3433 _M_trailing_empty = true;
3434 }
3435 }
3436 else
3437 do
3438 {
3439 auto [__b, __p]
3440 = ranges::mismatch(__current(), __end, __pbegin, __pend);
3441 if (__p == __pend)
3442 {
3443 __current() = __b;
3444 if (__current() == __end)
3445 _M_trailing_empty = true;
3446 break;
3447 }
3448 } while (++__current() != __end);
3449 return *this;
3450 }
3451
3452 constexpr decltype(auto)
3453 operator++(int)
3454 {
3455 if constexpr (forward_range<_Base>)
3456 {
3457 auto __tmp = *this;
3458 ++*this;
3459 return __tmp;
3460 }
3461 else
3462 ++*this;
3463 }
3464
3465 friend constexpr bool
3466 operator==(const _OuterIter& __x, const _OuterIter& __y)
3467 requires forward_range<_Base>
3468 {
3469 return __x._M_current == __y._M_current
3470 && __x._M_trailing_empty == __y._M_trailing_empty;
3471 }
3472
3473 friend constexpr bool
3474 operator==(const _OuterIter& __x, default_sentinel_t)
3475 { return __x.__at_end(); };
3476
3477 friend _OuterIter<!_Const>;
3478 friend _InnerIter<_Const>;
3479 };
3480
3481 template<bool _Const>
3482 struct _InnerIter
3483 : __detail::__lazy_split_view_inner_iter_cat<_Base<_Const>>
3484 {
3485 private:
3486 using _Base = lazy_split_view::_Base<_Const>;
3487
3488 constexpr bool
3489 __at_end() const
3490 {
3491 auto [__pcur, __pend] = subrange{_M_i._M_parent->_M_pattern};
3492 auto __end = ranges::end(_M_i._M_parent->_M_base);
3493 if constexpr (__detail::__tiny_range<_Pattern>)
3494 {
3495 const auto& __cur = _M_i_current();
3496 if (__cur == __end)
3497 return true;
3498 if (__pcur == __pend)
3499 return _M_incremented;
3500 return *__cur == *__pcur;
3501 }
3502 else
3503 {
3504 auto __cur = _M_i_current();
3505 if (__cur == __end)
3506 return true;
3507 if (__pcur == __pend)
3508 return _M_incremented;
3509 do
3510 {
3511 if (*__cur != *__pcur)
3512 return false;
3513 if (++__pcur == __pend)
3514 return true;
3515 } while (++__cur != __end);
3516 return false;
3517 }
3518 }
3519
3520 constexpr auto&
3521 _M_i_current() noexcept
3522 { return _M_i.__current(); }
3523
3524 constexpr auto&
3525 _M_i_current() const noexcept
3526 { return _M_i.__current(); }
3527
3528 _OuterIter<_Const> _M_i = _OuterIter<_Const>();
3529 bool _M_incremented = false;
3530
3531 public:
3532 using iterator_concept
3533 = typename _OuterIter<_Const>::iterator_concept;
3534 // iterator_category defined in __lazy_split_view_inner_iter_cat
3535 using value_type = range_value_t<_Base>;
3536 using difference_type = range_difference_t<_Base>;
3537
3538 _InnerIter() = default;
3539
3540 constexpr explicit
3541 _InnerIter(_OuterIter<_Const> __i)
3542 : _M_i(std::move(__i))
3543 { }
3544
3545 constexpr const iterator_t<_Base>&
3546 base() const& noexcept
3547 { return _M_i_current(); }
3548
3549 constexpr iterator_t<_Base>
3550 base() && requires forward_range<_Vp>
3551 { return std::move(_M_i_current()); }
3552
3553 constexpr decltype(auto)
3554 operator*() const
3555 { return *_M_i_current(); }
3556
3557 constexpr _InnerIter&
3558 operator++()
3559 {
3560 _M_incremented = true;
3561 if constexpr (!forward_range<_Base>)
3562 if constexpr (_Pattern::size() == 0)
3563 return *this;
3564 ++_M_i_current();
3565 return *this;
3566 }
3567
3568 constexpr decltype(auto)
3569 operator++(int)
3570 {
3571 if constexpr (forward_range<_Base>)
3572 {
3573 auto __tmp = *this;
3574 ++*this;
3575 return __tmp;
3576 }
3577 else
3578 ++*this;
3579 }
3580
3581 friend constexpr bool
3582 operator==(const _InnerIter& __x, const _InnerIter& __y)
3583 requires forward_range<_Base>
3584 { return __x._M_i == __y._M_i; }
3585
3586 friend constexpr bool
3587 operator==(const _InnerIter& __x, default_sentinel_t)
3588 { return __x.__at_end(); }
3589
3590 friend constexpr decltype(auto)
3591 iter_move(const _InnerIter& __i)
3592 noexcept(noexcept(ranges::iter_move(__i._M_i_current())))
3593 { return ranges::iter_move(__i._M_i_current()); }
3594
3595 friend constexpr void
3596 iter_swap(const _InnerIter& __x, const _InnerIter& __y)
3597 noexcept(noexcept(ranges::iter_swap(__x._M_i_current(),
3598 __y._M_i_current())))
3599 requires indirectly_swappable<iterator_t<_Base>>
3600 { ranges::iter_swap(__x._M_i_current(), __y._M_i_current()); }
3601 };
3602
3603 _Vp _M_base = _Vp();
3604 _Pattern _M_pattern = _Pattern();
3605 [[no_unique_address]]
3606 __detail::__maybe_present_t<!forward_range<_Vp>,
3607 __detail::__non_propagating_cache<iterator_t<_Vp>>> _M_current;
3608
3609
3610 public:
3611 lazy_split_view() requires (default_initializable<_Vp>
3612 && default_initializable<_Pattern>)
3613 = default;
3614
3615 constexpr
3616 lazy_split_view(_Vp __base, _Pattern __pattern)
3617 : _M_base(std::move(__base)), _M_pattern(std::move(__pattern))
3618 { }
3619
3620 template<input_range _Range>
3621 requires constructible_from<_Vp, views::all_t<_Range>>
3622 && constructible_from<_Pattern, single_view<range_value_t<_Range>>>
3623 constexpr
3624 lazy_split_view(_Range&& __r, range_value_t<_Range> __e)
3625 : _M_base(views::all(std::forward<_Range>(__r))),
3626 _M_pattern(views::single(std::move(__e)))
3627 { }
3628
3629 constexpr _Vp
3630 base() const& requires copy_constructible<_Vp>
3631 { return _M_base; }
3632
3633 constexpr _Vp
3634 base() &&
3635 { return std::move(_M_base); }
3636
3637 constexpr auto
3638 begin()
3639 {
3640 if constexpr (forward_range<_Vp>)
3641 {
3642 constexpr bool __simple
3643 = __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
3644 return _OuterIter<__simple>{this, ranges::begin(_M_base)};
3645 }
3646 else
3647 {
3648 _M_current = ranges::begin(_M_base);
3649 return _OuterIter<false>{this};
3650 }
3651 }
3652
3653 constexpr auto
3654 begin() const requires forward_range<_Vp> && forward_range<const _Vp>
3655 {
3656 return _OuterIter<true>{this, ranges::begin(_M_base)};
3657 }
3658
3659 constexpr auto
3660 end() requires forward_range<_Vp> && common_range<_Vp>
3661 {
3662 constexpr bool __simple
3663 = __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
3664 return _OuterIter<__simple>{this, ranges::end(_M_base)};
3665 }
3666
3667 constexpr auto
3668 end() const
3669 {
3670 if constexpr (forward_range<_Vp>
3671 && forward_range<const _Vp>
3672 && common_range<const _Vp>)
3673 return _OuterIter<true>{this, ranges::end(_M_base)};
3674 else
3675 return default_sentinel;
3676 }
3677 };
3678
3679 template<typename _Range, typename _Pattern>
3680 lazy_split_view(_Range&&, _Pattern&&)
3681 -> lazy_split_view<views::all_t<_Range>, views::all_t<_Pattern>>;
3682
3683 template<input_range _Range>
3684 lazy_split_view(_Range&&, range_value_t<_Range>)
3685 -> lazy_split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
3686
3687 namespace views
3688 {
3689 namespace __detail
3690 {
3691 template<typename _Range, typename _Pattern>
3692 concept __can_lazy_split_view
3693 = requires { lazy_split_view(std::declval<_Range>(), std::declval<_Pattern>()); };
3694 } // namespace __detail
3695
3696 struct _LazySplit : __adaptor::_RangeAdaptor<_LazySplit>
3697 {
3698 template<viewable_range _Range, typename _Pattern>
3699 requires __detail::__can_lazy_split_view<_Range, _Pattern>
3700 constexpr auto
3701 operator() [[nodiscard]] (_Range&& __r, _Pattern&& __f) const
3702 {
3703 return lazy_split_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
3704 }
3705
3706 using _RangeAdaptor<_LazySplit>::operator();
3707 static constexpr int _S_arity = 2;
3708 // The pattern argument of views::lazy_split is not always simple -- it can be
3709 // a non-view range, the value category of which affects whether the call
3710 // is well-formed. But a scalar or a view pattern argument is surely
3711 // simple.
3712 template<typename _Pattern>
3713 static constexpr bool _S_has_simple_extra_args
3714 = is_scalar_v<_Pattern> || (view<_Pattern>
3715 && copy_constructible<_Pattern>);
3716 };
3717
3718 inline constexpr _LazySplit lazy_split;
3719 } // namespace views
3720
3721 template<forward_range _Vp, forward_range _Pattern>
3722 requires view<_Vp> && view<_Pattern>
3723 && indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
3724 ranges::equal_to>
3725 class split_view : public view_interface<split_view<_Vp, _Pattern>>
3726 {
3727 private:
3728 _Vp _M_base = _Vp();
3729 _Pattern _M_pattern = _Pattern();
3730 __detail::__non_propagating_cache<subrange<iterator_t<_Vp>>> _M_cached_begin;
3731
3732 struct _Iterator;
3733 struct _Sentinel;
3734
3735 public:
3736 split_view() requires (default_initializable<_Vp>
3737 && default_initializable<_Pattern>)
3738 = default;
3739
3740 constexpr
3741 split_view(_Vp __base, _Pattern __pattern)
3742 : _M_base(std::move(__base)), _M_pattern(std::move(__pattern))
3743 { }
3744
3745 template<forward_range _Range>
3746 requires constructible_from<_Vp, views::all_t<_Range>>
3747 && constructible_from<_Pattern, single_view<range_value_t<_Range>>>
3748 constexpr
3749 split_view(_Range&& __r, range_value_t<_Range> __e)
3750 : _M_base(views::all(std::forward<_Range>(__r))),
3751 _M_pattern(views::single(std::move(__e)))
3752 { }
3753
3754 constexpr _Vp
3755 base() const& requires copy_constructible<_Vp>
3756 { return _M_base; }
3757
3758 constexpr _Vp
3759 base() &&
3760 { return std::move(_M_base); }
3761
3762 constexpr _Iterator
3763 begin()
3764 {
3765 if (!_M_cached_begin)
3766 _M_cached_begin = _M_find_next(ranges::begin(_M_base));
3767 return {this, ranges::begin(_M_base), *_M_cached_begin};
3768 }
3769
3770 constexpr auto
3771 end()
3772 {
3773 if constexpr (common_range<_Vp>)
3774 return _Iterator{this, ranges::end(_M_base), {}};
3775 else
3776 return _Sentinel{this};
3777 }
3778
3779 constexpr subrange<iterator_t<_Vp>>
3780 _M_find_next(iterator_t<_Vp> __it)
3781 {
3782 auto [__b, __e] = ranges::search(subrange(__it, ranges::end(_M_base)), _M_pattern);
3783 if (__b != ranges::end(_M_base) && ranges::empty(_M_pattern))
3784 {
3785 ++__b;
3786 ++__e;
3787 }
3788 return {__b, __e};
3789 }
3790
3791 private:
3792 struct _Iterator
3793 {
3794 private:
3795 split_view* _M_parent = nullptr;
3796 iterator_t<_Vp> _M_cur = iterator_t<_Vp>();
3797 subrange<iterator_t<_Vp>> _M_next = subrange<iterator_t<_Vp>>();
3798 bool _M_trailing_empty = false;
3799
3800 friend struct _Sentinel;
3801
3802 public:
3803 using iterator_concept = forward_iterator_tag;
3804 using iterator_category = input_iterator_tag;
3805 using value_type = subrange<iterator_t<_Vp>>;
3806 using difference_type = range_difference_t<_Vp>;
3807
3808 _Iterator() = default;
3809
3810 constexpr
3811 _Iterator(split_view* __parent,
3812 iterator_t<_Vp> __current,
3813 subrange<iterator_t<_Vp>> __next)
3814 : _M_parent(__parent),
3815 _M_cur(std::move(__current)),
3816 _M_next(std::move(__next))
3817 { }
3818
3819 constexpr iterator_t<_Vp>
3820 base() const
3821 { return _M_cur; }
3822
3823 constexpr value_type
3824 operator*() const
3825 { return {_M_cur, _M_next.begin()}; }
3826
3827 constexpr _Iterator&
3828 operator++()
3829 {
3830 _M_cur = _M_next.begin();
3831 if (_M_cur != ranges::end(_M_parent->_M_base))
3832 {
3833 _M_cur = _M_next.end();
3834 if (_M_cur == ranges::end(_M_parent->_M_base))
3835 {
3836 _M_trailing_empty = true;
3837 _M_next = {_M_cur, _M_cur};
3838 }
3839 else
3840 _M_next = _M_parent->_M_find_next(_M_cur);
3841 }
3842 else
3843 _M_trailing_empty = false;
3844 return *this;
3845 }
3846
3847 constexpr _Iterator
3848 operator++(int)
3849 {
3850 auto __tmp = *this;
3851 ++*this;
3852 return __tmp;
3853 }
3854
3855 friend constexpr bool
3856 operator==(const _Iterator& __x, const _Iterator& __y)
3857 {
3858 return __x._M_cur == __y._M_cur
3859 && __x._M_trailing_empty == __y._M_trailing_empty;
3860 }
3861 };
3862
3863 struct _Sentinel
3864 {
3865 private:
3866 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
3867
3868 constexpr bool
3869 _M_equal(const _Iterator& __x) const
3870 { return __x._M_cur == _M_end && !__x._M_trailing_empty; }
3871
3872 public:
3873 _Sentinel() = default;
3874
3875 constexpr explicit
3876 _Sentinel(split_view* __parent)
3877 : _M_end(ranges::end(__parent->_M_base))
3878 { }
3879
3880 friend constexpr bool
3881 operator==(const _Iterator& __x, const _Sentinel& __y)
3882 { return __y._M_equal(__x); }
3883 };
3884 };
3885
3886 template<typename _Range, typename _Pattern>
3887 split_view(_Range&&, _Pattern&&)
3888 -> split_view<views::all_t<_Range>, views::all_t<_Pattern>>;
3889
3890 template<forward_range _Range>
3891 split_view(_Range&&, range_value_t<_Range>)
3892 -> split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
3893
3894 namespace views
3895 {
3896 namespace __detail
3897 {
3898 template<typename _Range, typename _Pattern>
3899 concept __can_split_view
3900 = requires { split_view(std::declval<_Range>(), std::declval<_Pattern>()); };
3901 } // namespace __detail
3902
3903 struct _Split : __adaptor::_RangeAdaptor<_Split>
3904 {
3905 template<viewable_range _Range, typename _Pattern>
3906 requires __detail::__can_split_view<_Range, _Pattern>
3907 constexpr auto
3908 operator() [[nodiscard]] (_Range&& __r, _Pattern&& __f) const
3909 {
3910 return split_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
3911 }
3912
3913 using _RangeAdaptor<_Split>::operator();
3914 static constexpr int _S_arity = 2;
3915 template<typename _Pattern>
3916 static constexpr bool _S_has_simple_extra_args
3917 = _LazySplit::_S_has_simple_extra_args<_Pattern>;
3918 };
3919
3920 inline constexpr _Split split;
3921 } // namespace views
3922
3923 namespace views
3924 {
3925 struct _Counted
3926 {
3927 template<input_or_output_iterator _Iter>
3928 constexpr auto
3929 operator() [[nodiscard]] (_Iter __i, iter_difference_t<_Iter> __n) const
3930 {
3931 if constexpr (contiguous_iterator<_Iter>)
3932 return span(std::__to_address(__i), __n);
3933 else if constexpr (random_access_iterator<_Iter>)
3934 return subrange(__i, __i + __n);
3935 else
3936 return subrange(counted_iterator(std::move(__i), __n),
3937 default_sentinel);
3938 }
3939 };
3940
3941 inline constexpr _Counted counted{};
3942 } // namespace views
3943
3944 template<view _Vp>
3945 requires (!common_range<_Vp>) && copyable<iterator_t<_Vp>>
3946 class common_view : public view_interface<common_view<_Vp>>
3947 {
3948 private:
3949 _Vp _M_base = _Vp();
3950
3951 public:
3952 common_view() requires default_initializable<_Vp> = default;
3953
3954 constexpr explicit
3955 common_view(_Vp __r)
3956 : _M_base(std::move(__r))
3957 { }
3958
3959 constexpr _Vp
3960 base() const& requires copy_constructible<_Vp>
3961 { return _M_base; }
3962
3963 constexpr _Vp
3964 base() &&
3965 { return std::move(_M_base); }
3966
3967 // _GLIBCXX_RESOLVE_LIB_DEFECTS
3968 // 4012. common_view::begin/end are missing the simple-view check
3969 constexpr auto
3970 begin() requires (!__detail::__simple_view<_Vp>)
3971 {
3972 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3973 return ranges::begin(_M_base);
3974 else
3975 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
3976 (ranges::begin(_M_base));
3977 }
3978
3979 constexpr auto
3980 begin() const requires range<const _Vp>
3981 {
3982 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
3983 return ranges::begin(_M_base);
3984 else
3985 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
3986 (ranges::begin(_M_base));
3987 }
3988
3989 constexpr auto
3990 end() requires (!__detail::__simple_view<_Vp>)
3991 {
3992 if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3993 return ranges::begin(_M_base) + ranges::size(_M_base);
3994 else
3995 return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
3996 (ranges::end(_M_base));
3997 }
3998
3999 constexpr auto
4000 end() const requires range<const _Vp>
4001 {
4002 if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
4003 return ranges::begin(_M_base) + ranges::size(_M_base);
4004 else
4005 return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
4006 (ranges::end(_M_base));
4007 }
4008
4009 constexpr auto
4010 size() requires sized_range<_Vp>
4011 { return ranges::size(_M_base); }
4012
4013 constexpr auto
4014 size() const requires sized_range<const _Vp>
4015 { return ranges::size(_M_base); }
4016 };
4017
4018 template<typename _Range>
4019 common_view(_Range&&) -> common_view<views::all_t<_Range>>;
4020
4021 template<typename _Tp>
4022 inline constexpr bool enable_borrowed_range<common_view<_Tp>>
4023 = enable_borrowed_range<_Tp>;
4024
4025 namespace views
4026 {
4027 namespace __detail
4028 {
4029 template<typename _Range>
4030 concept __already_common = common_range<_Range>
4031 && requires { views::all(std::declval<_Range>()); };
4032
4033 template<typename _Range>
4034 concept __can_common_view
4035 = requires { common_view{std::declval<_Range>()}; };
4036 } // namespace __detail
4037
4038 struct _Common : __adaptor::_RangeAdaptorClosure<_Common>
4039 {
4040 template<viewable_range _Range>
4041 requires __detail::__already_common<_Range>
4042 || __detail::__can_common_view<_Range>
4043 constexpr auto
4044 operator() [[nodiscard]] (_Range&& __r) const
4045 {
4046 if constexpr (__detail::__already_common<_Range>)
4047 return views::all(std::forward<_Range>(__r));
4048 else
4049 return common_view{std::forward<_Range>(__r)};
4050 }
4051
4052 static constexpr bool _S_has_simple_call_op = true;
4053 };
4054
4055 inline constexpr _Common common;
4056 } // namespace views
4057
4058 template<view _Vp>
4059 requires bidirectional_range<_Vp>
4060 class reverse_view : public view_interface<reverse_view<_Vp>>
4061 {
4062 private:
4063 static constexpr bool _S_needs_cached_begin
4064 = !common_range<_Vp> && !(random_access_range<_Vp>
4065 && sized_sentinel_for<sentinel_t<_Vp>,
4066 iterator_t<_Vp>>);
4067
4068 _Vp _M_base = _Vp();
4069 [[no_unique_address]]
4070 __detail::__maybe_present_t<_S_needs_cached_begin,
4071 __detail::_CachedPosition<_Vp>>
4072 _M_cached_begin;
4073
4074 public:
4075 reverse_view() requires default_initializable<_Vp> = default;
4076
4077 constexpr explicit
4078 reverse_view(_Vp __r)
4079 : _M_base(std::move(__r))
4080 { }
4081
4082 constexpr _Vp
4083 base() const& requires copy_constructible<_Vp>
4084 { return _M_base; }
4085
4086 constexpr _Vp
4087 base() &&
4088 { return std::move(_M_base); }
4089
4090 constexpr reverse_iterator<iterator_t<_Vp>>
4091 begin()
4092 {
4093 if constexpr (_S_needs_cached_begin)
4094 if (_M_cached_begin._M_has_value())
4095 return std::make_reverse_iterator(_M_cached_begin._M_get(_M_base));
4096
4097 auto __it = ranges::next(ranges::begin(_M_base), ranges::end(_M_base));
4098 if constexpr (_S_needs_cached_begin)
4099 _M_cached_begin._M_set(_M_base, __it);
4100 return std::make_reverse_iterator(std::move(__it));
4101 }
4102
4103 constexpr auto
4104 begin() requires common_range<_Vp>
4105 { return std::make_reverse_iterator(ranges::end(_M_base)); }
4106
4107 constexpr auto
4108 begin() const requires common_range<const _Vp>
4109 { return std::make_reverse_iterator(ranges::end(_M_base)); }
4110
4111 constexpr reverse_iterator<iterator_t<_Vp>>
4112 end()
4113 { return std::make_reverse_iterator(ranges::begin(_M_base)); }
4114
4115 constexpr auto
4116 end() const requires common_range<const _Vp>
4117 { return std::make_reverse_iterator(ranges::begin(_M_base)); }
4118
4119 constexpr auto
4120 size() requires sized_range<_Vp>
4121 { return ranges::size(_M_base); }
4122
4123 constexpr auto
4124 size() const requires sized_range<const _Vp>
4125 { return ranges::size(_M_base); }
4126 };
4127
4128 template<typename _Range>
4129 reverse_view(_Range&&) -> reverse_view<views::all_t<_Range>>;
4130
4131 template<typename _Tp>
4132 inline constexpr bool enable_borrowed_range<reverse_view<_Tp>>
4133 = enable_borrowed_range<_Tp>;
4134
4135 namespace views
4136 {
4137 namespace __detail
4138 {
4139 template<typename>
4140 inline constexpr bool __is_reversible_subrange = false;
4141
4142 template<typename _Iter, subrange_kind _Kind>
4143 inline constexpr bool
4144 __is_reversible_subrange<subrange<reverse_iterator<_Iter>,
4145 reverse_iterator<_Iter>,
4146 _Kind>> = true;
4147
4148 template<typename>
4149 inline constexpr bool __is_reverse_view = false;
4150
4151 template<typename _Vp>
4152 inline constexpr bool __is_reverse_view<reverse_view<_Vp>> = true;
4153
4154 template<typename _Range>
4155 concept __can_reverse_view
4156 = requires { reverse_view{std::declval<_Range>()}; };
4157 } // namespace __detail
4158
4159 struct _Reverse : __adaptor::_RangeAdaptorClosure<_Reverse>
4160 {
4161 template<viewable_range _Range>
4162 requires __detail::__is_reverse_view<remove_cvref_t<_Range>>
4163 || __detail::__is_reversible_subrange<remove_cvref_t<_Range>>
4164 || __detail::__can_reverse_view<_Range>
4165 constexpr auto
4166 operator() [[nodiscard]] (_Range&& __r) const
4167 {
4168 using _Tp = remove_cvref_t<_Range>;
4169 if constexpr (__detail::__is_reverse_view<_Tp>)
4170 return std::forward<_Range>(__r).base();
4171 else if constexpr (__detail::__is_reversible_subrange<_Tp>)
4172 {
4173 using _Iter = decltype(ranges::begin(__r).base());
4174 if constexpr (sized_range<_Tp>)
4175 return subrange<_Iter, _Iter, subrange_kind::sized>
4176 {__r.end().base(), __r.begin().base(), __r.size()};
4177 else
4178 return subrange<_Iter, _Iter, subrange_kind::unsized>
4179 {__r.end().base(), __r.begin().base()};
4180 }
4181 else
4182 return reverse_view{std::forward<_Range>(__r)};
4183 }
4184
4185 static constexpr bool _S_has_simple_call_op = true;
4186 };
4187
4188 inline constexpr _Reverse reverse;
4189 } // namespace views
4190
4191 namespace __detail
4192 {
4193#if __cpp_lib_tuple_like // >= C++23
4194 template<typename _Tp, size_t _Nm>
4195 concept __has_tuple_element = __tuple_like<_Tp> && _Nm < tuple_size_v<_Tp>;
4196#else
4197 template<typename _Tp, size_t _Nm>
4198 concept __has_tuple_element = requires(_Tp __t)
4199 {
4200 typename tuple_size<_Tp>::type;
4201 requires _Nm < tuple_size_v<_Tp>;
4202 typename tuple_element_t<_Nm, _Tp>;
4203 { std::get<_Nm>(__t) }
4204 -> convertible_to<const tuple_element_t<_Nm, _Tp>&>;
4205 };
4206#endif
4207
4208 template<typename _Tp, size_t _Nm>
4209 concept __returnable_element
4210 = is_reference_v<_Tp> || move_constructible<tuple_element_t<_Nm, _Tp>>;
4211 }
4212
4213 template<input_range _Vp, size_t _Nm>
4214 requires view<_Vp>
4215 && __detail::__has_tuple_element<range_value_t<_Vp>, _Nm>
4216 && __detail::__has_tuple_element<remove_reference_t<range_reference_t<_Vp>>,
4217 _Nm>
4218 && __detail::__returnable_element<range_reference_t<_Vp>, _Nm>
4219 class elements_view : public view_interface<elements_view<_Vp, _Nm>>
4220 {
4221 public:
4222 elements_view() requires default_initializable<_Vp> = default;
4223
4224 constexpr explicit
4225 elements_view(_Vp __base)
4226 : _M_base(std::move(__base))
4227 { }
4228
4229 constexpr _Vp
4230 base() const& requires copy_constructible<_Vp>
4231 { return _M_base; }
4232
4233 constexpr _Vp
4234 base() &&
4235 { return std::move(_M_base); }
4236
4237 constexpr auto
4238 begin() requires (!__detail::__simple_view<_Vp>)
4239 { return _Iterator<false>(ranges::begin(_M_base)); }
4240
4241 constexpr auto
4242 begin() const requires range<const _Vp>
4243 { return _Iterator<true>(ranges::begin(_M_base)); }
4244
4245 constexpr auto
4246 end() requires (!__detail::__simple_view<_Vp> && !common_range<_Vp>)
4247 { return _Sentinel<false>{ranges::end(_M_base)}; }
4248
4249 constexpr auto
4250 end() requires (!__detail::__simple_view<_Vp> && common_range<_Vp>)
4251 { return _Iterator<false>{ranges::end(_M_base)}; }
4252
4253 constexpr auto
4254 end() const requires range<const _Vp>
4255 { return _Sentinel<true>{ranges::end(_M_base)}; }
4256
4257 constexpr auto
4258 end() const requires common_range<const _Vp>
4259 { return _Iterator<true>{ranges::end(_M_base)}; }
4260
4261 constexpr auto
4262 size() requires sized_range<_Vp>
4263 { return ranges::size(_M_base); }
4264
4265 constexpr auto
4266 size() const requires sized_range<const _Vp>
4267 { return ranges::size(_M_base); }
4268
4269 private:
4270 template<bool _Const>
4271 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
4272
4273 template<bool _Const>
4274 struct __iter_cat
4275 { };
4276
4277 template<bool _Const>
4278 requires forward_range<_Base<_Const>>
4279 struct __iter_cat<_Const>
4280 {
4281 private:
4282 static auto _S_iter_cat()
4283 {
4284 using _Base = elements_view::_Base<_Const>;
4285 using _Cat = typename iterator_traits<iterator_t<_Base>>::iterator_category;
4286 using _Res = decltype((std::get<_Nm>(*std::declval<iterator_t<_Base>>())));
4287 if constexpr (!is_lvalue_reference_v<_Res>)
4288 return input_iterator_tag{};
4289 else if constexpr (derived_from<_Cat, random_access_iterator_tag>)
4290 return random_access_iterator_tag{};
4291 else
4292 return _Cat{};
4293 }
4294 public:
4295 using iterator_category = decltype(_S_iter_cat());
4296 };
4297
4298 template<bool _Const>
4299 struct _Sentinel;
4300
4301 template<bool _Const>
4302 struct _Iterator : __iter_cat<_Const>
4303 {
4304 private:
4305 using _Base = elements_view::_Base<_Const>;
4306
4307 iterator_t<_Base> _M_current = iterator_t<_Base>();
4308
4309 static constexpr decltype(auto)
4310 _S_get_element(const iterator_t<_Base>& __i)
4311 {
4312 if constexpr (is_reference_v<range_reference_t<_Base>>)
4313 return std::get<_Nm>(*__i);
4314 else
4315 {
4316 using _Et = remove_cv_t<tuple_element_t<_Nm, range_reference_t<_Base>>>;
4317 return static_cast<_Et>(std::get<_Nm>(*__i));
4318 }
4319 }
4320
4321 static auto
4322 _S_iter_concept()
4323 {
4324 if constexpr (random_access_range<_Base>)
4325 return random_access_iterator_tag{};
4326 else if constexpr (bidirectional_range<_Base>)
4327 return bidirectional_iterator_tag{};
4328 else if constexpr (forward_range<_Base>)
4329 return forward_iterator_tag{};
4330 else
4331 return input_iterator_tag{};
4332 }
4333
4334 friend _Iterator<!_Const>;
4335
4336 public:
4337 using iterator_concept = decltype(_S_iter_concept());
4338 // iterator_category defined in elements_view::__iter_cat
4339 using value_type
4340 = remove_cvref_t<tuple_element_t<_Nm, range_value_t<_Base>>>;
4341 using difference_type = range_difference_t<_Base>;
4342
4343 _Iterator() requires default_initializable<iterator_t<_Base>> = default;
4344
4345 constexpr explicit
4346 _Iterator(iterator_t<_Base> __current)
4347 : _M_current(std::move(__current))
4348 { }
4349
4350 constexpr
4351 _Iterator(_Iterator<!_Const> __i)
4352 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
4353 : _M_current(std::move(__i._M_current))
4354 { }
4355
4356 constexpr const iterator_t<_Base>&
4357 base() const& noexcept
4358 { return _M_current; }
4359
4360 constexpr iterator_t<_Base>
4361 base() &&
4362 { return std::move(_M_current); }
4363
4364 constexpr decltype(auto)
4365 operator*() const
4366 { return _S_get_element(_M_current); }
4367
4368 constexpr _Iterator&
4369 operator++()
4370 {
4371 ++_M_current;
4372 return *this;
4373 }
4374
4375 constexpr void
4376 operator++(int)
4377 { ++_M_current; }
4378
4379 constexpr _Iterator
4380 operator++(int) requires forward_range<_Base>
4381 {
4382 auto __tmp = *this;
4383 ++_M_current;
4384 return __tmp;
4385 }
4386
4387 constexpr _Iterator&
4388 operator--() requires bidirectional_range<_Base>
4389 {
4390 --_M_current;
4391 return *this;
4392 }
4393
4394 constexpr _Iterator
4395 operator--(int) requires bidirectional_range<_Base>
4396 {
4397 auto __tmp = *this;
4398 --_M_current;
4399 return __tmp;
4400 }
4401
4402 constexpr _Iterator&
4403 operator+=(difference_type __n)
4404 requires random_access_range<_Base>
4405 {
4406 _M_current += __n;
4407 return *this;
4408 }
4409
4410 constexpr _Iterator&
4411 operator-=(difference_type __n)
4412 requires random_access_range<_Base>
4413 {
4414 _M_current -= __n;
4415 return *this;
4416 }
4417
4418 constexpr decltype(auto)
4419 operator[](difference_type __n) const
4420 requires random_access_range<_Base>
4421 { return _S_get_element(_M_current + __n); }
4422
4423 friend constexpr bool
4424 operator==(const _Iterator& __x, const _Iterator& __y)
4425 requires equality_comparable<iterator_t<_Base>>
4426 { return __x._M_current == __y._M_current; }
4427
4428 friend constexpr bool
4429 operator<(const _Iterator& __x, const _Iterator& __y)
4430 requires random_access_range<_Base>
4431 { return __x._M_current < __y._M_current; }
4432
4433 friend constexpr bool
4434 operator>(const _Iterator& __x, const _Iterator& __y)
4435 requires random_access_range<_Base>
4436 { return __y._M_current < __x._M_current; }
4437
4438 friend constexpr bool
4439 operator<=(const _Iterator& __x, const _Iterator& __y)
4440 requires random_access_range<_Base>
4441 { return !(__y._M_current > __x._M_current); }
4442
4443 friend constexpr bool
4444 operator>=(const _Iterator& __x, const _Iterator& __y)
4445 requires random_access_range<_Base>
4446 { return !(__x._M_current > __y._M_current); }
4447
4448#ifdef __cpp_lib_three_way_comparison
4449 friend constexpr auto
4450 operator<=>(const _Iterator& __x, const _Iterator& __y)
4451 requires random_access_range<_Base>
4452 && three_way_comparable<iterator_t<_Base>>
4453 { return __x._M_current <=> __y._M_current; }
4454#endif
4455
4456 friend constexpr _Iterator
4457 operator+(const _Iterator& __x, difference_type __y)
4458 requires random_access_range<_Base>
4459 { return _Iterator{__x} += __y; }
4460
4461 friend constexpr _Iterator
4462 operator+(difference_type __x, const _Iterator& __y)
4463 requires random_access_range<_Base>
4464 { return __y + __x; }
4465
4466 friend constexpr _Iterator
4467 operator-(const _Iterator& __x, difference_type __y)
4468 requires random_access_range<_Base>
4469 { return _Iterator{__x} -= __y; }
4470
4471 // _GLIBCXX_RESOLVE_LIB_DEFECTS
4472 // 3483. transform_view::iterator's difference is overconstrained
4473 friend constexpr difference_type
4474 operator-(const _Iterator& __x, const _Iterator& __y)
4475 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
4476 { return __x._M_current - __y._M_current; }
4477
4478 template <bool> friend struct _Sentinel;
4479 };
4480
4481 template<bool _Const>
4482 struct _Sentinel
4483 {
4484 private:
4485 template<bool _Const2>
4486 constexpr bool
4487 _M_equal(const _Iterator<_Const2>& __x) const
4488 { return __x._M_current == _M_end; }
4489
4490 template<bool _Const2>
4491 constexpr auto
4492 _M_distance_from(const _Iterator<_Const2>& __i) const
4493 { return _M_end - __i._M_current; }
4494
4495 using _Base = elements_view::_Base<_Const>;
4496 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
4497
4498 public:
4499 _Sentinel() = default;
4500
4501 constexpr explicit
4502 _Sentinel(sentinel_t<_Base> __end)
4503 : _M_end(std::move(__end))
4504 { }
4505
4506 constexpr
4507 _Sentinel(_Sentinel<!_Const> __other)
4508 requires _Const
4509 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
4510 : _M_end(std::move(__other._M_end))
4511 { }
4512
4513 constexpr sentinel_t<_Base>
4514 base() const
4515 { return _M_end; }
4516
4517 template<bool _Const2>
4518 requires sentinel_for<sentinel_t<_Base>,
4519 iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
4520 friend constexpr bool
4521 operator==(const _Iterator<_Const2>& __x, const _Sentinel& __y)
4522 { return __y._M_equal(__x); }
4523
4524 template<bool _Const2,
4525 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
4526 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
4527 friend constexpr range_difference_t<_Base2>
4528 operator-(const _Iterator<_Const2>& __x, const _Sentinel& __y)
4529 { return -__y._M_distance_from(__x); }
4530
4531 template<bool _Const2,
4532 typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
4533 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
4534 friend constexpr range_difference_t<_Base2>
4535 operator-(const _Sentinel& __x, const _Iterator<_Const2>& __y)
4536 { return __x._M_distance_from(__y); }
4537
4538 friend _Sentinel<!_Const>;
4539 };
4540
4541 _Vp _M_base = _Vp();
4542 };
4543
4544 template<typename _Tp, size_t _Nm>
4545 inline constexpr bool enable_borrowed_range<elements_view<_Tp, _Nm>>
4546 = enable_borrowed_range<_Tp>;
4547
4548 template<typename _Range>
4549 using keys_view = elements_view<views::all_t<_Range>, 0>;
4550
4551 template<typename _Range>
4552 using values_view = elements_view<views::all_t<_Range>, 1>;
4553
4554 namespace views
4555 {
4556 namespace __detail
4557 {
4558 template<size_t _Nm, typename _Range>
4559 concept __can_elements_view
4560 = requires { elements_view<all_t<_Range>, _Nm>{std::declval<_Range>()}; };
4561 } // namespace __detail
4562
4563 template<size_t _Nm>
4564 struct _Elements : __adaptor::_RangeAdaptorClosure<_Elements<_Nm>>
4565 {
4566 template<viewable_range _Range>
4567 requires __detail::__can_elements_view<_Nm, _Range>
4568 constexpr auto
4569 operator() [[nodiscard]] (_Range&& __r) const
4570 {
4571 return elements_view<all_t<_Range>, _Nm>{std::forward<_Range>(__r)};
4572 }
4573
4574 static constexpr bool _S_has_simple_call_op = true;
4575 };
4576
4577 template<size_t _Nm>
4578 inline constexpr _Elements<_Nm> elements;
4579 inline constexpr auto keys = elements<0>;
4580 inline constexpr auto values = elements<1>;
4581 } // namespace views
4582
4583#ifdef __cpp_lib_ranges_zip // C++ >= 23
4584 namespace __detail
4585 {
4586 template<typename... _Rs>
4587 concept __zip_is_common = (sizeof...(_Rs) == 1 && (common_range<_Rs> && ...))
4588 || (!(bidirectional_range<_Rs> && ...) && (common_range<_Rs> && ...))
4589 || ((random_access_range<_Rs> && ...) && (sized_range<_Rs> && ...));
4590
4591 template<typename _Fp, typename _Tuple>
4592 constexpr auto
4593 __tuple_transform(_Fp&& __f, _Tuple&& __tuple)
4594 {
4595 return std::apply([&]<typename... _Ts>(_Ts&&... __elts) {
4596 return tuple<invoke_result_t<_Fp&, _Ts>...>
4597 (std::__invoke(__f, std::forward<_Ts>(__elts))...);
4598 }, std::forward<_Tuple>(__tuple));
4599 }
4600
4601 template<typename _Fp, typename _Tuple>
4602 constexpr void
4603 __tuple_for_each(_Fp&& __f, _Tuple&& __tuple)
4604 {
4605 std::apply([&]<typename... _Ts>(_Ts&&... __elts) {
4606 (std::__invoke(__f, std::forward<_Ts>(__elts)), ...);
4607 }, std::forward<_Tuple>(__tuple));
4608 }
4609 } // namespace __detail
4610
4611 template<input_range... _Vs>
4612 requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0)
4613 class zip_view : public view_interface<zip_view<_Vs...>>
4614 {
4615 tuple<_Vs...> _M_views;
4616
4617 template<bool> class _Iterator;
4618 template<bool> class _Sentinel;
4619
4620 public:
4621 zip_view() = default;
4622
4623 constexpr explicit
4624 zip_view(_Vs... __views)
4625 : _M_views(std::move(__views)...)
4626 { }
4627
4628 constexpr auto
4629 begin() requires (!(__detail::__simple_view<_Vs> && ...))
4630 { return _Iterator<false>(__detail::__tuple_transform(ranges::begin, _M_views)); }
4631
4632 constexpr auto
4633 begin() const requires (range<const _Vs> && ...)
4634 { return _Iterator<true>(__detail::__tuple_transform(ranges::begin, _M_views)); }
4635
4636 constexpr auto
4637 end() requires (!(__detail::__simple_view<_Vs> && ...))
4638 {
4639 if constexpr (!__detail::__zip_is_common<_Vs...>)
4640 return _Sentinel<false>(__detail::__tuple_transform(ranges::end, _M_views));
4641 else if constexpr ((random_access_range<_Vs> && ...))
4642 return begin() + iter_difference_t<_Iterator<false>>(size());
4643 else
4644 return _Iterator<false>(__detail::__tuple_transform(ranges::end, _M_views));
4645 }
4646
4647 constexpr auto
4648 end() const requires (range<const _Vs> && ...)
4649 {
4650 if constexpr (!__detail::__zip_is_common<const _Vs...>)
4651 return _Sentinel<true>(__detail::__tuple_transform(ranges::end, _M_views));
4652 else if constexpr ((random_access_range<const _Vs> && ...))
4653 return begin() + iter_difference_t<_Iterator<true>>(size());
4654 else
4655 return _Iterator<true>(__detail::__tuple_transform(ranges::end, _M_views));
4656 }
4657
4658 constexpr auto
4659 size() requires (sized_range<_Vs> && ...)
4660 {
4661 return std::apply([](auto... sizes) {
4662 using _CT = __detail::__make_unsigned_like_t<common_type_t<decltype(sizes)...>>;
4663 return ranges::min({_CT(sizes)...});
4664 }, __detail::__tuple_transform(ranges::size, _M_views));
4665 }
4666
4667 constexpr auto
4668 size() const requires (sized_range<const _Vs> && ...)
4669 {
4670 return std::apply([](auto... sizes) {
4671 using _CT = __detail::__make_unsigned_like_t<common_type_t<decltype(sizes)...>>;
4672 return ranges::min({_CT(sizes)...});
4673 }, __detail::__tuple_transform(ranges::size, _M_views));
4674 }
4675 };
4676
4677 template<typename... _Rs>
4678 zip_view(_Rs&&...) -> zip_view<views::all_t<_Rs>...>;
4679
4680 template<typename... _Views>
4681 inline constexpr bool enable_borrowed_range<zip_view<_Views...>>
4682 = (enable_borrowed_range<_Views> && ...);
4683
4684 namespace __detail
4685 {
4686 template<bool _Const, typename... _Vs>
4687 concept __all_random_access
4688 = (random_access_range<__maybe_const_t<_Const, _Vs>> && ...);
4689
4690 template<bool _Const, typename... _Vs>
4691 concept __all_bidirectional
4692 = (bidirectional_range<__maybe_const_t<_Const, _Vs>> && ...);
4693
4694 template<bool _Const, typename... _Vs>
4695 concept __all_forward
4696 = (forward_range<__maybe_const_t<_Const, _Vs>> && ...);
4697
4698 template<bool _Const, typename... _Views>
4699 struct __zip_view_iter_cat
4700 { };
4701
4702 template<bool _Const, typename... _Views>
4703 requires __all_forward<_Const, _Views...>
4704 struct __zip_view_iter_cat<_Const, _Views...>
4705 { using iterator_category = input_iterator_tag; };
4706 } // namespace __detail
4707
4708 template<input_range... _Vs>
4709 requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0)
4710 template<bool _Const>
4711 class zip_view<_Vs...>::_Iterator
4712 : public __detail::__zip_view_iter_cat<_Const, _Vs...>
4713 {
4714#ifdef __clang__ // LLVM-61763 workaround
4715 public:
4716#endif
4717 tuple<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>...> _M_current;
4718
4719 constexpr explicit
4720 _Iterator(decltype(_M_current) __current)
4721 : _M_current(std::move(__current))
4722 { }
4723
4724 static auto
4725 _S_iter_concept()
4726 {
4727 if constexpr (__detail::__all_random_access<_Const, _Vs...>)
4728 return random_access_iterator_tag{};
4729 else if constexpr (__detail::__all_bidirectional<_Const, _Vs...>)
4730 return bidirectional_iterator_tag{};
4731 else if constexpr (__detail::__all_forward<_Const, _Vs...>)
4732 return forward_iterator_tag{};
4733 else
4734 return input_iterator_tag{};
4735 }
4736
4737#ifndef __clang__ // LLVM-61763 workaround
4738 template<move_constructible _Fp, input_range... _Ws>
4739 requires (view<_Ws> && ...) && (sizeof...(_Ws) > 0) && is_object_v<_Fp>
4740 && regular_invocable<_Fp&, range_reference_t<_Ws>...>
4741 && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Ws>...>>
4742 friend class zip_transform_view;
4743#endif
4744
4745 public:
4746 // iterator_category defined in __zip_view_iter_cat
4747 using iterator_concept = decltype(_S_iter_concept());
4748 using value_type
4749 = tuple<range_value_t<__detail::__maybe_const_t<_Const, _Vs>>...>;
4750 using difference_type
4751 = common_type_t<range_difference_t<__detail::__maybe_const_t<_Const, _Vs>>...>;
4752
4753 _Iterator() = default;
4754
4755 constexpr
4756 _Iterator(_Iterator<!_Const> __i)
4757 requires _Const
4758 && (convertible_to<iterator_t<_Vs>,
4759 iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4760 : _M_current(std::move(__i._M_current))
4761 { }
4762
4763 constexpr auto
4764 operator*() const
4765 {
4766 auto __f = [](auto& __i) -> decltype(auto) {
4767 return *__i;
4768 };
4769 return __detail::__tuple_transform(__f, _M_current);
4770 }
4771
4772 constexpr _Iterator&
4773 operator++()
4774 {
4775 __detail::__tuple_for_each([](auto& __i) { ++__i; }, _M_current);
4776 return *this;
4777 }
4778
4779 constexpr void
4780 operator++(int)
4781 { ++*this; }
4782
4783 constexpr _Iterator
4784 operator++(int)
4785 requires __detail::__all_forward<_Const, _Vs...>
4786 {
4787 auto __tmp = *this;
4788 ++*this;
4789 return __tmp;
4790 }
4791
4792 constexpr _Iterator&
4793 operator--()
4794 requires __detail::__all_bidirectional<_Const, _Vs...>
4795 {
4796 __detail::__tuple_for_each([](auto& __i) { --__i; }, _M_current);
4797 return *this;
4798 }
4799
4800 constexpr _Iterator
4801 operator--(int)
4802 requires __detail::__all_bidirectional<_Const, _Vs...>
4803 {
4804 auto __tmp = *this;
4805 --*this;
4806 return __tmp;
4807 }
4808
4809 constexpr _Iterator&
4810 operator+=(difference_type __x)
4811 requires __detail::__all_random_access<_Const, _Vs...>
4812 {
4813 auto __f = [&]<typename _It>(_It& __i) {
4814 __i += iter_difference_t<_It>(__x);
4815 };
4816 __detail::__tuple_for_each(__f, _M_current);
4817 return *this;
4818 }
4819
4820 constexpr _Iterator&
4821 operator-=(difference_type __x)
4822 requires __detail::__all_random_access<_Const, _Vs...>
4823 {
4824 auto __f = [&]<typename _It>(_It& __i) {
4825 __i -= iter_difference_t<_It>(__x);
4826 };
4827 __detail::__tuple_for_each(__f, _M_current);
4828 return *this;
4829 }
4830
4831 constexpr auto
4832 operator[](difference_type __n) const
4833 requires __detail::__all_random_access<_Const, _Vs...>
4834 {
4835 auto __f = [&]<typename _It>(_It& __i) -> decltype(auto) {
4836 return __i[iter_difference_t<_It>(__n)];
4837 };
4838 return __detail::__tuple_transform(__f, _M_current);
4839 }
4840
4841 friend constexpr bool
4842 operator==(const _Iterator& __x, const _Iterator& __y)
4843 requires (equality_comparable<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4844 {
4845 if constexpr (__detail::__all_bidirectional<_Const, _Vs...>)
4846 return __x._M_current == __y._M_current;
4847 else
4848 return [&]<size_t... _Is>(index_sequence<_Is...>) {
4849 return ((std::get<_Is>(__x._M_current) == std::get<_Is>(__y._M_current)) || ...);
4850 }(make_index_sequence<sizeof...(_Vs)>{});
4851 }
4852
4853 friend constexpr auto
4854 operator<=>(const _Iterator& __x, const _Iterator& __y)
4855 requires __detail::__all_random_access<_Const, _Vs...>
4856 { return __x._M_current <=> __y._M_current; }
4857
4858 friend constexpr _Iterator
4859 operator+(const _Iterator& __i, difference_type __n)
4860 requires __detail::__all_random_access<_Const, _Vs...>
4861 {
4862 auto __r = __i;
4863 __r += __n;
4864 return __r;
4865 }
4866
4867 friend constexpr _Iterator
4868 operator+(difference_type __n, const _Iterator& __i)
4869 requires __detail::__all_random_access<_Const, _Vs...>
4870 {
4871 auto __r = __i;
4872 __r += __n;
4873 return __r;
4874 }
4875
4876 friend constexpr _Iterator
4877 operator-(const _Iterator& __i, difference_type __n)
4878 requires __detail::__all_random_access<_Const, _Vs...>
4879 {
4880 auto __r = __i;
4881 __r -= __n;
4882 return __r;
4883 }
4884
4885 friend constexpr difference_type
4886 operator-(const _Iterator& __x, const _Iterator& __y)
4887 requires (sized_sentinel_for<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>,
4888 iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4889 {
4890 return [&]<size_t... _Is>(index_sequence<_Is...>) {
4891 return ranges::min({difference_type(std::get<_Is>(__x._M_current)
4892 - std::get<_Is>(__y._M_current))...},
4893 ranges::less{},
4894 [](difference_type __i) {
4895 return __detail::__to_unsigned_like(__i < 0 ? -__i : __i);
4896 });
4897 }(make_index_sequence<sizeof...(_Vs)>{});
4898 }
4899
4900 friend constexpr auto
4901 iter_move(const _Iterator& __i)
4902 { return __detail::__tuple_transform(ranges::iter_move, __i._M_current); }
4903
4904 friend constexpr void
4905 iter_swap(const _Iterator& __l, const _Iterator& __r)
4906 requires (indirectly_swappable<iterator_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4907 {
4908 [&]<size_t... _Is>(index_sequence<_Is...>) {
4909 (ranges::iter_swap(std::get<_Is>(__l._M_current), std::get<_Is>(__r._M_current)), ...);
4910 }(make_index_sequence<sizeof...(_Vs)>{});
4911 }
4912
4913 friend class zip_view;
4914 };
4915
4916 template<input_range... _Vs>
4917 requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0)
4918 template<bool _Const>
4919 class zip_view<_Vs...>::_Sentinel
4920 {
4921 tuple<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>...> _M_end;
4922
4923 constexpr explicit
4924 _Sentinel(decltype(_M_end) __end)
4925 : _M_end(__end)
4926 { }
4927
4928 friend class zip_view;
4929
4930 public:
4931 _Sentinel() = default;
4932
4933 constexpr
4934 _Sentinel(_Sentinel<!_Const> __i)
4935 requires _Const
4936 && (convertible_to<sentinel_t<_Vs>,
4937 sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>> && ...)
4938 : _M_end(std::move(__i._M_end))
4939 { }
4940
4941 template<bool _OtherConst>
4942 requires (sentinel_for<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>,
4943 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vs>>> && ...)
4944 friend constexpr bool
4945 operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
4946 {
4947 return [&]<size_t... _Is>(index_sequence<_Is...>) {
4948 return ((std::get<_Is>(__x._M_current) == std::get<_Is>(__y._M_end)) || ...);
4949 }(make_index_sequence<sizeof...(_Vs)>{});
4950 }
4951
4952 template<bool _OtherConst>
4953 requires (sized_sentinel_for<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>,
4954 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vs>>> && ...)
4955 friend constexpr auto
4956 operator-(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
4957 {
4958 using _Ret
4959 = common_type_t<range_difference_t<__detail::__maybe_const_t<_OtherConst, _Vs>>...>;
4960 return [&]<size_t... _Is>(index_sequence<_Is...>) {
4961 return ranges::min({_Ret(std::get<_Is>(__x._M_current) - std::get<_Is>(__y._M_end))...},
4962 ranges::less{},
4963 [](_Ret __i) {
4964 return __detail::__to_unsigned_like(__i < 0 ? -__i : __i);
4965 });
4966 }(make_index_sequence<sizeof...(_Vs)>{});
4967 }
4968
4969 template<bool _OtherConst>
4970 requires (sized_sentinel_for<sentinel_t<__detail::__maybe_const_t<_Const, _Vs>>,
4971 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vs>>> && ...)
4972 friend constexpr auto
4973 operator-(const _Sentinel& __y, const _Iterator<_OtherConst>& __x)
4974 { return -(__x - __y); }
4975 };
4976
4977 namespace views
4978 {
4979 namespace __detail
4980 {
4981 template<typename... _Ts>
4982 concept __can_zip_view
4983 = requires { zip_view<all_t<_Ts>...>(std::declval<_Ts>()...); };
4984 }
4985
4986 struct _Zip
4987 {
4988 template<typename... _Ts>
4989 requires (sizeof...(_Ts) == 0 || __detail::__can_zip_view<_Ts...>)
4990 constexpr auto
4991 operator() [[nodiscard]] (_Ts&&... __ts) const
4992 {
4993 if constexpr (sizeof...(_Ts) == 0)
4994 return views::empty<tuple<>>;
4995 else
4996 return zip_view<all_t<_Ts>...>(std::forward<_Ts>(__ts)...);
4997 }
4998 };
4999
5000 inline constexpr _Zip zip;
5001 }
5002
5003 namespace __detail
5004 {
5005 template<typename _Range, bool _Const>
5006 using __range_iter_cat
5007 = typename iterator_traits<iterator_t<__maybe_const_t<_Const, _Range>>>::iterator_category;
5008 }
5009
5010 template<move_constructible _Fp, input_range... _Vs>
5011 requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0) && is_object_v<_Fp>
5012 && regular_invocable<_Fp&, range_reference_t<_Vs>...>
5013 && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Vs>...>>
5014 class zip_transform_view : public view_interface<zip_transform_view<_Fp, _Vs...>>
5015 {
5016 [[no_unique_address]] __detail::__box<_Fp> _M_fun;
5017 zip_view<_Vs...> _M_zip;
5018
5019 using _InnerView = zip_view<_Vs...>;
5020
5021 template<bool _Const>
5022 using __ziperator = iterator_t<__detail::__maybe_const_t<_Const, _InnerView>>;
5023
5024 template<bool _Const>
5025 using __zentinel = sentinel_t<__detail::__maybe_const_t<_Const, _InnerView>>;
5026
5027 template<bool _Const>
5028 using _Base = __detail::__maybe_const_t<_Const, _InnerView>;
5029
5030 template<bool _Const>
5031 struct __iter_cat
5032 { };
5033
5034 template<bool _Const>
5035 requires forward_range<_Base<_Const>>
5036 struct __iter_cat<_Const>
5037 {
5038 private:
5039 static auto
5040 _S_iter_cat()
5041 {
5042 using __detail::__maybe_const_t;
5043 using __detail::__range_iter_cat;
5044 using _Res = invoke_result_t<__maybe_const_t<_Const, _Fp>&,
5045 range_reference_t<__maybe_const_t<_Const, _Vs>>...>;
5046 if constexpr (!is_lvalue_reference_v<_Res>)
5047 return input_iterator_tag{};
5048 else if constexpr ((derived_from<__range_iter_cat<_Vs, _Const>,
5049 random_access_iterator_tag> && ...))
5050 return random_access_iterator_tag{};
5051 else if constexpr ((derived_from<__range_iter_cat<_Vs, _Const>,
5052 bidirectional_iterator_tag> && ...))
5053 return bidirectional_iterator_tag{};
5054 else if constexpr ((derived_from<__range_iter_cat<_Vs, _Const>,
5055 forward_iterator_tag> && ...))
5056 return forward_iterator_tag{};
5057 else
5058 return input_iterator_tag{};
5059 }
5060 public:
5061 using iterator_category = decltype(_S_iter_cat());
5062 };
5063
5064 template<bool> class _Iterator;
5065 template<bool> class _Sentinel;
5066
5067 public:
5068 zip_transform_view() = default;
5069
5070 constexpr explicit
5071 zip_transform_view(_Fp __fun, _Vs... __views)
5072 : _M_fun(std::move(__fun)), _M_zip(std::move(__views)...)
5073 { }
5074
5075 constexpr auto
5076 begin()
5077 { return _Iterator<false>(*this, _M_zip.begin()); }
5078
5079 constexpr auto
5080 begin() const
5081 requires range<const _InnerView>
5082 && regular_invocable<const _Fp&, range_reference_t<const _Vs>...>
5083 { return _Iterator<true>(*this, _M_zip.begin()); }
5084
5085 constexpr auto
5086 end()
5087 {
5088 if constexpr (common_range<_InnerView>)
5089 return _Iterator<false>(*this, _M_zip.end());
5090 else
5091 return _Sentinel<false>(_M_zip.end());
5092 }
5093
5094 constexpr auto
5095 end() const
5096 requires range<const _InnerView>
5097 && regular_invocable<const _Fp&, range_reference_t<const _Vs>...>
5098 {
5099 if constexpr (common_range<const _InnerView>)
5100 return _Iterator<true>(*this, _M_zip.end());
5101 else
5102 return _Sentinel<true>(_M_zip.end());
5103 }
5104
5105 constexpr auto
5106 size() requires sized_range<_InnerView>
5107 { return _M_zip.size(); }
5108
5109 constexpr auto
5110 size() const requires sized_range<const _InnerView>
5111 { return _M_zip.size(); }
5112 };
5113
5114 template<class _Fp, class... Rs>
5115 zip_transform_view(_Fp, Rs&&...) -> zip_transform_view<_Fp, views::all_t<Rs>...>;
5116
5117 template<move_constructible _Fp, input_range... _Vs>
5118 requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0) && is_object_v<_Fp>
5119 && regular_invocable<_Fp&, range_reference_t<_Vs>...>
5120 && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Vs>...>>
5121 template<bool _Const>
5122 class zip_transform_view<_Fp, _Vs...>::_Iterator : public __iter_cat<_Const>
5123 {
5124 using _Parent = __detail::__maybe_const_t<_Const, zip_transform_view>;
5125
5126 _Parent* _M_parent = nullptr;
5127 __ziperator<_Const> _M_inner;
5128
5129 constexpr
5130 _Iterator(_Parent& __parent, __ziperator<_Const> __inner)
5131 : _M_parent(std::__addressof(__parent)), _M_inner(std::move(__inner))
5132 { }
5133
5134 friend class zip_transform_view;
5135
5136 public:
5137 // iterator_category defined in zip_transform_view::__iter_cat
5138 using iterator_concept = typename __ziperator<_Const>::iterator_concept;
5139 using value_type
5140 = remove_cvref_t<invoke_result_t<__detail::__maybe_const_t<_Const, _Fp>&,
5141 range_reference_t<__detail::__maybe_const_t<_Const, _Vs>>...>>;
5142 using difference_type = range_difference_t<_Base<_Const>>;
5143
5144 _Iterator() = default;
5145
5146 constexpr
5147 _Iterator(_Iterator<!_Const> __i)
5148 requires _Const && convertible_to<__ziperator<false>, __ziperator<_Const>>
5149 : _M_parent(__i._M_parent), _M_inner(std::move(__i._M_inner))
5150 { }
5151
5152 constexpr decltype(auto)
5153 operator*() const
5154 {
5155 return std::apply([&](const auto&... __iters) -> decltype(auto) {
5156 return std::__invoke(*_M_parent->_M_fun, *__iters...);
5157 }, _M_inner._M_current);
5158 }
5159
5160 constexpr _Iterator&
5161 operator++()
5162 {
5163 ++_M_inner;
5164 return *this;
5165 }
5166
5167 constexpr void
5168 operator++(int)
5169 { ++*this; }
5170
5171 constexpr _Iterator
5172 operator++(int) requires forward_range<_Base<_Const>>
5173 {
5174 auto __tmp = *this;
5175 ++*this;
5176 return __tmp;
5177 }
5178
5179 constexpr _Iterator&
5180 operator--() requires bidirectional_range<_Base<_Const>>
5181 {
5182 --_M_inner;
5183 return *this;
5184 }
5185
5186 constexpr _Iterator
5187 operator--(int) requires bidirectional_range<_Base<_Const>>
5188 {
5189 auto __tmp = *this;
5190 --*this;
5191 return __tmp;
5192 }
5193
5194 constexpr _Iterator&
5195 operator+=(difference_type __x) requires random_access_range<_Base<_Const>>
5196 {
5197 _M_inner += __x;
5198 return *this;
5199 }
5200
5201 constexpr _Iterator&
5202 operator-=(difference_type __x) requires random_access_range<_Base<_Const>>
5203 {
5204 _M_inner -= __x;
5205 return *this;
5206 }
5207
5208 constexpr decltype(auto)
5209 operator[](difference_type __n) const requires random_access_range<_Base<_Const>>
5210 {
5211 return std::apply([&]<typename... _Is>(const _Is&... __iters) -> decltype(auto) {
5212 return std::__invoke(*_M_parent->_M_fun, __iters[iter_difference_t<_Is>(__n)]...);
5213 }, _M_inner._M_current);
5214 }
5215
5216 friend constexpr bool
5217 operator==(const _Iterator& __x, const _Iterator& __y)
5218 requires equality_comparable<__ziperator<_Const>>
5219 { return __x._M_inner == __y._M_inner; }
5220
5221 friend constexpr auto
5222 operator<=>(const _Iterator& __x, const _Iterator& __y)
5223 requires random_access_range<_Base<_Const>>
5224 { return __x._M_inner <=> __y._M_inner; }
5225
5226 friend constexpr _Iterator
5227 operator+(const _Iterator& __i, difference_type __n)
5228 requires random_access_range<_Base<_Const>>
5229 { return _Iterator(*__i._M_parent, __i._M_inner + __n); }
5230
5231 friend constexpr _Iterator
5232 operator+(difference_type __n, const _Iterator& __i)
5233 requires random_access_range<_Base<_Const>>
5234 { return _Iterator(*__i._M_parent, __i._M_inner + __n); }
5235
5236 friend constexpr _Iterator
5237 operator-(const _Iterator& __i, difference_type __n)
5238 requires random_access_range<_Base<_Const>>
5239 { return _Iterator(*__i._M_parent, __i._M_inner - __n); }
5240
5241 friend constexpr difference_type
5242 operator-(const _Iterator& __x, const _Iterator& __y)
5243 requires sized_sentinel_for<__ziperator<_Const>, __ziperator<_Const>>
5244 { return __x._M_inner - __y._M_inner; }
5245 };
5246
5247 template<move_constructible _Fp, input_range... _Vs>
5248 requires (view<_Vs> && ...) && (sizeof...(_Vs) > 0) && is_object_v<_Fp>
5249 && regular_invocable<_Fp&, range_reference_t<_Vs>...>
5250 && std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Vs>...>>
5251 template<bool _Const>
5252 class zip_transform_view<_Fp, _Vs...>::_Sentinel
5253 {
5254 __zentinel<_Const> _M_inner;
5255
5256 constexpr explicit
5257 _Sentinel(__zentinel<_Const> __inner)
5258 : _M_inner(__inner)
5259 { }
5260
5261 friend class zip_transform_view;
5262
5263 public:
5264 _Sentinel() = default;
5265
5266 constexpr
5267 _Sentinel(_Sentinel<!_Const> __i)
5268 requires _Const && convertible_to<__zentinel<false>, __zentinel<_Const>>
5269 : _M_inner(std::move(__i._M_inner))
5270 { }
5271
5272 template<bool _OtherConst>
5273 requires sentinel_for<__zentinel<_Const>, __ziperator<_OtherConst>>
5274 friend constexpr bool
5275 operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
5276 { return __x._M_inner == __y._M_inner; }
5277
5278 template<bool _OtherConst>
5279 requires sized_sentinel_for<__zentinel<_Const>, __ziperator<_OtherConst>>
5280 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
5281 operator-(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
5282 { return __x._M_inner - __y._M_inner; }
5283
5284 template<bool _OtherConst>
5285 requires sized_sentinel_for<__zentinel<_Const>, __ziperator<_OtherConst>>
5286 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
5287 operator-(const _Sentinel& __x, const _Iterator<_OtherConst>& __y)
5288 { return __x._M_inner - __y._M_inner; }
5289 };
5290
5291 namespace views
5292 {
5293 namespace __detail
5294 {
5295 template<typename _Fp, typename... _Ts>
5296 concept __can_zip_transform_view
5297 = requires { zip_transform_view(std::declval<_Fp>(), std::declval<_Ts>()...); };
5298 }
5299
5300 struct _ZipTransform
5301 {
5302 template<typename _Fp, typename... _Ts>
5303 requires (sizeof...(_Ts) == 0) || __detail::__can_zip_transform_view<_Fp, _Ts...>
5304 constexpr auto
5305 operator() [[nodiscard]] (_Fp&& __f, _Ts&&... __ts) const
5306 {
5307 if constexpr (sizeof...(_Ts) == 0)
5308 return views::empty<decay_t<invoke_result_t<decay_t<_Fp>&>>>;
5309 else
5310 return zip_transform_view(std::forward<_Fp>(__f), std::forward<_Ts>(__ts)...);
5311 }
5312 };
5313
5314 inline constexpr _ZipTransform zip_transform;
5315 }
5316
5317 template<forward_range _Vp, size_t _Nm>
5318 requires view<_Vp> && (_Nm > 0)
5319 class adjacent_view : public view_interface<adjacent_view<_Vp, _Nm>>
5320 {
5321 _Vp _M_base = _Vp();
5322
5323 template<bool> class _Iterator;
5324 template<bool> class _Sentinel;
5325
5326 struct __as_sentinel
5327 { };
5328
5329 public:
5330 adjacent_view() requires default_initializable<_Vp> = default;
5331
5332 constexpr explicit
5333 adjacent_view(_Vp __base)
5334 : _M_base(std::move(__base))
5335 { }
5336
5337 // _GLIBCXX_RESOLVE_LIB_DEFECTS
5338 // 3848. adjacent_view, adjacent_transform_view and slide_view missing base accessor
5339 constexpr _Vp
5340 base() const & requires copy_constructible<_Vp>
5341 { return _M_base; }
5342
5343 constexpr _Vp
5344 base() &&
5345 { return std::move(_M_base); }
5346
5347 constexpr auto
5348 begin() requires (!__detail::__simple_view<_Vp>)
5349 { return _Iterator<false>(ranges::begin(_M_base), ranges::end(_M_base)); }
5350
5351 constexpr auto
5352 begin() const requires range<const _Vp>
5353 { return _Iterator<true>(ranges::begin(_M_base), ranges::end(_M_base)); }
5354
5355 constexpr auto
5356 end() requires (!__detail::__simple_view<_Vp>)
5357 {
5358 if constexpr (common_range<_Vp>)
5359 return _Iterator<false>(__as_sentinel{}, ranges::begin(_M_base), ranges::end(_M_base));
5360 else
5361 return _Sentinel<false>(ranges::end(_M_base));
5362 }
5363
5364 constexpr auto
5365 end() const requires range<const _Vp>
5366 {
5367 if constexpr (common_range<const _Vp>)
5368 return _Iterator<true>(__as_sentinel{}, ranges::begin(_M_base), ranges::end(_M_base));
5369 else
5370 return _Sentinel<true>(ranges::end(_M_base));
5371 }
5372
5373 constexpr auto
5374 size() requires sized_range<_Vp>
5375 {
5376 using _ST = decltype(ranges::size(_M_base));
5377 using _CT = common_type_t<_ST, size_t>;
5378 auto __sz = static_cast<_CT>(ranges::size(_M_base));
5379 __sz -= std::min<_CT>(__sz, _Nm - 1);
5380 return static_cast<_ST>(__sz);
5381 }
5382
5383 constexpr auto
5384 size() const requires sized_range<const _Vp>
5385 {
5386 using _ST = decltype(ranges::size(_M_base));
5387 using _CT = common_type_t<_ST, size_t>;
5388 auto __sz = static_cast<_CT>(ranges::size(_M_base));
5389 __sz -= std::min<_CT>(__sz, _Nm - 1);
5390 return static_cast<_ST>(__sz);
5391 }
5392 };
5393
5394 template<typename _Vp, size_t _Nm>
5395 inline constexpr bool enable_borrowed_range<adjacent_view<_Vp, _Nm>>
5396 = enable_borrowed_range<_Vp>;
5397
5398 namespace __detail
5399 {
5400 // Yields tuple<_Tp, ..., _Tp> with _Nm elements.
5401 template<typename _Tp, size_t _Nm>
5402 using __repeated_tuple = decltype(std::tuple_cat(std::declval<array<_Tp, _Nm>>()));
5403
5404 // For a functor F that is callable with N arguments, the expression
5405 // declval<__unarize<F, N>>(x) is equivalent to declval<F>(x, ..., x).
5406 template<typename _Fp, size_t _Nm>
5407 struct __unarize
5408 {
5409 template<typename... _Ts>
5410 static invoke_result_t<_Fp, _Ts...>
5411 __tuple_apply(const tuple<_Ts...>&); // not defined
5412
5413 template<typename _Tp>
5414 decltype(__tuple_apply(std::declval<__repeated_tuple<_Tp, _Nm>>()))
5415 operator()(_Tp&&); // not defined
5416 };
5417 }
5418
5419 template<forward_range _Vp, size_t _Nm>
5420 requires view<_Vp> && (_Nm > 0)
5421 template<bool _Const>
5422 class adjacent_view<_Vp, _Nm>::_Iterator
5423 {
5424#ifdef __clang__ // LLVM-61763 workaround
5425 public:
5426#endif
5427 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
5428 array<iterator_t<_Base>, _Nm> _M_current = array<iterator_t<_Base>, _Nm>();
5429
5430 constexpr
5431 _Iterator(iterator_t<_Base> __first, sentinel_t<_Base> __last)
5432 {
5433 for (auto& __i : _M_current)
5434 {
5435 __i = __first;
5436 ranges::advance(__first, 1, __last);
5437 }
5438 }
5439
5440 constexpr
5441 _Iterator(__as_sentinel, iterator_t<_Base> __first, iterator_t<_Base> __last)
5442 {
5443 if constexpr (!bidirectional_range<_Base>)
5444 for (auto& __it : _M_current)
5445 __it = __last;
5446 else
5447 for (size_t __i = 0; __i < _Nm; ++__i)
5448 {
5449 _M_current[_Nm - 1 - __i] = __last;
5450 ranges::advance(__last, -1, __first);
5451 }
5452 }
5453
5454 static auto
5455 _S_iter_concept()
5456 {
5457 if constexpr (random_access_range<_Base>)
5458 return random_access_iterator_tag{};
5459 else if constexpr (bidirectional_range<_Base>)
5460 return bidirectional_iterator_tag{};
5461 else
5462 return forward_iterator_tag{};
5463 }
5464
5465 friend class adjacent_view;
5466
5467#ifndef __clang__ // LLVM-61763 workaround
5468 template<forward_range _Wp, move_constructible _Fp, size_t _Mm>
5469 requires view<_Wp> && (_Mm > 0) && is_object_v<_Fp>
5470 && regular_invocable<__detail::__unarize<_Fp&, _Mm>, range_reference_t<_Wp>>
5471 && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Mm>,
5472 range_reference_t<_Wp>>>
5473 friend class adjacent_transform_view;
5474#endif
5475
5476 public:
5477 using iterator_category = input_iterator_tag;
5478 using iterator_concept = decltype(_S_iter_concept());
5479 using value_type = conditional_t<_Nm == 2,
5480 pair<range_value_t<_Base>, range_value_t<_Base>>,
5481 __detail::__repeated_tuple<range_value_t<_Base>, _Nm>>;
5482 using difference_type = range_difference_t<_Base>;
5483
5484 _Iterator() = default;
5485
5486 constexpr
5487 _Iterator(_Iterator<!_Const> __i)
5488 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
5489 {
5490 for (size_t __j = 0; __j < _Nm; ++__j)
5491 _M_current[__j] = std::move(__i._M_current[__j]);
5492 }
5493
5494 constexpr auto
5495 operator*() const
5496 {
5497 auto __f = [](auto& __i) -> decltype(auto) { return *__i; };
5498 return __detail::__tuple_transform(__f, _M_current);
5499 }
5500
5501 constexpr _Iterator&
5502 operator++()
5503 {
5504 for (auto& __i : _M_current)
5505 ++__i;
5506 return *this;
5507 }
5508
5509 constexpr _Iterator
5510 operator++(int)
5511 {
5512 auto __tmp = *this;
5513 ++*this;
5514 return __tmp;
5515 }
5516
5517 constexpr _Iterator&
5518 operator--() requires bidirectional_range<_Base>
5519 {
5520 for (auto& __i : _M_current)
5521 --__i;
5522 return *this;
5523 }
5524
5525 constexpr _Iterator
5526 operator--(int) requires bidirectional_range<_Base>
5527 {
5528 auto __tmp = *this;
5529 --*this;
5530 return __tmp;
5531 }
5532
5533 constexpr _Iterator&
5534 operator+=(difference_type __x)
5535 requires random_access_range<_Base>
5536 {
5537 for (auto& __i : _M_current)
5538 __i += __x;
5539 return *this;
5540 }
5541
5542 constexpr _Iterator&
5543 operator-=(difference_type __x)
5544 requires random_access_range<_Base>
5545 {
5546 for (auto& __i : _M_current)
5547 __i -= __x;
5548 return *this;
5549 }
5550
5551 constexpr auto
5552 operator[](difference_type __n) const
5553 requires random_access_range<_Base>
5554 {
5555 auto __f = [&](auto& __i) -> decltype(auto) { return __i[__n]; };
5556 return __detail::__tuple_transform(__f, _M_current);
5557 }
5558
5559 friend constexpr bool
5560 operator==(const _Iterator& __x, const _Iterator& __y)
5561 { return __x._M_current.back() == __y._M_current.back(); }
5562
5563 friend constexpr bool
5564 operator<(const _Iterator& __x, const _Iterator& __y)
5565 requires random_access_range<_Base>
5566 { return __x._M_current.back() < __y._M_current.back(); }
5567
5568 friend constexpr bool
5569 operator>(const _Iterator& __x, const _Iterator& __y)
5570 requires random_access_range<_Base>
5571 { return __y < __x; }
5572
5573 friend constexpr bool
5574 operator<=(const _Iterator& __x, const _Iterator& __y)
5575 requires random_access_range<_Base>
5576 { return !(__y < __x); }
5577
5578 friend constexpr bool
5579 operator>=(const _Iterator& __x, const _Iterator& __y)
5580 requires random_access_range<_Base>
5581 { return !(__x < __y); }
5582
5583 friend constexpr auto
5584 operator<=>(const _Iterator& __x, const _Iterator& __y)
5585 requires random_access_range<_Base>
5586 && three_way_comparable<iterator_t<_Base>>
5587 { return __x._M_current.back() <=> __y._M_current.back(); }
5588
5589 friend constexpr _Iterator
5590 operator+(const _Iterator& __i, difference_type __n)
5591 requires random_access_range<_Base>
5592 {
5593 auto __r = __i;
5594 __r += __n;
5595 return __r;
5596 }
5597
5598 friend constexpr _Iterator
5599 operator+(difference_type __n, const _Iterator& __i)
5600 requires random_access_range<_Base>
5601 {
5602 auto __r = __i;
5603 __r += __n;
5604 return __r;
5605 }
5606
5607 friend constexpr _Iterator
5608 operator-(const _Iterator& __i, difference_type __n)
5609 requires random_access_range<_Base>
5610 {
5611 auto __r = __i;
5612 __r -= __n;
5613 return __r;
5614 }
5615
5616 friend constexpr difference_type
5617 operator-(const _Iterator& __x, const _Iterator& __y)
5618 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
5619 { return __x._M_current.back() - __y._M_current.back(); }
5620
5621 friend constexpr auto
5622 iter_move(const _Iterator& __i)
5623 { return __detail::__tuple_transform(ranges::iter_move, __i._M_current); }
5624
5625 friend constexpr void
5626 iter_swap(const _Iterator& __l, const _Iterator& __r)
5627 requires indirectly_swappable<iterator_t<_Base>>
5628 {
5629 for (size_t __i = 0; __i < _Nm; __i++)
5630 ranges::iter_swap(__l._M_current[__i], __r._M_current[__i]);
5631 }
5632 };
5633
5634 template<forward_range _Vp, size_t _Nm>
5635 requires view<_Vp> && (_Nm > 0)
5636 template<bool _Const>
5637 class adjacent_view<_Vp, _Nm>::_Sentinel
5638 {
5639 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
5640
5641 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
5642
5643 constexpr explicit
5644 _Sentinel(sentinel_t<_Base> __end)
5645 : _M_end(__end)
5646 { }
5647
5648 friend class adjacent_view;
5649
5650 public:
5651 _Sentinel() = default;
5652
5653 constexpr
5654 _Sentinel(_Sentinel<!_Const> __i)
5655 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
5656 : _M_end(std::move(__i._M_end))
5657 { }
5658
5659 template<bool _OtherConst>
5660 requires sentinel_for<sentinel_t<_Base>,
5661 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
5662 friend constexpr bool
5663 operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
5664 { return __x._M_current.back() == __y._M_end; }
5665
5666 template<bool _OtherConst>
5667 requires sized_sentinel_for<sentinel_t<_Base>,
5668 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
5669 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _Vp>>
5670 operator-(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
5671 { return __x._M_current.back() - __y._M_end; }
5672
5673 template<bool _OtherConst>
5674 requires sized_sentinel_for<sentinel_t<_Base>,
5675 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
5676 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _Vp>>
5677 operator-(const _Sentinel& __y, const _Iterator<_OtherConst>& __x)
5678 { return __y._M_end - __x._M_current.back(); }
5679 };
5680
5681 namespace views
5682 {
5683 namespace __detail
5684 {
5685 template<size_t _Nm, typename _Range>
5686 concept __can_adjacent_view
5687 = requires { adjacent_view<all_t<_Range>, _Nm>(std::declval<_Range>()); };
5688 }
5689
5690 template<size_t _Nm>
5691 struct _Adjacent : __adaptor::_RangeAdaptorClosure<_Adjacent<_Nm>>
5692 {
5693 template<viewable_range _Range>
5694 requires (_Nm == 0) || __detail::__can_adjacent_view<_Nm, _Range>
5695 constexpr auto
5696 operator() [[nodiscard]] (_Range&& __r) const
5697 {
5698 if constexpr (_Nm == 0)
5699 return views::empty<tuple<>>;
5700 else
5701 return adjacent_view<all_t<_Range>, _Nm>(std::forward<_Range>(__r));
5702 }
5703 };
5704
5705 template<size_t _Nm>
5706 inline constexpr _Adjacent<_Nm> adjacent;
5707
5708 inline constexpr auto pairwise = adjacent<2>;
5709 }
5710
5711 template<forward_range _Vp, move_constructible _Fp, size_t _Nm>
5712 requires view<_Vp> && (_Nm > 0) && is_object_v<_Fp>
5713 && regular_invocable<__detail::__unarize<_Fp&, _Nm>, range_reference_t<_Vp>>
5714 && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Nm>,
5715 range_reference_t<_Vp>>>
5716 class adjacent_transform_view : public view_interface<adjacent_transform_view<_Vp, _Fp, _Nm>>
5717 {
5718 [[no_unique_address]] __detail::__box<_Fp> _M_fun;
5719 adjacent_view<_Vp, _Nm> _M_inner;
5720
5721 using _InnerView = adjacent_view<_Vp, _Nm>;
5722
5723 template<bool _Const>
5724 using _InnerIter = iterator_t<__detail::__maybe_const_t<_Const, _InnerView>>;
5725
5726 template<bool _Const>
5727 using _InnerSent = sentinel_t<__detail::__maybe_const_t<_Const, _InnerView>>;
5728
5729 template<bool> class _Iterator;
5730 template<bool> class _Sentinel;
5731
5732 public:
5733 adjacent_transform_view() = default;
5734
5735 constexpr explicit
5736 adjacent_transform_view(_Vp __base, _Fp __fun)
5737 : _M_fun(std::move(__fun)), _M_inner(std::move(__base))
5738 { }
5739
5740 // _GLIBCXX_RESOLVE_LIB_DEFECTS
5741 // 3848. adjacent_view, adjacent_transform_view and slide_view missing base accessor
5742 // 3947. Unexpected constraints on adjacent_transform_view::base()
5743 constexpr _Vp
5744 base() const & requires copy_constructible<_Vp>
5745 { return _M_inner.base(); }
5746
5747 constexpr _Vp
5748 base() &&
5749 { return std::move(_M_inner.base()); }
5750
5751 constexpr auto
5752 begin()
5753 { return _Iterator<false>(*this, _M_inner.begin()); }
5754
5755 constexpr auto
5756 begin() const
5757 requires range<const _InnerView>
5758 && regular_invocable<__detail::__unarize<const _Fp&, _Nm>,
5759 range_reference_t<const _Vp>>
5760 { return _Iterator<true>(*this, _M_inner.begin()); }
5761
5762 constexpr auto
5763 end()
5764 {
5765 if constexpr (common_range<_InnerView>)
5766 return _Iterator<false>(*this, _M_inner.end());
5767 else
5768 return _Sentinel<false>(_M_inner.end());
5769 }
5770
5771 constexpr auto
5772 end() const
5773 requires range<const _InnerView>
5774 && regular_invocable<__detail::__unarize<const _Fp&, _Nm>,
5775 range_reference_t<const _Vp>>
5776 {
5777 if constexpr (common_range<const _InnerView>)
5778 return _Iterator<true>(*this, _M_inner.end());
5779 else
5780 return _Sentinel<true>(_M_inner.end());
5781 }
5782
5783 constexpr auto
5784 size() requires sized_range<_InnerView>
5785 { return _M_inner.size(); }
5786
5787 constexpr auto
5788 size() const requires sized_range<const _InnerView>
5789 { return _M_inner.size(); }
5790 };
5791
5792 template<forward_range _Vp, move_constructible _Fp, size_t _Nm>
5793 requires view<_Vp> && (_Nm > 0) && is_object_v<_Fp>
5794 && regular_invocable<__detail::__unarize<_Fp&, _Nm>, range_reference_t<_Vp>>
5795 && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Nm>,
5796 range_reference_t<_Vp>>>
5797 template<bool _Const>
5798 class adjacent_transform_view<_Vp, _Fp, _Nm>::_Iterator
5799 {
5800 using _Parent = __detail::__maybe_const_t<_Const, adjacent_transform_view>;
5801 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
5802
5803 _Parent* _M_parent = nullptr;
5804 _InnerIter<_Const> _M_inner;
5805
5806 constexpr
5807 _Iterator(_Parent& __parent, _InnerIter<_Const> __inner)
5808 : _M_parent(std::__addressof(__parent)), _M_inner(std::move(__inner))
5809 { }
5810
5811 static auto
5812 _S_iter_cat()
5813 {
5814 using __detail::__maybe_const_t;
5815 using __detail::__unarize;
5816 using _Res = invoke_result_t<__unarize<__maybe_const_t<_Const, _Fp>&, _Nm>,
5817 range_reference_t<_Base>>;
5818 using _Cat = typename iterator_traits<iterator_t<_Base>>::iterator_category;
5819 if constexpr (!is_lvalue_reference_v<_Res>)
5820 return input_iterator_tag{};
5821 else if constexpr (derived_from<_Cat, random_access_iterator_tag>)
5822 return random_access_iterator_tag{};
5823 else if constexpr (derived_from<_Cat, bidirectional_iterator_tag>)
5824 return bidirectional_iterator_tag{};
5825 else if constexpr (derived_from<_Cat, forward_iterator_tag>)
5826 return forward_iterator_tag{};
5827 else
5828 return input_iterator_tag{};
5829 }
5830
5831 friend class adjacent_transform_view;
5832
5833 public:
5834 using iterator_category = decltype(_S_iter_cat());
5835 using iterator_concept = typename _InnerIter<_Const>::iterator_concept;
5836 using value_type
5837 = remove_cvref_t<invoke_result_t
5838 <__detail::__unarize<__detail::__maybe_const_t<_Const, _Fp>&, _Nm>,
5839 range_reference_t<_Base>>>;
5840 using difference_type = range_difference_t<_Base>;
5841
5842 _Iterator() = default;
5843
5844 constexpr
5845 _Iterator(_Iterator<!_Const> __i)
5846 requires _Const && convertible_to<_InnerIter<false>, _InnerIter<_Const>>
5847 : _M_parent(__i._M_parent), _M_inner(std::move(__i._M_inner))
5848 { }
5849
5850 constexpr decltype(auto)
5851 operator*() const
5852 {
5853 return std::apply([&](const auto&... __iters) -> decltype(auto) {
5854 return std::__invoke(*_M_parent->_M_fun, *__iters...);
5855 }, _M_inner._M_current);
5856 }
5857
5858 constexpr _Iterator&
5859 operator++()
5860 {
5861 ++_M_inner;
5862 return *this;
5863 }
5864
5865 constexpr _Iterator
5866 operator++(int)
5867 {
5868 auto __tmp = *this;
5869 ++*this;
5870 return __tmp;
5871 }
5872
5873 constexpr _Iterator&
5874 operator--() requires bidirectional_range<_Base>
5875 {
5876 --_M_inner;
5877 return *this;
5878 }
5879
5880 constexpr _Iterator
5881 operator--(int) requires bidirectional_range<_Base>
5882 {
5883 auto __tmp = *this;
5884 --*this;
5885 return __tmp;
5886 }
5887
5888 constexpr _Iterator&
5889 operator+=(difference_type __x) requires random_access_range<_Base>
5890 {
5891 _M_inner += __x;
5892 return *this;
5893 }
5894
5895 constexpr _Iterator&
5896 operator-=(difference_type __x) requires random_access_range<_Base>
5897 {
5898 _M_inner -= __x;
5899 return *this;
5900 }
5901
5902 constexpr decltype(auto)
5903 operator[](difference_type __n) const requires random_access_range<_Base>
5904 {
5905 return std::apply([&](const auto&... __iters) -> decltype(auto) {
5906 return std::__invoke(*_M_parent->_M_fun, __iters[__n]...);
5907 }, _M_inner._M_current);
5908 }
5909
5910 friend constexpr bool
5911 operator==(const _Iterator& __x, const _Iterator& __y)
5912 { return __x._M_inner == __y._M_inner; }
5913
5914 friend constexpr bool
5915 operator<(const _Iterator& __x, const _Iterator& __y)
5916 requires random_access_range<_Base>
5917 { return __x._M_inner < __y._M_inner; }
5918
5919 friend constexpr bool
5920 operator>(const _Iterator& __x, const _Iterator& __y)
5921 requires random_access_range<_Base>
5922 { return __x._M_inner > __y._M_inner; }
5923
5924 friend constexpr bool
5925 operator<=(const _Iterator& __x, const _Iterator& __y)
5926 requires random_access_range<_Base>
5927 { return __x._M_inner <= __y._M_inner; }
5928
5929 friend constexpr bool
5930 operator>=(const _Iterator& __x, const _Iterator& __y)
5931 requires random_access_range<_Base>
5932 { return __x._M_inner >= __y._M_inner; }
5933
5934 friend constexpr auto
5935 operator<=>(const _Iterator& __x, const _Iterator& __y)
5936 requires random_access_range<_Base> &&
5937 three_way_comparable<_InnerIter<_Const>>
5938 { return __x._M_inner <=> __y._M_inner; }
5939
5940 friend constexpr _Iterator
5941 operator+(const _Iterator& __i, difference_type __n)
5942 requires random_access_range<_Base>
5943 { return _Iterator(*__i._M_parent, __i._M_inner + __n); }
5944
5945 friend constexpr _Iterator
5946 operator+(difference_type __n, const _Iterator& __i)
5947 requires random_access_range<_Base>
5948 { return _Iterator(*__i._M_parent, __i._M_inner + __n); }
5949
5950 friend constexpr _Iterator
5951 operator-(const _Iterator& __i, difference_type __n)
5952 requires random_access_range<_Base>
5953 { return _Iterator(*__i._M_parent, __i._M_inner - __n); }
5954
5955 friend constexpr difference_type
5956 operator-(const _Iterator& __x, const _Iterator& __y)
5957 requires sized_sentinel_for<_InnerIter<_Const>, _InnerIter<_Const>>
5958 { return __x._M_inner - __y._M_inner; }
5959 };
5960
5961 template<forward_range _Vp, move_constructible _Fp, size_t _Nm>
5962 requires view<_Vp> && (_Nm > 0) && is_object_v<_Fp>
5963 && regular_invocable<__detail::__unarize<_Fp&, _Nm>, range_reference_t<_Vp>>
5964 && std::__detail::__can_reference<invoke_result_t<__detail::__unarize<_Fp&, _Nm>,
5965 range_reference_t<_Vp>>>
5966 template<bool _Const>
5967 class adjacent_transform_view<_Vp, _Fp, _Nm>::_Sentinel
5968 {
5969 _InnerSent<_Const> _M_inner;
5970
5971 constexpr explicit
5972 _Sentinel(_InnerSent<_Const> __inner)
5973 : _M_inner(__inner)
5974 { }
5975
5976 friend class adjacent_transform_view;
5977
5978 public:
5979 _Sentinel() = default;
5980
5981 constexpr
5982 _Sentinel(_Sentinel<!_Const> __i)
5983 requires _Const && convertible_to<_InnerSent<false>, _InnerSent<_Const>>
5984 : _M_inner(std::move(__i._M_inner))
5985 { }
5986
5987 template<bool _OtherConst>
5988 requires sentinel_for<_InnerSent<_Const>, _InnerIter<_OtherConst>>
5989 friend constexpr bool
5990 operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
5991 { return __x._M_inner == __y._M_inner; }
5992
5993 template<bool _OtherConst>
5994 requires sized_sentinel_for<_InnerSent<_Const>, _InnerIter<_OtherConst>>
5995 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
5996 operator-(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
5997 { return __x._M_inner - __y._M_inner; }
5998
5999 template<bool _OtherConst>
6000 requires sized_sentinel_for<_InnerSent<_Const>, _InnerIter<_OtherConst>>
6001 friend constexpr range_difference_t<__detail::__maybe_const_t<_OtherConst, _InnerView>>
6002 operator-(const _Sentinel& __x, const _Iterator<_OtherConst>& __y)
6003 { return __x._M_inner - __y._M_inner; }
6004 };
6005
6006 namespace views
6007 {
6008 namespace __detail
6009 {
6010 template<size_t _Nm, typename _Range, typename _Fp>
6011 concept __can_adjacent_transform_view
6012 = requires { adjacent_transform_view<all_t<_Range>, decay_t<_Fp>, _Nm>
6013 (std::declval<_Range>(), std::declval<_Fp>()); };
6014 }
6015
6016 template<size_t _Nm>
6017 struct _AdjacentTransform : __adaptor::_RangeAdaptor<_AdjacentTransform<_Nm>>
6018 {
6019 template<viewable_range _Range, typename _Fp>
6020 requires (_Nm == 0) || __detail::__can_adjacent_transform_view<_Nm, _Range, _Fp>
6021 constexpr auto
6022 operator() [[nodiscard]] (_Range&& __r, _Fp&& __f) const
6023 {
6024 if constexpr (_Nm == 0)
6025 return zip_transform(std::forward<_Fp>(__f));
6026 else
6027 return adjacent_transform_view<all_t<_Range>, decay_t<_Fp>, _Nm>
6028 (std::forward<_Range>(__r), std::forward<_Fp>(__f));
6029 }
6030
6031 using __adaptor::_RangeAdaptor<_AdjacentTransform>::operator();
6032 static constexpr int _S_arity = 2;
6033 static constexpr bool _S_has_simple_extra_args = true;
6034 };
6035
6036 template<size_t _Nm>
6037 inline constexpr _AdjacentTransform<_Nm> adjacent_transform;
6038
6039 inline constexpr auto pairwise_transform = adjacent_transform<2>;
6040 }
6041#endif // __cpp_lib_ranges_zip
6042
6043#ifdef __cpp_lib_ranges_chunk // C++ >= 23
6044 namespace __detail
6045 {
6046 template<typename _Tp>
6047 constexpr _Tp __div_ceil(_Tp __num, _Tp __denom)
6048 {
6049 _Tp __r = __num / __denom;
6050 if (__num % __denom)
6051 ++__r;
6052 return __r;
6053 }
6054 }
6055
6056 template<view _Vp>
6057 requires input_range<_Vp>
6058 class chunk_view : public view_interface<chunk_view<_Vp>>
6059 {
6060 _Vp _M_base;
6061 range_difference_t<_Vp> _M_n;
6062 range_difference_t<_Vp> _M_remainder = 0;
6063 __detail::__non_propagating_cache<iterator_t<_Vp>> _M_current;
6064
6065 class _OuterIter;
6066 class _InnerIter;
6067
6068 public:
6069 constexpr explicit
6070 chunk_view(_Vp __base, range_difference_t<_Vp> __n)
6071 : _M_base(std::move(__base)), _M_n(__n)
6072 { __glibcxx_assert(__n >= 0); }
6073
6074 constexpr _Vp
6075 base() const & requires copy_constructible<_Vp>
6076 { return _M_base; }
6077
6078 constexpr _Vp
6079 base() &&
6080 { return std::move(_M_base); }
6081
6082 constexpr _OuterIter
6083 begin()
6084 {
6085 _M_current = ranges::begin(_M_base);
6086 _M_remainder = _M_n;
6087 return _OuterIter(*this);
6088 }
6089
6090 constexpr default_sentinel_t
6091 end() const noexcept
6092 { return default_sentinel; }
6093
6094 constexpr auto
6095 size() requires sized_range<_Vp>
6096 {
6097 return __detail::__to_unsigned_like(__detail::__div_ceil
6098 (ranges::distance(_M_base), _M_n));
6099 }
6100
6101 constexpr auto
6102 size() const requires sized_range<const _Vp>
6103 {
6104 return __detail::__to_unsigned_like(__detail::__div_ceil
6105 (ranges::distance(_M_base), _M_n));
6106 }
6107 };
6108
6109 template<typename _Range>
6110 chunk_view(_Range&&, range_difference_t<_Range>) -> chunk_view<views::all_t<_Range>>;
6111
6112 template<view _Vp>
6113 requires input_range<_Vp>
6114 class chunk_view<_Vp>::_OuterIter
6115 {
6116 chunk_view* _M_parent;
6117
6118 constexpr explicit
6119 _OuterIter(chunk_view& __parent) noexcept
6120 : _M_parent(std::__addressof(__parent))
6121 { }
6122
6123 friend chunk_view;
6124
6125 public:
6126 using iterator_concept = input_iterator_tag;
6127 using difference_type = range_difference_t<_Vp>;
6128
6129 struct value_type;
6130
6131 _OuterIter(_OuterIter&&) = default;
6132 _OuterIter& operator=(_OuterIter&&) = default;
6133
6134 constexpr value_type
6135 operator*() const
6136 {
6137 __glibcxx_assert(*this != default_sentinel);
6138 return value_type(*_M_parent);
6139 }
6140
6141 constexpr _OuterIter&
6142 operator++()
6143 {
6144 __glibcxx_assert(*this != default_sentinel);
6145 ranges::advance(*_M_parent->_M_current, _M_parent->_M_remainder,
6146 ranges::end(_M_parent->_M_base));
6147 _M_parent->_M_remainder = _M_parent->_M_n;
6148 return *this;
6149 }
6150
6151 constexpr void
6152 operator++(int)
6153 { ++*this; }
6154
6155 friend constexpr bool
6156 operator==(const _OuterIter& __x, default_sentinel_t)
6157 {
6158 return *__x._M_parent->_M_current == ranges::end(__x._M_parent->_M_base)
6159 && __x._M_parent->_M_remainder != 0;
6160 }
6161
6162 friend constexpr difference_type
6163 operator-(default_sentinel_t, const _OuterIter& __x)
6164 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6165 {
6166 const auto __dist = ranges::end(__x._M_parent->_M_base) - *__x._M_parent->_M_current;
6167
6168 if (__dist < __x._M_parent->_M_remainder)
6169 return __dist == 0 ? 0 : 1;
6170
6171 return 1 + __detail::__div_ceil(__dist - __x._M_parent->_M_remainder,
6172 __x._M_parent->_M_n);
6173 }
6174
6175 friend constexpr difference_type
6176 operator-(const _OuterIter& __x, default_sentinel_t __y)
6177 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6178 { return -(__y - __x); }
6179 };
6180
6181 template<view _Vp>
6182 requires input_range<_Vp>
6183 struct chunk_view<_Vp>::_OuterIter::value_type : view_interface<value_type>
6184 {
6185 private:
6186 chunk_view* _M_parent;
6187
6188 constexpr explicit
6189 value_type(chunk_view& __parent) noexcept
6190 : _M_parent(std::__addressof(__parent))
6191 { }
6192
6193 friend _OuterIter;
6194
6195 public:
6196 constexpr _InnerIter
6197 begin() const noexcept
6198 { return _InnerIter(*_M_parent); }
6199
6200 constexpr default_sentinel_t
6201 end() const noexcept
6202 { return default_sentinel; }
6203
6204 constexpr auto
6205 size() const
6206 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6207 {
6208 return __detail::__to_unsigned_like
6209 (ranges::min(_M_parent->_M_remainder,
6210 ranges::end(_M_parent->_M_base) - *_M_parent->_M_current));
6211 }
6212 };
6213
6214 template<view _Vp>
6215 requires input_range<_Vp>
6216 class chunk_view<_Vp>::_InnerIter
6217 {
6218 chunk_view* _M_parent;
6219
6220 constexpr explicit
6221 _InnerIter(chunk_view& __parent) noexcept
6222 : _M_parent(std::__addressof(__parent))
6223 { }
6224
6225 friend _OuterIter::value_type;
6226
6227 public:
6228 using iterator_concept = input_iterator_tag;
6229 using difference_type = range_difference_t<_Vp>;
6230 using value_type = range_value_t<_Vp>;
6231
6232 _InnerIter(_InnerIter&&) = default;
6233 _InnerIter& operator=(_InnerIter&&) = default;
6234
6235 constexpr const iterator_t<_Vp>&
6236 base() const &
6237 { return *_M_parent->_M_current; }
6238
6239 constexpr range_reference_t<_Vp>
6240 operator*() const
6241 {
6242 __glibcxx_assert(*this != default_sentinel);
6243 return **_M_parent->_M_current;
6244 }
6245
6246 constexpr _InnerIter&
6247 operator++()
6248 {
6249 __glibcxx_assert(*this != default_sentinel);
6250 ++*_M_parent->_M_current;
6251 if (*_M_parent->_M_current == ranges::end(_M_parent->_M_base))
6252 _M_parent->_M_remainder = 0;
6253 else
6254 --_M_parent->_M_remainder;
6255 return *this;
6256 }
6257
6258 constexpr void
6259 operator++(int)
6260 { ++*this; }
6261
6262 friend constexpr bool
6263 operator==(const _InnerIter& __x, default_sentinel_t) noexcept
6264 { return __x._M_parent->_M_remainder == 0; }
6265
6266 friend constexpr difference_type
6267 operator-(default_sentinel_t, const _InnerIter& __x)
6268 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6269 {
6270 return ranges::min(__x._M_parent->_M_remainder,
6271 ranges::end(__x._M_parent->_M_base) - *__x._M_parent->_M_current);
6272 }
6273
6274 friend constexpr difference_type
6275 operator-(const _InnerIter& __x, default_sentinel_t __y)
6276 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6277 { return -(__y - __x); }
6278
6279 // _GLIBCXX_RESOLVE_LIB_DEFECTS
6280 // 3851. chunk_view::inner-iterator missing custom iter_move and iter_swap
6281 friend constexpr range_rvalue_reference_t<_Vp>
6282 iter_move(const _InnerIter& __i)
6283 noexcept(noexcept(ranges::iter_move(*__i._M_parent->_M_current)))
6284 { return ranges::iter_move(*__i._M_parent->_M_current); }
6285
6286 friend constexpr void
6287 iter_swap(const _InnerIter& __x, const _InnerIter& __y)
6288 noexcept(noexcept(ranges::iter_swap(*__x._M_parent->_M_current,
6289 *__x._M_parent->_M_current)))
6290 requires indirectly_swappable<iterator_t<_Vp>>
6291 { return ranges::iter_swap(*__x._M_parent->_M_current, *__y._M_parent->_M_current); }
6292 };
6293
6294 template<view _Vp>
6295 requires forward_range<_Vp>
6296 class chunk_view<_Vp> : public view_interface<chunk_view<_Vp>>
6297 {
6298 _Vp _M_base;
6299 range_difference_t<_Vp> _M_n;
6300 template<bool> class _Iterator;
6301
6302 public:
6303 constexpr explicit
6304 chunk_view(_Vp __base, range_difference_t<_Vp> __n)
6305 : _M_base(std::move(__base)), _M_n(__n)
6306 { __glibcxx_assert(__n > 0); }
6307
6308 constexpr _Vp
6309 base() const & requires copy_constructible<_Vp>
6310 { return _M_base; }
6311
6312 constexpr _Vp
6313 base() &&
6314 { return std::move(_M_base); }
6315
6316 constexpr auto
6317 begin() requires (!__detail::__simple_view<_Vp>)
6318 { return _Iterator<false>(this, ranges::begin(_M_base)); }
6319
6320 constexpr auto
6321 begin() const requires forward_range<const _Vp>
6322 { return _Iterator<true>(this, ranges::begin(_M_base)); }
6323
6324 constexpr auto
6325 end() requires (!__detail::__simple_view<_Vp>)
6326 {
6327 if constexpr (common_range<_Vp> && sized_range<_Vp>)
6328 {
6329 auto __missing = (_M_n - ranges::distance(_M_base) % _M_n) % _M_n;
6330 return _Iterator<false>(this, ranges::end(_M_base), __missing);
6331 }
6332 else if constexpr (common_range<_Vp> && !bidirectional_range<_Vp>)
6333 return _Iterator<false>(this, ranges::end(_M_base));
6334 else
6335 return default_sentinel;
6336 }
6337
6338 constexpr auto
6339 end() const requires forward_range<const _Vp>
6340 {
6341 if constexpr (common_range<const _Vp> && sized_range<const _Vp>)
6342 {
6343 auto __missing = (_M_n - ranges::distance(_M_base) % _M_n) % _M_n;
6344 return _Iterator<true>(this, ranges::end(_M_base), __missing);
6345 }
6346 else if constexpr (common_range<const _Vp> && !bidirectional_range<const _Vp>)
6347 return _Iterator<true>(this, ranges::end(_M_base));
6348 else
6349 return default_sentinel;
6350 }
6351
6352 constexpr auto
6353 size() requires sized_range<_Vp>
6354 {
6355 return __detail::__to_unsigned_like(__detail::__div_ceil
6356 (ranges::distance(_M_base), _M_n));
6357 }
6358
6359 constexpr auto
6360 size() const requires sized_range<const _Vp>
6361 {
6362 return __detail::__to_unsigned_like(__detail::__div_ceil
6363 (ranges::distance(_M_base), _M_n));
6364 }
6365 };
6366
6367 template<typename _Vp>
6368 inline constexpr bool enable_borrowed_range<chunk_view<_Vp>>
6369 = forward_range<_Vp> && enable_borrowed_range<_Vp>;
6370
6371 template<view _Vp>
6372 requires forward_range<_Vp>
6373 template<bool _Const>
6374 class chunk_view<_Vp>::_Iterator
6375 {
6376 using _Parent = __detail::__maybe_const_t<_Const, chunk_view>;
6377 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
6378
6379 iterator_t<_Base> _M_current = iterator_t<_Base>();
6380 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
6381 range_difference_t<_Base> _M_n = 0;
6382 range_difference_t<_Base> _M_missing = 0;
6383
6384 constexpr
6385 _Iterator(_Parent* __parent, iterator_t<_Base> __current,
6386 range_difference_t<_Base> __missing = 0)
6387 : _M_current(__current), _M_end(ranges::end(__parent->_M_base)),
6388 _M_n(__parent->_M_n), _M_missing(__missing)
6389 { }
6390
6391 static auto
6392 _S_iter_cat()
6393 {
6394 if constexpr (random_access_range<_Base>)
6395 return random_access_iterator_tag{};
6396 else if constexpr (bidirectional_range<_Base>)
6397 return bidirectional_iterator_tag{};
6398 else
6399 return forward_iterator_tag{};
6400 }
6401
6402 friend chunk_view;
6403
6404 public:
6405 using iterator_category = input_iterator_tag;
6406 using iterator_concept = decltype(_S_iter_cat());
6407 using value_type = decltype(views::take(subrange(_M_current, _M_end), _M_n));
6408 using difference_type = range_difference_t<_Base>;
6409
6410 _Iterator() = default;
6411
6412 constexpr _Iterator(_Iterator<!_Const> __i)
6413 requires _Const
6414 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
6415 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
6416 : _M_current(std::move(__i._M_current)), _M_end(std::move(__i._M_end)),
6417 _M_n(__i._M_n), _M_missing(__i._M_missing)
6418 { }
6419
6420 constexpr iterator_t<_Base>
6421 base() const
6422 { return _M_current; }
6423
6424 constexpr value_type
6425 operator*() const
6426 {
6427 __glibcxx_assert(_M_current != _M_end);
6428 return views::take(subrange(_M_current, _M_end), _M_n);
6429 }
6430
6431 constexpr _Iterator&
6432 operator++()
6433 {
6434 __glibcxx_assert(_M_current != _M_end);
6435 _M_missing = ranges::advance(_M_current, _M_n, _M_end);
6436 return *this;
6437 }
6438
6439 constexpr _Iterator
6440 operator++(int)
6441 {
6442 auto __tmp = *this;
6443 ++*this;
6444 return __tmp;
6445 }
6446
6447 constexpr _Iterator&
6448 operator--() requires bidirectional_range<_Base>
6449 {
6450 ranges::advance(_M_current, _M_missing - _M_n);
6451 _M_missing = 0;
6452 return *this;
6453 }
6454
6455 constexpr _Iterator
6456 operator--(int) requires bidirectional_range<_Base>
6457 {
6458 auto __tmp = *this;
6459 --*this;
6460 return __tmp;
6461 }
6462
6463 constexpr _Iterator&
6464 operator+=(difference_type __x)
6465 requires random_access_range<_Base>
6466 {
6467 if (__x > 0)
6468 {
6469 __glibcxx_assert(ranges::distance(_M_current, _M_end) > _M_n * (__x - 1));
6470 _M_missing = ranges::advance(_M_current, _M_n * __x, _M_end);
6471 }
6472 else if (__x < 0)
6473 {
6474 ranges::advance(_M_current, _M_n * __x + _M_missing);
6475 _M_missing = 0;
6476 }
6477 return *this;
6478 }
6479
6480 constexpr _Iterator&
6481 operator-=(difference_type __x)
6482 requires random_access_range<_Base>
6483 { return *this += -__x; }
6484
6485 constexpr value_type
6486 operator[](difference_type __n) const
6487 requires random_access_range<_Base>
6488 { return *(*this + __n); }
6489
6490 friend constexpr bool
6491 operator==(const _Iterator& __x, const _Iterator& __y)
6492 { return __x._M_current == __y._M_current; }
6493
6494 friend constexpr bool
6495 operator==(const _Iterator& __x, default_sentinel_t)
6496 { return __x._M_current == __x._M_end; }
6497
6498 friend constexpr bool
6499 operator<(const _Iterator& __x, const _Iterator& __y)
6500 requires random_access_range<_Base>
6501 { return __x._M_current > __y._M_current; }
6502
6503 friend constexpr bool
6504 operator>(const _Iterator& __x, const _Iterator& __y)
6505 requires random_access_range<_Base>
6506 { return __y < __x; }
6507
6508 friend constexpr bool
6509 operator<=(const _Iterator& __x, const _Iterator& __y)
6510 requires random_access_range<_Base>
6511 { return !(__y < __x); }
6512
6513 friend constexpr bool
6514 operator>=(const _Iterator& __x, const _Iterator& __y)
6515 requires random_access_range<_Base>
6516 { return !(__x < __y); }
6517
6518 friend constexpr auto
6519 operator<=>(const _Iterator& __x, const _Iterator& __y)
6520 requires random_access_range<_Base>
6521 && three_way_comparable<iterator_t<_Base>>
6522 { return __x._M_current <=> __y._M_current; }
6523
6524 friend constexpr _Iterator
6525 operator+(const _Iterator& __i, difference_type __n)
6526 requires random_access_range<_Base>
6527 {
6528 auto __r = __i;
6529 __r += __n;
6530 return __r;
6531 }
6532
6533 friend constexpr _Iterator
6534 operator+(difference_type __n, const _Iterator& __i)
6535 requires random_access_range<_Base>
6536 {
6537 auto __r = __i;
6538 __r += __n;
6539 return __r;
6540 }
6541
6542 friend constexpr _Iterator
6543 operator-(const _Iterator& __i, difference_type __n)
6544 requires random_access_range<_Base>
6545 {
6546 auto __r = __i;
6547 __r -= __n;
6548 return __r;
6549 }
6550
6551 friend constexpr difference_type
6552 operator-(const _Iterator& __x, const _Iterator& __y)
6553 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
6554 {
6555 return (__x._M_current - __y._M_current
6556 + __x._M_missing - __y._M_missing) / __x._M_n;
6557 }
6558
6559 friend constexpr difference_type
6560 operator-(default_sentinel_t __y, const _Iterator& __x)
6561 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
6562 { return __detail::__div_ceil(__x._M_end - __x._M_current, __x._M_n); }
6563
6564 friend constexpr difference_type
6565 operator-(const _Iterator& __x, default_sentinel_t __y)
6566 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
6567 { return -(__y - __x); }
6568 };
6569
6570 namespace views
6571 {
6572 namespace __detail
6573 {
6574 template<typename _Range, typename _Dp>
6575 concept __can_chunk_view
6576 = requires { chunk_view(std::declval<_Range>(), std::declval<_Dp>()); };
6577 }
6578
6579 struct _Chunk : __adaptor::_RangeAdaptor<_Chunk>
6580 {
6581 template<viewable_range _Range, typename _Dp = range_difference_t<_Range>>
6582 requires __detail::__can_chunk_view<_Range, _Dp>
6583 constexpr auto
6584 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n) const
6585 { return chunk_view(std::forward<_Range>(__r), __n); }
6586
6587 using __adaptor::_RangeAdaptor<_Chunk>::operator();
6588 static constexpr int _S_arity = 2;
6589 static constexpr bool _S_has_simple_extra_args = true;
6590 };
6591
6592 inline constexpr _Chunk chunk;
6593 }
6594#endif // __cpp_lib_ranges_chunk
6595
6596#ifdef __cpp_lib_ranges_slide // C++ >= 23
6597 namespace __detail
6598 {
6599 template<typename _Vp>
6600 concept __slide_caches_nothing = random_access_range<_Vp> && sized_range<_Vp>;
6601
6602 template<typename _Vp>
6603 concept __slide_caches_last
6604 = !__slide_caches_nothing<_Vp> && bidirectional_range<_Vp> && common_range<_Vp>;
6605
6606 template<typename _Vp>
6607 concept __slide_caches_first
6608 = !__slide_caches_nothing<_Vp> && !__slide_caches_last<_Vp>;
6609 }
6610
6611 template<forward_range _Vp>
6612 requires view<_Vp>
6613 class slide_view : public view_interface<slide_view<_Vp>>
6614 {
6615 _Vp _M_base;
6616 range_difference_t<_Vp> _M_n;
6617 [[no_unique_address]]
6618 __detail::__maybe_present_t<__detail::__slide_caches_first<_Vp>,
6619 __detail::_CachedPosition<_Vp>, 0> _M_cached_begin;
6620 [[no_unique_address]]
6621 __detail::__maybe_present_t<__detail::__slide_caches_last<_Vp>,
6622 __detail::_CachedPosition<_Vp>, 1> _M_cached_end;
6623
6624 template<bool> class _Iterator;
6625 class _Sentinel;
6626
6627 public:
6628 constexpr explicit
6629 slide_view(_Vp __base, range_difference_t<_Vp> __n)
6630 : _M_base(std::move(__base)), _M_n(__n)
6631 { __glibcxx_assert(__n > 0); }
6632
6633 // _GLIBCXX_RESOLVE_LIB_DEFECTS
6634 // 3848. adjacent_view, adjacent_transform_view and slide_view missing base accessor
6635 constexpr _Vp
6636 base() const & requires copy_constructible<_Vp>
6637 { return _M_base; }
6638
6639 constexpr _Vp
6640 base() &&
6641 { return std::move(_M_base); }
6642
6643 constexpr auto
6644 begin() requires (!(__detail::__simple_view<_Vp>
6645 && __detail::__slide_caches_nothing<const _Vp>))
6646 {
6647 if constexpr (__detail::__slide_caches_first<_Vp>)
6648 {
6649 iterator_t<_Vp> __it;
6650 if (_M_cached_begin._M_has_value())
6651 __it = _M_cached_begin._M_get(_M_base);
6652 else
6653 {
6654 __it = ranges::next(ranges::begin(_M_base), _M_n - 1, ranges::end(_M_base));
6655 _M_cached_begin._M_set(_M_base, __it);
6656 }
6657 return _Iterator<false>(ranges::begin(_M_base), std::move(__it), _M_n);
6658 }
6659 else
6660 return _Iterator<false>(ranges::begin(_M_base), _M_n);
6661 }
6662
6663 constexpr auto
6664 begin() const requires __detail::__slide_caches_nothing<const _Vp>
6665 { return _Iterator<true>(ranges::begin(_M_base), _M_n); }
6666
6667 constexpr auto
6668 end() requires (!(__detail::__simple_view<_Vp>
6669 && __detail::__slide_caches_nothing<const _Vp>))
6670 {
6671 if constexpr (__detail::__slide_caches_nothing<_Vp>)
6672 return _Iterator<false>(ranges::begin(_M_base) + range_difference_t<_Vp>(size()),
6673 _M_n);
6674 else if constexpr (__detail::__slide_caches_last<_Vp>)
6675 {
6676 iterator_t<_Vp> __it;
6677 if (_M_cached_end._M_has_value())
6678 __it = _M_cached_end._M_get(_M_base);
6679 else
6680 {
6681 __it = ranges::prev(ranges::end(_M_base), _M_n - 1, ranges::begin(_M_base));
6682 _M_cached_end._M_set(_M_base, __it);
6683 }
6684 return _Iterator<false>(std::move(__it), _M_n);
6685 }
6686 else if constexpr (common_range<_Vp>)
6687 return _Iterator<false>(ranges::end(_M_base), ranges::end(_M_base), _M_n);
6688 else
6689 return _Sentinel(ranges::end(_M_base));
6690 }
6691
6692 constexpr auto
6693 end() const requires __detail::__slide_caches_nothing<const _Vp>
6694 { return begin() + range_difference_t<const _Vp>(size()); }
6695
6696 constexpr auto
6697 size() requires sized_range<_Vp>
6698 {
6699 auto __sz = ranges::distance(_M_base) - _M_n + 1;
6700 if (__sz < 0)
6701 __sz = 0;
6702 return __detail::__to_unsigned_like(__sz);
6703 }
6704
6705 constexpr auto
6706 size() const requires sized_range<const _Vp>
6707 {
6708 auto __sz = ranges::distance(_M_base) - _M_n + 1;
6709 if (__sz < 0)
6710 __sz = 0;
6711 return __detail::__to_unsigned_like(__sz);
6712 }
6713 };
6714
6715 template<typename _Range>
6716 slide_view(_Range&&, range_difference_t<_Range>) -> slide_view<views::all_t<_Range>>;
6717
6718 template<typename _Vp>
6719 inline constexpr bool enable_borrowed_range<slide_view<_Vp>>
6720 = enable_borrowed_range<_Vp>;
6721
6722 template<forward_range _Vp>
6723 requires view<_Vp>
6724 template<bool _Const>
6725 class slide_view<_Vp>::_Iterator
6726 {
6727 using _Base = __detail::__maybe_const_t<_Const, _Vp>;
6728 static constexpr bool _S_last_elt_present
6729 = __detail::__slide_caches_first<_Base>;
6730
6731 iterator_t<_Base> _M_current = iterator_t<_Base>();
6732 [[no_unique_address]]
6733 __detail::__maybe_present_t<_S_last_elt_present, iterator_t<_Base>>
6734 _M_last_elt = decltype(_M_last_elt)();
6735 range_difference_t<_Base> _M_n = 0;
6736
6737 constexpr
6738 _Iterator(iterator_t<_Base> __current, range_difference_t<_Base> __n)
6739 requires (!_S_last_elt_present)
6740 : _M_current(__current), _M_n(__n)
6741 { }
6742
6743 constexpr
6744 _Iterator(iterator_t<_Base> __current, iterator_t<_Base> __last_elt,
6745 range_difference_t<_Base> __n)
6746 requires _S_last_elt_present
6747 : _M_current(__current), _M_last_elt(__last_elt), _M_n(__n)
6748 { }
6749
6750 static auto
6751 _S_iter_concept()
6752 {
6753 if constexpr (random_access_range<_Base>)
6754 return random_access_iterator_tag{};
6755 else if constexpr (bidirectional_range<_Base>)
6756 return bidirectional_iterator_tag{};
6757 else
6758 return forward_iterator_tag{};
6759 }
6760
6761 friend slide_view;
6762 friend slide_view::_Sentinel;
6763
6764 public:
6765 using iterator_category = input_iterator_tag;
6766 using iterator_concept = decltype(_S_iter_concept());
6767 using value_type = decltype(views::counted(_M_current, _M_n));
6768 using difference_type = range_difference_t<_Base>;
6769
6770 _Iterator() = default;
6771
6772 constexpr
6773 _Iterator(_Iterator<!_Const> __i)
6774 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
6775 : _M_current(std::move(__i._M_current)), _M_n(__i._M_n)
6776 { }
6777
6778 constexpr auto
6779 operator*() const
6780 { return views::counted(_M_current, _M_n); }
6781
6782 constexpr _Iterator&
6783 operator++()
6784 {
6785 ++_M_current;
6786 if constexpr (_S_last_elt_present)
6787 ++_M_last_elt;
6788 return *this;
6789 }
6790
6791 constexpr _Iterator
6792 operator++(int)
6793 {
6794 auto __tmp = *this;
6795 ++*this;
6796 return __tmp;
6797 }
6798
6799 constexpr _Iterator&
6800 operator--() requires bidirectional_range<_Base>
6801 {
6802 --_M_current;
6803 if constexpr (_S_last_elt_present)
6804 --_M_last_elt;
6805 return *this;
6806 }
6807
6808 constexpr _Iterator
6809 operator--(int) requires bidirectional_range<_Base>
6810 {
6811 auto __tmp = *this;
6812 --*this;
6813 return __tmp;
6814 }
6815
6816 constexpr _Iterator&
6817 operator+=(difference_type __x)
6818 requires random_access_range<_Base>
6819 {
6820 _M_current += __x;
6821 if constexpr (_S_last_elt_present)
6822 _M_last_elt += __x;
6823 return *this;
6824 }
6825
6826 constexpr _Iterator&
6827 operator-=(difference_type __x)
6828 requires random_access_range<_Base>
6829 {
6830 _M_current -= __x;
6831 if constexpr (_S_last_elt_present)
6832 _M_last_elt -= __x;
6833 return *this;
6834 }
6835
6836 constexpr auto
6837 operator[](difference_type __n) const
6838 requires random_access_range<_Base>
6839 { return views::counted(_M_current + __n, _M_n); }
6840
6841 friend constexpr bool
6842 operator==(const _Iterator& __x, const _Iterator& __y)
6843 {
6844 if constexpr (_S_last_elt_present)
6845 return __x._M_last_elt == __y._M_last_elt;
6846 else
6847 return __x._M_current == __y._M_current;
6848 }
6849
6850 friend constexpr bool
6851 operator<(const _Iterator& __x, const _Iterator& __y)
6852 requires random_access_range<_Base>
6853 { return __x._M_current < __y._M_current; }
6854
6855 friend constexpr bool
6856 operator>(const _Iterator& __x, const _Iterator& __y)
6857 requires random_access_range<_Base>
6858 { return __y < __x; }
6859
6860 friend constexpr bool
6861 operator<=(const _Iterator& __x, const _Iterator& __y)
6862 requires random_access_range<_Base>
6863 { return !(__y < __x); }
6864
6865 friend constexpr bool
6866 operator>=(const _Iterator& __x, const _Iterator& __y)
6867 requires random_access_range<_Base>
6868 { return !(__x < __y); }
6869
6870 friend constexpr auto
6871 operator<=>(const _Iterator& __x, const _Iterator& __y)
6872 requires random_access_range<_Base>
6873 && three_way_comparable<iterator_t<_Base>>
6874 { return __x._M_current <=> __y._M_current; }
6875
6876 friend constexpr _Iterator
6877 operator+(const _Iterator& __i, difference_type __n)
6878 requires random_access_range<_Base>
6879 {
6880 auto __r = __i;
6881 __r += __n;
6882 return __r;
6883 }
6884
6885 friend constexpr _Iterator
6886 operator+(difference_type __n, const _Iterator& __i)
6887 requires random_access_range<_Base>
6888 {
6889 auto __r = __i;
6890 __r += __n;
6891 return __r;
6892 }
6893
6894 friend constexpr _Iterator
6895 operator-(const _Iterator& __i, difference_type __n)
6896 requires random_access_range<_Base>
6897 {
6898 auto __r = __i;
6899 __r -= __n;
6900 return __r;
6901 }
6902
6903 friend constexpr difference_type
6904 operator-(const _Iterator& __x, const _Iterator& __y)
6905 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
6906 {
6907 if constexpr (_S_last_elt_present)
6908 return __x._M_last_elt - __y._M_last_elt;
6909 else
6910 return __x._M_current - __y._M_current;
6911 }
6912 };
6913
6914 template<forward_range _Vp>
6915 requires view<_Vp>
6916 class slide_view<_Vp>::_Sentinel
6917 {
6918 sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
6919
6920 constexpr explicit
6921 _Sentinel(sentinel_t<_Vp> __end)
6922 : _M_end(__end)
6923 { }
6924
6925 friend slide_view;
6926
6927 public:
6928 _Sentinel() = default;
6929
6930 friend constexpr bool
6931 operator==(const _Iterator<false>& __x, const _Sentinel& __y)
6932 { return __x._M_last_elt == __y._M_end; }
6933
6934 friend constexpr range_difference_t<_Vp>
6935 operator-(const _Iterator<false>& __x, const _Sentinel& __y)
6936 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6937 { return __x._M_last_elt - __y._M_end; }
6938
6939 friend constexpr range_difference_t<_Vp>
6940 operator-(const _Sentinel& __y, const _Iterator<false>& __x)
6941 requires sized_sentinel_for<sentinel_t<_Vp>, iterator_t<_Vp>>
6942 { return __y._M_end -__x._M_last_elt; }
6943 };
6944
6945 namespace views
6946 {
6947 namespace __detail
6948 {
6949 template<typename _Range, typename _Dp>
6950 concept __can_slide_view
6951 = requires { slide_view(std::declval<_Range>(), std::declval<_Dp>()); };
6952 }
6953
6954 struct _Slide : __adaptor::_RangeAdaptor<_Slide>
6955 {
6956 template<viewable_range _Range, typename _Dp = range_difference_t<_Range>>
6957 requires __detail::__can_slide_view<_Range, _Dp>
6958 constexpr auto
6959 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n) const
6960 { return slide_view(std::forward<_Range>(__r), __n); }
6961
6962 using __adaptor::_RangeAdaptor<_Slide>::operator();
6963 static constexpr int _S_arity = 2;
6964 static constexpr bool _S_has_simple_extra_args = true;
6965 };
6966
6967 inline constexpr _Slide slide;
6968 }
6969#endif // __cpp_lib_ranges_slide
6970
6971#ifdef __cpp_lib_ranges_chunk_by // C++ >= 23
6972 template<forward_range _Vp,
6973 indirect_binary_predicate<iterator_t<_Vp>, iterator_t<_Vp>> _Pred>
6974 requires view<_Vp> && is_object_v<_Pred>
6975 class chunk_by_view : public view_interface<chunk_by_view<_Vp, _Pred>>
6976 {
6977 _Vp _M_base = _Vp();
6978 __detail::__box<_Pred> _M_pred;
6979 __detail::_CachedPosition<_Vp> _M_cached_begin;
6980
6981 constexpr iterator_t<_Vp>
6982 _M_find_next(iterator_t<_Vp> __current)
6983 {
6984 __glibcxx_assert(_M_pred.has_value());
6985 auto __pred = [this]<typename _Tp, typename _Up>(_Tp&& __x, _Up&& __y) {
6986 return !bool((*_M_pred)(std::forward<_Tp>(__x), std::forward<_Up>(__y)));
6987 };
6988 auto __it = ranges::adjacent_find(__current, ranges::end(_M_base), __pred);
6989 return ranges::next(__it, 1, ranges::end(_M_base));
6990 }
6991
6992 constexpr iterator_t<_Vp>
6993 _M_find_prev(iterator_t<_Vp> __current) requires bidirectional_range<_Vp>
6994 {
6995 __glibcxx_assert(_M_pred.has_value());
6996 auto __pred = [this]<typename _Tp, typename _Up>(_Tp&& __x, _Up&& __y) {
6997 return !bool((*_M_pred)(std::forward<_Up>(__y), std::forward<_Tp>(__x)));
6998 };
6999 auto __rbegin = std::make_reverse_iterator(__current);
7000 auto __rend = std::make_reverse_iterator(ranges::begin(_M_base));
7001 __glibcxx_assert(__rbegin != __rend);
7002 auto __it = ranges::adjacent_find(__rbegin, __rend, __pred).base();
7003 return ranges::prev(__it, 1, ranges::begin(_M_base));
7004 }
7005
7006 class _Iterator;
7007
7008 public:
7009 chunk_by_view() requires (default_initializable<_Vp>
7010 && default_initializable<_Pred>)
7011 = default;
7012
7013 constexpr explicit
7014 chunk_by_view(_Vp __base, _Pred __pred)
7015 : _M_base(std::move(__base)), _M_pred(std::move(__pred))
7016 { }
7017
7018 constexpr _Vp
7019 base() const & requires copy_constructible<_Vp>
7020 { return _M_base; }
7021
7022 constexpr _Vp
7023 base() &&
7024 { return std::move(_M_base); }
7025
7026 constexpr const _Pred&
7027 pred() const
7028 { return *_M_pred; }
7029
7030 constexpr _Iterator
7031 begin()
7032 {
7033 __glibcxx_assert(_M_pred.has_value());
7034 iterator_t<_Vp> __it;
7035 if (_M_cached_begin._M_has_value())
7036 __it = _M_cached_begin._M_get(_M_base);
7037 else
7038 {
7039 __it = _M_find_next(ranges::begin(_M_base));
7040 _M_cached_begin._M_set(_M_base, __it);
7041 }
7042 return _Iterator(*this, ranges::begin(_M_base), __it);
7043 }
7044
7045 constexpr auto
7046 end()
7047 {
7048 if constexpr (common_range<_Vp>)
7049 return _Iterator(*this, ranges::end(_M_base), ranges::end(_M_base));
7050 else
7051 return default_sentinel;
7052 }
7053 };
7054
7055 template<typename _Range, typename _Pred>
7056 chunk_by_view(_Range&&, _Pred) -> chunk_by_view<views::all_t<_Range>, _Pred>;
7057
7058 template<forward_range _Vp,
7059 indirect_binary_predicate<iterator_t<_Vp>, iterator_t<_Vp>> _Pred>
7060 requires view<_Vp> && is_object_v<_Pred>
7061 class chunk_by_view<_Vp, _Pred>::_Iterator
7062 {
7063 chunk_by_view* _M_parent = nullptr;
7064 iterator_t<_Vp> _M_current = iterator_t<_Vp>();
7065 iterator_t<_Vp> _M_next = iterator_t<_Vp>();
7066
7067 constexpr
7068 _Iterator(chunk_by_view& __parent, iterator_t<_Vp> __current, iterator_t<_Vp> __next)
7069 : _M_parent(std::__addressof(__parent)), _M_current(__current), _M_next(__next)
7070 { }
7071
7072 static auto
7073 _S_iter_concept()
7074 {
7075 if constexpr (bidirectional_range<_Vp>)
7076 return bidirectional_iterator_tag{};
7077 else
7078 return forward_iterator_tag{};
7079 }
7080
7081 friend chunk_by_view;
7082
7083 public:
7084 using value_type = subrange<iterator_t<_Vp>>;
7085 using difference_type = range_difference_t<_Vp>;
7086 using iterator_category = input_iterator_tag;
7087 using iterator_concept = decltype(_S_iter_concept());
7088
7089 _Iterator() = default;
7090
7091 constexpr value_type
7092 operator*() const
7093 {
7094 __glibcxx_assert(_M_current != _M_next);
7095 return ranges::subrange(_M_current, _M_next);
7096 }
7097
7098 constexpr _Iterator&
7099 operator++()
7100 {
7101 __glibcxx_assert(_M_current != _M_next);
7102 _M_current = _M_next;
7103 _M_next = _M_parent->_M_find_next(_M_current);
7104 return *this;
7105 }
7106
7107 constexpr _Iterator
7108 operator++(int)
7109 {
7110 auto __tmp = *this;
7111 ++*this;
7112 return __tmp;
7113 }
7114
7115 constexpr _Iterator&
7116 operator--() requires bidirectional_range<_Vp>
7117 {
7118 _M_next = _M_current;
7119 _M_current = _M_parent->_M_find_prev(_M_next);
7120 return *this;
7121 }
7122
7123 constexpr _Iterator
7124 operator--(int) requires bidirectional_range<_Vp>
7125 {
7126 auto __tmp = *this;
7127 --*this;
7128 return __tmp;
7129 }
7130
7131 friend constexpr bool
7132 operator==(const _Iterator& __x, const _Iterator& __y)
7133 { return __x._M_current == __y._M_current; }
7134
7135 friend constexpr bool
7136 operator==(const _Iterator& __x, default_sentinel_t)
7137 { return __x._M_current == __x._M_next; }
7138 };
7139
7140 namespace views
7141 {
7142 namespace __detail
7143 {
7144 template<typename _Range, typename _Pred>
7145 concept __can_chunk_by_view
7146 = requires { chunk_by_view(std::declval<_Range>(), std::declval<_Pred>()); };
7147 }
7148
7149 struct _ChunkBy : __adaptor::_RangeAdaptor<_ChunkBy>
7150 {
7151 template<viewable_range _Range, typename _Pred>
7152 requires __detail::__can_chunk_by_view<_Range, _Pred>
7153 constexpr auto
7154 operator() [[nodiscard]] (_Range&& __r, _Pred&& __pred) const
7155 { return chunk_by_view(std::forward<_Range>(__r), std::forward<_Pred>(__pred)); }
7156
7157 using __adaptor::_RangeAdaptor<_ChunkBy>::operator();
7158 static constexpr int _S_arity = 2;
7159 static constexpr bool _S_has_simple_extra_args = true;
7160 };
7161
7162 inline constexpr _ChunkBy chunk_by;
7163 }
7164#endif // __cpp_lib_ranges_chunk_by
7165
7166#ifdef __cpp_lib_ranges_join_with // C++ >= 23
7167 namespace __detail
7168 {
7169 template<typename _Range, typename _Pattern>
7170 concept __compatible_joinable_ranges
7171 = common_with<range_value_t<_Range>, range_value_t<_Pattern>>
7172 && common_reference_with<range_reference_t<_Range>,
7173 range_reference_t<_Pattern>>
7174 && common_reference_with<range_rvalue_reference_t<_Range>,
7175 range_rvalue_reference_t<_Pattern>>;
7176
7177 template<typename _Range>
7178 concept __bidirectional_common = bidirectional_range<_Range> && common_range<_Range>;
7179 }
7180
7181 template<input_range _Vp, forward_range _Pattern>
7182 requires view<_Vp> && view<_Pattern>
7183 && input_range<range_reference_t<_Vp>>
7184 && __detail::__compatible_joinable_ranges<range_reference_t<_Vp>, _Pattern>
7185 class join_with_view : public view_interface<join_with_view<_Vp, _Pattern>>
7186 {
7187 using _InnerRange = range_reference_t<_Vp>;
7188
7189 _Vp _M_base = _Vp();
7190 [[no_unique_address]]
7191 __detail::__maybe_present_t<!forward_range<_Vp>,
7192 __detail::__non_propagating_cache<iterator_t<_Vp>>> _M_outer_it;
7193 __detail::__non_propagating_cache<remove_cv_t<_InnerRange>> _M_inner;
7194 _Pattern _M_pattern = _Pattern();
7195
7196 template<bool _Const> using _Base = __detail::__maybe_const_t<_Const, _Vp>;
7197 template<bool _Const> using _InnerBase = range_reference_t<_Base<_Const>>;
7198 template<bool _Const> using _PatternBase = __detail::__maybe_const_t<_Const, _Pattern>;
7199
7200 template<bool _Const> using _OuterIter = iterator_t<_Base<_Const>>;
7201 template<bool _Const> using _InnerIter = iterator_t<_InnerBase<_Const>>;
7202 template<bool _Const> using _PatternIter = iterator_t<_PatternBase<_Const>>;
7203
7204 template<bool _Const>
7205 static constexpr bool _S_ref_is_glvalue = is_reference_v<_InnerBase<_Const>>;
7206
7207 template<bool _Const>
7208 struct __iter_cat
7209 { };
7210
7211 template<bool _Const>
7212 requires _S_ref_is_glvalue<_Const>
7213 && forward_range<_Base<_Const>>
7214 && forward_range<_InnerBase<_Const>>
7215 struct __iter_cat<_Const>
7216 {
7217 private:
7218 static auto
7219 _S_iter_cat()
7220 {
7221 using _OuterIter = join_with_view::_OuterIter<_Const>;
7222 using _InnerIter = join_with_view::_InnerIter<_Const>;
7223 using _PatternIter = join_with_view::_PatternIter<_Const>;
7224 using _OuterCat = typename iterator_traits<_OuterIter>::iterator_category;
7225 using _InnerCat = typename iterator_traits<_InnerIter>::iterator_category;
7226 using _PatternCat = typename iterator_traits<_PatternIter>::iterator_category;
7227 if constexpr (!is_lvalue_reference_v<common_reference_t<iter_reference_t<_InnerIter>,
7228 iter_reference_t<_PatternIter>>>)
7229 return input_iterator_tag{};
7230 else if constexpr (derived_from<_OuterCat, bidirectional_iterator_tag>
7231 && derived_from<_InnerCat, bidirectional_iterator_tag>
7232 && derived_from<_PatternCat, bidirectional_iterator_tag>
7233 && common_range<_InnerBase<_Const>>
7234 && common_range<_PatternBase<_Const>>)
7235 return bidirectional_iterator_tag{};
7236 else if constexpr (derived_from<_OuterCat, forward_iterator_tag>
7237 && derived_from<_InnerCat, forward_iterator_tag>
7238 && derived_from<_PatternCat, forward_iterator_tag>)
7239 return forward_iterator_tag{};
7240 else
7241 return input_iterator_tag{};
7242 }
7243 public:
7244 using iterator_category = decltype(_S_iter_cat());
7245 };
7246
7247 template<bool> struct _Iterator;
7248 template<bool> struct _Sentinel;
7249
7250 public:
7251 join_with_view() requires (default_initializable<_Vp>
7252 && default_initializable<_Pattern>)
7253 = default;
7254
7255 constexpr
7256 join_with_view(_Vp __base, _Pattern __pattern)
7257 : _M_base(std::move(__base)), _M_pattern(std::move(__pattern))
7258 { }
7259
7260 template<input_range _Range>
7261 requires constructible_from<_Vp, views::all_t<_Range>>
7262 && constructible_from<_Pattern, single_view<range_value_t<_InnerRange>>>
7263 constexpr
7264 join_with_view(_Range&& __r, range_value_t<_InnerRange> __e)
7265 : _M_base(views::all(std::forward<_Range>(__r))),
7266 _M_pattern(views::single(std::move(__e)))
7267 { }
7268
7269 constexpr _Vp
7270 base() const& requires copy_constructible<_Vp>
7271 { return _M_base; }
7272
7273 constexpr _Vp
7274 base() &&
7275 { return std::move(_M_base); }
7276
7277 constexpr auto
7278 begin()
7279 {
7280 if constexpr (forward_range<_Vp>)
7281 {
7282 constexpr bool __use_const = is_reference_v<_InnerRange>
7283 && __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
7284 return _Iterator<__use_const>{*this, ranges::begin(_M_base)};
7285 }
7286 else
7287 {
7288 _M_outer_it = ranges::begin(_M_base);
7289 return _Iterator<false>{*this};
7290 }
7291 }
7292
7293 constexpr auto
7294 begin() const
7295 requires forward_range<const _Vp>
7296 && forward_range<const _Pattern>
7297 && is_reference_v<range_reference_t<const _Vp>>
7298 && input_range<range_reference_t<const _Vp>>
7299 { return _Iterator<true>{*this, ranges::begin(_M_base)}; }
7300
7301 constexpr auto
7302 end()
7303 {
7304 constexpr bool __use_const
7305 = __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
7306 if constexpr (is_reference_v<_InnerRange>
7307 && forward_range<_Vp> && common_range<_Vp>
7308 && forward_range<_InnerRange> && common_range<_InnerRange>)
7309 return _Iterator<__use_const>{*this, ranges::end(_M_base)};
7310 else
7311 return _Sentinel<__use_const>{*this};
7312 }
7313
7314 constexpr auto
7315 end() const
7316 requires forward_range<const _Vp>
7317 && forward_range<const _Pattern>
7318 && is_reference_v<range_reference_t<const _Vp>>
7319 && input_range<range_reference_t<const _Vp>>
7320 {
7321 using _InnerConstRange = range_reference_t<const _Vp>;
7322 if constexpr (forward_range<_InnerConstRange>
7323 && common_range<const _Vp>
7324 && common_range<_InnerConstRange>)
7325 return _Iterator<true>{*this, ranges::end(_M_base)};
7326 else
7327 return _Sentinel<true>{*this};
7328 }
7329 };
7330
7331 template<typename _Range, typename _Pattern>
7332 join_with_view(_Range&&, _Pattern&&)
7333 -> join_with_view<views::all_t<_Range>, views::all_t<_Pattern>>;
7334
7335 template<input_range _Range>
7336 join_with_view(_Range&&, range_value_t<range_reference_t<_Range>>)
7337 -> join_with_view<views::all_t<_Range>,
7338 single_view<range_value_t<range_reference_t<_Range>>>>;
7339
7340 template<input_range _Vp, forward_range _Pattern>
7341 requires view<_Vp> && view<_Pattern>
7342 && input_range<range_reference_t<_Vp>>
7343 && __detail::__compatible_joinable_ranges<range_reference_t<_Vp>, _Pattern>
7344 template<bool _Const>
7345 class join_with_view<_Vp, _Pattern>::_Iterator : public __iter_cat<_Const>
7346 {
7347 using _Parent = __detail::__maybe_const_t<_Const, join_with_view>;
7348 using _Base = join_with_view::_Base<_Const>;
7349 using _InnerBase = join_with_view::_InnerBase<_Const>;
7350 using _PatternBase = join_with_view::_PatternBase<_Const>;
7351
7352 using _OuterIter = join_with_view::_OuterIter<_Const>;
7353 using _InnerIter = join_with_view::_InnerIter<_Const>;
7354 using _PatternIter = join_with_view::_PatternIter<_Const>;
7355
7356 static constexpr bool _S_ref_is_glvalue = join_with_view::_S_ref_is_glvalue<_Const>;
7357
7358 _Parent* _M_parent = nullptr;
7359 [[no_unique_address]]
7360 __detail::__maybe_present_t<forward_range<_Base>, _OuterIter> _M_outer_it;
7361 variant<_PatternIter, _InnerIter> _M_inner_it;
7362
7363 constexpr _OuterIter&
7364 _M_get_outer()
7365 {
7366 if constexpr (forward_range<_Base>)
7367 return _M_outer_it;
7368 else
7369 return *_M_parent->_M_outer_it;
7370 }
7371
7372 constexpr const _OuterIter&
7373 _M_get_outer() const
7374 {
7375 if constexpr (forward_range<_Base>)
7376 return _M_outer_it;
7377 else
7378 return *_M_parent->_M_outer_it;
7379 }
7380
7381 constexpr
7382 _Iterator(_Parent& __parent, _OuterIter __outer)
7383 requires forward_range<_Base>
7384 : _M_parent(std::__addressof(__parent)), _M_outer_it(std::move(__outer))
7385 {
7386 if (_M_get_outer() != ranges::end(_M_parent->_M_base))
7387 {
7388 auto&& __inner = _M_update_inner();
7389 _M_inner_it.template emplace<1>(ranges::begin(__inner));
7390 _M_satisfy();
7391 }
7392 }
7393
7394 constexpr
7395 _Iterator(_Parent& __parent)
7396 requires (!forward_range<_Base>)
7397 : _M_parent(std::__addressof(__parent))
7398 {
7399 if (_M_get_outer() != ranges::end(_M_parent->_M_base))
7400 {
7401 auto&& __inner = _M_update_inner();
7402 _M_inner_it.template emplace<1>(ranges::begin(__inner));
7403 _M_satisfy();
7404 }
7405 }
7406
7407 constexpr auto&
7408 _M_update_inner()
7409 {
7410 _OuterIter& __outer = _M_get_outer();
7411 if constexpr (_S_ref_is_glvalue)
7412 return __detail::__as_lvalue(*__outer);
7413 else
7414 return _M_parent->_M_inner._M_emplace_deref(__outer);
7415 }
7416
7417 constexpr auto&
7418 _M_get_inner()
7419 {
7420 if constexpr (_S_ref_is_glvalue)
7421 return __detail::__as_lvalue(*_M_get_outer());
7422 else
7423 return *_M_parent->_M_inner;
7424 }
7425
7426 constexpr void
7427 _M_satisfy()
7428 {
7429 while (true)
7430 {
7431 if (_M_inner_it.index() == 0)
7432 {
7433 if (std::get<0>(_M_inner_it) != ranges::end(_M_parent->_M_pattern))
7434 break;
7435
7436 auto&& __inner = _M_update_inner();
7437 _M_inner_it.template emplace<1>(ranges::begin(__inner));
7438 }
7439 else
7440 {
7441 auto&& __inner = _M_get_inner();
7442 if (std::get<1>(_M_inner_it) != ranges::end(__inner))
7443 break;
7444
7445 if (++_M_get_outer() == ranges::end(_M_parent->_M_base))
7446 {
7447 if constexpr (_S_ref_is_glvalue)
7448 _M_inner_it.template emplace<0>();
7449 break;
7450 }
7451
7452 _M_inner_it.template emplace<0>(ranges::begin(_M_parent->_M_pattern));
7453 }
7454 }
7455 }
7456
7457 static auto
7458 _S_iter_concept()
7459 {
7460 if constexpr (_S_ref_is_glvalue
7461 && bidirectional_range<_Base>
7462 && __detail::__bidirectional_common<_InnerBase>
7463 && __detail::__bidirectional_common<_PatternBase>)
7464 return bidirectional_iterator_tag{};
7465 else if constexpr (_S_ref_is_glvalue
7466 && forward_range<_Base>
7467 && forward_range<_InnerBase>)
7468 return forward_iterator_tag{};
7469 else
7470 return input_iterator_tag{};
7471 }
7472
7473 friend join_with_view;
7474
7475 public:
7476 using iterator_concept = decltype(_S_iter_concept());
7477 // iterator_category defined in join_with_view::__iter_cat
7478 using value_type = common_type_t<iter_value_t<_InnerIter>,
7479 iter_value_t<_PatternIter>>;
7480 using difference_type = common_type_t<iter_difference_t<_OuterIter>,
7481 iter_difference_t<_InnerIter>,
7482 iter_difference_t<_PatternIter>>;
7483
7484 _Iterator() = default;
7485
7486 constexpr
7487 _Iterator(_Iterator<!_Const> __i)
7488 requires _Const
7489 && convertible_to<iterator_t<_Vp>, _OuterIter>
7490 && convertible_to<iterator_t<_InnerRange>, _InnerIter>
7491 && convertible_to<iterator_t<_Pattern>, _PatternIter>
7492 : _M_parent(__i._M_parent),
7493 _M_outer_it(std::move(__i._M_outer_it))
7494 {
7495 if (__i._M_inner_it.index() == 0)
7496 _M_inner_it.template emplace<0>(std::get<0>(std::move(__i._M_inner_it)));
7497 else
7498 _M_inner_it.template emplace<1>(std::get<1>(std::move(__i._M_inner_it)));
7499 }
7500
7501 constexpr common_reference_t<iter_reference_t<_InnerIter>,
7502 iter_reference_t<_PatternIter>>
7503 operator*() const
7504 {
7505 if (_M_inner_it.index() == 0)
7506 return *std::get<0>(_M_inner_it);
7507 else
7508 return *std::get<1>(_M_inner_it);
7509 }
7510
7511 constexpr _Iterator&
7512 operator++()
7513 {
7514 if (_M_inner_it.index() == 0)
7515 ++std::get<0>(_M_inner_it);
7516 else
7517 ++std::get<1>(_M_inner_it);
7518 _M_satisfy();
7519 return *this;
7520 }
7521
7522 constexpr void
7523 operator++(int)
7524 { ++*this; }
7525
7526 constexpr _Iterator
7527 operator++(int)
7528 requires _S_ref_is_glvalue
7529 && forward_iterator<_OuterIter> && forward_iterator<_InnerIter>
7530 {
7531 _Iterator __tmp = *this;
7532 ++*this;
7533 return __tmp;
7534 }
7535
7536 constexpr _Iterator&
7537 operator--()
7538 requires _S_ref_is_glvalue
7539 && bidirectional_range<_Base>
7540 && __detail::__bidirectional_common<_InnerBase>
7541 && __detail::__bidirectional_common<_PatternBase>
7542 {
7543 if (_M_outer_it == ranges::end(_M_parent->_M_base))
7544 {
7545 auto&& __inner = *--_M_outer_it;
7546 _M_inner_it.template emplace<1>(ranges::end(__inner));
7547 }
7548
7549 while (true)
7550 {
7551 if (_M_inner_it.index() == 0)
7552 {
7553 auto& __it = std::get<0>(_M_inner_it);
7554 if (__it == ranges::begin(_M_parent->_M_pattern))
7555 {
7556 auto&& __inner = *--_M_outer_it;
7557 _M_inner_it.template emplace<1>(ranges::end(__inner));
7558 }
7559 else
7560 break;
7561 }
7562 else
7563 {
7564 auto& __it = std::get<1>(_M_inner_it);
7565 auto&& __inner = *_M_outer_it;
7566 if (__it == ranges::begin(__inner))
7567 _M_inner_it.template emplace<0>(ranges::end(_M_parent->_M_pattern));
7568 else
7569 break;
7570 }
7571 }
7572
7573 if (_M_inner_it.index() == 0)
7574 --std::get<0>(_M_inner_it);
7575 else
7576 --std::get<1>(_M_inner_it);
7577 return *this;
7578 }
7579
7580 constexpr _Iterator
7581 operator--(int)
7582 requires _S_ref_is_glvalue && bidirectional_range<_Base>
7583 && __detail::__bidirectional_common<_InnerBase>
7584 && __detail::__bidirectional_common<_PatternBase>
7585 {
7586 _Iterator __tmp = *this;
7587 --*this;
7588 return __tmp;
7589 }
7590
7591 friend constexpr bool
7592 operator==(const _Iterator& __x, const _Iterator& __y)
7593 requires _S_ref_is_glvalue
7594 && forward_range<_Base> && equality_comparable<_InnerIter>
7595 { return __x._M_outer_it == __y._M_outer_it && __x._M_inner_it ==__y._M_inner_it; }
7596
7597 friend constexpr common_reference_t<iter_rvalue_reference_t<_InnerIter>,
7598 iter_rvalue_reference_t<_PatternIter>>
7599 iter_move(const _Iterator& __x)
7600 {
7601 if (__x._M_inner_it.index() == 0)
7602 return ranges::iter_move(std::get<0>(__x._M_inner_it));
7603 else
7604 return ranges::iter_move(std::get<1>(__x._M_inner_it));
7605 }
7606
7607 friend constexpr void
7608 iter_swap(const _Iterator& __x, const _Iterator& __y)
7609 requires indirectly_swappable<_InnerIter, _PatternIter>
7610 {
7611 if (__x._M_inner_it.index() == 0)
7612 {
7613 if (__y._M_inner_it.index() == 0)
7614 ranges::iter_swap(std::get<0>(__x._M_inner_it), std::get<0>(__y._M_inner_it));
7615 else
7616 ranges::iter_swap(std::get<0>(__x._M_inner_it), std::get<1>(__y._M_inner_it));
7617 }
7618 else
7619 {
7620 if (__y._M_inner_it.index() == 0)
7621 ranges::iter_swap(std::get<1>(__x._M_inner_it), std::get<0>(__y._M_inner_it));
7622 else
7623 ranges::iter_swap(std::get<1>(__x._M_inner_it), std::get<1>(__y._M_inner_it));
7624 }
7625 }
7626 };
7627
7628 template<input_range _Vp, forward_range _Pattern>
7629 requires view<_Vp> && view<_Pattern>
7630 && input_range<range_reference_t<_Vp>>
7631 && __detail::__compatible_joinable_ranges<range_reference_t<_Vp>, _Pattern>
7632 template<bool _Const>
7633 class join_with_view<_Vp, _Pattern>::_Sentinel
7634 {
7635 using _Parent = __detail::__maybe_const_t<_Const, join_with_view>;
7636 using _Base = join_with_view::_Base<_Const>;
7637
7638 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
7639
7640 constexpr explicit
7641 _Sentinel(_Parent& __parent)
7642 : _M_end(ranges::end(__parent._M_base))
7643 { }
7644
7645 friend join_with_view;
7646
7647 public:
7648 _Sentinel() = default;
7649
7650 constexpr
7651 _Sentinel(_Sentinel<!_Const> __s)
7652 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
7653 : _M_end(std::move(__s._M_end))
7654 { }
7655
7656 template<bool _OtherConst>
7657 requires sentinel_for<sentinel_t<_Base>,
7658 iterator_t<__detail::__maybe_const_t<_OtherConst, _Vp>>>
7659 friend constexpr bool
7660 operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
7661 { return __x._M_get_outer() == __y._M_end; }
7662 };
7663
7664 namespace views
7665 {
7666 namespace __detail
7667 {
7668 template<typename _Range, typename _Pattern>
7669 concept __can_join_with_view
7670 = requires { join_with_view(std::declval<_Range>(), std::declval<_Pattern>()); };
7671 } // namespace __detail
7672
7673 struct _JoinWith : __adaptor::_RangeAdaptor<_JoinWith>
7674 {
7675 template<viewable_range _Range, typename _Pattern>
7676 requires __detail::__can_join_with_view<_Range, _Pattern>
7677 constexpr auto
7678 operator() [[nodiscard]] (_Range&& __r, _Pattern&& __f) const
7679 {
7680 return join_with_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
7681 }
7682
7683 using _RangeAdaptor<_JoinWith>::operator();
7684 static constexpr int _S_arity = 2;
7685 template<typename _Pattern>
7686 static constexpr bool _S_has_simple_extra_args
7687 = _LazySplit::_S_has_simple_extra_args<_Pattern>;
7688 };
7689
7690 inline constexpr _JoinWith join_with;
7691 } // namespace views
7692#endif // __cpp_lib_ranges_join_with
7693
7694#ifdef __cpp_lib_ranges_repeat // C++ >= 23
7695 template<move_constructible _Tp, semiregular _Bound = unreachable_sentinel_t>
7696 requires is_object_v<_Tp> && same_as<_Tp, remove_cv_t<_Tp>>
7697 && (__detail::__is_integer_like<_Bound> || same_as<_Bound, unreachable_sentinel_t>)
7698 class repeat_view : public view_interface<repeat_view<_Tp, _Bound>>
7699 {
7700 __detail::__box<_Tp> _M_value;
7701 [[no_unique_address]] _Bound _M_bound = _Bound();
7702
7703 struct _Iterator;
7704
7705 template<typename _Range>
7706 friend constexpr auto
7707 views::__detail::__take_of_repeat_view(_Range&&, range_difference_t<_Range>);
7708
7709 template<typename _Range>
7710 friend constexpr auto
7711 views::__detail::__drop_of_repeat_view(_Range&&, range_difference_t<_Range>);
7712
7713 public:
7714 repeat_view() requires default_initializable<_Tp> = default;
7715
7716 constexpr explicit
7717 repeat_view(const _Tp& __value, _Bound __bound = _Bound())
7718 requires copy_constructible<_Tp>
7719 : _M_value(__value), _M_bound(__bound)
7720 {
7721 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7722 __glibcxx_assert(__bound >= 0);
7723 }
7724
7725 constexpr explicit
7726 repeat_view(_Tp&& __value, _Bound __bound = _Bound())
7727 : _M_value(std::move(__value)), _M_bound(__bound)
7728 { }
7729
7730 template<typename... _Args, typename... _BoundArgs>
7731 requires constructible_from<_Tp, _Args...>
7732 && constructible_from<_Bound, _BoundArgs...>
7733 constexpr explicit
7734 repeat_view(piecewise_construct_t,
7735 tuple<_Args...> __args,
7736 tuple<_BoundArgs...> __bound_args = tuple<>{})
7737 : _M_value(std::make_from_tuple<_Tp>(std::move(__args))),
7738 _M_bound(std::make_from_tuple<_Bound>(std::move(__bound_args)))
7739 { }
7740
7741 constexpr _Iterator
7742 begin() const
7743 { return _Iterator(std::__addressof(*_M_value)); }
7744
7745 constexpr _Iterator
7746 end() const requires (!same_as<_Bound, unreachable_sentinel_t>)
7747 { return _Iterator(std::__addressof(*_M_value), _M_bound); }
7748
7749 constexpr unreachable_sentinel_t
7750 end() const noexcept
7751 { return unreachable_sentinel; }
7752
7753 constexpr auto
7754 size() const requires (!same_as<_Bound, unreachable_sentinel_t>)
7755 { return __detail::__to_unsigned_like(_M_bound); }
7756 };
7757
7758 // _GLIBCXX_RESOLVE_LIB_DEFECTS
7759 // 4053. Unary call to std::views::repeat does not decay the argument
7760 template<typename _Tp, typename _Bound = unreachable_sentinel_t>
7761 repeat_view(_Tp, _Bound = _Bound()) -> repeat_view<_Tp, _Bound>;
7762
7763 template<move_constructible _Tp, semiregular _Bound>
7764 requires is_object_v<_Tp> && same_as<_Tp, remove_cv_t<_Tp>>
7765 && (__detail::__is_integer_like<_Bound> || same_as<_Bound, unreachable_sentinel_t>)
7766 class repeat_view<_Tp, _Bound>::_Iterator
7767 {
7768 using __index_type
7769 = __conditional_t<same_as<_Bound, unreachable_sentinel_t>, ptrdiff_t, _Bound>;
7770
7771 const _Tp* _M_value = nullptr;
7772 __index_type _M_current = __index_type();
7773
7774 constexpr explicit
7775 _Iterator(const _Tp* __value, __index_type __bound = __index_type())
7776 : _M_value(__value), _M_current(__bound)
7777 {
7778 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7779 __glibcxx_assert(__bound >= 0);
7780 }
7781
7782 friend repeat_view;
7783
7784 public:
7785 using iterator_concept = random_access_iterator_tag;
7786 using iterator_category = random_access_iterator_tag;
7787 using value_type = _Tp;
7788 using difference_type = __conditional_t<__detail::__is_signed_integer_like<__index_type>,
7789 __index_type,
7790 __detail::__iota_diff_t<__index_type>>;
7791
7792 _Iterator() = default;
7793
7794 constexpr const _Tp&
7795 operator*() const noexcept
7796 { return *_M_value; }
7797
7798 constexpr _Iterator&
7799 operator++()
7800 {
7801 ++_M_current;
7802 return *this;
7803 }
7804
7805 constexpr _Iterator
7806 operator++(int)
7807 {
7808 auto __tmp = *this;
7809 ++*this;
7810 return __tmp;
7811 }
7812
7813 constexpr _Iterator&
7814 operator--()
7815 {
7816 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7817 __glibcxx_assert(_M_current > 0);
7818 --_M_current;
7819 return *this;
7820 }
7821
7822 constexpr _Iterator
7823 operator--(int)
7824 {
7825 auto __tmp = *this;
7826 --*this;
7827 return __tmp;
7828 }
7829
7830 constexpr _Iterator&
7831 operator+=(difference_type __n)
7832 {
7833 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7834 __glibcxx_assert(_M_current + __n >= 0);
7835 _M_current += __n;
7836 return *this;
7837 }
7838
7839 constexpr _Iterator&
7840 operator-=(difference_type __n)
7841 {
7842 if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
7843 __glibcxx_assert(_M_current - __n >= 0);
7844 _M_current -= __n;
7845 return *this;
7846 }
7847
7848 constexpr const _Tp&
7849 operator[](difference_type __n) const noexcept
7850 { return *(*this + __n); }
7851
7852 friend constexpr bool
7853 operator==(const _Iterator& __x, const _Iterator& __y)
7854 { return __x._M_current == __y._M_current; }
7855
7856 friend constexpr auto
7857 operator<=>(const _Iterator& __x, const _Iterator& __y)
7858 { return __x._M_current <=> __y._M_current; }
7859
7860 friend constexpr _Iterator
7861 operator+(_Iterator __i, difference_type __n)
7862 {
7863 __i += __n;
7864 return __i;
7865 }
7866
7867 friend constexpr _Iterator
7868 operator+(difference_type __n, _Iterator __i)
7869 { return __i + __n; }
7870
7871 friend constexpr _Iterator
7872 operator-(_Iterator __i, difference_type __n)
7873 {
7874 __i -= __n;
7875 return __i;
7876 }
7877
7878 friend constexpr difference_type
7879 operator-(const _Iterator& __x, const _Iterator& __y)
7880 {
7881 return (static_cast<difference_type>(__x._M_current)
7882 - static_cast<difference_type>(__y._M_current));
7883 }
7884 };
7885
7886 namespace views
7887 {
7888 namespace __detail
7889 {
7890 template<typename _Tp, typename _Bound>
7891 inline constexpr bool __is_repeat_view<repeat_view<_Tp, _Bound>> = true;
7892
7893 template<typename _Tp>
7894 concept __can_repeat_view
7895 = requires { repeat_view(std::declval<_Tp>()); };
7896
7897 template<typename _Tp, typename _Bound>
7898 concept __can_bounded_repeat_view
7899 = requires { repeat_view(std::declval<_Tp>(), std::declval<_Bound>()); };
7900 }
7901
7902 struct _Repeat
7903 {
7904 template<typename _Tp>
7905 requires __detail::__can_repeat_view<_Tp>
7906 constexpr auto
7907 operator() [[nodiscard]] (_Tp&& __value) const
7908 {
7909 // _GLIBCXX_RESOLVE_LIB_DEFECTS
7910 // 4054. Repeating a repeat_view should repeat the view
7911 return repeat_view<decay_t<_Tp>>(std::forward<_Tp>(__value));
7912 }
7913
7914 template<typename _Tp, typename _Bound>
7915 requires __detail::__can_bounded_repeat_view<_Tp, _Bound>
7916 constexpr auto
7917 operator() [[nodiscard]] (_Tp&& __value, _Bound __bound) const
7918 { return repeat_view(std::forward<_Tp>(__value), __bound); }
7919 };
7920
7921 inline constexpr _Repeat repeat;
7922
7923 namespace __detail
7924 {
7925 template<typename _Range>
7926 constexpr auto
7927 __take_of_repeat_view(_Range&& __r, range_difference_t<_Range> __n)
7928 {
7929 using _Tp = remove_cvref_t<_Range>;
7930 static_assert(__is_repeat_view<_Tp>);
7931 if constexpr (sized_range<_Tp>)
7932 return views::repeat(*std::forward<_Range>(__r)._M_value,
7933 std::min(ranges::distance(__r), __n));
7934 else
7935 return views::repeat(*std::forward<_Range>(__r)._M_value, __n);
7936 }
7937
7938 template<typename _Range>
7939 constexpr auto
7940 __drop_of_repeat_view(_Range&& __r, range_difference_t<_Range> __n)
7941 {
7942 using _Tp = remove_cvref_t<_Range>;
7943 static_assert(__is_repeat_view<_Tp>);
7944 if constexpr (sized_range<_Tp>)
7945 {
7946 auto __sz = ranges::distance(__r);
7947 return views::repeat(*std::forward<_Range>(__r)._M_value,
7948 __sz - std::min(__sz, __n));
7949 }
7950 else
7951 return __r;
7952 }
7953 }
7954 }
7955#endif // __cpp_lib_ranges_repeat
7956
7957#ifdef __cpp_lib_ranges_stride // C++ >= 23
7958 template<input_range _Vp>
7959 requires view<_Vp>
7960 class stride_view : public view_interface<stride_view<_Vp>>
7961 {
7962 _Vp _M_base;
7963 range_difference_t<_Vp> _M_stride;
7964
7965 template<bool _Const> using _Base = __detail::__maybe_const_t<_Const, _Vp>;
7966
7967 template<bool _Const>
7968 struct __iter_cat
7969 { };
7970
7971 template<bool _Const>
7972 requires forward_range<_Base<_Const>>
7973 struct __iter_cat<_Const>
7974 {
7975 private:
7976 static auto
7977 _S_iter_cat()
7978 {
7979 using _Cat = typename iterator_traits<iterator_t<_Base<_Const>>>::iterator_category;
7980 if constexpr (derived_from<_Cat, random_access_iterator_tag>)
7981 return random_access_iterator_tag{};
7982 else
7983 return _Cat{};
7984 }
7985 public:
7986 using iterator_category = decltype(_S_iter_cat());
7987 };
7988
7989 template<bool> class _Iterator;
7990
7991 public:
7992 constexpr explicit
7993 stride_view(_Vp __base, range_difference_t<_Vp> __stride)
7994 : _M_base(std::move(__base)), _M_stride(__stride)
7995 { __glibcxx_assert(__stride > 0); }
7996
7997 constexpr _Vp
7998 base() const& requires copy_constructible<_Vp>
7999 { return _M_base; }
8000
8001 constexpr _Vp
8002 base() &&
8003 { return std::move(_M_base); }
8004
8005 constexpr range_difference_t<_Vp>
8006 stride() const noexcept
8007 { return _M_stride; }
8008
8009 constexpr auto
8010 begin() requires (!__detail::__simple_view<_Vp>)
8011 { return _Iterator<false>(this, ranges::begin(_M_base)); }
8012
8013 constexpr auto
8014 begin() const requires range<const _Vp>
8015 { return _Iterator<true>(this, ranges::begin(_M_base)); }
8016
8017 constexpr auto
8018 end() requires (!__detail::__simple_view<_Vp>)
8019 {
8020 if constexpr (common_range<_Vp> && sized_range<_Vp> && forward_range<_Vp>)
8021 {
8022 auto __missing = (_M_stride - ranges::distance(_M_base) % _M_stride) % _M_stride;
8023 return _Iterator<false>(this, ranges::end(_M_base), __missing);
8024 }
8025 else if constexpr (common_range<_Vp> && !bidirectional_range<_Vp>)
8026 return _Iterator<false>(this, ranges::end(_M_base));
8027 else
8028 return default_sentinel;
8029 }
8030
8031 constexpr auto
8032 end() const requires range<const _Vp>
8033 {
8034 if constexpr (common_range<const _Vp> && sized_range<const _Vp>
8035 && forward_range<const _Vp>)
8036 {
8037 auto __missing = (_M_stride - ranges::distance(_M_base) % _M_stride) % _M_stride;
8038 return _Iterator<true>(this, ranges::end(_M_base), __missing);
8039 }
8040 else if constexpr (common_range<const _Vp> && !bidirectional_range<const _Vp>)
8041 return _Iterator<true>(this, ranges::end(_M_base));
8042 else
8043 return default_sentinel;
8044 }
8045
8046 constexpr auto
8047 size() requires sized_range<_Vp>
8048 {
8049 return __detail::__to_unsigned_like
8050 (__detail::__div_ceil(ranges::distance(_M_base), _M_stride));
8051 }
8052
8053 constexpr auto
8054 size() const requires sized_range<const _Vp>
8055 {
8056 return __detail::__to_unsigned_like
8057 (__detail::__div_ceil(ranges::distance(_M_base), _M_stride));
8058 }
8059 };
8060
8061 template<typename _Range>
8062 stride_view(_Range&&, range_difference_t<_Range>) -> stride_view<views::all_t<_Range>>;
8063
8064 template<typename _Vp>
8065 inline constexpr bool enable_borrowed_range<stride_view<_Vp>>
8066 = enable_borrowed_range<_Vp>;
8067
8068 template<input_range _Vp>
8069 requires view<_Vp>
8070 template<bool _Const>
8071 class stride_view<_Vp>::_Iterator : public __iter_cat<_Const>
8072 {
8073 using _Parent = __detail::__maybe_const_t<_Const, stride_view>;
8074 using _Base = stride_view::_Base<_Const>;
8075
8076 iterator_t<_Base> _M_current = iterator_t<_Base>();
8077 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
8078 range_difference_t<_Base> _M_stride = 0;
8079 range_difference_t<_Base> _M_missing = 0;
8080
8081 constexpr
8082 _Iterator(_Parent* __parent, iterator_t<_Base> __current,
8083 range_difference_t<_Base> __missing = 0)
8084 : _M_current(std::move(__current)), _M_end(ranges::end(__parent->_M_base)),
8085 _M_stride(__parent->_M_stride), _M_missing(__missing)
8086 { }
8087
8088 static auto
8089 _S_iter_concept()
8090 {
8091 if constexpr (random_access_range<_Base>)
8092 return random_access_iterator_tag{};
8093 else if constexpr (bidirectional_range<_Base>)
8094 return bidirectional_iterator_tag{};
8095 else if constexpr (forward_range<_Base>)
8096 return forward_iterator_tag{};
8097 else
8098 return input_iterator_tag{};
8099 }
8100
8101 friend stride_view;
8102
8103 public:
8104 using difference_type = range_difference_t<_Base>;
8105 using value_type = range_value_t<_Base>;
8106 using iterator_concept = decltype(_S_iter_concept());
8107 // iterator_category defined in stride_view::__iter_cat
8108
8109 _Iterator() requires default_initializable<iterator_t<_Base>> = default;
8110
8111 constexpr
8112 _Iterator(_Iterator<!_Const> __other)
8113 requires _Const
8114 && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
8115 && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
8116 : _M_current(std::move(__other._M_current)), _M_end(std::move(__other._M_end)),
8117 _M_stride(__other._M_stride), _M_missing(__other._M_missing)
8118 { }
8119
8120 constexpr iterator_t<_Base>
8121 base() &&
8122 { return std::move(_M_current); }
8123
8124 constexpr const iterator_t<_Base>&
8125 base() const & noexcept
8126 { return _M_current; }
8127
8128 constexpr decltype(auto)
8129 operator*() const
8130 { return *_M_current; }
8131
8132 constexpr _Iterator&
8133 operator++()
8134 {
8135 __glibcxx_assert(_M_current != _M_end);
8136 _M_missing = ranges::advance(_M_current, _M_stride, _M_end);
8137 return *this;
8138 }
8139
8140 constexpr void
8141 operator++(int)
8142 { ++*this; }
8143
8144 constexpr _Iterator
8145 operator++(int) requires forward_range<_Base>
8146 {
8147 auto __tmp = *this;
8148 ++*this;
8149 return __tmp;
8150 }
8151
8152 constexpr _Iterator&
8153 operator--() requires bidirectional_range<_Base>
8154 {
8155 ranges::advance(_M_current, _M_missing - _M_stride);
8156 _M_missing = 0;
8157 return *this;
8158 }
8159
8160 constexpr _Iterator
8161 operator--(int) requires bidirectional_range<_Base>
8162 {
8163 auto __tmp = *this;
8164 --*this;
8165 return __tmp;
8166 }
8167
8168 constexpr _Iterator&
8169 operator+=(difference_type __n) requires random_access_range<_Base>
8170 {
8171 if (__n > 0)
8172 {
8173 __glibcxx_assert(ranges::distance(_M_current, _M_end) > _M_stride * (__n - 1));
8174 _M_missing = ranges::advance(_M_current, _M_stride * __n, _M_end);
8175 }
8176 else if (__n < 0)
8177 {
8178 ranges::advance(_M_current, _M_stride * __n + _M_missing);
8179 _M_missing = 0;
8180 }
8181 return *this;
8182 }
8183
8184 constexpr _Iterator&
8185 operator-=(difference_type __n) requires random_access_range<_Base>
8186 { return *this += -__n; }
8187
8188 constexpr decltype(auto) operator[](difference_type __n) const
8189 requires random_access_range<_Base>
8190 { return *(*this + __n); }
8191
8192 friend constexpr bool
8193 operator==(const _Iterator& __x, default_sentinel_t)
8194 { return __x._M_current == __x._M_end; }
8195
8196 friend constexpr bool
8197 operator==(const _Iterator& __x, const _Iterator& __y)
8198 requires equality_comparable<iterator_t<_Base>>
8199 { return __x._M_current == __y._M_current; }
8200
8201 friend constexpr bool
8202 operator<(const _Iterator& __x, const _Iterator& __y)
8203 requires random_access_range<_Base>
8204 { return __x._M_current < __y._M_current; }
8205
8206 friend constexpr bool
8207 operator>(const _Iterator& __x, const _Iterator& __y)
8208 requires random_access_range<_Base>
8209 { return __y._M_current < __x._M_current; }
8210
8211 friend constexpr bool
8212 operator<=(const _Iterator& __x, const _Iterator& __y)
8213 requires random_access_range<_Base>
8214 { return !(__y._M_current < __x._M_current); }
8215
8216 friend constexpr bool
8217 operator>=(const _Iterator& __x, const _Iterator& __y)
8218 requires random_access_range<_Base>
8219 { return !(__x._M_current < __y._M_current); }
8220
8221 friend constexpr auto
8222 operator<=>(const _Iterator& __x, const _Iterator& __y)
8223 requires random_access_range<_Base> && three_way_comparable<iterator_t<_Base>>
8224 { return __x._M_current <=> __y._M_current; }
8225
8226 friend constexpr _Iterator
8227 operator+(const _Iterator& __i, difference_type __n)
8228 requires random_access_range<_Base>
8229 {
8230 auto __r = __i;
8231 __r += __n;
8232 return __r;
8233 }
8234
8235 friend constexpr _Iterator
8236 operator+(difference_type __n, const _Iterator& __i)
8237 requires random_access_range<_Base>
8238 { return __i + __n; }
8239
8240 friend constexpr _Iterator
8241 operator-(const _Iterator& __i, difference_type __n)
8242 requires random_access_range<_Base>
8243 {
8244 auto __r = __i;
8245 __r -= __n;
8246 return __r;
8247 }
8248
8249 friend constexpr difference_type
8250 operator-(const _Iterator& __x, const _Iterator& __y)
8251 requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
8252 {
8253 auto __n = __x._M_current - __y._M_current;
8254 if constexpr (forward_range<_Base>)
8255 return (__n + __x._M_missing - __y._M_missing) / __x._M_stride;
8256 else if (__n < 0)
8257 return -__detail::__div_ceil(-__n, __x._M_stride);
8258 else
8259 return __detail::__div_ceil(__n, __x._M_stride);
8260 }
8261
8262 friend constexpr difference_type
8263 operator-(default_sentinel_t __y, const _Iterator& __x)
8264 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
8265 { return __detail::__div_ceil(__x._M_end - __x._M_current, __x._M_stride); }
8266
8267 friend constexpr difference_type
8268 operator-(const _Iterator& __x, default_sentinel_t __y)
8269 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
8270 { return -(__y - __x); }
8271
8272 friend constexpr range_rvalue_reference_t<_Base>
8273 iter_move(const _Iterator& __i)
8274 noexcept(noexcept(ranges::iter_move(__i._M_current)))
8275 { return ranges::iter_move(__i._M_current); }
8276
8277 friend constexpr void
8278 iter_swap(const _Iterator& __x, const _Iterator& __y)
8279 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
8280 requires indirectly_swappable<iterator_t<_Base>>
8281 { ranges::iter_swap(__x._M_current, __y._M_current); }
8282 };
8283
8284 namespace views
8285 {
8286 namespace __detail
8287 {
8288 template<typename _Range, typename _Dp>
8289 concept __can_stride_view
8290 = requires { stride_view(std::declval<_Range>(), std::declval<_Dp>()); };
8291 }
8292
8293 struct _Stride : __adaptor::_RangeAdaptor<_Stride>
8294 {
8295 template<viewable_range _Range, typename _Dp = range_difference_t<_Range>>
8296 requires __detail::__can_stride_view<_Range, _Dp>
8297 constexpr auto
8298 operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n) const
8299 { return stride_view(std::forward<_Range>(__r), __n); }
8300
8301 using __adaptor::_RangeAdaptor<_Stride>::operator();
8302 static constexpr int _S_arity = 2;
8303 static constexpr bool _S_has_simple_extra_args = true;
8304 };
8305
8306 inline constexpr _Stride stride;
8307 }
8308#endif // __cpp_lib_ranges_stride
8309
8310#ifdef __cpp_lib_ranges_cartesian_product // C++ >= 23
8311 namespace __detail
8312 {
8313 template<bool _Const, typename _First, typename... _Vs>
8314 concept __cartesian_product_is_random_access
8315 = (random_access_range<__maybe_const_t<_Const, _First>>
8316 && ...
8317 && (random_access_range<__maybe_const_t<_Const, _Vs>>
8318 && sized_range<__maybe_const_t<_Const, _Vs>>));
8319
8320 template<typename _Range>
8321 concept __cartesian_product_common_arg
8322 = common_range<_Range> || (sized_range<_Range> && random_access_range<_Range>);
8323
8324 template<bool _Const, typename _First, typename... _Vs>
8325 concept __cartesian_product_is_bidirectional
8326 = (bidirectional_range<__maybe_const_t<_Const, _First>>
8327 && ...
8328 && (bidirectional_range<__maybe_const_t<_Const, _Vs>>
8329 && __cartesian_product_common_arg<__maybe_const_t<_Const, _Vs>>));
8330
8331 template<typename _First, typename... _Vs>
8332 concept __cartesian_product_is_common = __cartesian_product_common_arg<_First>;
8333
8334 template<typename... _Vs>
8335 concept __cartesian_product_is_sized = (sized_range<_Vs> && ...);
8336
8337 template<bool _Const, template<typename> class FirstSent, typename _First, typename... _Vs>
8338 concept __cartesian_is_sized_sentinel
8339 = (sized_sentinel_for<FirstSent<__maybe_const_t<_Const, _First>>,
8340 iterator_t<__maybe_const_t<_Const, _First>>>
8341 && ...
8342 && (sized_range<__maybe_const_t<_Const, _Vs>>
8343 && sized_sentinel_for<iterator_t<__maybe_const_t<_Const, _Vs>>,
8344 iterator_t<__maybe_const_t<_Const, _Vs>>>));
8345
8346 template<__cartesian_product_common_arg _Range>
8347 constexpr auto
8348 __cartesian_common_arg_end(_Range& __r)
8349 {
8350 if constexpr (common_range<_Range>)
8351 return ranges::end(__r);
8352 else
8353 return ranges::begin(__r) + ranges::distance(__r);
8354 }
8355 } // namespace __detail
8356
8357 template<input_range _First, forward_range... _Vs>
8358 requires (view<_First> && ... && view<_Vs>)
8359 class cartesian_product_view : public view_interface<cartesian_product_view<_First, _Vs...>>
8360 {
8361 tuple<_First, _Vs...> _M_bases;
8362
8363 template<bool> class _Iterator;
8364
8365 static auto
8366 _S_difference_type()
8367 {
8368 // TODO: Implement the recommended practice of using the smallest
8369 // sufficiently wide type according to the maximum sizes of the
8370 // underlying ranges?
8371 return common_type_t<ptrdiff_t,
8372 range_difference_t<_First>,
8373 range_difference_t<_Vs>...>{};
8374 }
8375
8376 public:
8377 cartesian_product_view() = default;
8378
8379 constexpr explicit
8380 cartesian_product_view(_First __first, _Vs... __rest)
8381 : _M_bases(std::move(__first), std::move(__rest)...)
8382 { }
8383
8384 constexpr _Iterator<false>
8385 begin() requires (!__detail::__simple_view<_First> || ... || !__detail::__simple_view<_Vs>)
8386 { return _Iterator<false>(*this, __detail::__tuple_transform(ranges::begin, _M_bases)); }
8387
8388 constexpr _Iterator<true>
8389 begin() const requires (range<const _First> && ... && range<const _Vs>)
8390 { return _Iterator<true>(*this, __detail::__tuple_transform(ranges::begin, _M_bases)); }
8391
8392 constexpr _Iterator<false>
8393 end() requires ((!__detail::__simple_view<_First> || ... || !__detail::__simple_view<_Vs>)
8394 && __detail::__cartesian_product_is_common<_First, _Vs...>)
8395 {
8396 auto __its = [this]<size_t... _Is>(index_sequence<_Is...>) {
8397 using _Ret = tuple<iterator_t<_First>, iterator_t<_Vs>...>;
8398 bool __empty_tail = (ranges::empty(std::get<1 + _Is>(_M_bases)) || ...);
8399 auto& __first = std::get<0>(_M_bases);
8400 return _Ret{(__empty_tail
8401 ? ranges::begin(__first)
8402 : __detail::__cartesian_common_arg_end(__first)),
8403 ranges::begin(std::get<1 + _Is>(_M_bases))...};
8404 }(make_index_sequence<sizeof...(_Vs)>{});
8405
8406 return _Iterator<false>{*this, std::move(__its)};
8407 }
8408
8409 constexpr _Iterator<true>
8410 end() const requires __detail::__cartesian_product_is_common<const _First, const _Vs...>
8411 {
8412 auto __its = [this]<size_t... _Is>(index_sequence<_Is...>) {
8413 using _Ret = tuple<iterator_t<const _First>, iterator_t<const _Vs>...>;
8414 bool __empty_tail = (ranges::empty(std::get<1 + _Is>(_M_bases)) || ...);
8415 auto& __first = std::get<0>(_M_bases);
8416 return _Ret{(__empty_tail
8417 ? ranges::begin(__first)
8418 : __detail::__cartesian_common_arg_end(__first)),
8419 ranges::begin(std::get<1 + _Is>(_M_bases))...};
8420 }(make_index_sequence<sizeof...(_Vs)>{});
8421
8422 return _Iterator<true>{*this, std::move(__its)};
8423 }
8424
8425 constexpr default_sentinel_t
8426 end() const noexcept
8427 { return default_sentinel; }
8428
8429 constexpr auto
8430 size() requires __detail::__cartesian_product_is_sized<_First, _Vs...>
8431 {
8432 using _ST = __detail::__make_unsigned_like_t<decltype(_S_difference_type())>;
8433 return [&]<size_t... _Is>(index_sequence<_Is...>) {
8434 auto __size = static_cast<_ST>(1);
8435#ifdef _GLIBCXX_ASSERTIONS
8436 if constexpr (integral<_ST>)
8437 {
8438 bool __overflow
8439 = (__builtin_mul_overflow(__size,
8440 static_cast<_ST>(ranges::size(std::get<_Is>(_M_bases))),
8441 &__size)
8442 || ...);
8443 __glibcxx_assert(!__overflow);
8444 }
8445 else
8446#endif
8447 __size = (static_cast<_ST>(ranges::size(std::get<_Is>(_M_bases))) * ...);
8448 return __size;
8449 }(make_index_sequence<1 + sizeof...(_Vs)>{});
8450 }
8451
8452 constexpr auto
8453 size() const requires __detail::__cartesian_product_is_sized<const _First, const _Vs...>
8454 {
8455 using _ST = __detail::__make_unsigned_like_t<decltype(_S_difference_type())>;
8456 return [&]<size_t... _Is>(index_sequence<_Is...>) {
8457 auto __size = static_cast<_ST>(1);
8458#ifdef _GLIBCXX_ASSERTIONS
8459 if constexpr (integral<_ST>)
8460 {
8461 bool __overflow
8462 = (__builtin_mul_overflow(__size,
8463 static_cast<_ST>(ranges::size(std::get<_Is>(_M_bases))),
8464 &__size)
8465 || ...);
8466 __glibcxx_assert(!__overflow);
8467 }
8468 else
8469#endif
8470 __size = (static_cast<_ST>(ranges::size(std::get<_Is>(_M_bases))) * ...);
8471 return __size;
8472 }(make_index_sequence<1 + sizeof...(_Vs)>{});
8473 }
8474 };
8475
8476 template<typename... _Vs>
8477 cartesian_product_view(_Vs&&...) -> cartesian_product_view<views::all_t<_Vs>...>;
8478
8479 template<input_range _First, forward_range... _Vs>
8480 requires (view<_First> && ... && view<_Vs>)
8481 template<bool _Const>
8482 class cartesian_product_view<_First, _Vs...>::_Iterator
8483 {
8484 using _Parent = __maybe_const_t<_Const, cartesian_product_view>;
8485 _Parent* _M_parent = nullptr;
8486 tuple<iterator_t<__maybe_const_t<_Const, _First>>,
8487 iterator_t<__maybe_const_t<_Const, _Vs>>...> _M_current;
8488
8489 constexpr
8490 _Iterator(_Parent& __parent, decltype(_M_current) __current)
8491 : _M_parent(std::__addressof(__parent)),
8492 _M_current(std::move(__current))
8493 { }
8494
8495 static auto
8496 _S_iter_concept()
8497 {
8498 if constexpr (__detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>)
8499 return random_access_iterator_tag{};
8500 else if constexpr (__detail::__cartesian_product_is_bidirectional<_Const, _First, _Vs...>)
8501 return bidirectional_iterator_tag{};
8502 else if constexpr (forward_range<__maybe_const_t<_Const, _First>>)
8503 return forward_iterator_tag{};
8504 else
8505 return input_iterator_tag{};
8506 }
8507
8508 friend cartesian_product_view;
8509
8510 public:
8511 using iterator_category = input_iterator_tag;
8512 using iterator_concept = decltype(_S_iter_concept());
8513 using value_type
8514 = tuple<range_value_t<__maybe_const_t<_Const, _First>>,
8515 range_value_t<__maybe_const_t<_Const, _Vs>>...>;
8516 using reference
8517 = tuple<range_reference_t<__maybe_const_t<_Const, _First>>,
8518 range_reference_t<__maybe_const_t<_Const, _Vs>>...>;
8519 using difference_type = decltype(cartesian_product_view::_S_difference_type());
8520
8521 _Iterator() = default;
8522
8523 constexpr
8524 _Iterator(_Iterator<!_Const> __i)
8525 requires _Const
8526 && (convertible_to<iterator_t<_First>, iterator_t<const _First>>
8527 && ... && convertible_to<iterator_t<_Vs>, iterator_t<const _Vs>>)
8528 : _M_parent(std::__addressof(__i._M_parent)),
8529 _M_current(std::move(__i._M_current))
8530 { }
8531
8532 constexpr auto
8533 operator*() const
8534 {
8535 auto __f = [](auto& __i) -> decltype(auto) {
8536 return *__i;
8537 };
8538 return __detail::__tuple_transform(__f, _M_current);
8539 }
8540
8541 constexpr _Iterator&
8542 operator++()
8543 {
8544 _M_next();
8545 return *this;
8546 }
8547
8548 constexpr void
8549 operator++(int)
8550 { ++*this; }
8551
8552 constexpr _Iterator
8553 operator++(int) requires forward_range<__maybe_const_t<_Const, _First>>
8554 {
8555 auto __tmp = *this;
8556 ++*this;
8557 return __tmp;
8558 }
8559
8560 constexpr _Iterator&
8561 operator--()
8562 requires __detail::__cartesian_product_is_bidirectional<_Const, _First, _Vs...>
8563 {
8564 _M_prev();
8565 return *this;
8566 }
8567
8568 constexpr _Iterator
8569 operator--(int)
8570 requires __detail::__cartesian_product_is_bidirectional<_Const, _First, _Vs...>
8571 {
8572 auto __tmp = *this;
8573 --*this;
8574 return __tmp;
8575 }
8576
8577 constexpr _Iterator&
8578 operator+=(difference_type __x)
8579 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8580 {
8581 _M_advance(__x);
8582 return *this;
8583 }
8584
8585 constexpr _Iterator&
8586 operator-=(difference_type __x)
8587 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8588 { return *this += -__x; }
8589
8590 constexpr reference
8591 operator[](difference_type __n) const
8592 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8593 { return *((*this) + __n); }
8594
8595 friend constexpr bool
8596 operator==(const _Iterator& __x, const _Iterator& __y)
8597 requires equality_comparable<iterator_t<__maybe_const_t<_Const, _First>>>
8598 { return __x._M_current == __y._M_current; }
8599
8600 friend constexpr bool
8601 operator==(const _Iterator& __x, default_sentinel_t)
8602 {
8603 return [&]<size_t... _Is>(index_sequence<_Is...>) {
8604 return ((std::get<_Is>(__x._M_current)
8605 == ranges::end(std::get<_Is>(__x._M_parent->_M_bases)))
8606 || ...);
8607 }(make_index_sequence<1 + sizeof...(_Vs)>{});
8608 }
8609
8610 friend constexpr auto
8611 operator<=>(const _Iterator& __x, const _Iterator& __y)
8612 requires __detail::__all_random_access<_Const, _First, _Vs...>
8613 { return __x._M_current <=> __y._M_current; }
8614
8615 friend constexpr _Iterator
8616 operator+(_Iterator __x, difference_type __y)
8617 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8618 { return __x += __y; }
8619
8620 friend constexpr _Iterator
8621 operator+(difference_type __x, _Iterator __y)
8622 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8623 { return __y += __x; }
8624
8625 friend constexpr _Iterator
8626 operator-(_Iterator __x, difference_type __y)
8627 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8628 { return __x -= __y; }
8629
8630 friend constexpr difference_type
8631 operator-(const _Iterator& __x, const _Iterator& __y)
8632 requires __detail::__cartesian_is_sized_sentinel<_Const, iterator_t, _First, _Vs...>
8633 { return __x._M_distance_from(__y._M_current); }
8634
8635 friend constexpr difference_type
8636 operator-(const _Iterator& __i, default_sentinel_t)
8637 requires __detail::__cartesian_is_sized_sentinel<_Const, sentinel_t, _First, _Vs...>
8638 {
8639 tuple __end_tuple = [&]<size_t... _Is>(index_sequence<_Is...>) {
8640 return tuple{ranges::end(std::get<0>(__i._M_parent->_M_bases)),
8641 ranges::begin(std::get<1 + _Is>(__i._M_parent->_M_bases))...};
8642 }(make_index_sequence<sizeof...(_Vs)>{});
8643 return __i._M_distance_from(__end_tuple);
8644 }
8645
8646 friend constexpr difference_type
8647 operator-(default_sentinel_t, const _Iterator& __i)
8648 requires __detail::__cartesian_is_sized_sentinel<_Const, sentinel_t, _First, _Vs...>
8649 { return -(__i - default_sentinel); }
8650
8651 friend constexpr auto
8652 iter_move(const _Iterator& __i)
8653 { return __detail::__tuple_transform(ranges::iter_move, __i._M_current); }
8654
8655 friend constexpr void
8656 iter_swap(const _Iterator& __l, const _Iterator& __r)
8657 requires (indirectly_swappable<iterator_t<__maybe_const_t<_Const, _First>>>
8658 && ...
8659 && indirectly_swappable<iterator_t<__maybe_const_t<_Const, _Vs>>>)
8660 {
8661 [&]<size_t... _Is>(index_sequence<_Is...>) {
8662 (ranges::iter_swap(std::get<_Is>(__l._M_current), std::get<_Is>(__r._M_current)), ...);
8663 }(make_index_sequence<1 + sizeof...(_Vs)>{});
8664 }
8665
8666 private:
8667 template<size_t _Nm = sizeof...(_Vs)>
8668 constexpr void
8669 _M_next()
8670 {
8671 auto& __it = std::get<_Nm>(_M_current);
8672 ++__it;
8673 if constexpr (_Nm > 0)
8674 if (__it == ranges::end(std::get<_Nm>(_M_parent->_M_bases)))
8675 {
8676 __it = ranges::begin(std::get<_Nm>(_M_parent->_M_bases));
8677 _M_next<_Nm - 1>();
8678 }
8679 }
8680
8681 template<size_t _Nm = sizeof...(_Vs)>
8682 constexpr void
8683 _M_prev()
8684 {
8685 auto& __it = std::get<_Nm>(_M_current);
8686 if constexpr (_Nm > 0)
8687 if (__it == ranges::begin(std::get<_Nm>(_M_parent->_M_bases)))
8688 {
8689 __it = __detail::__cartesian_common_arg_end(std::get<_Nm>(_M_parent->_M_bases));
8690 _M_prev<_Nm - 1>();
8691 }
8692 --__it;
8693 }
8694
8695 template<size_t _Nm = sizeof...(_Vs)>
8696 constexpr void
8697 _M_advance(difference_type __x)
8698 requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
8699 {
8700 if (__x == 1)
8701 _M_next<_Nm>();
8702 else if (__x == -1)
8703 _M_prev<_Nm>();
8704 else if (__x != 0)
8705 {
8706 // Constant time iterator advancement.
8707 auto& __r = std::get<_Nm>(_M_parent->_M_bases);
8708 auto& __it = std::get<_Nm>(_M_current);
8709 if constexpr (_Nm == 0)
8710 {
8711#ifdef _GLIBCXX_ASSERTIONS
8712 if constexpr (sized_range<__maybe_const_t<_Const, _First>>)
8713 {
8714 auto __size = ranges::ssize(__r);
8715 auto __begin = ranges::begin(__r);
8716 auto __offset = __it - __begin;
8717 __glibcxx_assert(__offset + __x >= 0 && __offset + __x <= __size);
8718 }
8719#endif
8720 __it += __x;
8721 }
8722 else
8723 {
8724 auto __size = ranges::ssize(__r);
8725 auto __begin = ranges::begin(__r);
8726 auto __offset = __it - __begin;
8727 __offset += __x;
8728 __x = __offset / __size;
8729 __offset %= __size;
8730 if (__offset < 0)
8731 {
8732 __offset = __size + __offset;
8733 --__x;
8734 }
8735 __it = __begin + __offset;
8736 _M_advance<_Nm - 1>(__x);
8737 }
8738 }
8739 }
8740
8741 template<typename _Tuple>
8742 constexpr difference_type
8743 _M_distance_from(const _Tuple& __t) const
8744 {
8745 return [&]<size_t... _Is>(index_sequence<_Is...>) {
8746 auto __sum = static_cast<difference_type>(0);
8747#ifdef _GLIBCXX_ASSERTIONS
8748 if constexpr (integral<difference_type>)
8749 {
8750 bool __overflow
8751 = (__builtin_add_overflow(__sum, _M_scaled_distance<_Is>(__t), &__sum)
8752 || ...);
8753 __glibcxx_assert(!__overflow);
8754 }
8755 else
8756#endif
8757 __sum = (_M_scaled_distance<_Is>(__t) + ...);
8758 return __sum;
8759 }(make_index_sequence<1 + sizeof...(_Vs)>{});
8760 }
8761
8762 template<size_t _Nm, typename _Tuple>
8763 constexpr difference_type
8764 _M_scaled_distance(const _Tuple& __t) const
8765 {
8766 auto __dist = static_cast<difference_type>(std::get<_Nm>(_M_current)
8767 - std::get<_Nm>(__t));
8768#ifdef _GLIBCXX_ASSERTIONS
8769 if constexpr (integral<difference_type>)
8770 {
8771 bool __overflow = __builtin_mul_overflow(__dist, _M_scaled_size<_Nm+1>(), &__dist);
8772 __glibcxx_assert(!__overflow);
8773 }
8774 else
8775#endif
8776 __dist *= _M_scaled_size<_Nm+1>();
8777 return __dist;
8778 }
8779
8780 template<size_t _Nm>
8781 constexpr difference_type
8782 _M_scaled_size() const
8783 {
8784 if constexpr (_Nm <= sizeof...(_Vs))
8785 {
8786 auto __size = static_cast<difference_type>(ranges::size
8787 (std::get<_Nm>(_M_parent->_M_bases)));
8788#ifdef _GLIBCXX_ASSERTIONS
8789 if constexpr (integral<difference_type>)
8790 {
8791 bool __overflow = __builtin_mul_overflow(__size, _M_scaled_size<_Nm+1>(), &__size);
8792 __glibcxx_assert(!__overflow);
8793 }
8794 else
8795#endif
8796 __size *= _M_scaled_size<_Nm+1>();
8797 return __size;
8798 }
8799 else
8800 return static_cast<difference_type>(1);
8801 }
8802 };
8803
8804 namespace views
8805 {
8806 namespace __detail
8807 {
8808 template<typename... _Ts>
8809 concept __can_cartesian_product_view
8810 = requires { cartesian_product_view<all_t<_Ts>...>(std::declval<_Ts>()...); };
8811 }
8812
8813 struct _CartesianProduct
8814 {
8815 template<typename... _Ts>
8816 requires (sizeof...(_Ts) == 0 || __detail::__can_cartesian_product_view<_Ts...>)
8817 constexpr auto
8818 operator() [[nodiscard]] (_Ts&&... __ts) const
8819 {
8820 if constexpr (sizeof...(_Ts) == 0)
8821 return views::single(tuple{});
8822 else
8823 return cartesian_product_view<all_t<_Ts>...>(std::forward<_Ts>(__ts)...);
8824 }
8825 };
8826
8827 inline constexpr _CartesianProduct cartesian_product;
8828 }
8829#endif // __cpp_lib_ranges_cartesian_product
8830
8831#ifdef __cpp_lib_ranges_as_rvalue // C++ >= 23
8832 template<input_range _Vp>
8833 requires view<_Vp>
8834 class as_rvalue_view : public view_interface<as_rvalue_view<_Vp>>
8835 {
8836 _Vp _M_base = _Vp();
8837
8838 public:
8839 as_rvalue_view() requires default_initializable<_Vp> = default;
8840
8841 constexpr explicit
8842 as_rvalue_view(_Vp __base)
8843 : _M_base(std::move(__base))
8844 { }
8845
8846 constexpr _Vp
8847 base() const& requires copy_constructible<_Vp>
8848 { return _M_base; }
8849
8850 constexpr _Vp
8851 base() &&
8852 { return std::move(_M_base); }
8853
8854 constexpr auto
8855 begin() requires (!__detail::__simple_view<_Vp>)
8856 { return move_iterator(ranges::begin(_M_base)); }
8857
8858 constexpr auto
8859 begin() const requires range<const _Vp>
8860 { return move_iterator(ranges::begin(_M_base)); }
8861
8862 constexpr auto
8863 end() requires (!__detail::__simple_view<_Vp>)
8864 {
8865 if constexpr (common_range<_Vp>)
8866 return move_iterator(ranges::end(_M_base));
8867 else
8868 return move_sentinel(ranges::end(_M_base));
8869 }
8870
8871 constexpr auto
8872 end() const requires range<const _Vp>
8873 {
8874 if constexpr (common_range<const _Vp>)
8875 return move_iterator(ranges::end(_M_base));
8876 else
8877 return move_sentinel(ranges::end(_M_base));
8878 }
8879
8880 constexpr auto
8881 size() requires sized_range<_Vp>
8882 { return ranges::size(_M_base); }
8883
8884 constexpr auto
8885 size() const requires sized_range<const _Vp>
8886 { return ranges::size(_M_base); }
8887 };
8888
8889 template<typename _Range>
8890 as_rvalue_view(_Range&&) -> as_rvalue_view<views::all_t<_Range>>;
8891
8892 template<typename _Tp>
8893 inline constexpr bool enable_borrowed_range<as_rvalue_view<_Tp>>
8894 = enable_borrowed_range<_Tp>;
8895
8896 namespace views
8897 {
8898 namespace __detail
8899 {
8900 template<typename _Tp>
8901 concept __can_as_rvalue_view = requires { as_rvalue_view(std::declval<_Tp>()); };
8902 }
8903
8904 struct _AsRvalue : __adaptor::_RangeAdaptorClosure<_AsRvalue>
8905 {
8906 template<viewable_range _Range>
8907 requires __detail::__can_as_rvalue_view<_Range>
8908 constexpr auto
8909 operator() [[nodiscard]] (_Range&& __r) const
8910 {
8911 if constexpr (same_as<range_rvalue_reference_t<_Range>,
8912 range_reference_t<_Range>>)
8913 return views::all(std::forward<_Range>(__r));
8914 else
8915 return as_rvalue_view(std::forward<_Range>(__r));
8916 }
8917 };
8918
8919 inline constexpr _AsRvalue as_rvalue;
8920 }
8921#endif // __cpp_lib_as_rvalue
8922
8923#ifdef __cpp_lib_ranges_enumerate // C++ >= 23
8924 namespace __detail
8925 {
8926 template<typename _Range>
8927 concept __range_with_movable_reference = input_range<_Range>
8928 && move_constructible<range_reference_t<_Range>>
8929 && move_constructible<range_rvalue_reference_t<_Range>>;
8930 }
8931
8932 template<view _Vp>
8933 requires __detail::__range_with_movable_reference<_Vp>
8934 class enumerate_view : public view_interface<enumerate_view<_Vp>>
8935 {
8936 _Vp _M_base = _Vp();
8937
8938 template<bool _Const> class _Iterator;
8939 template<bool _Const> class _Sentinel;
8940
8941 public:
8942 enumerate_view() requires default_initializable<_Vp> = default;
8943
8944 constexpr explicit
8945 enumerate_view(_Vp __base)
8946 : _M_base(std::move(__base))
8947 { }
8948
8949 constexpr auto
8950 begin() requires (!__detail::__simple_view<_Vp>)
8951 { return _Iterator<false>(ranges::begin(_M_base), 0); }
8952
8953 constexpr auto
8954 begin() const requires __detail::__range_with_movable_reference<const _Vp>
8955 { return _Iterator<true>(ranges::begin(_M_base), 0); }
8956
8957 constexpr auto
8958 end() requires (!__detail::__simple_view<_Vp>)
8959 {
8960 if constexpr (common_range<_Vp> && sized_range<_Vp>)
8961 return _Iterator<false>(ranges::end(_M_base), ranges::distance(_M_base));
8962 else
8963 return _Sentinel<false>(ranges::end(_M_base));
8964 }
8965
8966 constexpr auto
8967 end() const requires __detail::__range_with_movable_reference<const _Vp>
8968 {
8969 if constexpr (common_range<const _Vp> && sized_range<const _Vp>)
8970 return _Iterator<true>(ranges::end(_M_base), ranges::distance(_M_base));
8971 else
8972 return _Sentinel<true>(ranges::end(_M_base));
8973 }
8974
8975 constexpr auto
8976 size() requires sized_range<_Vp>
8977 { return ranges::size(_M_base); }
8978
8979 constexpr auto
8980 size() const requires sized_range<const _Vp>
8981 { return ranges::size(_M_base); }
8982
8983 constexpr _Vp
8984 base() const & requires copy_constructible<_Vp>
8985 { return _M_base; }
8986
8987 constexpr _Vp
8988 base() &&
8989 { return std::move(_M_base); }
8990 };
8991
8992 template<typename _Range>
8993 enumerate_view(_Range&&) -> enumerate_view<views::all_t<_Range>>;
8994
8995 template<typename _Tp>
8996 inline constexpr bool enable_borrowed_range<enumerate_view<_Tp>>
8997 = enable_borrowed_range<_Tp>;
8998
8999 template<view _Vp>
9000 requires __detail::__range_with_movable_reference<_Vp>
9001 template<bool _Const>
9002 class enumerate_view<_Vp>::_Iterator
9003 {
9004 using _Base = __maybe_const_t<_Const, _Vp>;
9005
9006 static auto
9007 _S_iter_concept()
9008 {
9009 if constexpr (random_access_range<_Base>)
9010 return random_access_iterator_tag{};
9011 else if constexpr (bidirectional_range<_Base>)
9012 return bidirectional_iterator_tag{};
9013 else if constexpr (forward_range<_Base>)
9014 return forward_iterator_tag{};
9015 else
9016 return input_iterator_tag{};
9017 }
9018
9019 friend enumerate_view;
9020
9021 public:
9022 using iterator_category = input_iterator_tag;
9023 using iterator_concept = decltype(_S_iter_concept());
9024 using difference_type = range_difference_t<_Base>;
9025 using value_type = tuple<difference_type, range_value_t<_Base>>;
9026
9027 private:
9028 using __reference_type = tuple<difference_type, range_reference_t<_Base>>;
9029
9030 iterator_t<_Base> _M_current = iterator_t<_Base>();
9031 difference_type _M_pos = 0;
9032
9033 constexpr explicit
9034 _Iterator(iterator_t<_Base> __current, difference_type __pos)
9035 : _M_current(std::move(__current)), _M_pos(__pos)
9036 { }
9037
9038 public:
9039 _Iterator() requires default_initializable<iterator_t<_Base>> = default;
9040
9041 constexpr
9042 _Iterator(_Iterator<!_Const> __i)
9043 requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
9044 : _M_current(std::move(__i._M_current)), _M_pos(__i._M_pos)
9045 { }
9046
9047 constexpr const iterator_t<_Base> &
9048 base() const & noexcept
9049 { return _M_current; }
9050
9051 constexpr iterator_t<_Base>
9052 base() &&
9053 { return std::move(_M_current); }
9054
9055 constexpr difference_type
9056 index() const noexcept
9057 { return _M_pos; }
9058
9059 constexpr auto
9060 operator*() const
9061 { return __reference_type(_M_pos, *_M_current); }
9062
9063 constexpr _Iterator&
9064 operator++()
9065 {
9066 ++_M_current;
9067 ++_M_pos;
9068 return *this;
9069 }
9070
9071 constexpr void
9072 operator++(int)
9073 { ++*this; }
9074
9075 constexpr _Iterator
9076 operator++(int) requires forward_range<_Base>
9077 {
9078 auto __tmp = *this;
9079 ++*this;
9080 return __tmp;
9081 }
9082
9083 constexpr _Iterator&
9084 operator--() requires bidirectional_range<_Base>
9085 {
9086 --_M_current;
9087 --_M_pos;
9088 return *this;
9089 }
9090
9091 constexpr _Iterator
9092 operator--(int) requires bidirectional_range<_Base>
9093 {
9094 auto __tmp = *this;
9095 --*this;
9096 return __tmp;
9097 }
9098
9099 constexpr _Iterator&
9100 operator+=(difference_type __n) requires random_access_range<_Base>
9101 {
9102 _M_current += __n;
9103 _M_pos += __n;
9104 return *this;
9105 }
9106
9107 constexpr _Iterator&
9108 operator-=(difference_type __n) requires random_access_range<_Base>
9109 {
9110 _M_current -= __n;
9111 _M_pos -= __n;
9112 return *this;
9113 }
9114
9115 constexpr auto
9116 operator[](difference_type __n) const requires random_access_range<_Base>
9117 { return __reference_type(_M_pos + __n, _M_current[__n]); }
9118
9119 friend constexpr bool
9120 operator==(const _Iterator& __x, const _Iterator& __y) noexcept
9121 { return __x._M_pos == __y._M_pos; }
9122
9123 friend constexpr strong_ordering
9124 operator<=>(const _Iterator& __x, const _Iterator& __y) noexcept
9125 { return __x._M_pos <=> __y._M_pos; }
9126
9127 friend constexpr _Iterator
9128 operator+(const _Iterator& __x, difference_type __y)
9129 requires random_access_range<_Base>
9130 { return (auto(__x) += __y); }
9131
9132 friend constexpr _Iterator
9133 operator+(difference_type __x, const _Iterator& __y)
9134 requires random_access_range<_Base>
9135 { return auto(__y) += __x; }
9136
9137 friend constexpr _Iterator
9138 operator-(const _Iterator& __x, difference_type __y)
9139 requires random_access_range<_Base>
9140 { return auto(__x) -= __y; }
9141
9142 friend constexpr difference_type
9143 operator-(const _Iterator& __x, const _Iterator& __y)
9144 { return __x._M_pos - __y._M_pos; }
9145
9146 friend constexpr auto
9147 iter_move(const _Iterator& __i)
9148 noexcept(noexcept(ranges::iter_move(__i._M_current))
9149 && is_nothrow_move_constructible_v<range_rvalue_reference_t<_Base>>)
9150 {
9151 return tuple<difference_type, range_rvalue_reference_t<_Base>>
9152 (__i._M_pos, ranges::iter_move(__i._M_current));
9153 }
9154 };
9155
9156 template<view _Vp>
9157 requires __detail::__range_with_movable_reference<_Vp>
9158 template<bool _Const>
9159 class enumerate_view<_Vp>::_Sentinel
9160 {
9161 using _Base = __maybe_const_t<_Const, _Vp>;
9162
9163 sentinel_t<_Base> _M_end = sentinel_t<_Base>();
9164
9165 constexpr explicit
9166 _Sentinel(sentinel_t<_Base> __end)
9167 : _M_end(std::move(__end))
9168 { }
9169
9170 friend enumerate_view;
9171
9172 public:
9173 _Sentinel() = default;
9174
9175 constexpr
9176 _Sentinel(_Sentinel<!_Const> __other)
9177 requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
9178 : _M_end(std::move(__other._M_end))
9179 { }
9180
9181 constexpr sentinel_t<_Base>
9182 base() const
9183 { return _M_end; }
9184
9185 template<bool _OtherConst>
9186 requires sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const_t<_OtherConst, _Vp>>>
9187 friend constexpr bool
9188 operator==(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
9189 { return __x._M_current == __y._M_end; }
9190
9191 template<bool _OtherConst>
9192 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const_t<_OtherConst, _Vp>>>
9193 friend constexpr range_difference_t<__maybe_const_t<_OtherConst, _Vp>>
9194 operator-(const _Iterator<_OtherConst>& __x, const _Sentinel& __y)
9195 { return __x._M_current - __y._M_end; }
9196
9197 template<bool _OtherConst>
9198 requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const_t<_OtherConst, _Vp>>>
9199 friend constexpr range_difference_t<__maybe_const_t<_OtherConst, _Vp>>
9200 operator-(const _Sentinel& __x, const _Iterator<_OtherConst>& __y)
9201 { return __x._M_end - __y._M_current; }
9202 };
9203
9204 namespace views
9205 {
9206 namespace __detail
9207 {
9208 template<typename _Tp>
9209 concept __can_enumerate_view
9210 = requires { enumerate_view<all_t<_Tp>>(std::declval<_Tp>()); };
9211 }
9212
9213 struct _Enumerate : __adaptor::_RangeAdaptorClosure<_Enumerate>
9214 {
9215 template<viewable_range _Range>
9216 requires __detail::__can_enumerate_view<_Range>
9217 constexpr auto
9218 operator() [[nodiscard]] (_Range&& __r) const
9219 { return enumerate_view<all_t<_Range>>(std::forward<_Range>(__r)); }
9220 };
9221
9222 inline constexpr _Enumerate enumerate;
9223 }
9224#endif // __cpp_lib_ranges_enumerate
9225
9226#ifdef __cpp_lib_ranges_as_const // C++ >= 23
9227 template<view _Vp>
9228 requires input_range<_Vp>
9229 class as_const_view : public view_interface<as_const_view<_Vp>>
9230 {
9231 _Vp _M_base = _Vp();
9232
9233 public:
9234 as_const_view() requires default_initializable<_Vp> = default;
9235
9236 constexpr explicit
9237 as_const_view(_Vp __base)
9238 noexcept(is_nothrow_move_constructible_v<_Vp>)
9239 : _M_base(std::move(__base))
9240 { }
9241
9242 constexpr _Vp
9243 base() const &
9244 noexcept(is_nothrow_copy_constructible_v<_Vp>)
9245 requires copy_constructible<_Vp>
9246 { return _M_base; }
9247
9248 constexpr _Vp
9249 base() &&
9250 noexcept(is_nothrow_move_constructible_v<_Vp>)
9251 { return std::move(_M_base); }
9252
9253 constexpr auto
9254 begin() requires (!__detail::__simple_view<_Vp>)
9255 { return ranges::cbegin(_M_base); }
9256
9257 constexpr auto
9258 begin() const requires range<const _Vp>
9259 { return ranges::cbegin(_M_base); }
9260
9261 constexpr auto
9262 end() requires (!__detail::__simple_view<_Vp>)
9263 { return ranges::cend(_M_base); }
9264
9265 constexpr auto
9266 end() const requires range<const _Vp>
9267 { return ranges::cend(_M_base); }
9268
9269 constexpr auto
9270 size() requires sized_range<_Vp>
9271 { return ranges::size(_M_base); }
9272
9273 constexpr auto
9274 size() const requires sized_range<const _Vp>
9275 { return ranges::size(_M_base); }
9276 };
9277
9278 template<typename _Range>
9279 as_const_view(_Range&&) -> as_const_view<views::all_t<_Range>>;
9280
9281 template<typename _Tp>
9282 inline constexpr bool enable_borrowed_range<as_const_view<_Tp>>
9283 = enable_borrowed_range<_Tp>;
9284
9285 namespace views
9286 {
9287 namespace __detail
9288 {
9289 template<typename _Tp>
9290 inline constexpr bool __is_ref_view = false;
9291
9292 template<typename _Range>
9293 inline constexpr bool __is_ref_view<ref_view<_Range>> = true;
9294
9295 template<typename _Range>
9296 concept __can_as_const_view = requires { as_const_view(std::declval<_Range>()); };
9297 }
9298
9299 struct _AsConst : __adaptor::_RangeAdaptorClosure<_AsConst>
9300 {
9301 template<viewable_range _Range>
9302 constexpr auto
9303 operator()(_Range&& __r) const
9304 noexcept(noexcept(as_const_view(std::declval<_Range>())))
9305 requires __detail::__can_as_const_view<_Range>
9306 {
9307 using _Tp = remove_cvref_t<_Range>;
9308 using element_type = remove_reference_t<range_reference_t<_Range>>;
9309 if constexpr (constant_range<views::all_t<_Range>>)
9310 return views::all(std::forward<_Range>(__r));
9311 else if constexpr (__detail::__is_empty_view<_Tp>)
9312 return views::empty<const element_type>;
9313 else if constexpr (std::__detail::__is_span<_Tp>)
9314 return span<const element_type, _Tp::extent>(std::forward<_Range>(__r));
9315 else if constexpr (__detail::__is_ref_view<_Tp>
9316 && constant_range<const element_type>)
9317 return ref_view(static_cast<const element_type&>
9318 (std::forward<_Range>(__r).base()));
9319 else if constexpr (is_lvalue_reference_v<_Range>
9320 && constant_range<const _Tp>
9321 && !view<_Tp>)
9322 return ref_view(static_cast<const _Tp&>(__r));
9323 else
9324 return as_const_view(std::forward<_Range>(__r));
9325 }
9326 };
9327
9328 inline constexpr _AsConst as_const;
9329 }
9330#endif // __cpp_lib_as_const
9331} // namespace ranges
9332
9333 namespace views = ranges::views;
9334
9335#if __cpp_lib_ranges_to_container // C++ >= 23
9336namespace ranges
9337{
9338/// @cond undocumented
9339namespace __detail
9340{
9341 template<typename _Container>
9342 constexpr bool __reservable_container
9343 = sized_range<_Container>
9344 && requires(_Container& __c, range_size_t<_Container> __n) {
9345 __c.reserve(__n);
9346 { __c.capacity() } -> same_as<decltype(__n)>;
9347 { __c.max_size() } -> same_as<decltype(__n)>;
9348 };
9349
9350 template<typename _Cont, typename _Range>
9351 constexpr bool __toable = requires {
9352 requires (!input_range<_Cont>
9353 || convertible_to<range_reference_t<_Range>,
9354 range_value_t<_Cont>>);
9355 };
9356} // namespace __detail
9357/// @endcond
9358
9359 /// Convert a range to a container.
9360 /**
9361 * @tparam _Cont A container type.
9362 * @param __r A range that models the `input_range` concept.
9363 * @param __args... Arguments to pass to the container constructor.
9364 * @since C++23
9365 *
9366 * This function converts a range to the `_Cont` type.
9367 *
9368 * For example, `std::ranges::to<std::vector<int>>(some_view)`
9369 * will convert the view to `std::vector<int>`.
9370 *
9371 * Additional constructor arguments for the container can be supplied after
9372 * the input range argument, e.g.
9373 * `std::ranges::to<std::vector<int, Alloc<int>>>(a_range, an_allocator)`.
9374 */
9375 template<typename _Cont, input_range _Rg, typename... _Args>
9376 requires (!view<_Cont>)
9377 constexpr _Cont
9378 to [[nodiscard]] (_Rg&& __r, _Args&&... __args)
9379 {
9380 static_assert(!is_const_v<_Cont> && !is_volatile_v<_Cont>);
9381 static_assert(is_class_v<_Cont>);
9382
9383 if constexpr (__detail::__toable<_Cont, _Rg>)
9384 {
9385 if constexpr (constructible_from<_Cont, _Rg, _Args...>)
9386 return _Cont(std::forward<_Rg>(__r),
9387 std::forward<_Args>(__args)...);
9388 else if constexpr (constructible_from<_Cont, from_range_t, _Rg, _Args...>)
9389 return _Cont(from_range, std::forward<_Rg>(__r),
9390 std::forward<_Args>(__args)...);
9391 else if constexpr (requires { requires common_range<_Rg>;
9392 typename __iter_category_t<iterator_t<_Rg>>;
9393 requires derived_from<__iter_category_t<iterator_t<_Rg>>,
9394 input_iterator_tag>;
9395 requires constructible_from<_Cont, iterator_t<_Rg>,
9396 sentinel_t<_Rg>, _Args...>;
9397 })
9398 return _Cont(ranges::begin(__r), ranges::end(__r),
9399 std::forward<_Args>(__args)...);
9400 else
9401 {
9402 using _RefT = range_reference_t<_Rg>;
9403 static_assert(constructible_from<_Cont, _Args...>);
9404 _Cont __c(std::forward<_Args>(__args)...);
9405 if constexpr (sized_range<_Rg>
9406 && __detail::__reservable_container<_Cont>)
9407 __c.reserve(static_cast<range_size_t<_Cont>>(ranges::size(__r)));
9408 // _GLIBCXX_RESOLVE_LIB_DEFECTS
9409 // 4016. container-insertable checks do not match what
9410 // container-inserter does
9411 auto __it = ranges::begin(__r);
9412 const auto __sent = ranges::end(__r);
9413 while (__it != __sent)
9414 {
9415 if constexpr (requires { __c.emplace_back(*__it); })
9416 __c.emplace_back(*__it);
9417 else if constexpr (requires { __c.push_back(*__it); })
9418 __c.push_back(*__it);
9419 else if constexpr (requires { __c.emplace(__c.end(), *__it); })
9420 __c.emplace(__c.end(), *__it);
9421 else
9422 __c.insert(__c.end(), *__it);
9423 ++__it;
9424 }
9425 return __c;
9426 }
9427 }
9428 else
9429 {
9430 static_assert(input_range<range_reference_t<_Rg>>);
9431 // _GLIBCXX_RESOLVE_LIB_DEFECTS
9432 // 3984. ranges::to's recursion branch may be ill-formed
9433 return ranges::to<_Cont>(ref_view(__r) | views::transform(
9434 []<typename _Elt>(_Elt&& __elem) {
9435 using _ValT = range_value_t<_Cont>;
9436 return ranges::to<_ValT>(std::forward<_Elt>(__elem));
9437 }), std::forward<_Args>(__args)...);
9438 }
9439 }
9440
9441/// @cond undocumented
9442namespace __detail
9443{
9444 template<typename _Rg>
9445 struct _InputIter
9446 {
9447 using iterator_category = input_iterator_tag;
9448 using value_type = range_value_t<_Rg>;
9449 using difference_type = ptrdiff_t;
9450 using pointer = add_pointer_t<range_reference_t<_Rg>>;
9451 using reference = range_reference_t<_Rg>;
9452 reference operator*() const;
9453 pointer operator->() const;
9454 _InputIter& operator++();
9455 _InputIter operator++(int);
9456 bool operator==(const _InputIter&) const;
9457 };
9458
9459 template<template<typename...> typename _Cont, input_range _Rg,
9460 typename... _Args>
9461 using _DeduceExpr1
9462 = decltype(_Cont(std::declval<_Rg>(), std::declval<_Args>()...));
9463
9464 template<template<typename...> typename _Cont, input_range _Rg,
9465 typename... _Args>
9466 using _DeduceExpr2
9467 = decltype(_Cont(from_range, std::declval<_Rg>(),
9468 std::declval<_Args>()...));
9469
9470 template<template<typename...> typename _Cont, input_range _Rg,
9471 typename... _Args>
9472 using _DeduceExpr3
9473 = decltype(_Cont(std::declval<_InputIter<_Rg>>(),
9474 std::declval<_InputIter<_Rg>>(),
9475 std::declval<_Args>()...));
9476
9477} // namespace __detail
9478/// @endcond
9479
9480 template<template<typename...> typename _Cont, input_range _Rg,
9481 typename... _Args>
9482 constexpr auto
9483 to [[nodiscard]] (_Rg&& __r, _Args&&... __args)
9484 {
9485 using __detail::_DeduceExpr1;
9486 using __detail::_DeduceExpr2;
9487 using __detail::_DeduceExpr3;
9488 if constexpr (requires { typename _DeduceExpr1<_Cont, _Rg, _Args...>; })
9489 return ranges::to<_DeduceExpr1<_Cont, _Rg, _Args...>>(
9490 std::forward<_Rg>(__r), std::forward<_Args>(__args)...);
9491 else if constexpr (requires { typename _DeduceExpr2<_Cont, _Rg, _Args...>; })
9492 return ranges::to<_DeduceExpr2<_Cont, _Rg, _Args...>>(
9493 std::forward<_Rg>(__r), std::forward<_Args>(__args)...);
9494 else if constexpr (requires { typename _DeduceExpr3<_Cont, _Rg, _Args...>; })
9495 return ranges::to<_DeduceExpr3<_Cont, _Rg, _Args...>>(
9496 std::forward<_Rg>(__r), std::forward<_Args>(__args)...);
9497 else
9498 static_assert(false); // Cannot deduce container specialization.
9499 }
9500
9501/// @cond undocumented
9502namespace __detail
9503{
9504 template<typename _Cont>
9505 struct _To
9506 {
9507 template<typename _Range, typename... _Args>
9508 requires requires { ranges::to<_Cont>(std::declval<_Range>(),
9509 std::declval<_Args>()...); }
9510 constexpr auto
9511 operator()(_Range&& __r, _Args&&... __args) const
9512 {
9513 return ranges::to<_Cont>(std::forward<_Range>(__r),
9514 std::forward<_Args>(__args)...);
9515 }
9516 };
9517} // namespace __detail
9518/// @endcond
9519
9520 /// ranges::to adaptor for converting a range to a container type
9521 /**
9522 * @tparam _Cont A container type.
9523 * @param __args... Arguments to pass to the container constructor.
9524 * @since C++23
9525 *
9526 * This range adaptor returns a range adaptor closure object that converts
9527 * a range to the `_Cont` type.
9528 *
9529 * For example, `some_view | std::ranges::to<std::vector<int>>()`
9530 * will convert the view to `std::vector<int>`.
9531 *
9532 * Additional constructor arguments for the container can be supplied, e.g.
9533 * `r | std::ranges::to<std::vector<int, Alloc<int>>>(an_allocator)`.
9534 */
9535 template<typename _Cont, typename... _Args>
9536 requires (!view<_Cont>)
9537 constexpr auto
9538 to [[nodiscard]] (_Args&&... __args)
9539 {
9540 using __detail::_To;
9541 using views::__adaptor::_Partial;
9542 return _Partial<_To<_Cont>, decay_t<_Args>...>{0, std::forward<_Args>(__args)...};
9543 }
9544
9545/// @cond undocumented
9546namespace __detail
9547{
9548 template<template<typename...> typename _Cont>
9549 struct _To2
9550 {
9551 template<typename _Range, typename... _Args>
9552 requires requires { ranges::to<_Cont>(std::declval<_Range>(),
9553 std::declval<_Args>()...); }
9554 constexpr auto
9555 operator()(_Range&& __r, _Args&&... __args) const
9556 {
9557 return ranges::to<_Cont>(std::forward<_Range>(__r),
9558 std::forward<_Args>(__args)...);
9559 }
9560 };
9561} // namespace __detail
9562/// @endcond
9563
9564 /// ranges::to adaptor for converting a range to a deduced container type.
9565 /**
9566 * @tparam _Cont A container template.
9567 * @param __args... Arguments to pass to the container constructor.
9568 * @since C++23
9569 *
9570 * This range adaptor returns a range adaptor closure object that converts
9571 * a range to a specialization of the `_Cont` class template. The specific
9572 * specialization of `_Cont` to be used is deduced automatically.
9573 *
9574 * For example, `some_view | std::ranges::to<std::vector>(Alloc<int>{})`
9575 * will convert the view to `std::vector<T, Alloc<T>>`, where `T` is the
9576 * view's value type, i.e. `std::ranges::range_value_t<decltype(some_view)>`.
9577 *
9578 * Additional constructor arguments for the container can be supplied, e.g.
9579 * `r | std::ranges::to<std::vector>(an_allocator)`.
9580 */
9581 template<template<typename...> typename _Cont, typename... _Args>
9582 constexpr auto
9583 to [[nodiscard]] (_Args&&... __args)
9584 {
9585 using __detail::_To2;
9586 using views::__adaptor::_Partial;
9587 return _Partial<_To2<_Cont>, decay_t<_Args>...>{0, std::forward<_Args>(__args)...};
9588 }
9589
9590} // namespace ranges
9591#endif // __cpp_lib_ranges_to_container
9592
9593_GLIBCXX_END_NAMESPACE_VERSION
9594} // namespace std
9595#endif // library concepts
9596#endif // C++2a
9597#endif /* _GLIBCXX_RANGES */