30 #ifndef _ITERATOR_CONCEPTS_H
31 #define _ITERATOR_CONCEPTS_H 1
33 #pragma GCC system_header
39 #if __cpp_lib_concepts
40 namespace std _GLIBCXX_VISIBILITY(default)
42 _GLIBCXX_BEGIN_NAMESPACE_VERSION
44 struct input_iterator_tag;
45 struct output_iterator_tag;
46 struct forward_iterator_tag;
47 struct bidirectional_iterator_tag;
48 struct random_access_iterator_tag;
49 struct contiguous_iterator_tag;
51 template<
typename _Iterator>
52 struct iterator_traits;
54 template<
typename _Tp> requires is_object_v<_Tp>
55 struct iterator_traits<_Tp*>;
57 template<
typename _Iterator,
typename>
58 struct __iterator_traits;
62 template<
typename _Tp>
63 using __with_ref = _Tp&;
65 template<
typename _Tp>
66 concept __can_reference = requires {
typename __with_ref<_Tp>; };
68 template<
typename _Tp>
69 concept __dereferenceable = requires(_Tp& __t)
71 { *__t } -> __can_reference;
75 template<__detail::__dereferenceable _Tp>
76 using iter_reference_t = decltype(*std::declval<_Tp&>());
80 namespace __cust_imove
84 template<
typename _Tp>
86 = (std::__detail::__class_or_enum<remove_reference_t<_Tp>>)
87 && requires(_Tp&& __t) { iter_move(static_cast<_Tp&&>(__t)); };
92 template<
typename _Tp>
94 {
using type = iter_reference_t<_Tp>; };
96 template<
typename _Tp>
97 requires __adl_imove<_Tp>
99 {
using type = decltype(iter_move(std::declval<_Tp>())); };
101 template<
typename _Tp>
102 requires (!__adl_imove<_Tp>)
103 && is_lvalue_reference_v<iter_reference_t<_Tp>>
105 {
using type = remove_reference_t<iter_reference_t<_Tp>>&&; };
107 template<
typename _Tp>
108 static constexpr
bool
111 if constexpr (__adl_imove<_Tp>)
112 return noexcept(iter_move(std::declval<_Tp>()));
114 return noexcept(*std::declval<_Tp>());
119 template<std::__detail::__dereferenceable _Tp>
120 using __type = typename __result<_Tp>::type;
122 template<std::__detail::__dereferenceable _Tp>
123 constexpr __type<_Tp>
124 operator()(_Tp&& __e) const
125 noexcept(_S_noexcept<_Tp>())
127 if constexpr (__adl_imove<_Tp>)
128 return iter_move(static_cast<_Tp&&>(__e));
129 else if constexpr (is_lvalue_reference_v<iter_reference_t<_Tp>>)
130 return static_cast<__type<_Tp>>(*__e);
137 inline namespace __cust
139 inline constexpr __cust_imove::_IMove iter_move{};
143 template<__detail::__dereferenceable _Tp>
144 requires requires(_Tp& __t)
145 { { ranges::iter_move(__t) } -> __detail::__can_reference; }
146 using iter_rvalue_reference_t
147 = decltype(ranges::iter_move(std::declval<_Tp&>()));
149 template<
typename>
struct incrementable_traits { };
151 template<
typename _Tp> requires is_object_v<_Tp>
152 struct incrementable_traits<_Tp*>
153 {
using difference_type = ptrdiff_t; };
155 template<
typename _Iter>
156 struct incrementable_traits<const _Iter>
157 : incrementable_traits<_Iter> { };
159 template<
typename _Tp> requires requires {
typename _Tp::difference_type; }
160 struct incrementable_traits<_Tp>
161 {
using difference_type =
typename _Tp::difference_type; };
163 template<
typename _Tp>
164 requires (!requires {
typename _Tp::difference_type; }
165 && requires(
const _Tp& __a,
const _Tp& __b)
167 requires (!is_void_v<remove_pointer_t<_Tp>>);
168 { __a - __b } -> integral;
170 struct incrementable_traits<_Tp>
172 using difference_type
173 = make_signed_t<decltype(std::declval<_Tp>() - std::declval<_Tp>())>;
180 template<
typename _Iter>
181 concept __primary_traits_iter
182 = __is_base_of(__iterator_traits<_Iter, void>, iterator_traits<_Iter>);
184 template<
typename _Iter,
typename _Tp>
185 struct __iter_traits_impl
186 {
using type = iterator_traits<_Iter>; };
188 template<
typename _Iter,
typename _Tp>
189 requires __primary_traits_iter<_Iter>
190 struct __iter_traits_impl<_Iter, _Tp>
191 {
using type = _Tp; };
194 template<
typename _Iter,
typename _Tp = _Iter>
195 using __iter_traits =
typename __iter_traits_impl<_Iter, _Tp>::type;
197 template<
typename _Tp>
198 using __iter_diff_t =
typename
199 __iter_traits<_Tp, incrementable_traits<_Tp>>::difference_type;
202 template<
typename _Tp>
203 using iter_difference_t = __detail::__iter_diff_t<remove_cvref_t<_Tp>>;
207 template<
typename>
struct __cond_value_type { };
209 template<
typename _Tp> requires is_object_v<_Tp>
210 struct __cond_value_type<_Tp>
211 {
using value_type = remove_cv_t<_Tp>; };
214 template<
typename>
struct indirectly_readable_traits { };
216 template<
typename _Tp>
217 struct indirectly_readable_traits<_Tp*>
218 : __detail::__cond_value_type<_Tp>
221 template<
typename _Iter> requires is_array_v<_Iter>
222 struct indirectly_readable_traits<_Iter>
223 {
using value_type = remove_cv_t<remove_extent_t<_Iter>>; };
225 template<
typename _Iter>
226 struct indirectly_readable_traits<const _Iter>
227 : indirectly_readable_traits<_Iter>
230 template<
typename _Tp> requires requires {
typename _Tp::value_type; }
231 struct indirectly_readable_traits<_Tp>
232 : __detail::__cond_value_type<typename _Tp::value_type>
235 template<
typename _Tp> requires requires {
typename _Tp::element_type; }
236 struct indirectly_readable_traits<_Tp>
237 : __detail::__cond_value_type<typename _Tp::element_type>
242 template<
typename _Tp>
243 using __iter_value_t =
typename
244 __iter_traits<_Tp, indirectly_readable_traits<_Tp>>::value_type;
247 template<
typename _Tp>
248 using iter_value_t = __detail::__iter_value_t<remove_cvref_t<_Tp>>;
254 template<
typename _Iter>
255 concept __cpp17_iterator = requires(_Iter __it)
257 { *__it } -> __can_reference;
258 { ++__it } -> same_as<_Iter&>;
259 { *__it++ } -> __can_reference;
260 } && copyable<_Iter>;
262 template<
typename _Iter>
263 concept __cpp17_input_iterator = __cpp17_iterator<_Iter>
264 && equality_comparable<_Iter>
265 && requires(_Iter __it)
267 typename incrementable_traits<_Iter>::difference_type;
268 typename indirectly_readable_traits<_Iter>::value_type;
269 typename common_reference_t<iter_reference_t<_Iter>&&,
270 typename indirectly_readable_traits<_Iter>::value_type&>;
271 typename common_reference_t<decltype(*__it++)&&,
272 typename indirectly_readable_traits<_Iter>::value_type&>;
273 requires signed_integral<
274 typename incrementable_traits<_Iter>::difference_type>;
277 template<
typename _Iter>
278 concept __cpp17_fwd_iterator = __cpp17_input_iterator<_Iter>
279 && constructible_from<_Iter>
280 && is_lvalue_reference_v<iter_reference_t<_Iter>>
281 && same_as<remove_cvref_t<iter_reference_t<_Iter>>,
282 typename indirectly_readable_traits<_Iter>::value_type>
283 && requires(_Iter __it)
285 { __it++ } -> convertible_to<const _Iter&>;
286 { *__it++ } -> same_as<iter_reference_t<_Iter>>;
289 template<
typename _Iter>
290 concept __cpp17_bidi_iterator = __cpp17_fwd_iterator<_Iter>
291 && requires(_Iter __it)
293 { --__it } -> same_as<_Iter&>;
294 { __it-- } -> convertible_to<const _Iter&>;
295 { *__it-- } -> same_as<iter_reference_t<_Iter>>;
298 template<
typename _Iter>
299 concept __cpp17_randacc_iterator = __cpp17_bidi_iterator<_Iter>
300 && totally_ordered<_Iter>
301 && requires(_Iter __it,
302 typename incrementable_traits<_Iter>::difference_type __n)
304 { __it += __n } -> same_as<_Iter&>;
305 { __it -= __n } -> same_as<_Iter&>;
306 { __it + __n } -> same_as<_Iter>;
307 { __n + __it } -> same_as<_Iter>;
308 { __it - __n } -> same_as<_Iter>;
309 { __it - __it } -> same_as<decltype(__n)>;
310 { __it[__n] } -> convertible_to<iter_reference_t<_Iter>>;
313 template<
typename _Iter>
314 concept __iter_with_nested_types = requires {
315 typename _Iter::iterator_category;
316 typename _Iter::value_type;
317 typename _Iter::difference_type;
318 typename _Iter::reference;
321 template<
typename _Iter>
322 concept __iter_without_nested_types = !__iter_with_nested_types<_Iter>;
325 template<
typename _Iter,
bool __use_arrow = false>
327 {
using type = void; };
329 template<
typename _Iter> requires requires {
typename _Iter::pointer; }
330 struct __ptr<_Iter, true>
331 {
using type =
typename _Iter::pointer; };
333 template<
typename _Iter> requires requires {
typename _Iter::pointer; }
334 struct __ptr<_Iter, false>
335 {
using type =
typename _Iter::pointer; };
337 template<
typename _Iter>
338 requires (!requires {
typename _Iter::pointer; }
339 && requires(_Iter& __it) { __it.operator->(); })
340 struct __ptr<_Iter, true>
341 {
using type = decltype(std::declval<_Iter&>().operator->()); };
343 template<
typename _Iter>
345 {
using type = iter_reference_t<_Iter>; };
347 template<
typename _Iter> requires requires {
typename _Iter::reference; }
349 {
using type =
typename _Iter::reference; };
351 template<
typename _Iter>
353 {
using type = input_iterator_tag; };
355 template<
typename _Iter>
356 requires requires {
typename _Iter::iterator_category; }
358 {
using type =
typename _Iter::iterator_category; };
360 template<
typename _Iter>
361 requires (!requires {
typename _Iter::iterator_category; }
362 && __detail::__cpp17_randacc_iterator<_Iter>)
364 {
using type = random_access_iterator_tag; };
366 template<
typename _Iter>
367 requires (!requires {
typename _Iter::iterator_category; }
368 && __detail::__cpp17_bidi_iterator<_Iter>)
370 {
using type = bidirectional_iterator_tag; };
372 template<
typename _Iter>
373 requires (!requires {
typename _Iter::iterator_category; }
374 && __detail::__cpp17_fwd_iterator<_Iter>)
376 {
using type = forward_iterator_tag; };
378 template<
typename _Iter>
380 {
using type = void; };
382 template<
typename _Iter>
384 typename incrementable_traits<_Iter>::difference_type;
388 using type =
typename incrementable_traits<_Iter>::difference_type;
393 template<
typename _Iterator>
394 requires __detail::__iter_with_nested_types<_Iterator>
395 struct __iterator_traits<_Iterator, void>
397 using iterator_category =
typename _Iterator::iterator_category;
398 using value_type =
typename _Iterator::value_type;
399 using difference_type =
typename _Iterator::difference_type;
400 using pointer =
typename __detail::__ptr<_Iterator>::type;
401 using reference =
typename _Iterator::reference;
404 template<
typename _Iterator>
405 requires __detail::__iter_without_nested_types<_Iterator>
406 && __detail::__cpp17_input_iterator<_Iterator>
407 struct __iterator_traits<_Iterator, void>
409 using iterator_category =
typename __detail::__cat<_Iterator>::type;
411 =
typename indirectly_readable_traits<_Iterator>::value_type;
412 using difference_type
413 =
typename incrementable_traits<_Iterator>::difference_type;
414 using pointer =
typename __detail::__ptr<_Iterator, true>::type;
415 using reference =
typename __detail::__ref<_Iterator>::type;
418 template<
typename _Iterator>
419 requires __detail::__iter_without_nested_types<_Iterator>
420 && __detail::__cpp17_iterator<_Iterator>
421 struct __iterator_traits<_Iterator, void>
423 using iterator_category = output_iterator_tag;
424 using value_type = void;
425 using difference_type =
typename __detail::__diff<_Iterator>::type;
426 using pointer = void;
427 using reference = void;
432 template<
typename _Iter>
433 struct __iter_concept_impl;
436 template<
typename _Iter>
437 requires requires {
typename __iter_traits<_Iter>::iterator_concept; }
438 struct __iter_concept_impl<_Iter>
439 {
using type =
typename __iter_traits<_Iter>::iterator_concept; };
442 template<
typename _Iter>
443 requires (!requires {
typename __iter_traits<_Iter>::iterator_concept; }
444 && requires {
typename __iter_traits<_Iter>::iterator_category; })
445 struct __iter_concept_impl<_Iter>
446 {
using type =
typename __iter_traits<_Iter>::iterator_category; };
449 template<
typename _Iter>
450 requires (!requires {
typename __iter_traits<_Iter>::iterator_concept; }
451 && !requires {
typename __iter_traits<_Iter>::iterator_category; }
452 && __primary_traits_iter<_Iter>)
453 struct __iter_concept_impl<_Iter>
454 {
using type = random_access_iterator_tag; };
457 template<
typename _Iter>
458 struct __iter_concept_impl
462 template<
typename _Iter>
463 using __iter_concept =
typename __iter_concept_impl<_Iter>::type;
465 template<
typename _In>
466 concept __indirectly_readable_impl = requires(
const _In __in)
468 typename iter_value_t<_In>;
469 typename iter_reference_t<_In>;
470 typename iter_rvalue_reference_t<_In>;
471 { *__in } -> same_as<iter_reference_t<_In>>;
472 { ranges::iter_move(__in) } -> same_as<iter_rvalue_reference_t<_In>>;
474 && common_reference_with<iter_reference_t<_In>&&, iter_value_t<_In>&>
475 && common_reference_with<iter_reference_t<_In>&&,
476 iter_rvalue_reference_t<_In>&&>
477 && common_reference_with<iter_rvalue_reference_t<_In>&&,
478 const iter_value_t<_In>&>;
483 template<
typename _In>
484 concept indirectly_readable
485 = __detail::__indirectly_readable_impl<remove_cvref_t<_In>>;
487 template<indirectly_readable _Tp>
488 using iter_common_reference_t
489 = common_reference_t<iter_reference_t<_Tp>, iter_value_t<_Tp>&>;
492 template<
typename _Out,
typename _Tp>
493 concept indirectly_writable = requires(_Out&& __o, _Tp&& __t)
495 *__o = std::forward<_Tp>(__t);
496 *std::forward<_Out>(__o) = std::forward<_Tp>(__t);
497 const_cast<const iter_reference_t<_Out>&&
>(*__o)
498 = std::forward<_Tp>(__t);
499 const_cast<const iter_reference_t<_Out>&&
>(*std::forward<_Out>(__o))
500 = std::forward<_Tp>(__t);
503 namespace ranges::__detail
505 #if __SIZEOF_INT128__
506 using __max_diff_type = __int128;
507 using __max_size_type =
unsigned __int128;
509 using __max_diff_type =
long long;
510 using __max_size_type =
unsigned long long;
513 template<
typename _Tp>
514 concept __is_integer_like = integral<_Tp>
515 || same_as<_Tp, __max_diff_type> || same_as<_Tp, __max_size_type>;
517 template<
typename _Tp>
518 concept __is_signed_integer_like = signed_integral<_Tp>
519 || same_as<_Tp, __max_diff_type>;
523 namespace __detail {
using ranges::__detail::__is_signed_integer_like; }
526 template<
typename _Iter>
527 concept weakly_incrementable = default_initializable<_Iter>
529 && requires(_Iter __i)
531 typename iter_difference_t<_Iter>;
532 requires __detail::__is_signed_integer_like<iter_difference_t<_Iter>>;
533 { ++__i } -> same_as<_Iter&>;
537 template<
typename _Iter>
538 concept incrementable = regular<_Iter> && weakly_incrementable<_Iter>
539 && requires(_Iter __i) { { __i++ } -> same_as<_Iter>; };
541 template<
typename _Iter>
542 concept input_or_output_iterator
543 = requires(_Iter __i) { { *__i } -> __detail::__can_reference; }
544 && weakly_incrementable<_Iter>;
546 template<
typename _Sent,
typename _Iter>
547 concept sentinel_for = semiregular<_Sent>
548 && input_or_output_iterator<_Iter>
549 && __detail::__weakly_eq_cmp_with<_Sent, _Iter>;
551 template<
typename _Sent,
typename _Iter>
552 inline constexpr
bool disable_sized_sentinel_for =
false;
554 template<
typename _Sent,
typename _Iter>
555 concept sized_sentinel_for = sentinel_for<_Sent, _Iter>
556 && !disable_sized_sentinel_for<remove_cv_t<_Sent>, remove_cv_t<_Iter>>
557 && requires(
const _Iter& __i,
const _Sent& __s)
559 { __s - __i } -> same_as<iter_difference_t<_Iter>>;
560 { __i - __s } -> same_as<iter_difference_t<_Iter>>;
563 template<
typename _Iter>
564 concept input_iterator = input_or_output_iterator<_Iter>
565 && indirectly_readable<_Iter>
566 && requires {
typename __detail::__iter_concept<_Iter>; }
567 && derived_from<__detail::__iter_concept<_Iter>, input_iterator_tag>;
569 template<
typename _Iter,
typename _Tp>
570 concept output_iterator = input_or_output_iterator<_Iter>
571 && indirectly_writable<_Iter, _Tp>
572 && requires(_Iter __i, _Tp&& __t) { *__i++ = std::forward<_Tp>(__t); };
574 template<
typename _Iter>
575 concept forward_iterator = input_iterator<_Iter>
576 && derived_from<__detail::__iter_concept<_Iter>, forward_iterator_tag>
577 && incrementable<_Iter> && sentinel_for<_Iter, _Iter>;
579 template<
typename _Iter>
580 concept bidirectional_iterator = forward_iterator<_Iter>
581 && derived_from<__detail::__iter_concept<_Iter>,
582 bidirectional_iterator_tag>
583 && requires(_Iter __i)
585 { --__i } -> same_as<_Iter&>;
586 { __i-- } -> same_as<_Iter>;
589 template<
typename _Iter>
590 concept random_access_iterator = bidirectional_iterator<_Iter>
591 && derived_from<__detail::__iter_concept<_Iter>,
592 random_access_iterator_tag>
593 && totally_ordered<_Iter> && sized_sentinel_for<_Iter, _Iter>
594 && requires(_Iter __i,
const _Iter __j,
595 const iter_difference_t<_Iter> __n)
597 { __i += __n } -> same_as<_Iter&>;
598 { __j + __n } -> same_as<_Iter>;
599 { __n + __j } -> same_as<_Iter>;
600 { __i -= __n } -> same_as<_Iter&>;
601 { __j - __n } -> same_as<_Iter>;
602 { __j[__n] } -> same_as<iter_reference_t<_Iter>>;
605 template<
typename _Iter>
606 concept contiguous_iterator = random_access_iterator<_Iter>
607 && derived_from<__detail::__iter_concept<_Iter>, contiguous_iterator_tag>
608 && is_lvalue_reference_v<iter_reference_t<_Iter>>
609 && same_as<iter_value_t<_Iter>, remove_cvref_t<iter_reference_t<_Iter>>>
610 && requires(
const _Iter& __i)
612 { std::to_address(__i) }
613 -> same_as<add_pointer_t<iter_reference_t<_Iter>>>;
620 template<
typename _Fn,
typename _Iter>
621 concept indirectly_unary_invocable = indirectly_readable<_Iter>
622 && copy_constructible<_Fn> && invocable<_Fn&, iter_value_t<_Iter>&>
623 && invocable<_Fn&, iter_reference_t<_Iter>>
624 && invocable<_Fn&, iter_common_reference_t<_Iter>>
625 && common_reference_with<invoke_result_t<_Fn&, iter_value_t<_Iter>&>,
626 invoke_result_t<_Fn&, iter_reference_t<_Iter>>>;
628 template<
typename _Fn,
typename _Iter>
629 concept indirectly_regular_unary_invocable = indirectly_readable<_Iter>
630 && copy_constructible<_Fn>
631 && regular_invocable<_Fn&, iter_value_t<_Iter>&>
632 && regular_invocable<_Fn&, iter_reference_t<_Iter>>
633 && regular_invocable<_Fn&, iter_common_reference_t<_Iter>>
634 && common_reference_with<invoke_result_t<_Fn&, iter_value_t<_Iter>&>,
635 invoke_result_t<_Fn&, iter_reference_t<_Iter>>>;
637 template<
typename _Fn,
typename _Iter>
638 concept indirect_unary_predicate = indirectly_readable<_Iter>
639 && copy_constructible<_Fn> && predicate<_Fn&, iter_value_t<_Iter>&>
640 && predicate<_Fn&, iter_reference_t<_Iter>>
641 && predicate<_Fn&, iter_common_reference_t<_Iter>>;
643 template<
typename _Fn,
typename _I1,
typename _I2>
644 concept indirect_binary_predicate
645 = indirectly_readable<_I1> && indirectly_readable<_I2>
646 && copy_constructible<_Fn>
647 && predicate<_Fn&, iter_value_t<_I1>&, iter_value_t<_I2>&>
648 && predicate<_Fn&, iter_value_t<_I1>&, iter_reference_t<_I2>>
649 && predicate<_Fn&, iter_reference_t<_I1>, iter_value_t<_I2>&>
650 && predicate<_Fn&, iter_reference_t<_I1>, iter_reference_t<_I2>>
651 && predicate<_Fn&, iter_common_reference_t<_I1>,
652 iter_common_reference_t<_I2>>;
654 template<
typename _Fn,
typename _I1,
typename _I2 = _I1>
655 concept indirect_equivalence_relation
656 = indirectly_readable<_I1> && indirectly_readable<_I2>
657 && copy_constructible<_Fn>
658 && equivalence_relation<_Fn&, iter_value_t<_I1>&, iter_value_t<_I2>&>
659 && equivalence_relation<_Fn&, iter_value_t<_I1>&, iter_reference_t<_I2>>
660 && equivalence_relation<_Fn&, iter_reference_t<_I1>, iter_value_t<_I2>&>
661 && equivalence_relation<_Fn&, iter_reference_t<_I1>,
662 iter_reference_t<_I2>>
663 && equivalence_relation<_Fn&, iter_common_reference_t<_I1>,
664 iter_common_reference_t<_I2>>;
666 template<
typename _Fn,
typename _I1,
typename _I2 = _I1>
667 concept indirect_strict_weak_order
668 = indirectly_readable<_I1> && indirectly_readable<_I2>
669 && copy_constructible<_Fn>
670 && strict_weak_order<_Fn&, iter_value_t<_I1>&, iter_value_t<_I2>&>
671 && strict_weak_order<_Fn&, iter_value_t<_I1>&, iter_reference_t<_I2>>
672 && strict_weak_order<_Fn&, iter_reference_t<_I1>, iter_value_t<_I2>&>
673 && strict_weak_order<_Fn&, iter_reference_t<_I1>, iter_reference_t<_I2>>
674 && strict_weak_order<_Fn&, iter_common_reference_t<_I1>,
675 iter_common_reference_t<_I2>>;
677 template<
typename _Fn,
typename... _Is>
678 requires (indirectly_readable<_Is> && ...)
679 && invocable<_Fn, iter_reference_t<_Is>...>
680 using indirect_result_t = invoke_result_t<_Fn, iter_reference_t<_Is>...>;
683 template<indirectly_readable _Iter,
684 indirectly_regular_unary_invocable<_Iter> _Proj>
687 using value_type = remove_cvref_t<indirect_result_t<_Proj&, _Iter>>;
689 indirect_result_t<_Proj&, _Iter>
operator*()
const;
692 template<weakly_incrementable _Iter,
typename _Proj>
693 struct incrementable_traits<projected<_Iter, _Proj>>
694 {
using difference_type = iter_difference_t<_Iter>; };
700 template<
typename _In,
typename _Out>
701 concept indirectly_movable = indirectly_readable<_In>
702 && indirectly_writable<_Out, iter_rvalue_reference_t<_In>>;
704 template<
typename _In,
typename _Out>
705 concept indirectly_movable_storable = indirectly_movable<_In, _Out>
706 && indirectly_writable<_Out, iter_value_t<_In>>
707 && movable<iter_value_t<_In>>
708 && constructible_from<iter_value_t<_In>, iter_rvalue_reference_t<_In>>
709 && assignable_from<iter_value_t<_In>&, iter_rvalue_reference_t<_In>>;
712 template<
typename _In,
typename _Out>
713 concept indirectly_copyable = indirectly_readable<_In>
714 && indirectly_writable<_Out, iter_reference_t<_In>>;
716 template<
typename _In,
typename _Out>
717 concept indirectly_copyable_storable = indirectly_copyable<_In, _Out>
718 && indirectly_writable<_Out, iter_value_t<_In>&>
719 && indirectly_writable<_Out, const iter_value_t<_In>&>
720 && indirectly_writable<_Out, iter_value_t<_In>&&>
721 && indirectly_writable<_Out, const iter_value_t<_In>&&>
722 && copyable<iter_value_t<_In>>
723 && constructible_from<iter_value_t<_In>, iter_reference_t<_In>>
724 && assignable_from<iter_value_t<_In>&, iter_reference_t<_In>>;
728 namespace __cust_iswap
730 template<
typename _It1,
typename _It2>
731 void iter_swap(_It1, _It2) =
delete;
733 template<
typename _Tp,
typename _Up>
735 = (std::__detail::__class_or_enum<remove_reference_t<_Tp>>
736 || std::__detail::__class_or_enum<remove_reference_t<_Up>>)
737 && requires(_Tp&& __t, _Up&& __u) {
738 iter_swap(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u));
741 template<
typename _Xp,
typename _Yp>
742 constexpr iter_value_t<_Xp>
743 __iter_exchange_move(_Xp&& __x, _Yp&& __y)
744 noexcept(noexcept(iter_value_t<_Xp>(iter_move(__x)))
745 && noexcept(*__x = iter_move(__y)))
747 iter_value_t<_Xp> __old_value(iter_move(__x));
748 *__x = iter_move(__y);
755 template<
typename _Tp,
typename _Up>
756 static constexpr
bool
759 if constexpr (__adl_iswap<_Tp, _Up>)
760 return noexcept(iter_swap(std::declval<_Tp>(),
761 std::declval<_Up>()));
762 else if constexpr (indirectly_readable<_Tp>
763 && indirectly_readable<_Up>
764 && swappable_with<iter_reference_t<_Tp>, iter_reference_t<_Up>>)
765 return noexcept(ranges::swap(*std::declval<_Tp>(),
766 *std::declval<_Up>()));
768 return noexcept(*std::declval<_Tp>()
769 = __iter_exchange_move(std::declval<_Up>(),
770 std::declval<_Tp>()));
774 template<typename _Tp, typename _Up>
775 requires __adl_iswap<_Tp, _Up>
778 && swappable_with<iter_reference_t<_Tp>, iter_reference_t<_Up>>)
779 || (indirectly_movable_storable<_Tp, _Up>
780 && indirectly_movable_storable<_Up, _Tp>)
782 operator()(_Tp&& __e1, _Up&& __e2) const
783 noexcept(_S_noexcept<_Tp, _Up>())
785 if constexpr (__adl_iswap<_Tp, _Up>)
786 iter_swap(static_cast<_Tp&&>(__e1), static_cast<_Up&&>(__e2));
787 else if constexpr (indirectly_readable<_Tp>
788 && indirectly_readable<_Up>
789 && swappable_with<iter_reference_t<_Tp>, iter_reference_t<_Up>>)
790 ranges::swap(*__e1, *__e2);
792 *__e1 = __iter_exchange_move(__e2, __e1);
797 inline namespace __cust
799 inline constexpr __cust_iswap::_IterSwap iter_swap{};
805 template<
typename _I1,
typename _I2 = _I1>
806 concept indirectly_swappable
807 = indirectly_readable<_I1> && indirectly_readable<_I2>
808 && requires(
const _I1 __i1,
const _I2 __i2)
810 ranges::iter_swap(__i1, __i1);
811 ranges::iter_swap(__i2, __i2);
812 ranges::iter_swap(__i1, __i2);
813 ranges::iter_swap(__i2, __i1);
817 template<
typename _I1,
typename _I2,
typename _Rel,
typename _P1 = identity,
818 typename _P2 = identity>
819 concept indirectly_comparable
820 = indirect_binary_predicate<_Rel, projected<_I1, _P1>,
821 projected<_I2, _P2>>;
824 template<
typename _Iter>
825 concept permutable = forward_iterator<_Iter>
826 && indirectly_movable_storable<_Iter, _Iter>
827 && indirectly_swappable<_Iter, _Iter>;
830 template<
typename _I1,
typename _I2,
typename _Out,
831 typename _Rel = ranges::less,
typename _P1 = identity,
832 typename _P2 = identity>
833 concept mergeable = input_iterator<_I1> && input_iterator<_I2>
834 && weakly_incrementable<_Out> && indirectly_copyable<_I1, _Out>
835 && indirectly_copyable<_I2, _Out>
836 && indirect_strict_weak_order<_Rel, projected<_I1, _P1>,
837 projected<_I2, _P2>>;
840 template<
typename _Iter,
typename _Rel = ranges::less,
841 typename _Proj = identity>
842 concept sortable = permutable<_Iter>
843 && indirect_strict_weak_order<_Rel, projected<_Iter, _Proj>>;
845 struct unreachable_sentinel_t
847 template<weakly_incrementable _It>
848 friend constexpr
bool
849 operator==(unreachable_sentinel_t,
const _It&) noexcept
853 inline constexpr unreachable_sentinel_t unreachable_sentinel{};
855 struct default_sentinel_t { };
856 inline constexpr default_sentinel_t default_sentinel{};
860 template<
typename _Tp>
861 constexpr decay_t<_Tp>
862 __decay_copy(_Tp&& __t)
863 noexcept(is_nothrow_convertible_v<_Tp,
decay_t<_Tp>>)
864 {
return std::forward<_Tp>(__t); }
866 template<
typename _Tp>
867 concept __member_begin = requires(_Tp& __t)
869 { __detail::__decay_copy(__t.begin()) } -> input_or_output_iterator;
872 void begin(
auto&) =
delete;
873 void begin(
const auto&) =
delete;
875 template<
typename _Tp>
876 concept __adl_begin = __class_or_enum<remove_reference_t<_Tp>>
877 && requires(_Tp& __t)
879 { __detail::__decay_copy(
begin(__t)) } -> input_or_output_iterator;
884 template<
typename _Tp>
885 requires is_array_v<_Tp> || __member_begin<_Tp&> || __adl_begin<_Tp&>
887 __ranges_begin(_Tp& __t)
889 if constexpr (is_array_v<_Tp>)
891 static_assert(
sizeof(remove_all_extents_t<_Tp>) != 0,
892 "not array of incomplete type");
895 else if constexpr (__member_begin<_Tp&>)
902 template<typename _Tp>
904 = decltype(__detail::__ranges_begin(std::declval<_Tp&>()));
908 _GLIBCXX_END_NAMESPACE_VERSION
910 #endif // C++20 library concepts
911 #endif // _ITERATOR_CONCEPTS_H
typename decay< _Tp >::type decay_t
Alias template for decay.
typename remove_reference< _Tp >::type remove_reference_t
Alias template for remove_reference.
_Tp * begin(valarray< _Tp > &__va)
Return an iterator pointing to the first element of the valarray.
constexpr complex< _Tp > operator*(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x times y.