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