1// -*- C++ -*-
2//===----------------------------------------------------------------------===//
3//
4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5// See https://llvm.org/LICENSE.txt for license information.
6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7//
8//===----------------------------------------------------------------------===//
9
10#ifndef _LIBCPP___RANGES_CONCAT_VIEW_H
11#define _LIBCPP___RANGES_CONCAT_VIEW_H
12
13#include <__assert>
14#include <__concepts/common_reference_with.h>
15#include <__concepts/constructible.h>
16#include <__concepts/convertible_to.h>
17#include <__concepts/copyable.h>
18#include <__concepts/derived_from.h>
19#include <__concepts/equality_comparable.h>
20#include <__concepts/swappable.h>
21#include <__config>
22#include <__iterator/concepts.h>
23#include <__iterator/default_sentinel.h>
24#include <__iterator/distance.h>
25#include <__iterator/incrementable_traits.h>
26#include <__iterator/iter_move.h>
27#include <__iterator/iter_swap.h>
28#include <__iterator/iterator_traits.h>
29#include <__iterator/next.h>
30#include <__ranges/access.h>
31#include <__ranges/all.h>
32#include <__ranges/concepts.h>
33#include <__ranges/movable_box.h>
34#include <__ranges/range_adaptor.h>
35#include <__ranges/size.h>
36#include <__ranges/view_interface.h>
37#include <__tuple/tuple_transform.h>
38#include <__type_traits/conditional.h>
39#include <__type_traits/decay.h>
40#include <__type_traits/is_nothrow_constructible.h>
41#include <__type_traits/make_unsigned.h>
42#include <__type_traits/maybe_const.h>
43#include <__utility/forward.h>
44#include <__utility/in_place.h>
45#include <__utility/move.h>
46#include <tuple>
47#include <variant>
48
49#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
50# pragma GCC system_header
51#endif
52
53_LIBCPP_PUSH_MACROS
54#include <__undef_macros>
55
56_LIBCPP_BEGIN_NAMESPACE_STD
57
58#if _LIBCPP_STD_VER >= 26
59
60namespace ranges {
61
62# ifdef __cpp_pack_indexing
63template <class... _Tp>
64using __extract_last _LIBCPP_NODEBUG = _Tp...[sizeof...(_Tp) - 1];
65# else
66template <class _Tp, class... _Tail>
67struct __extract_last_impl : __extract_last_impl<_Tail...> {};
68template <class _Tp>
69struct __extract_last_impl<_Tp> {
70 using type _LIBCPP_NODEBUG = _Tp;
71};
72
73template <class... _Tp>
74using __extract_last _LIBCPP_NODEBUG = __extract_last_impl<_Tp...>::type;
75# endif
76
77template <bool _Const, class... _Tp>
78struct __all_but_first_model_sized_range;
79
80template <bool _Const, class _Head, class... _Tail>
81struct __all_but_first_model_sized_range<_Const, _Head, _Tail...> {
82 static constexpr bool value = (sized_range<__maybe_const<_Const, _Tail>> && ...);
83};
84
85template <bool _Const, class... _Views>
86concept __all_random_access = (random_access_range<__maybe_const<_Const, _Views>> && ...);
87
88template <bool _Const, class... _Views>
89concept __all_bidirectional = (bidirectional_range<__maybe_const<_Const, _Views>> && ...);
90
91template <bool _Const, class... _Views>
92concept __all_forward = (forward_range<__maybe_const<_Const, _Views>> && ...);
93
94template <bool _Const, class _First, class... _Tail>
95struct __all_common_ignore_last {
96 static constexpr bool value =
97 common_range<__maybe_const<_Const, _First>> && __all_common_ignore_last<_Const, _Tail...>::value;
98};
99
100template <bool _Const, class _Tail>
101struct __all_common_ignore_last<_Const, _Tail> {
102 static constexpr bool value = true;
103};
104
105template <bool _Const, class... _Rs>
106concept __concat_is_random_access =
107 (__all_random_access<_Const, _Rs...>) && (__all_common_ignore_last<_Const, _Rs...>::value);
108
109template <bool _Const, class... _Rs>
110concept __concat_is_bidirectional =
111 (__all_bidirectional<_Const, _Rs...>) && (__all_common_ignore_last<_Const, _Rs...>::value);
112
113template <input_range... _Views>
114 requires((view<_Views> && ...) && (sizeof...(_Views) > 0) && __concatable<_Views...>)
115class concat_view : public view_interface<concat_view<_Views...>> {
116 tuple<_Views...> __views_;
117
118 template <bool _Const>
119 class __iterator;
120
121public:
122 _LIBCPP_HIDE_FROM_ABI constexpr concat_view() = default;
123
124 _LIBCPP_HIDE_FROM_ABI constexpr explicit concat_view(_Views... __views) : __views_(std::move(__views)...) {}
125
126 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __iterator<false> begin()
127 requires(!(__simple_view<_Views> && ...))
128 {
129 __iterator<false> __it(this, in_place_index<0>, ranges::begin(std::get<0>(__views_)));
130 __it.template __satisfy<0>();
131 return __it;
132 }
133
134 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __iterator<true> begin() const
135 requires((range<const _Views> && ...) && __concatable<const _Views...>)
136 {
137 __iterator<true> __it(this, in_place_index<0>, ranges::begin(std::get<0>(__views_)));
138 __it.template __satisfy<0>();
139 return __it;
140 }
141
142 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto end()
143 requires(!(__simple_view<_Views> && ...))
144 {
145 if constexpr (__all_forward<false, _Views...> && common_range<__maybe_const<false, __extract_last<_Views...>>>) {
146 constexpr auto __n = sizeof...(_Views);
147 return __iterator<false>(this, in_place_index<__n - 1>, ranges::end(std::get<__n - 1>(__views_)));
148 } else {
149 return default_sentinel;
150 }
151 }
152
153 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
154 requires((range<const _Views> && ...) && __concatable<const _Views...>)
155 {
156 if constexpr (__all_forward<true, _Views...> && common_range<__maybe_const<true, __extract_last<_Views...>>>) {
157 constexpr auto __n = sizeof...(_Views);
158 return __iterator<true>(this, in_place_index<__n - 1>, ranges::end(std::get<__n - 1>(__views_)));
159 } else {
160 return default_sentinel;
161 }
162 }
163
164 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto size()
165 requires(sized_range<_Views> && ...)
166 {
167 return std::apply(
168 [](auto... __sizes) { return (make_unsigned_t<common_type_t<decltype(__sizes)...>>(__sizes) + ...); },
169 std::__tuple_transform(ranges::size, __views_));
170 }
171
172 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
173 requires(sized_range<const _Views> && ...)
174 {
175 return std::apply(
176 [](auto... __sizes) { return (make_unsigned_t<common_type_t<decltype(__sizes)...>>(__sizes) + ...); },
177 std::__tuple_transform(ranges::size, __views_));
178 }
179};
180
181template <class... _Views>
182concat_view(_Views&&...) -> concat_view<views::all_t<_Views>...>;
183
184template <bool _Const, typename... _Views>
185struct __concat_view_iterator_category {};
186
187template <bool _Const, typename... _Views>
188 requires __all_forward<_Const, _Views...>
189struct __concat_view_iterator_category<_Const, _Views...> {
190private:
191 constexpr static bool __derive_pack_random_iterator =
192 (derived_from<typename iterator_traits<iterator_t<__maybe_const<_Const, _Views>>>::iterator_category,
193 random_access_iterator_tag> &&
194 ...);
195 constexpr static bool __derive_pack_bidirectional_iterator =
196 (derived_from<typename iterator_traits<iterator_t<__maybe_const<_Const, _Views>>>::iterator_category,
197 bidirectional_iterator_tag> &&
198 ...);
199 constexpr static bool __derive_pack_forward_iterator =
200 (derived_from<typename iterator_traits< iterator_t<__maybe_const<_Const, _Views>>>::iterator_category,
201 forward_iterator_tag> &&
202 ...);
203
204public:
205 using iterator_category =
206 _If<!is_reference_v<__concat_reference_t<__maybe_const<_Const, _Views>...>>,
207 input_iterator_tag,
208 _If<__derive_pack_random_iterator,
209 random_access_iterator_tag,
210 _If<__derive_pack_bidirectional_iterator,
211 bidirectional_iterator_tag,
212 _If<__derive_pack_forward_iterator, forward_iterator_tag, input_iterator_tag > > > >;
213};
214
215template <input_range... _Views>
216 requires((view<_Views> && ...) && (sizeof...(_Views) > 0) && __concatable<_Views...>)
217template <bool _Const>
218class concat_view<_Views...>::__iterator : public __concat_view_iterator_category<_Const, _Views...> {
219public:
220 using iterator_concept =
221 _If<__concat_is_random_access<_Const, _Views...>,
222 random_access_iterator_tag,
223 _If<__concat_is_bidirectional<_Const, _Views...>,
224 bidirectional_iterator_tag,
225 _If< __all_forward<_Const, _Views...>, forward_iterator_tag, input_iterator_tag > > >;
226 using value_type = __concat_value_t<__maybe_const<_Const, _Views>...>;
227 using difference_type = common_type_t<range_difference_t<__maybe_const<_Const, _Views>>...>;
228
229private:
230 using __base_iter _LIBCPP_NODEBUG = variant<iterator_t<__maybe_const<_Const, _Views>>...>;
231 __base_iter __it_;
232 __maybe_const<_Const, concat_view>* __parent_ = nullptr;
233
234 template <size_t _Idx>
235 _LIBCPP_HIDE_FROM_ABI constexpr void __satisfy() {
236 if constexpr (_Idx < (sizeof...(_Views) - 1)) {
237 if (std::get<_Idx>(__it_) == ranges::end(std::get<_Idx>(__parent_->__views_))) {
238 __it_.template emplace<_Idx + 1>(ranges::begin(std::get<_Idx + 1>(__parent_->__views_)));
239 __satisfy<_Idx + 1>();
240 }
241 }
242 }
243
244 template <size_t _Idx>
245 _LIBCPP_HIDE_FROM_ABI constexpr void __prev() {
246 if constexpr (_Idx == 0) {
247 --std::get<0>(__it_);
248 } else {
249 if (std::get<_Idx>(__it_) == ranges::begin(std::get<_Idx>(__parent_->__views_))) {
250 __it_.template emplace<_Idx - 1>(ranges::end(std::get<_Idx - 1>(__parent_->__views_)));
251 __prev<_Idx - 1>();
252 } else {
253 --std::get<_Idx>(__it_);
254 }
255 }
256 }
257
258 template <size_t _Idx>
259 _LIBCPP_HIDE_FROM_ABI constexpr void __advance_fwd(difference_type __offset, difference_type __steps) {
260 using __underlying_diff_type = iter_difference_t<variant_alternative_t<_Idx, __base_iter>>;
261 if constexpr (_Idx == sizeof...(_Views) - 1) {
262 std::get<_Idx>(__it_) += static_cast<__underlying_diff_type>(__steps);
263 } else {
264 auto __n_size = ranges::distance(std::get<_Idx>(__parent_->__views_));
265 if (__offset + __steps < __n_size) {
266 std::get<_Idx>(__it_) += static_cast<__underlying_diff_type>(__steps);
267 } else {
268 __it_.template emplace<_Idx + 1>(ranges::begin(std::get<_Idx + 1>(__parent_->__views_)));
269 __advance_fwd<_Idx + 1>(0, __offset + __steps - __n_size);
270 }
271 }
272 }
273
274 template <size_t _Idx>
275 _LIBCPP_HIDE_FROM_ABI constexpr void __advance_bwd(difference_type __offset, difference_type __steps) {
276 using __underlying_diff_type = iter_difference_t<variant_alternative_t<_Idx, __base_iter>>;
277 if constexpr (_Idx == 0) {
278 std::get<_Idx>(__it_) -= static_cast<__underlying_diff_type>(__steps);
279 } else {
280 if (__offset >= __steps) {
281 std::get<_Idx>(__it_) -= static_cast<__underlying_diff_type>(__steps);
282 } else {
283 auto __prev_size = ranges::distance(std::get<_Idx - 1>(__parent_->__views_));
284 __it_.template emplace<_Idx - 1>(ranges::end(std::get<_Idx - 1>(__parent_->__views_)));
285 __advance_bwd<_Idx - 1>(__prev_size, __steps - __offset);
286 }
287 }
288 }
289
290 template <typename _Func>
291 _LIBCPP_HIDE_FROM_ABI constexpr auto __invoke_at_index(_Func&& __func) const {
292 return [&__func, this]<std::size_t _Is>(this auto&& __self) {
293 if (_Is == __it_.index()) {
294 return __func.template operator()<_Is>();
295 }
296 if constexpr (_Is + 1 < sizeof...(_Views)) {
297 return __self.template operator()<_Is + 1>();
298 }
299 __builtin_unreachable();
300 }.template operator()<0>();
301 }
302
303 template <size_t... _Is, typename _Func>
304 _LIBCPP_HIDE_FROM_ABI constexpr void __apply_at_index(size_t __index, _Func&& __func, index_sequence<_Is...>) const {
305 ((__index == _Is ? (static_cast<void>(__func(integral_constant<size_t, _Is>{})), 0) : 0), ...);
306 }
307
308 template <size_t _Idx, typename _Func>
309 _LIBCPP_HIDE_FROM_ABI constexpr void __apply_at_index(size_t __index, _Func&& __func) const {
310 __apply_at_index(__index, std::forward<_Func>(__func), make_index_sequence<_Idx>{});
311 }
312
313 template <class... _Args>
314 _LIBCPP_HIDE_FROM_ABI explicit constexpr __iterator(__maybe_const<_Const, concat_view>* __parent, _Args&&... __args)
315 requires constructible_from<__base_iter, _Args&&...>
316 : __it_(std::forward<_Args>(__args)...), __parent_(__parent) {}
317
318 friend class concat_view;
319 friend class __iterator<!_Const>;
320
321public:
322 _LIBCPP_HIDE_FROM_ABI __iterator() = default;
323
324 _LIBCPP_HIDE_FROM_ABI constexpr __iterator(__iterator<!_Const> __i)
325 requires _Const && (convertible_to<iterator_t<_Views>, iterator_t<const _Views>> && ...)
326 : __it_([&__src = __i.__it_]<size_t... _Indices>(size_t __idx, index_sequence<_Indices...>) -> __base_iter {
327 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
328 !__src.valueless_by_exception(), "Trying to convert from a valueless iterator of concat_view.");
329 using __src_lref = decltype((__src));
330 using __construction_fptr = __base_iter (*)(__src_lref);
331 static constexpr __construction_fptr __vtable[]{[](__src_lref __src_var) -> __base_iter {
332 return __base_iter(in_place_index<_Indices>, std::__unchecked_get<_Indices>(std::move(__src_var)));
333 }...};
334 return __vtable[__idx](__src);
335 }(__i.__it_.index(), make_index_sequence<variant_size_v<__base_iter>>{})),
336 __parent_(__i.__parent_) {}
337
338 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator*() const {
339 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
340 !__it_.valueless_by_exception(), "Trying to dereference a valueless iterator of concat_view.");
341 return __variant_detail::__visitation::__variant::__visit_value(
342 [](auto&& __it) -> __concat_reference_t<__maybe_const<_Const, _Views>...> { return *__it; }, __it_);
343 }
344
345 _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator++() {
346 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
347 !__it_.valueless_by_exception(), "Trying to increment a valueless iterator of concat_view.");
348 size_t __active_index = __it_.index();
349 __apply_at_index<variant_size_v<decltype(__it_)>>(__active_index, [&](auto __index_constant) {
350 constexpr size_t __i = __index_constant.value;
351 ++std::__unchecked_get<__i>(__it_);
352 __satisfy<__i>();
353 });
354 return *this;
355 }
356
357 _LIBCPP_HIDE_FROM_ABI constexpr void operator++(int) { ++*this; }
358
359 _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator++(int)
360 requires(__all_forward<_Const, _Views...>)
361 {
362 auto __tmp = *this;
363 ++*this;
364 return __tmp;
365 }
366
367 _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator--()
368 requires __concat_is_bidirectional<_Const, _Views...>
369 {
370 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
371 !__it_.valueless_by_exception(), "Trying to decrement a valueless iterator of concat_view.");
372 size_t __active_index = __it_.index();
373 __apply_at_index<variant_size_v<decltype(__it_)>>(__active_index, [&](auto __index_constant) {
374 constexpr size_t __i = __index_constant.value;
375 __prev<__i>();
376 });
377 return *this;
378 }
379
380 _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator--(int)
381 requires __concat_is_bidirectional<_Const, _Views...>
382 {
383 auto __tmp = *this;
384 --*this;
385 return __tmp;
386 }
387
388 _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator& __x, const __iterator& __y)
389 requires(equality_comparable<iterator_t<__maybe_const<_Const, _Views>>> && ...)
390 {
391 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!__x.__it_.valueless_by_exception() && !__y.__it_.valueless_by_exception(),
392 "Trying to compare a valueless iterator of concat_view.");
393 return __x.__it_ == __y.__it_;
394 }
395
396 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator[](difference_type __n) const
397 requires __concat_is_random_access<_Const, _Views...>
398 {
399 return *((*this) + __n);
400 }
401
402 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(const __iterator& __it, difference_type __n)
403 requires __concat_is_random_access<_Const, _Views...>
404 {
405 auto __temp = __it;
406 __temp += __n;
407 return __temp;
408 }
409
410 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(difference_type __n, const __iterator& __it)
411 requires __concat_is_random_access<_Const, _Views...>
412 {
413 return __it + __n;
414 }
415
416 _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator+=(difference_type __n)
417 requires __concat_is_random_access<_Const, _Views...>
418 {
419 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
420 !__it_.valueless_by_exception(), "Trying to increment a valueless iterator of concat_view.");
421 size_t __active_index = __it_.index();
422 if (__n > 0) {
423 __apply_at_index<tuple_size_v<decltype(__parent_->__views_)>>(__active_index, [&](auto __index_constant) {
424 constexpr size_t __i = __index_constant.value;
425 auto& __active_view = std::get<__i>(__parent_->__views_);
426 difference_type __idx = std::get<__i>(__it_) - ranges::begin(__active_view);
427 __advance_fwd<__i>(__idx, __n);
428 });
429
430 }
431
432 else if (__n < 0) {
433 __apply_at_index<tuple_size_v<decltype(__parent_->__views_)>>(__active_index, [&](auto __index_constant) {
434 constexpr size_t __i = __index_constant.value;
435 auto& __active_view = std::get<__i>(__parent_->__views_);
436 difference_type __idx = std::get<__i>(__it_) - ranges::begin(__active_view);
437 __advance_bwd<__i>(__idx, -__n);
438 });
439 }
440
441 return *this;
442 }
443
444 _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator-=(difference_type __n)
445 requires __concat_is_random_access<_Const, _Views...>
446 {
447 *this += -__n;
448 return *this;
449 }
450
451 _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator& __it, default_sentinel_t) {
452 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
453 !__it.__it_.valueless_by_exception(),
454 "Trying to compare a valueless iterator of concat_view with the default sentinel.");
455 constexpr auto __last_idx = sizeof...(_Views) - 1;
456 return __it.__it_.index() == __last_idx &&
457 std::__unchecked_get<__last_idx>(__it.__it_) == ranges::end(std::get<__last_idx>(__it.__parent_->__views_));
458 }
459
460 _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<(const __iterator& __x, const __iterator& __y)
461 requires(__all_random_access<_Const, _Views> && ...)
462 {
463 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!__x.__it_.valueless_by_exception() && !__y.__it_.valueless_by_exception(),
464 "Trying to compare a valueless iterator of concat_view.");
465 return __x.__it_ < __y.__it_;
466 }
467
468 _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>(const __iterator& __x, const __iterator& __y)
469 requires(__all_random_access<_Const, _Views> && ...)
470 {
471 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!__x.__it_.valueless_by_exception() && !__y.__it_.valueless_by_exception(),
472 "Trying to compare a valueless iterator of concat_view.");
473 return __x.__it_ > __y.__it_;
474 }
475
476 _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<=(const __iterator& __x, const __iterator& __y)
477 requires(__all_random_access<_Const, _Views> && ...)
478 {
479 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!__x.__it_.valueless_by_exception() && !__y.__it_.valueless_by_exception(),
480 "Trying to compare a valueless iterator of concat_view.");
481 return __x.__it_ <= __y.__it_;
482 }
483
484 _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>=(const __iterator& __x, const __iterator& __y)
485 requires(__all_random_access<_Const, _Views> && ...)
486 {
487 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!__x.__it_.valueless_by_exception() && !__y.__it_.valueless_by_exception(),
488 "Trying to compare a valueless iterator of concat_view.");
489 return __x.__it_ >= __y.__it_;
490 }
491
492 _LIBCPP_HIDE_FROM_ABI friend constexpr auto operator<=>(const __iterator& __x, const __iterator& __y)
493 requires((__all_random_access<_Const, _Views> && ...) &&
494 (three_way_comparable<iterator_t<__maybe_const<_Const, _Views>>> && ...))
495 {
496 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!__x.__it_.valueless_by_exception() && !__y.__it_.valueless_by_exception(),
497 "Trying to compare a valueless iterator of concat_view.");
498 return __x.__it_ <=> __y.__it_;
499 }
500
501 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI friend constexpr decltype(auto) iter_move(const __iterator& __it) noexcept(
502
503 ((is_nothrow_invocable_v< decltype(ranges::iter_move), const iterator_t<__maybe_const<_Const, _Views>>& > &&
504 is_nothrow_convertible_v< range_rvalue_reference_t<__maybe_const<_Const, _Views>>,
505 __concat_rvalue_reference_t<__maybe_const<_Const, _Views>...> >) &&
506 ...))
507
508 {
509 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
510 !__it.__it_.valueless_by_exception(), "Trying to apply iter_move to a valueless iterator of concat_view.");
511 return __variant_detail::__visitation::__variant::__visit_value(
512 [](const auto& __i) -> __concat_rvalue_reference_t<__maybe_const<_Const, _Views>...> {
513 return ranges::iter_move(__i);
514 },
515 __it.__it_);
516 }
517
518 _LIBCPP_HIDE_FROM_ABI friend constexpr void iter_swap(const __iterator& __x, const __iterator& __y)
519
520 noexcept((noexcept(ranges::swap(*__x, *__y))) &&
521 (noexcept(ranges::iter_swap(std::declval<const iterator_t<__maybe_const<_Const, _Views>>>(),
522 std::declval<const iterator_t<__maybe_const<_Const, _Views>>>())) &&
523 ...))
524
525 requires swappable_with<iter_reference_t<__iterator>, iter_reference_t<__iterator>> &&
526 (... && indirectly_swappable<iterator_t<__maybe_const<_Const, _Views>>>)
527 {
528 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
529 !__x.__it_.valueless_by_exception() && !__y.__it_.valueless_by_exception(),
530 "Trying to swap iterators of concat_view where at least one iterator is valueless.");
531 __variant_detail::__visitation::__variant::__visit_value(
532 [&](const auto& __it1, const auto& __it2) {
533 if constexpr (is_same_v<decltype(__it1), decltype(__it2)>) {
534 ranges::iter_swap(__it1, __it2);
535 } else {
536 ranges::swap(*__x, *__y);
537 }
538 },
539 __x.__it_,
540 __y.__it_);
541 }
542
543 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI friend constexpr difference_type
544 operator-(const __iterator& __x, const __iterator& __y)
545 requires __concat_is_random_access<_Const, _Views...>
546 {
547 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
548 !__x.__it_.valueless_by_exception() && !__y.__it_.valueless_by_exception(),
549 "Trying to subtract two iterators of concat_view where at least one iterator is valueless.");
550 return __x.__invoke_at_index([&]<std::size_t __index_x>() -> difference_type {
551 return __y.__invoke_at_index([&]<std::size_t __index_y>() -> difference_type {
552 if constexpr (__index_x > __index_y) {
553 auto __dx = ranges::distance(
554 ranges::begin(std::get<__index_x>(__x.__parent_->__views_)), std::get<__index_x>(__x.__it_));
555 auto __dy = ranges::distance(
556 std::get<__index_y>(__y.__it_), ranges::end(std::get<__index_y>(__y.__parent_->__views_)));
557 difference_type __s = [&]<std::size_t __start, std::size_t __end>(this auto&& __self) -> difference_type {
558 if constexpr (__start < __end) {
559 return ranges::size(std::get<__start>(__x.__parent_->__views_)) +
560 __self.template operator()<__start + 1, __end>();
561 }
562 return 0;
563 }.template operator()<__index_y + 1, __index_x>();
564 return __dy + __s + __dx;
565 } else if constexpr (__index_x < __index_y) {
566 return -(__y - __x);
567 } else {
568 return std::get<__index_x>(__x.__it_) - std::get<__index_y>(__y.__it_);
569 }
570 });
571 });
572 }
573
574 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator-(const __iterator& __it, difference_type __n)
575 requires __concat_is_random_access<_Const, _Views...>
576 {
577 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
578 !__it.__it_.valueless_by_exception(), "Trying to subtract a valuess iterators of concat_view.");
579 auto __temp = __it;
580 __temp -= __n;
581 return __temp;
582 }
583
584 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI friend constexpr difference_type
585 operator-(const __iterator& __x, default_sentinel_t)
586 requires(sized_sentinel_for<sentinel_t<__maybe_const<_Const, _Views>>, iterator_t<__maybe_const<_Const, _Views>>> &&
587 ...) &&
588 (__all_but_first_model_sized_range<_Const, _Views...>::value)
589 {
590 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
591 !__x.__it_.valueless_by_exception(),
592 "Trying to subtract a valuess iterators of concat_view from the default sentinel.");
593 return __x.__invoke_at_index([&]<std::size_t __index_x>() -> difference_type {
594 auto __dx =
595 ranges::distance(std::get<__index_x>(__x.__it_), ranges::end(std::get<__index_x>(__x.__parent_->__views_)));
596 difference_type __s = [&]<std::size_t __start, std::size_t __end>(this auto&& __self) -> difference_type {
597 if constexpr (__start < __end) {
598 return ranges::size(std::get<__start>(__x.__parent_->__views_)) +
599 __self.template operator()<__start + 1, __end>();
600 }
601 return 0;
602 }.template operator()<__index_x + 1, sizeof...(_Views)>();
603 return -(__dx + __s);
604 });
605 }
606
607 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI friend constexpr difference_type
608 operator-(default_sentinel_t, const __iterator& __x)
609 requires(sized_sentinel_for<sentinel_t<__maybe_const<_Const, _Views>>, iterator_t<__maybe_const<_Const, _Views>>> &&
610 ...) &&
611 (__all_but_first_model_sized_range<_Const, _Views...>::value)
612 {
613 return -(__x - default_sentinel);
614 }
615};
616
617namespace views {
618namespace __concat {
619struct __fn {
620 template <input_range _Range>
621 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto
622 operator()(_Range&& __range) noexcept(noexcept(views::all((std::forward<_Range>(__range)))))
623 -> decltype(views::all((std::forward<_Range>(__range)))) {
624 return views::all(std::forward<_Range>(__range));
625 }
626
627 template <class _FirstRange, class... _TailRanges>
628 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto
629 operator()(_FirstRange&& __first, _TailRanges&&... __tail) noexcept(
630 noexcept(concat_view(std::forward<_FirstRange>(__first), std::forward<_TailRanges>(__tail)...)))
631 -> decltype(concat_view(std::forward<_FirstRange>(__first), std::forward<_TailRanges>(__tail)...)) {
632 return concat_view(std::forward<_FirstRange>(__first), std::forward<_TailRanges>(__tail)...);
633 }
634};
635} // namespace __concat
636
637inline namespace __cpo {
638inline constexpr auto concat = __concat::__fn{};
639} // namespace __cpo
640} // namespace views
641
642} // namespace ranges
643
644#endif // _LIBCPP_STD_VER >= 26
645
646_LIBCPP_END_NAMESPACE_STD
647
648_LIBCPP_POP_MACROS
649
650#endif // _LIBCPP___RANGES_CONCAT_VIEW_H
651