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