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_COMPARE 11#define _LIBCPP_COMPARE 12 13/* 14 compare synopsis 15 16namespace std { 17 // [cmp.categories], comparison category types 18 class partial_ordering; 19 class weak_ordering; 20 class strong_ordering; 21 22 // named comparison functions 23 constexpr bool is_eq (partial_ordering cmp) noexcept { return cmp == 0; } 24 constexpr bool is_neq (partial_ordering cmp) noexcept { return cmp != 0; } 25 constexpr bool is_lt (partial_ordering cmp) noexcept { return cmp < 0; } 26 constexpr bool is_lteq(partial_ordering cmp) noexcept { return cmp <= 0; } 27 constexpr bool is_gt (partial_ordering cmp) noexcept { return cmp > 0; } 28 constexpr bool is_gteq(partial_ordering cmp) noexcept { return cmp >= 0; } 29 30 // [cmp.common], common comparison category type 31 template<class... Ts> 32 struct common_comparison_category { 33 using type = see below; 34 }; 35 template<class... Ts> 36 using common_comparison_category_t = typename common_comparison_category<Ts...>::type; 37 38 // [cmp.concept], concept three_way_comparable 39 template<class T, class Cat = partial_ordering> 40 concept three_way_comparable = see below; 41 template<class T, class U, class Cat = partial_ordering> 42 concept three_way_comparable_with = see below; 43 44 // [cmp.result], result of three-way comparison 45 template<class T, class U = T> struct compare_three_way_result; 46 47 template<class T, class U = T> 48 using compare_three_way_result_t = typename compare_three_way_result<T, U>::type; 49 50 // [comparisons.three.way], class compare_three_way 51 struct compare_three_way; // C++20 52 53 // [cmp.alg], comparison algorithms 54 inline namespace unspecified { 55 inline constexpr unspecified strong_order = unspecified; 56 inline constexpr unspecified weak_order = unspecified; 57 inline constexpr unspecified partial_order = unspecified; 58 inline constexpr unspecified compare_strong_order_fallback = unspecified; 59 inline constexpr unspecified compare_weak_order_fallback = unspecified; 60 inline constexpr unspecified compare_partial_order_fallback = unspecified; 61 } 62 63 // [cmp.partialord], Class partial_ordering 64 class partial_ordering { 65 public: 66 // valid values 67 static const partial_ordering less; 68 static const partial_ordering equivalent; 69 static const partial_ordering greater; 70 static const partial_ordering unordered; 71 72 // comparisons 73 friend constexpr bool operator==(partial_ordering v, unspecified) noexcept; 74 friend constexpr bool operator==(partial_ordering v, partial_ordering w) noexcept = default; 75 friend constexpr bool operator< (partial_ordering v, unspecified) noexcept; 76 friend constexpr bool operator> (partial_ordering v, unspecified) noexcept; 77 friend constexpr bool operator<=(partial_ordering v, unspecified) noexcept; 78 friend constexpr bool operator>=(partial_ordering v, unspecified) noexcept; 79 friend constexpr bool operator< (unspecified, partial_ordering v) noexcept; 80 friend constexpr bool operator> (unspecified, partial_ordering v) noexcept; 81 friend constexpr bool operator<=(unspecified, partial_ordering v) noexcept; 82 friend constexpr bool operator>=(unspecified, partial_ordering v) noexcept; 83 friend constexpr partial_ordering operator<=>(partial_ordering v, unspecified) noexcept; 84 friend constexpr partial_ordering operator<=>(unspecified, partial_ordering v) noexcept; 85 }; 86 87 // [cmp.weakord], Class weak_ordering 88 class weak_ordering { 89 public: 90 // valid values 91 static const weak_ordering less; 92 static const weak_ordering equivalent; 93 static const weak_ordering greater; 94 95 // conversions 96 constexpr operator partial_ordering() const noexcept; 97 98 // comparisons 99 friend constexpr bool operator==(weak_ordering v, unspecified) noexcept; 100 friend constexpr bool operator==(weak_ordering v, weak_ordering w) noexcept = default; 101 friend constexpr bool operator< (weak_ordering v, unspecified) noexcept; 102 friend constexpr bool operator> (weak_ordering v, unspecified) noexcept; 103 friend constexpr bool operator<=(weak_ordering v, unspecified) noexcept; 104 friend constexpr bool operator>=(weak_ordering v, unspecified) noexcept; 105 friend constexpr bool operator< (unspecified, weak_ordering v) noexcept; 106 friend constexpr bool operator> (unspecified, weak_ordering v) noexcept; 107 friend constexpr bool operator<=(unspecified, weak_ordering v) noexcept; 108 friend constexpr bool operator>=(unspecified, weak_ordering v) noexcept; 109 friend constexpr weak_ordering operator<=>(weak_ordering v, unspecified) noexcept; 110 friend constexpr weak_ordering operator<=>(unspecified, weak_ordering v) noexcept; 111 }; 112 113 // [cmp.strongord], Class strong_ordering 114 class strong_ordering { 115 public: 116 // valid values 117 static const strong_ordering less; 118 static const strong_ordering equal; 119 static const strong_ordering equivalent; 120 static const strong_ordering greater; 121 122 // conversions 123 constexpr operator partial_ordering() const noexcept; 124 constexpr operator weak_ordering() const noexcept; 125 126 // comparisons 127 friend constexpr bool operator==(strong_ordering v, unspecified) noexcept; 128 friend constexpr bool operator==(strong_ordering v, strong_ordering w) noexcept = default; 129 friend constexpr bool operator< (strong_ordering v, unspecified) noexcept; 130 friend constexpr bool operator> (strong_ordering v, unspecified) noexcept; 131 friend constexpr bool operator<=(strong_ordering v, unspecified) noexcept; 132 friend constexpr bool operator>=(strong_ordering v, unspecified) noexcept; 133 friend constexpr bool operator< (unspecified, strong_ordering v) noexcept; 134 friend constexpr bool operator> (unspecified, strong_ordering v) noexcept; 135 friend constexpr bool operator<=(unspecified, strong_ordering v) noexcept; 136 friend constexpr bool operator>=(unspecified, strong_ordering v) noexcept; 137 friend constexpr strong_ordering operator<=>(strong_ordering v, unspecified) noexcept; 138 friend constexpr strong_ordering operator<=>(unspecified, strong_ordering v) noexcept; 139 }; 140} 141*/ 142 143#include <__assert> // all public C++ headers provide the assertion handler 144#include <__compare/common_comparison_category.h> 145#include <__compare/compare_partial_order_fallback.h> 146#include <__compare/compare_strong_order_fallback.h> 147#include <__compare/compare_three_way.h> 148#include <__compare/compare_three_way_result.h> 149#include <__compare/compare_weak_order_fallback.h> 150#include <__compare/is_eq.h> 151#include <__compare/ordering.h> 152#include <__compare/partial_order.h> 153#include <__compare/strong_order.h> 154#include <__compare/synth_three_way.h> 155#include <__compare/three_way_comparable.h> 156#include <__compare/weak_order.h> 157#include <__config> 158#include <version> 159 160#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 161# pragma GCC system_header 162#endif 163 164#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 165# include <type_traits> 166#endif 167 168#endif // _LIBCPP_COMPARE 169