30#ifndef _ITERATOR_CONCEPTS_H
31#define _ITERATOR_CONCEPTS_H 1
33#pragma GCC system_header
35#if __cplusplus >= 202002L
40namespace std _GLIBCXX_VISIBILITY(default)
42_GLIBCXX_BEGIN_NAMESPACE_VERSION
64 struct input_iterator_tag;
65 struct output_iterator_tag;
66 struct forward_iterator_tag;
67 struct bidirectional_iterator_tag;
68 struct random_access_iterator_tag;
69 struct contiguous_iterator_tag;
71 template<
typename _Iterator>
72 struct iterator_traits;
74 template<
typename _Tp>
requires is_object_v<_Tp>
75 struct iterator_traits<_Tp*>;
77 template<
typename _Iterator,
typename>
78 struct __iterator_traits;
82 template<
typename _Tp>
83 using __with_ref = _Tp&;
85 template<
typename _Tp>
86 concept __can_reference =
requires {
typename __with_ref<_Tp>; };
88 template<
typename _Tp>
89 concept __dereferenceable =
requires(_Tp& __t)
91 { *__t } -> __can_reference;
95 template<__detail::__dereferenceable _Tp>
103 void iter_move() =
delete;
105 template<
typename _Tp>
107 = (std::__detail::__class_or_enum<remove_reference_t<_Tp>>)
108 &&
requires(_Tp&& __t) { iter_move(
static_cast<_Tp&&
>(__t)); };
113 template<
typename _Tp>
115 {
using type = iter_reference_t<_Tp>; };
117 template<
typename _Tp>
118 requires __adl_imove<_Tp>
122 template<
typename _Tp>
123 requires (!__adl_imove<_Tp>)
124 && is_lvalue_reference_v<iter_reference_t<_Tp>>
126 {
using type = remove_reference_t<iter_reference_t<_Tp>>&&; };
128 template<
typename _Tp>
129 static constexpr bool
132 if constexpr (__adl_imove<_Tp>)
140 template<std::__detail::__dereferenceable _Tp>
141 using __type =
typename __result<_Tp>::type;
143 template<std::__detail::__dereferenceable _Tp>
145 constexpr __type<_Tp>
146 operator()(_Tp&& __e)
const
147 noexcept(_S_noexcept<_Tp>())
149 if constexpr (__adl_imove<_Tp>)
150 return iter_move(
static_cast<_Tp&&
>(__e));
151 else if constexpr (is_lvalue_reference_v<iter_reference_t<_Tp>>)
152 return static_cast<__type<_Tp>
>(*__e);
160 inline namespace _Cpo {
161 inline constexpr __imove::_IterMove iter_move{};
165 template<__detail::__dereferenceable _Tp>
166 requires __detail::__can_reference<ranges::__imove::_IterMove::__type<_Tp&>>
167 using iter_rvalue_reference_t = ranges::__imove::_IterMove::__type<_Tp&>;
169 template<
typename>
struct incrementable_traits { };
171 template<
typename _Tp>
requires is_object_v<_Tp>
172 struct incrementable_traits<_Tp*>
173 {
using difference_type = ptrdiff_t; };
175 template<
typename _Iter>
176 struct incrementable_traits<const _Iter>
177 : incrementable_traits<_Iter> { };
179 template<
typename _Tp>
requires requires {
typename _Tp::difference_type; }
180 struct incrementable_traits<_Tp>
181 {
using difference_type =
typename _Tp::difference_type; };
183 template<
typename _Tp>
184 requires (!
requires {
typename _Tp::difference_type; }
185 &&
requires(
const _Tp& __a,
const _Tp& __b)
186 { { __a - __b } -> integral; })
187 struct incrementable_traits<_Tp>
189 using difference_type
193#if defined __STRICT_ANSI__ && defined __SIZEOF_INT128__
196 struct incrementable_traits<__int128>
197 {
using difference_type = __int128; };
200 struct incrementable_traits<unsigned __int128>
201 {
using difference_type = __int128; };
208 template<
typename _Iter>
209 concept __primary_traits_iter
210 = __is_base_of(__iterator_traits<_Iter, void>, iterator_traits<_Iter>);
212 template<
typename _Iter,
typename _Tp>
213 struct __iter_traits_impl
214 {
using type = iterator_traits<_Iter>; };
216 template<
typename _Iter,
typename _Tp>
217 requires __primary_traits_iter<_Iter>
218 struct __iter_traits_impl<_Iter, _Tp>
219 {
using type = _Tp; };
222 template<
typename _Iter,
typename _Tp = _Iter>
223 using __iter_traits =
typename __iter_traits_impl<_Iter, _Tp>::type;
225 template<
typename _Tp>
226 using __iter_diff_t =
typename
227 __iter_traits<_Tp, incrementable_traits<_Tp>>::difference_type;
230 template<
typename _Tp>
231 using iter_difference_t = __detail::__iter_diff_t<remove_cvref_t<_Tp>>;
235 template<
typename>
struct __cond_value_type { };
237 template<
typename _Tp>
requires is_object_v<_Tp>
238 struct __cond_value_type<_Tp>
239 {
using value_type = remove_cv_t<_Tp>; };
241 template<
typename _Tp>
242 concept __has_member_value_type
243 =
requires {
typename _Tp::value_type; };
245 template<
typename _Tp>
246 concept __has_member_element_type
247 =
requires {
typename _Tp::element_type; };
251 template<
typename>
struct indirectly_readable_traits { };
253 template<
typename _Tp>
254 struct indirectly_readable_traits<_Tp*>
255 : __detail::__cond_value_type<_Tp>
258 template<
typename _Iter>
requires is_array_v<_Iter>
259 struct indirectly_readable_traits<_Iter>
260 {
using value_type = remove_cv_t<remove_extent_t<_Iter>>; };
262 template<
typename _Iter>
263 struct indirectly_readable_traits<const _Iter>
264 : indirectly_readable_traits<_Iter>
267 template<__detail::__has_member_value_type _Tp>
268 struct indirectly_readable_traits<_Tp>
269 : __detail::__cond_value_type<typename _Tp::value_type>
272 template<__detail::__has_member_element_type _Tp>
273 struct indirectly_readable_traits<_Tp>
274 : __detail::__cond_value_type<typename _Tp::element_type>
279 template<__detail::__has_member_value_type _Tp>
280 requires __detail::__has_member_element_type<_Tp>
281 && same_as<remove_cv_t<typename _Tp::element_type>,
282 remove_cv_t<typename _Tp::value_type>>
283 struct indirectly_readable_traits<_Tp>
284 : __detail::__cond_value_type<typename _Tp::value_type>
289 template<__detail::__has_member_value_type _Tp>
290 requires __detail::__has_member_element_type<_Tp>
291 struct indirectly_readable_traits<_Tp>
296 template<
typename _Tp>
297 using __iter_value_t =
typename
298 __iter_traits<_Tp, indirectly_readable_traits<_Tp>>::value_type;
301 template<
typename _Tp>
302 using iter_value_t = __detail::__iter_value_t<remove_cvref_t<_Tp>>;
308 template<
typename _Iter>
309 concept __cpp17_iterator =
requires(_Iter __it)
311 { *__it } -> __can_reference;
312 { ++__it } -> same_as<_Iter&>;
313 { *__it++ } -> __can_reference;
314 } && copyable<_Iter>;
316 template<
typename _Iter>
317 concept __cpp17_input_iterator = __cpp17_iterator<_Iter>
318 && equality_comparable<_Iter>
319 &&
requires(_Iter __it)
321 typename incrementable_traits<_Iter>::difference_type;
322 typename indirectly_readable_traits<_Iter>::value_type;
324 typename indirectly_readable_traits<_Iter>::value_type&>;
326 typename indirectly_readable_traits<_Iter>::value_type&>;
327 requires signed_integral<
328 typename incrementable_traits<_Iter>::difference_type>;
333 template<
typename _Iter>
334 concept __cpp17_fwd_iterator = __cpp17_input_iterator<_Iter>
335 && constructible_from<_Iter>
336 && is_reference_v<iter_reference_t<_Iter>>
337 && same_as<remove_cvref_t<iter_reference_t<_Iter>>,
338 typename indirectly_readable_traits<_Iter>::value_type>
339 &&
requires(_Iter __it)
341 { __it++ } -> convertible_to<const _Iter&>;
342 { *__it++ } -> same_as<iter_reference_t<_Iter>>;
345 template<
typename _Iter>
346 concept __cpp17_bidi_iterator = __cpp17_fwd_iterator<_Iter>
347 &&
requires(_Iter __it)
349 { --__it } -> same_as<_Iter&>;
350 { __it-- } -> convertible_to<const _Iter&>;
351 { *__it-- } -> same_as<iter_reference_t<_Iter>>;
354 template<
typename _Iter>
355 concept __cpp17_randacc_iterator = __cpp17_bidi_iterator<_Iter>
356 && totally_ordered<_Iter>
357 &&
requires(_Iter __it,
358 typename incrementable_traits<_Iter>::difference_type __n)
360 { __it += __n } -> same_as<_Iter&>;
361 { __it -= __n } -> same_as<_Iter&>;
362 { __it + __n } -> same_as<_Iter>;
363 { __n + __it } -> same_as<_Iter>;
364 { __it - __n } -> same_as<_Iter>;
365 { __it - __it } -> same_as<
decltype(__n)>;
366 { __it[__n] } -> convertible_to<iter_reference_t<_Iter>>;
369 template<
typename _Iter>
370 concept __iter_with_nested_types =
requires {
371 typename _Iter::iterator_category;
372 typename _Iter::value_type;
373 typename _Iter::difference_type;
374 typename _Iter::reference;
377 template<
typename _Iter>
378 concept __iter_without_nested_types = !__iter_with_nested_types<_Iter>;
380 template<
typename _Iter>
381 concept __iter_without_category
382 = !
requires {
typename _Iter::iterator_category; };
386 template<
typename _Iterator>
387 requires __detail::__iter_with_nested_types<_Iterator>
388 struct __iterator_traits<_Iterator, void>
391 template<
typename _Iter>
393 {
using type = void; };
395 template<
typename _Iter>
requires requires {
typename _Iter::pointer; }
397 {
using type =
typename _Iter::pointer; };
400 using iterator_category =
typename _Iterator::iterator_category;
401 using value_type =
typename _Iterator::value_type;
402 using difference_type =
typename _Iterator::difference_type;
403 using pointer =
typename __ptr<_Iterator>::type;
404 using reference =
typename _Iterator::reference;
407 template<
typename _Iterator>
408 requires __detail::__iter_without_nested_types<_Iterator>
409 && __detail::__cpp17_input_iterator<_Iterator>
410 struct __iterator_traits<_Iterator, void>
413 template<
typename _Iter>
415 {
using type = input_iterator_tag; };
417 template<
typename _Iter>
418 requires requires {
typename _Iter::iterator_category; }
420 {
using type =
typename _Iter::iterator_category; };
422 template<
typename _Iter>
423 requires __detail::__iter_without_category<_Iter>
424 && __detail::__cpp17_randacc_iterator<_Iter>
426 {
using type = random_access_iterator_tag; };
428 template<
typename _Iter>
429 requires __detail::__iter_without_category<_Iter>
430 && __detail::__cpp17_bidi_iterator<_Iter>
432 {
using type = bidirectional_iterator_tag; };
434 template<
typename _Iter>
435 requires __detail::__iter_without_category<_Iter>
436 && __detail::__cpp17_fwd_iterator<_Iter>
438 {
using type = forward_iterator_tag; };
440 template<
typename _Iter>
442 {
using type = void; };
444 template<
typename _Iter>
requires requires {
typename _Iter::pointer; }
446 {
using type =
typename _Iter::pointer; };
448 template<
typename _Iter>
449 requires (!
requires {
typename _Iter::pointer; }
450 &&
requires(_Iter& __it) { __it.operator->(); })
454 template<
typename _Iter>
456 {
using type = iter_reference_t<_Iter>; };
458 template<
typename _Iter>
requires requires {
typename _Iter::reference; }
460 {
using type =
typename _Iter::reference; };
463 using iterator_category =
typename __cat<_Iterator>::type;
465 =
typename indirectly_readable_traits<_Iterator>::value_type;
466 using difference_type
467 =
typename incrementable_traits<_Iterator>::difference_type;
468 using pointer =
typename __ptr<_Iterator>::type;
469 using reference =
typename __ref<_Iterator>::type;
472 template<
typename _Iterator>
473 requires __detail::__iter_without_nested_types<_Iterator>
474 && __detail::__cpp17_iterator<_Iterator>
475 struct __iterator_traits<_Iterator, void>
478 template<
typename _Iter>
480 {
using type = void; };
482 template<
typename _Iter>
484 {
typename incrementable_traits<_Iter>::difference_type; }
487 using type =
typename incrementable_traits<_Iter>::difference_type;
491 using iterator_category = output_iterator_tag;
492 using value_type = void;
493 using difference_type =
typename __diff<_Iterator>::type;
494 using pointer = void;
495 using reference = void;
500 template<
typename _Iter>
501 struct __iter_concept_impl;
504 template<
typename _Iter>
505 requires requires {
typename __iter_traits<_Iter>::iterator_concept; }
506 struct __iter_concept_impl<_Iter>
507 {
using type =
typename __iter_traits<_Iter>::iterator_concept; };
510 template<
typename _Iter>
511 requires (!
requires {
typename __iter_traits<_Iter>::iterator_concept; }
512 &&
requires {
typename __iter_traits<_Iter>::iterator_category; })
513 struct __iter_concept_impl<_Iter>
514 {
using type =
typename __iter_traits<_Iter>::iterator_category; };
517 template<
typename _Iter>
518 requires (!
requires {
typename __iter_traits<_Iter>::iterator_concept; }
519 && !
requires {
typename __iter_traits<_Iter>::iterator_category; }
520 && __primary_traits_iter<_Iter>)
521 struct __iter_concept_impl<_Iter>
522 {
using type = random_access_iterator_tag; };
525 template<
typename _Iter>
526 struct __iter_concept_impl
530 template<
typename _Iter>
531 using __iter_concept =
typename __iter_concept_impl<_Iter>::type;
533 template<
typename _In>
534 concept __indirectly_readable_impl =
requires
536 typename iter_value_t<_In>;
537 typename iter_reference_t<_In>;
538 typename iter_rvalue_reference_t<_In>;
539 requires same_as<iter_reference_t<const _In>,
540 iter_reference_t<_In>>;
541 requires same_as<iter_rvalue_reference_t<const _In>,
542 iter_rvalue_reference_t<_In>>;
544 && common_reference_with<iter_reference_t<_In>&&, iter_value_t<_In>&>
545 && common_reference_with<iter_reference_t<_In>&&,
546 iter_rvalue_reference_t<_In>&&>
547 && common_reference_with<iter_rvalue_reference_t<_In>&&,
548 const iter_value_t<_In>&>;
553 template<
typename _In>
554 concept indirectly_readable
555 = __detail::__indirectly_readable_impl<remove_cvref_t<_In>>;
559 template<
typename _Tp>
560 struct __indirect_value
561 {
using type = iter_value_t<_Tp>&; };
566 template<
typename _Tp>
567 using __indirect_value_t =
typename __detail::__indirect_value<_Tp>::type;
569 template<indirectly_readable _Tp>
570 using iter_common_reference_t
574 template<
typename _Out,
typename _Tp>
575 concept indirectly_writable =
requires(_Out&& __o, _Tp&& __t)
579 const_cast<const iter_reference_t<_Out>&&
>(*__o)
585 namespace ranges::__detail
587 class __max_diff_type;
588 class __max_size_type;
591 template<
typename _Tp>
592 concept __is_signed_int128
594 = same_as<_Tp, __int128>;
600 template<
typename _Tp>
601 concept __is_unsigned_int128
603 = same_as<_Tp, unsigned __int128>;
608 template<
typename _Tp>
609 concept __cv_bool = same_as<const volatile _Tp, const volatile bool>;
611 template<
typename _Tp>
612 concept __integral_nonbool = integral<_Tp> && !__cv_bool<_Tp>;
614 template<
typename _Tp>
615 concept __is_int128 = __is_signed_int128<_Tp> || __is_unsigned_int128<_Tp>;
617 template<
typename _Tp>
618 concept __is_integer_like = __integral_nonbool<_Tp>
620 || same_as<_Tp, __max_diff_type> || same_as<_Tp, __max_size_type>;
622 template<
typename _Tp>
623 concept __is_signed_integer_like = signed_integral<_Tp>
624 || __is_signed_int128<_Tp>
625 || same_as<_Tp, __max_diff_type>;
629 namespace __detail {
using ranges::__detail::__is_signed_integer_like; }
632 template<
typename _Iter>
633 concept weakly_incrementable = movable<_Iter>
634 &&
requires(_Iter __i)
636 typename iter_difference_t<_Iter>;
637 requires __detail::__is_signed_integer_like<iter_difference_t<_Iter>>;
638 { ++__i } -> same_as<_Iter&>;
642 template<
typename _Iter>
643 concept incrementable = regular<_Iter> && weakly_incrementable<_Iter>
644 &&
requires(_Iter __i) { { __i++ } -> same_as<_Iter>; };
646 template<
typename _Iter>
647 concept input_or_output_iterator
648 =
requires(_Iter __i) { { *__i } -> __detail::__can_reference; }
649 && weakly_incrementable<_Iter>;
651 template<
typename _Sent,
typename _Iter>
652 concept sentinel_for = semiregular<_Sent>
653 && input_or_output_iterator<_Iter>
654 && __detail::__weakly_eq_cmp_with<_Sent, _Iter>;
656 template<
typename _Sent,
typename _Iter>
657 inline constexpr bool disable_sized_sentinel_for =
false;
659 template<
typename _Sent,
typename _Iter>
660 concept sized_sentinel_for = sentinel_for<_Sent, _Iter>
661 && !disable_sized_sentinel_for<remove_cv_t<_Sent>, remove_cv_t<_Iter>>
662 &&
requires(
const _Iter& __i,
const _Sent& __s)
664 { __s - __i } -> same_as<iter_difference_t<_Iter>>;
665 { __i - __s } -> same_as<iter_difference_t<_Iter>>;
668 template<
typename _Iter>
669 concept input_iterator = input_or_output_iterator<_Iter>
670 && indirectly_readable<_Iter>
671 &&
requires {
typename __detail::__iter_concept<_Iter>; }
672 && derived_from<__detail::__iter_concept<_Iter>, input_iterator_tag>;
674 template<
typename _Iter,
typename _Tp>
675 concept output_iterator = input_or_output_iterator<_Iter>
676 && indirectly_writable<_Iter, _Tp>
679 template<
typename _Iter>
680 concept forward_iterator = input_iterator<_Iter>
681 && derived_from<__detail::__iter_concept<_Iter>, forward_iterator_tag>
682 && incrementable<_Iter> && sentinel_for<_Iter, _Iter>;
684 template<
typename _Iter>
685 concept bidirectional_iterator = forward_iterator<_Iter>
686 && derived_from<__detail::__iter_concept<_Iter>,
687 bidirectional_iterator_tag>
688 &&
requires(_Iter __i)
690 { --__i } -> same_as<_Iter&>;
691 { __i-- } -> same_as<_Iter>;
694 template<
typename _Iter>
695 concept random_access_iterator = bidirectional_iterator<_Iter>
696 && derived_from<__detail::__iter_concept<_Iter>,
697 random_access_iterator_tag>
698 && totally_ordered<_Iter> && sized_sentinel_for<_Iter, _Iter>
699 &&
requires(_Iter __i,
const _Iter __j,
700 const iter_difference_t<_Iter> __n)
702 { __i += __n } -> same_as<_Iter&>;
703 { __j + __n } -> same_as<_Iter>;
704 { __n + __j } -> same_as<_Iter>;
705 { __i -= __n } -> same_as<_Iter&>;
706 { __j - __n } -> same_as<_Iter>;
707 { __j[__n] } -> same_as<iter_reference_t<_Iter>>;
710 template<
typename _Iter>
711 concept contiguous_iterator = random_access_iterator<_Iter>
712 && derived_from<__detail::__iter_concept<_Iter>, contiguous_iterator_tag>
713 && is_lvalue_reference_v<iter_reference_t<_Iter>>
714 && same_as<iter_value_t<_Iter>, remove_cvref_t<iter_reference_t<_Iter>>>
715 &&
requires(
const _Iter& __i)
718 -> same_as<add_pointer_t<iter_reference_t<_Iter>>>;
725 template<
typename _Fn,
typename _Iter>
726 concept indirectly_unary_invocable = indirectly_readable<_Iter>
727 && copy_constructible<_Fn> && invocable<_Fn&, __indirect_value_t<_Iter>>
728 && invocable<_Fn&, iter_reference_t<_Iter>>
729 && common_reference_with<invoke_result_t<_Fn&, __indirect_value_t<_Iter>>,
730 invoke_result_t<_Fn&, iter_reference_t<_Iter>>>;
732 template<
typename _Fn,
typename _Iter>
733 concept indirectly_regular_unary_invocable = indirectly_readable<_Iter>
734 && copy_constructible<_Fn>
735 && regular_invocable<_Fn&, __indirect_value_t<_Iter>>
736 && regular_invocable<_Fn&, iter_reference_t<_Iter>>
737 && common_reference_with<invoke_result_t<_Fn&, __indirect_value_t<_Iter>>,
738 invoke_result_t<_Fn&, iter_reference_t<_Iter>>>;
740 template<
typename _Fn,
typename _Iter>
741 concept indirect_unary_predicate = indirectly_readable<_Iter>
742 && copy_constructible<_Fn> && predicate<_Fn&, __indirect_value_t<_Iter>>
743 && predicate<_Fn&, iter_reference_t<_Iter>>;
745 template<
typename _Fn,
typename _I1,
typename _I2>
746 concept indirect_binary_predicate
747 = indirectly_readable<_I1> && indirectly_readable<_I2>
748 && copy_constructible<_Fn>
749 && predicate<_Fn&, __indirect_value_t<_I1>, __indirect_value_t<_I2>>
750 && predicate<_Fn&, __indirect_value_t<_I1>, iter_reference_t<_I2>>
751 && predicate<_Fn&, iter_reference_t<_I1>, __indirect_value_t<_I2>>
752 && predicate<_Fn&, iter_reference_t<_I1>, iter_reference_t<_I2>>;
754 template<
typename _Fn,
typename _I1,
typename _I2 = _I1>
755 concept indirect_equivalence_relation
756 = indirectly_readable<_I1> && indirectly_readable<_I2>
757 && copy_constructible<_Fn>
758 && equivalence_relation<_Fn&, __indirect_value_t<_I1>, __indirect_value_t<_I2>>
759 && equivalence_relation<_Fn&, __indirect_value_t<_I1>, iter_reference_t<_I2>>
760 && equivalence_relation<_Fn&, iter_reference_t<_I1>, __indirect_value_t<_I2>>
761 && equivalence_relation<_Fn&, iter_reference_t<_I1>,
762 iter_reference_t<_I2>>;
764 template<
typename _Fn,
typename _I1,
typename _I2 = _I1>
765 concept indirect_strict_weak_order
766 = indirectly_readable<_I1> && indirectly_readable<_I2>
767 && copy_constructible<_Fn>
768 && strict_weak_order<_Fn&, __indirect_value_t<_I1>, __indirect_value_t<_I2>>
769 && strict_weak_order<_Fn&, __indirect_value_t<_I1>, iter_reference_t<_I2>>
770 && strict_weak_order<_Fn&, iter_reference_t<_I1>, __indirect_value_t<_I2>>
771 && strict_weak_order<_Fn&, iter_reference_t<_I1>, iter_reference_t<_I2>>;
773 template<
typename _Fn,
typename... _Is>
774 requires (indirectly_readable<_Is> && ...)
775 && invocable<_Fn, iter_reference_t<_Is>...>
776 using indirect_result_t = invoke_result_t<_Fn, iter_reference_t<_Is>...>;
780 template<
typename _Iter,
typename _Proj>
785 using value_type = remove_cvref_t<indirect_result_t<_Proj&, _Iter>>;
786 indirect_result_t<_Proj&, _Iter>
operator*()
const;
790 using __projected_Iter = _Iter;
791 using __projected_Proj = _Proj;
795 template<weakly_incrementable _Iter,
typename _Proj>
796 struct __projected<_Iter, _Proj>
800 using value_type = remove_cvref_t<indirect_result_t<_Proj&, _Iter>>;
801 using difference_type = iter_difference_t<_Iter>;
802 indirect_result_t<_Proj&, _Iter>
operator*()
const;
804 using __projected_Iter = _Iter;
805 using __projected_Proj = _Proj;
811 template<indirectly_readable _Iter,
812 indirectly_regular_unary_invocable<_Iter> _Proj>
813 using projected =
typename __detail::__projected<_Iter, _Proj>::__type;
816 template<
typename _Tp>
817 requires same_as<_Tp, projected<
typename _Tp::__projected_Iter,
818 typename _Tp::__projected_Proj>>
819 struct __detail::__indirect_value<_Tp>
821 using _Iter =
typename _Tp::__projected_Iter;
822 using _Proj =
typename _Tp::__projected_Proj;
823 using type = invoke_result_t<_Proj&, __indirect_value_t<_Iter>>;
830 template<
typename _In,
typename _Out>
831 concept indirectly_movable = indirectly_readable<_In>
832 && indirectly_writable<_Out, iter_rvalue_reference_t<_In>>;
834 template<
typename _In,
typename _Out>
835 concept indirectly_movable_storable = indirectly_movable<_In, _Out>
836 && indirectly_writable<_Out, iter_value_t<_In>>
837 && movable<iter_value_t<_In>>
838 && constructible_from<iter_value_t<_In>, iter_rvalue_reference_t<_In>>
839 && assignable_from<iter_value_t<_In>&, iter_rvalue_reference_t<_In>>;
842 template<
typename _In,
typename _Out>
843 concept indirectly_copyable = indirectly_readable<_In>
844 && indirectly_writable<_Out, iter_reference_t<_In>>;
846 template<
typename _In,
typename _Out>
847 concept indirectly_copyable_storable = indirectly_copyable<_In, _Out>
848 && indirectly_writable<_Out, iter_value_t<_In>&>
849 && indirectly_writable<_Out, const iter_value_t<_In>&>
850 && indirectly_writable<_Out, iter_value_t<_In>&&>
851 && indirectly_writable<_Out, const iter_value_t<_In>&&>
852 && copyable<iter_value_t<_In>>
853 && constructible_from<iter_value_t<_In>, iter_reference_t<_In>>
854 && assignable_from<iter_value_t<_In>&, iter_reference_t<_In>>;
861 template<
typename _It1,
typename _It2>
862 void iter_swap(_It1, _It2) =
delete;
864 template<
typename _Tp,
typename _Up>
866 = (std::__detail::__class_or_enum<remove_reference_t<_Tp>>
867 || std::__detail::__class_or_enum<remove_reference_t<_Up>>)
868 &&
requires(_Tp&& __t, _Up&& __u) {
869 iter_swap(
static_cast<_Tp&&
>(__t),
static_cast<_Up&&
>(__u));
872 template<
typename _Xp,
typename _Yp>
873 constexpr iter_value_t<_Xp>
874 __iter_exchange_move(_Xp&& __x, _Yp&& __y)
875 noexcept(
noexcept(iter_value_t<_Xp>(iter_move(__x)))
876 &&
noexcept(*__x = iter_move(__y)))
878 iter_value_t<_Xp> __old_value(iter_move(__x));
879 *__x = iter_move(__y);
886 template<
typename _Tp,
typename _Up>
887 static constexpr bool
890 if constexpr (__adl_iswap<_Tp, _Up>)
893 else if constexpr (indirectly_readable<_Tp>
894 && indirectly_readable<_Up>
895 && swappable_with<iter_reference_t<_Tp>, iter_reference_t<_Up>>)
905 template<
typename _Tp,
typename _Up>
906 requires __adl_iswap<_Tp, _Up>
907 || (indirectly_readable<remove_reference_t<_Tp>>
908 && indirectly_readable<remove_reference_t<_Up>>
909 && swappable_with<iter_reference_t<_Tp>, iter_reference_t<_Up>>)
910 || (indirectly_movable_storable<_Tp, _Up>
911 && indirectly_movable_storable<_Up, _Tp>)
913 operator()(_Tp&& __e1, _Up&& __e2)
const
914 noexcept(_S_noexcept<_Tp, _Up>())
916 if constexpr (__adl_iswap<_Tp, _Up>)
917 iter_swap(
static_cast<_Tp&&
>(__e1),
static_cast<_Up&&
>(__e2));
918 else if constexpr (indirectly_readable<_Tp>
919 && indirectly_readable<_Up>
920 && swappable_with<iter_reference_t<_Tp>, iter_reference_t<_Up>>)
921 ranges::swap(*__e1, *__e2);
923 *__e1 = __iswap::__iter_exchange_move(__e2, __e1);
929 inline namespace _Cpo {
930 inline constexpr __iswap::_IterSwap iter_swap{};
936 template<
typename _I1,
typename _I2 = _I1>
937 concept indirectly_swappable
938 = indirectly_readable<_I1> && indirectly_readable<_I2>
939 &&
requires(
const _I1 __i1,
const _I2 __i2)
941 ranges::iter_swap(__i1, __i1);
942 ranges::iter_swap(__i2, __i2);
943 ranges::iter_swap(__i1, __i2);
944 ranges::iter_swap(__i2, __i1);
948 template<
typename _I1,
typename _I2,
typename _Rel,
typename _P1 = identity,
949 typename _P2 = identity>
950 concept indirectly_comparable
951 = indirect_binary_predicate<_Rel, projected<_I1, _P1>,
952 projected<_I2, _P2>>;
955 template<
typename _Iter>
956 concept permutable = forward_iterator<_Iter>
957 && indirectly_movable_storable<_Iter, _Iter>
958 && indirectly_swappable<_Iter, _Iter>;
961 template<
typename _I1,
typename _I2,
typename _Out,
962 typename _Rel = ranges::less,
typename _P1 = identity,
963 typename _P2 = identity>
964 concept mergeable = input_iterator<_I1> && input_iterator<_I2>
965 && weakly_incrementable<_Out> && indirectly_copyable<_I1, _Out>
966 && indirectly_copyable<_I2, _Out>
967 && indirect_strict_weak_order<_Rel, projected<_I1, _P1>,
968 projected<_I2, _P2>>;
971 template<
typename _Iter,
typename _Rel = ranges::less,
972 typename _Proj = identity>
973 concept sortable = permutable<_Iter>
974 && indirect_strict_weak_order<_Rel, projected<_Iter, _Proj>>;
976 struct unreachable_sentinel_t
978 template<weakly_incrementable _It>
979 friend constexpr bool
980 operator==(unreachable_sentinel_t,
const _It&)
noexcept
984 inline constexpr unreachable_sentinel_t unreachable_sentinel{};
987 namespace ranges::__access
989 using std::__detail::__class_or_enum;
991 struct _Decay_copy final
993 template<
typename _Tp>
994 constexpr decay_t<_Tp>
995 operator()(_Tp&& __t)
const
996 noexcept(is_nothrow_convertible_v<_Tp, decay_t<_Tp>>)
998 }
inline constexpr __decay_copy{};
1000 template<
typename _Tp>
1001 concept __member_begin =
requires(_Tp& __t)
1003 { __decay_copy(__t.begin()) } -> input_or_output_iterator;
1007 void begin() =
delete;
1009 template<
typename _Tp>
1010 concept __adl_begin = __class_or_enum<remove_reference_t<_Tp>>
1011 &&
requires(_Tp& __t)
1013 { __decay_copy(
begin(__t)) } -> input_or_output_iterator;
1018 template<
typename _Tp>
1019 requires is_array_v<_Tp> || __member_begin<_Tp&> || __adl_begin<_Tp&>
1023 if constexpr (is_array_v<_Tp>)
1025 else if constexpr (__member_begin<_Tp&>)
1035 template<
typename _Tp>
1036 using __range_iter_t
1042_GLIBCXX_END_NAMESPACE_VERSION
constexpr complex< _Tp > operator*(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x times y.
constexpr _Tp * to_address(_Tp *__ptr) noexcept
Obtain address referenced by a pointer to an object.
typename common_reference< _Tp... >::type common_reference_t
typename make_signed< _Tp >::type make_signed_t
Alias template for make_signed.
auto declval() noexcept -> decltype(__declval< _Tp >(0))
constexpr _Tp && forward(typename std::remove_reference< _Tp >::type &__t) noexcept
Forward an lvalue.
_Tp * begin(valarray< _Tp > &__va) noexcept
Return an iterator pointing to the first element of the valarray.
ISO C++ entities toplevel namespace is std.
constexpr default_sentinel_t default_sentinel
A default sentinel value.