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