33 #pragma GCC system_header
35 #if __cplusplus > 201703L && __cpp_impl_three_way_comparison >= 201907L
37 #pragma GCC visibility push(default)
41 #if __cpp_lib_concepts
42 # define __cpp_lib_three_way_comparison 201711L
51 enum class _Ord { equivalent = 0, less = -1, greater = 1 };
53 enum class _Ncmp { _Unordered = -127 };
57 constexpr __unspec(__unspec*) { }
61 class partial_ordering
67 partial_ordering(__cmp_cat::_Ord __v) noexcept
68 : _M_value(
int(__v)), _M_is_ordered(
true)
72 partial_ordering(__cmp_cat::_Ncmp __v) noexcept
73 : _M_value(
int(__v)), _M_is_ordered(
false)
78 static const partial_ordering less;
79 static const partial_ordering equivalent;
80 static const partial_ordering greater;
81 static const partial_ordering unordered;
85 operator==(partial_ordering __v, __cmp_cat::__unspec) noexcept
86 {
return __v._M_is_ordered && __v._M_value == 0; }
89 operator==(partial_ordering, partial_ordering) noexcept =
default;
92 operator< (partial_ordering __v, __cmp_cat::__unspec) noexcept
93 {
return __v._M_is_ordered && __v._M_value < 0; }
96 operator> (partial_ordering __v, __cmp_cat::__unspec) noexcept
97 {
return __v._M_is_ordered && __v._M_value > 0; }
100 operator<=(partial_ordering __v, __cmp_cat::__unspec) noexcept
101 {
return __v._M_is_ordered && __v._M_value <= 0; }
103 friend constexpr
bool
104 operator>=(partial_ordering __v, __cmp_cat::__unspec) noexcept
105 {
return __v._M_is_ordered && __v._M_value >= 0; }
107 friend constexpr
bool
108 operator< (__cmp_cat::__unspec, partial_ordering __v) noexcept
109 {
return __v._M_is_ordered && 0 < __v._M_value; }
111 friend constexpr
bool
112 operator> (__cmp_cat::__unspec, partial_ordering __v) noexcept
113 {
return __v._M_is_ordered && 0 > __v._M_value; }
115 friend constexpr
bool
116 operator<=(__cmp_cat::__unspec, partial_ordering __v) noexcept
117 {
return __v._M_is_ordered && 0 <= __v._M_value; }
119 friend constexpr
bool
120 operator>=(__cmp_cat::__unspec, partial_ordering __v) noexcept
121 {
return __v._M_is_ordered && 0 >= __v._M_value; }
123 friend constexpr partial_ordering
124 operator<=>(partial_ordering __v, __cmp_cat::__unspec) noexcept
127 friend constexpr partial_ordering
128 operator<=>(__cmp_cat::__unspec, partial_ordering __v) noexcept
131 return partial_ordering::greater;
133 return partial_ordering::less;
140 inline constexpr partial_ordering
141 partial_ordering::less(__cmp_cat::_Ord::less);
143 inline constexpr partial_ordering
144 partial_ordering::equivalent(__cmp_cat::_Ord::equivalent);
146 inline constexpr partial_ordering
147 partial_ordering::greater(__cmp_cat::_Ord::greater);
149 inline constexpr partial_ordering
150 partial_ordering::unordered(__cmp_cat::_Ncmp::_Unordered);
157 weak_ordering(__cmp_cat::_Ord __v) noexcept : _M_value(
int(__v))
162 static const weak_ordering less;
163 static const weak_ordering equivalent;
164 static const weak_ordering greater;
166 constexpr
operator partial_ordering() const noexcept
169 return partial_ordering::equivalent;
170 else if (_M_value < 0)
171 return partial_ordering::less;
173 return partial_ordering::greater;
177 friend constexpr
bool
178 operator==(weak_ordering __v, __cmp_cat::__unspec) noexcept
179 {
return __v._M_value == 0; }
181 friend constexpr
bool
182 operator==(weak_ordering, weak_ordering) noexcept =
default;
184 friend constexpr
bool
185 operator< (weak_ordering __v, __cmp_cat::__unspec) noexcept
186 {
return __v._M_value < 0; }
188 friend constexpr
bool
189 operator> (weak_ordering __v, __cmp_cat::__unspec) noexcept
190 {
return __v._M_value > 0; }
192 friend constexpr
bool
193 operator<=(weak_ordering __v, __cmp_cat::__unspec) noexcept
194 {
return __v._M_value <= 0; }
196 friend constexpr
bool
197 operator>=(weak_ordering __v, __cmp_cat::__unspec) noexcept
198 {
return __v._M_value >= 0; }
200 friend constexpr
bool
201 operator< (__cmp_cat::__unspec, weak_ordering __v) noexcept
202 {
return 0 < __v._M_value; }
204 friend constexpr
bool
205 operator> (__cmp_cat::__unspec, weak_ordering __v) noexcept
206 {
return 0 > __v._M_value; }
208 friend constexpr
bool
209 operator<=(__cmp_cat::__unspec, weak_ordering __v) noexcept
210 {
return 0 <= __v._M_value; }
212 friend constexpr
bool
213 operator>=(__cmp_cat::__unspec, weak_ordering __v) noexcept
214 {
return 0 >= __v._M_value; }
216 friend constexpr weak_ordering
217 operator<=>(weak_ordering __v, __cmp_cat::__unspec) noexcept
220 friend constexpr weak_ordering
221 operator<=>(__cmp_cat::__unspec, weak_ordering __v) noexcept
224 return weak_ordering::greater;
226 return weak_ordering::less;
233 inline constexpr weak_ordering
234 weak_ordering::less(__cmp_cat::_Ord::less);
236 inline constexpr weak_ordering
237 weak_ordering::equivalent(__cmp_cat::_Ord::equivalent);
239 inline constexpr weak_ordering
240 weak_ordering::greater(__cmp_cat::_Ord::greater);
242 class strong_ordering
247 strong_ordering(__cmp_cat::_Ord __v) noexcept
253 static const strong_ordering less;
254 static const strong_ordering equal;
255 static const strong_ordering equivalent;
256 static const strong_ordering greater;
258 constexpr
operator partial_ordering() const noexcept
261 return partial_ordering::equivalent;
262 else if (_M_value < 0)
263 return partial_ordering::less;
265 return partial_ordering::greater;
268 constexpr
operator weak_ordering() const noexcept
271 return weak_ordering::equivalent;
272 else if (_M_value < 0)
273 return weak_ordering::less;
275 return weak_ordering::greater;
279 friend constexpr
bool
280 operator==(strong_ordering __v, __cmp_cat::__unspec) noexcept
281 {
return __v._M_value == 0; }
283 friend constexpr
bool
284 operator==(strong_ordering, strong_ordering) noexcept =
default;
286 friend constexpr
bool
287 operator< (strong_ordering __v, __cmp_cat::__unspec) noexcept
288 {
return __v._M_value < 0; }
290 friend constexpr
bool
291 operator> (strong_ordering __v, __cmp_cat::__unspec) noexcept
292 {
return __v._M_value > 0; }
294 friend constexpr
bool
295 operator<=(strong_ordering __v, __cmp_cat::__unspec) noexcept
296 {
return __v._M_value <= 0; }
298 friend constexpr
bool
299 operator>=(strong_ordering __v, __cmp_cat::__unspec) noexcept
300 {
return __v._M_value >= 0; }
302 friend constexpr
bool
303 operator< (__cmp_cat::__unspec, strong_ordering __v) noexcept
304 {
return 0 < __v._M_value; }
306 friend constexpr
bool
307 operator> (__cmp_cat::__unspec, strong_ordering __v) noexcept
308 {
return 0 > __v._M_value; }
310 friend constexpr
bool
311 operator<=(__cmp_cat::__unspec, strong_ordering __v) noexcept
312 {
return 0 <= __v._M_value; }
314 friend constexpr
bool
315 operator>=(__cmp_cat::__unspec, strong_ordering __v) noexcept
316 {
return 0 >= __v._M_value; }
318 friend constexpr strong_ordering
319 operator<=>(strong_ordering __v, __cmp_cat::__unspec) noexcept
322 friend constexpr strong_ordering
323 operator<=>(__cmp_cat::__unspec, strong_ordering __v) noexcept
326 return strong_ordering::greater;
328 return strong_ordering::less;
335 inline constexpr strong_ordering
336 strong_ordering::less(__cmp_cat::_Ord::less);
338 inline constexpr strong_ordering
339 strong_ordering::equal(__cmp_cat::_Ord::equivalent);
341 inline constexpr strong_ordering
342 strong_ordering::equivalent(__cmp_cat::_Ord::equivalent);
344 inline constexpr strong_ordering
345 strong_ordering::greater(__cmp_cat::_Ord::greater);
350 is_eq(partial_ordering __cmp) noexcept
351 {
return __cmp == 0; }
354 is_neq(partial_ordering __cmp) noexcept
355 {
return __cmp != 0; }
358 is_lt (partial_ordering __cmp) noexcept
359 {
return __cmp < 0; }
362 is_lteq(partial_ordering __cmp) noexcept
363 {
return __cmp <= 0; }
366 is_gt (partial_ordering __cmp) noexcept
367 {
return __cmp > 0; }
370 is_gteq(partial_ordering __cmp) noexcept
371 {
return __cmp >= 0; }
375 template<
typename _Tp>
376 inline constexpr
unsigned __cmp_cat_id = 1;
378 inline constexpr
unsigned __cmp_cat_id<partial_ordering> = 2;
380 inline constexpr
unsigned __cmp_cat_id<weak_ordering> = 4;
382 inline constexpr
unsigned __cmp_cat_id<strong_ordering> = 8;
384 template<
typename... _Ts>
385 constexpr
auto __common_cmp_cat()
387 constexpr
unsigned __cats = (__cmp_cat_id<_Ts> | ...);
389 if constexpr (__cats & 1)
393 else if constexpr (
bool(__cats & __cmp_cat_id<partial_ordering>))
394 return partial_ordering::equivalent;
397 else if constexpr (
bool(__cats & __cmp_cat_id<weak_ordering>))
398 return weak_ordering::equivalent;
401 return strong_ordering::equivalent;
406 template<
typename... _Ts>
407 struct common_comparison_category
409 using type = decltype(__detail::__common_cmp_cat<_Ts...>());
414 template<
typename _Tp>
415 struct common_comparison_category<_Tp>
416 {
using type = void; };
419 struct common_comparison_category<partial_ordering>
420 {
using type = partial_ordering; };
423 struct common_comparison_category<weak_ordering>
424 {
using type = weak_ordering; };
427 struct common_comparison_category<strong_ordering>
428 {
using type = strong_ordering; };
431 struct common_comparison_category<>
432 {
using type = strong_ordering; };
434 template<
typename... _Ts>
435 using common_comparison_category_t
436 =
typename common_comparison_category<_Ts...>::type;
438 #if __cpp_lib_concepts
441 template<
typename _Tp,
typename _Cat>
442 concept __compares_as
443 = same_as<common_comparison_category_t<_Tp, _Cat>, _Cat>;
445 template<
typename _Tp,
typename _Up>
446 concept __partially_ordered_with
447 = requires(
const remove_reference_t<_Tp>& __t,
448 const remove_reference_t<_Up>& __u) {
449 { __t < __u } -> boolean;
450 { __t > __u } -> boolean;
451 { __t <= __u } -> boolean;
452 { __t >= __u } -> boolean;
453 { __u < __t } -> boolean;
454 { __u > __t } -> boolean;
455 { __u <= __t } -> boolean;
456 { __u >= __t } -> boolean;
461 template<
typename _Tp,
typename _Cat = partial_ordering>
462 concept three_way_comparable
463 = __detail::__weakly_eq_cmp_with<_Tp, _Tp>
464 && (!convertible_to<_Cat, partial_ordering>
465 || __detail::__partially_ordered_with<_Tp, _Tp>)
466 && requires(
const remove_reference_t<_Tp>& __a,
467 const remove_reference_t<_Tp>& __b) {
468 { __a <=> __b } -> __detail::__compares_as<_Cat>;
471 template<
typename _Tp,
typename _Up,
typename _Cat = partial_ordering>
472 concept three_way_comparable_with
473 = __detail::__weakly_eq_cmp_with<_Tp, _Up>
474 && (!convertible_to<_Cat, partial_ordering>
475 || __detail::__partially_ordered_with<_Tp, _Up>)
476 && three_way_comparable<_Tp, _Cat>
477 && three_way_comparable<_Up, _Cat>
478 && common_reference_with<
const remove_reference_t<_Tp>&,
479 const remove_reference_t<_Up>&>
480 && three_way_comparable<
481 common_reference_t<
const remove_reference_t<_Tp>&,
482 const remove_reference_t<_Up>&>, _Cat>
483 && requires(
const remove_reference_t<_Tp>& __t,
484 const remove_reference_t<_Up>& __u) {
485 { __t <=> __u } -> __detail::__compares_as<_Cat>;
486 { __u <=> __t } -> __detail::__compares_as<_Cat>;
491 template<
typename _Tp,
typename _Up>
492 using __cmp3way_res_t
493 = decltype(std::declval<_Tp>() <=> std::declval<_Up>());
500 template<
typename _Tp,
typename _Up>
501 struct __cmp3way_res_impl
504 template<
typename _Tp,
typename _Up>
505 requires requires {
typename __cmp3way_res_t<__cref<_Tp>, __cref<_Up>>; }
506 struct __cmp3way_res_impl<_Tp, _Up>
508 using type = __cmp3way_res_t<__cref<_Tp>, __cref<_Up>>;
513 template<
typename _Tp,
typename _Up = _Tp>
514 struct compare_three_way_result
515 : __detail::__cmp3way_res_impl<_Tp, _Up>
519 template<
typename _Tp,
typename _Up = _Tp>
520 using compare_three_way_result_t
521 =
typename __detail::__cmp3way_res_impl<_Tp, _Up>::type;
526 template<
typename _Tp,
typename _Up>
527 concept __3way_builtin_ptr_cmp
528 = three_way_comparable_with<_Tp, _Up>
529 && convertible_to<_Tp, const volatile void*>
530 && convertible_to<_Up, const volatile void*>
531 && ! requires(_Tp&& __t, _Up&& __u)
532 { operator<=>(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u)); }
533 && ! requires(_Tp&& __t, _Up&& __u)
534 { static_cast<_Tp&&>(__t).operator<=>(static_cast<_Up&&>(__u)); };
538 struct compare_three_way
540 template<
typename _Tp,
typename _Up>
541 requires three_way_comparable_with<_Tp, _Up>
543 operator()(_Tp&& __t, _Up&& __u)
const noexcept
545 if constexpr (__detail::__3way_builtin_ptr_cmp<_Tp, _Up>)
547 auto __pt = static_cast<const volatile void*>(__t);
548 auto __pu = static_cast<const volatile void*>(__u);
549 if (__builtin_is_constant_evaluated())
550 return __pt <=> __pu;
551 auto __it = reinterpret_cast<__UINTPTR_TYPE__>(__pt);
552 auto __iu = reinterpret_cast<__UINTPTR_TYPE__>(__pu);
553 return __it <=> __iu;
556 return static_cast<_Tp&&>(__t) <=> static_cast<_Up&&>(__u);
559 using is_transparent = void;
564 template<
floating_po
int _Tp>
565 constexpr weak_ordering
566 __fp_weak_ordering(_Tp __e, _Tp __f)
570 auto __cat = [](_Tp __fp) ->
int {
571 const int __sign = __builtin_signbit(__fp) ? -1 : 1;
572 if (__builtin_isnormal(__fp))
573 return (__fp == 0 ? 1 : 3) * __sign;
574 if (__builtin_isnan(__fp))
576 if (
int __inf = __builtin_isinf_sign(__fp))
581 auto __po = __e <=> __f;
583 return weak_ordering::less;
584 else if (is_gt(__po))
585 return weak_ordering::greater;
586 else if (__po == partial_ordering::equivalent)
587 return weak_ordering::equivalent;
591 auto __isnan_sign = [](_Tp __fp) ->
int {
592 return __builtin_isnan(__fp)
593 ? __builtin_signbit(__fp) ? -1 : 1
596 auto __ord = __isnan_sign(__e) <=> __isnan_sign(__f);
598 return weak_ordering::equivalent;
599 else if (is_lt(__ord))
600 return weak_ordering::less;
602 return weak_ordering::greater;
606 template<
typename _Tp,
typename _Up>
607 concept __adl_strong = requires(_Tp&& __t, _Up&& __u)
609 strong_ordering(strong_order(static_cast<_Tp&&>(__t),
610 static_cast<_Up&&>(__u)));
613 template<
typename _Tp,
typename _Up>
614 concept __adl_weak = requires(_Tp&& __t, _Up&& __u)
616 weak_ordering(weak_order(static_cast<_Tp&&>(__t),
617 static_cast<_Up&&>(__u)));
620 template<
typename _Tp,
typename _Up>
621 concept __adl_partial = requires(_Tp&& __t, _Up&& __u)
623 partial_ordering(partial_order(static_cast<_Tp&&>(__t),
624 static_cast<_Up&&>(__u)));
627 template<
typename _Ord,
typename _Tp,
typename _Up>
628 concept __op_cmp = requires(_Tp&& __t, _Up&& __u)
630 _Ord(static_cast<_Tp&&>(__t) <=> static_cast<_Up&&>(__u));
633 template<
typename _Tp,
typename _Up>
634 concept __strongly_ordered
635 = __adl_strong<_Tp, _Up>
637 || __op_cmp<strong_ordering, _Tp, _Up>;
641 template<
typename _Tp,
typename _Up>
642 static constexpr
bool
645 if constexpr (floating_point<decay_t<_Tp>>)
647 else if constexpr (__adl_strong<_Tp, _Up>)
648 return noexcept(strong_ordering(strong_order(
std::declval<_Tp>(),
649 std::declval<_Up>())));
650 else if constexpr (__op_cmp<strong_ordering, _Tp, _Up>)
651 return noexcept(
std::declval<_Tp>() <=>
std::declval<_Up>());
654 friend class _Weak_order;
655 friend class _Strong_fallback;
658 template<typename _Tp, typename _Up>
659 requires __strongly_ordered<_Tp, _Up>
660 constexpr strong_ordering
661 operator()(_Tp&& __e, _Up&& __f) const
662 noexcept(_S_noexcept<_Tp, _Up>())
664 static_assert(same_as<decay_t<_Tp>, decay_t<_Up>>);
669 if constexpr (__adl_strong<_Tp, _Up>)
670 return strong_ordering(strong_order(static_cast<_Tp&&>(__e),
671 static_cast<_Up&&>(__f)));
672 else if constexpr (__op_cmp<strong_ordering, _Tp, _Up>)
673 return static_cast<_Tp&&>(__e) <=> static_cast<_Up&&>(__f);
677 template<
typename _Tp,
typename _Up>
678 concept __weakly_ordered
679 = floating_point<remove_reference_t<_Tp>>
680 || __adl_weak<_Tp, _Up>
681 || __op_cmp<weak_ordering, _Tp, _Up>
682 || __strongly_ordered<_Tp, _Up>;
686 template<
typename _Tp,
typename _Up>
687 static constexpr
bool
690 if constexpr (floating_point<decay_t<_Tp>>)
692 else if constexpr (__adl_weak<_Tp, _Up>)
693 return noexcept(weak_ordering(weak_order(
std::declval<_Tp>(),
694 std::declval<_Up>())));
695 else if constexpr (__op_cmp<weak_ordering, _Tp, _Up>)
696 return noexcept(
std::declval<_Tp>() <=>
std::declval<_Up>());
697 else if constexpr (__strongly_ordered<_Tp, _Up>)
698 return _Strong_order::_S_noexcept<_Tp, _Up>();
701 friend class _Partial_order;
702 friend class _Weak_fallback;
705 template<typename _Tp, typename _Up>
706 requires __weakly_ordered<_Tp, _Up>
707 constexpr weak_ordering
708 operator()(_Tp&& __e, _Up&& __f) const
709 noexcept(_S_noexcept<_Tp, _Up>())
711 static_assert(same_as<decay_t<_Tp>, decay_t<_Up>>);
713 if constexpr (floating_point<decay_t<_Tp>>)
714 return __cmp_cust::__fp_weak_ordering(__e, __f);
715 else if constexpr (__adl_weak<_Tp, _Up>)
716 return weak_ordering(weak_order(static_cast<_Tp&&>(__e),
717 static_cast<_Up&&>(__f)));
718 else if constexpr (__op_cmp<weak_ordering, _Tp, _Up>)
719 return static_cast<_Tp&&>(__e) <=> static_cast<_Up&&>(__f);
720 else if constexpr (__strongly_ordered<_Tp, _Up>)
721 return _Strong_order{}(static_cast<_Tp&&>(__e),
722 static_cast<_Up&&>(__f));
726 template<
typename _Tp,
typename _Up>
727 concept __partially_ordered
728 = __adl_partial<_Tp, _Up>
729 || __op_cmp<partial_ordering, _Tp, _Up>
730 || __weakly_ordered<_Tp, _Up>;
734 template<
typename _Tp,
typename _Up>
735 static constexpr
bool
738 if constexpr (__adl_partial<_Tp, _Up>)
739 return noexcept(partial_ordering(partial_order(std::declval<_Tp>(),
740 std::declval<_Up>())));
741 else if constexpr (__op_cmp<partial_ordering, _Tp, _Up>)
742 return noexcept(std::declval<_Tp>() <=> std::declval<_Up>());
743 else if constexpr (__weakly_ordered<_Tp, _Up>)
744 return _Weak_order::_S_noexcept<_Tp, _Up>();
747 friend class _Partial_fallback;
750 template<
typename _Tp,
typename _Up>
751 requires __partially_ordered<_Tp, _Up>
752 constexpr partial_ordering
753 operator()(_Tp&& __e, _Up&& __f)
const
754 noexcept(_S_noexcept<_Tp, _Up>())
756 static_assert(same_as<decay_t<_Tp>, decay_t<_Up>>);
758 if constexpr (__adl_partial<_Tp, _Up>)
759 return partial_ordering(partial_order(static_cast<_Tp&&>(__e),
760 static_cast<_Up&&>(__f)));
761 else if constexpr (__op_cmp<partial_ordering, _Tp, _Up>)
762 return static_cast<_Tp&&>(__e) <=> static_cast<_Up&&>(__f);
763 else if constexpr (__weakly_ordered<_Tp, _Up>)
764 return _Weak_order{}(static_cast<_Tp&&>(__e),
765 static_cast<_Up&&>(__f));
769 template<
typename _Tp,
typename _Up>
770 concept __op_eq_lt = requires(_Tp&& __t, _Up&& __u)
772 { static_cast<_Tp&&>(__t) == static_cast<_Up&&>(__u) }
773 -> convertible_to<bool>;
774 { static_cast<_Tp&&>(__t) < static_cast<_Up&&>(__u) }
775 -> convertible_to<bool>;
778 class _Strong_fallback
780 template<
typename _Tp,
typename _Up>
781 static constexpr
bool
784 if constexpr (__strongly_ordered<_Tp, _Up>)
785 return _Strong_order::_S_noexcept<_Tp, _Up>();
787 return noexcept(
bool(std::declval<_Tp>() == std::declval<_Up>()))
788 && noexcept(
bool(std::declval<_Tp>() < std::declval<_Up>()));
792 template<
typename _Tp,
typename _Up>
793 requires __strongly_ordered<_Tp, _Up> || __op_eq_lt<_Tp, _Up>
794 constexpr decltype(
auto)
795 operator()(_Tp&& __e, _Up&& __f) const
796 noexcept(_S_noexcept<_Tp, _Up>())
798 static_assert(same_as<decay_t<_Tp>, decay_t<_Up>>);
800 if constexpr (__strongly_ordered<_Tp, _Up>)
801 return _Strong_order{}(static_cast<_Tp&&>(__e),
802 static_cast<_Up&&>(__f));
803 else if constexpr (__op_eq_lt<_Tp, _Up>)
804 return static_cast<_Tp&&>(__e) == static_cast<_Up&&>(__f)
805 ? strong_ordering::equal
806 : static_cast<_Tp&&>(__e) < static_cast<_Up&&>(__f)
807 ? strong_ordering::less
808 : strong_ordering::greater;
814 template<
typename _Tp,
typename _Up>
815 static constexpr
bool
818 if constexpr (__weakly_ordered<_Tp, _Up>)
819 return _Weak_order::_S_noexcept<_Tp, _Up>();
821 return noexcept(
bool(std::declval<_Tp>() == std::declval<_Up>()))
822 && noexcept(
bool(std::declval<_Tp>() < std::declval<_Up>()));
826 template<
typename _Tp,
typename _Up>
827 requires __weakly_ordered<_Tp, _Up> || __op_eq_lt<_Tp, _Up>
828 constexpr decltype(
auto)
829 operator()(_Tp&& __e, _Up&& __f) const
830 noexcept(_S_noexcept<_Tp, _Up>())
832 static_assert(same_as<decay_t<_Tp>, decay_t<_Up>>);
834 if constexpr (__weakly_ordered<_Tp, _Up>)
835 return _Weak_order{}(static_cast<_Tp&&>(__e),
836 static_cast<_Up&&>(__f));
837 else if constexpr (__op_eq_lt<_Tp, _Up>)
838 return static_cast<_Tp&&>(__e) == static_cast<_Up&&>(__f)
839 ? weak_ordering::equivalent
840 : static_cast<_Tp&&>(__e) < static_cast<_Up&&>(__f)
841 ? weak_ordering::less
842 : weak_ordering::greater;
846 class _Partial_fallback
848 template<
typename _Tp,
typename _Up>
849 static constexpr
bool
852 if constexpr (__partially_ordered<_Tp, _Up>)
853 return _Partial_order::_S_noexcept<_Tp, _Up>();
855 return noexcept(
bool(std::declval<_Tp>() == std::declval<_Up>()))
856 && noexcept(
bool(std::declval<_Tp>() < std::declval<_Up>()));
860 template<
typename _Tp,
typename _Up>
861 requires __partially_ordered<_Tp, _Up> || __op_eq_lt<_Tp, _Up>
862 constexpr decltype(
auto)
863 operator()(_Tp&& __e, _Up&& __f) const
864 noexcept(_S_noexcept<_Tp, _Up>())
866 static_assert(same_as<decay_t<_Tp>, decay_t<_Up>>);
868 if constexpr (__partially_ordered<_Tp, _Up>)
869 return _Partial_order{}(static_cast<_Tp&&>(__e),
870 static_cast<_Up&&>(__f));
871 else if constexpr (__op_eq_lt<_Tp, _Up>)
872 return static_cast<_Tp&&>(__e) == static_cast<_Up&&>(__f)
873 ? partial_ordering::equivalent
874 : static_cast<_Tp&&>(__e) < static_cast<_Up&&>(__f)
875 ? partial_ordering::less
876 : static_cast<_Up&&>(__f) < static_cast<_Tp&&>(__e)
877 ? partial_ordering::greater
878 : partial_ordering::unordered;
884 inline namespace __cmp_alg
886 inline constexpr __cmp_cust::_Strong_order strong_order{};
888 inline constexpr __cmp_cust::_Weak_order weak_order{};
890 inline constexpr __cmp_cust::_Partial_order partial_order{};
892 inline constexpr __cmp_cust::_Strong_fallback
893 compare_strong_order_fallback{};
895 inline constexpr __cmp_cust::_Weak_fallback
896 compare_weak_order_fallback{};
898 inline constexpr __cmp_cust::_Partial_fallback
899 compare_partial_order_fallback{};
905 inline constexpr
struct _Synth3way
907 template<
typename _Tp,
typename _Up>
909 operator()(
const _Tp& __t,
const _Up& __u)
const
912 { __t < __u } -> convertible_to<bool>;
913 { __u < __t } -> convertible_to<bool>;
916 if constexpr (three_way_comparable_with<_Tp, _Up>)
921 return weak_ordering::less;
923 return weak_ordering::greater;
925 return weak_ordering::equivalent;
930 template<
typename _Tp,
typename _Up = _Tp>
932 = decltype(__detail::__synth3way(std::declval<_Tp&>(),
933 std::declval<_Up&>()));
938 #pragma GCC visibility pop