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