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