namespace std {
// [cmp.categories], comparison category types
- class weak_equality;
- class strong_equality;
class partial_ordering;
class weak_ordering;
class strong_ordering;
// named comparison functions
- constexpr bool is_eq (weak_equality cmp) noexcept { return cmp == 0; }
- constexpr bool is_neq (weak_equality cmp) noexcept { return cmp != 0; }
+ constexpr bool is_eq (partial_ordering cmp) noexcept { return cmp == 0; }
+ constexpr bool is_neq (partial_ordering cmp) noexcept { return cmp != 0; }
constexpr bool is_lt (partial_ordering cmp) noexcept { return cmp < 0; }
constexpr bool is_lteq(partial_ordering cmp) noexcept { return cmp <= 0; }
constexpr bool is_gt (partial_ordering cmp) noexcept { return cmp > 0; }
template<class T> constexpr strong_ordering strong_order(const T& a, const T& b);
template<class T> constexpr weak_ordering weak_order(const T& a, const T& b);
template<class T> constexpr partial_ordering partial_order(const T& a, const T& b);
- template<class T> constexpr strong_equality strong_equal(const T& a, const T& b);
- template<class T> constexpr weak_equality weak_equal(const T& a, const T& b);
// [cmp.partialord], Class partial_ordering
class partial_ordering {
_CmpUnspecifiedParam(_Tp) = delete;
};
-class weak_equality {
- _LIBCPP_INLINE_VISIBILITY
- constexpr explicit weak_equality(_EqResult __val) noexcept : __value_(__val) {}
-
-public:
- static const weak_equality equivalent;
- static const weak_equality nonequivalent;
-
- _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(weak_equality __v, _CmpUnspecifiedParam) noexcept;
- _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(_CmpUnspecifiedParam, weak_equality __v) noexcept;
- _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator!=(weak_equality __v, _CmpUnspecifiedParam) noexcept;
- _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator!=(_CmpUnspecifiedParam, weak_equality __v) noexcept;
-
-#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
- _LIBCPP_INLINE_VISIBILITY friend constexpr weak_equality operator<=>(weak_equality __v, _CmpUnspecifiedParam) noexcept;
- _LIBCPP_INLINE_VISIBILITY friend constexpr weak_equality operator<=>(_CmpUnspecifiedParam, weak_equality __v) noexcept;
-#endif
-
-private:
- _EqResult __value_;
-};
-
-_LIBCPP_INLINE_VAR constexpr weak_equality weak_equality::equivalent(_EqResult::__equiv);
-_LIBCPP_INLINE_VAR constexpr weak_equality weak_equality::nonequivalent(_EqResult::__nonequiv);
-
-_LIBCPP_INLINE_VISIBILITY
-inline constexpr bool operator==(weak_equality __v, _CmpUnspecifiedParam) noexcept {
- return __v.__value_ == _EqResult::__zero;
-}
-
-_LIBCPP_INLINE_VISIBILITY
-inline constexpr bool operator==(_CmpUnspecifiedParam, weak_equality __v) noexcept {
- return __v.__value_ == _EqResult::__zero;
-}
-
-_LIBCPP_INLINE_VISIBILITY
-inline constexpr bool operator!=(weak_equality __v, _CmpUnspecifiedParam) noexcept {
- return __v.__value_ != _EqResult::__zero;
-}
-
-_LIBCPP_INLINE_VISIBILITY
-inline constexpr bool operator!=(_CmpUnspecifiedParam, weak_equality __v) noexcept {
- return __v.__value_ != _EqResult::__zero;
-}
-
-#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
-_LIBCPP_INLINE_VISIBILITY
-inline constexpr weak_equality operator<=>(weak_equality __v, _CmpUnspecifiedParam) noexcept {
- return __v;
-}
-
-_LIBCPP_INLINE_VISIBILITY
-inline constexpr weak_equality operator<=>(_CmpUnspecifiedParam, weak_equality __v) noexcept {
- return __v;
-}
-#endif
-
-class strong_equality {
- _LIBCPP_INLINE_VISIBILITY
- explicit constexpr strong_equality(_EqResult __val) noexcept : __value_(__val) {}
-
-public:
- static const strong_equality equal;
- static const strong_equality nonequal;
- static const strong_equality equivalent;
- static const strong_equality nonequivalent;
-
- // conversion
- _LIBCPP_INLINE_VISIBILITY constexpr operator weak_equality() const noexcept {
- return __value_ == _EqResult::__zero ? weak_equality::equivalent
- : weak_equality::nonequivalent;
- }
-
- // comparisons
- _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(strong_equality __v, _CmpUnspecifiedParam) noexcept;
- _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator!=(strong_equality __v, _CmpUnspecifiedParam) noexcept;
- _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(_CmpUnspecifiedParam, strong_equality __v) noexcept;
- _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator!=(_CmpUnspecifiedParam, strong_equality __v) noexcept;
-
-#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
- _LIBCPP_INLINE_VISIBILITY friend constexpr strong_equality operator<=>(strong_equality __v, _CmpUnspecifiedParam) noexcept;
- _LIBCPP_INLINE_VISIBILITY friend constexpr strong_equality operator<=>(_CmpUnspecifiedParam, strong_equality __v) noexcept;
-#endif
-private:
- _EqResult __value_;
-};
-
-_LIBCPP_INLINE_VAR constexpr strong_equality strong_equality::equal(_EqResult::__equal);
-_LIBCPP_INLINE_VAR constexpr strong_equality strong_equality::nonequal(_EqResult::__nonequal);
-_LIBCPP_INLINE_VAR constexpr strong_equality strong_equality::equivalent(_EqResult::__equiv);
-_LIBCPP_INLINE_VAR constexpr strong_equality strong_equality::nonequivalent(_EqResult::__nonequiv);
-
-_LIBCPP_INLINE_VISIBILITY
-constexpr bool operator==(strong_equality __v, _CmpUnspecifiedParam) noexcept {
- return __v.__value_ == _EqResult::__zero;
-}
-
-_LIBCPP_INLINE_VISIBILITY
-constexpr bool operator==(_CmpUnspecifiedParam, strong_equality __v) noexcept {
- return __v.__value_ == _EqResult::__zero;
-}
-
-_LIBCPP_INLINE_VISIBILITY
-constexpr bool operator!=(strong_equality __v, _CmpUnspecifiedParam) noexcept {
- return __v.__value_ != _EqResult::__zero;
-}
-
-_LIBCPP_INLINE_VISIBILITY
-constexpr bool operator!=(_CmpUnspecifiedParam, strong_equality __v) noexcept {
- return __v.__value_ != _EqResult::__zero;
-}
-
-#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
-_LIBCPP_INLINE_VISIBILITY
-constexpr strong_equality operator<=>(strong_equality __v, _CmpUnspecifiedParam) noexcept {
- return __v;
-}
-
-_LIBCPP_INLINE_VISIBILITY
-constexpr strong_equality operator<=>(_CmpUnspecifiedParam, strong_equality __v) noexcept {
- return __v;
-}
-#endif // _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
-
class partial_ordering {
using _ValueT = signed char;
static const partial_ordering greater;
static const partial_ordering unordered;
- // conversion
- constexpr operator weak_equality() const noexcept {
- return __value_ == 0 ? weak_equality::equivalent : weak_equality::nonequivalent;
- }
-
// comparisons
_LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(partial_ordering __v, _CmpUnspecifiedParam) noexcept;
_LIBCPP_INLINE_VISIBILITY friend constexpr bool operator!=(partial_ordering __v, _CmpUnspecifiedParam) noexcept;
static const weak_ordering equivalent;
static const weak_ordering greater;
- // conversions
- _LIBCPP_INLINE_VISIBILITY
- constexpr operator weak_equality() const noexcept {
- return __value_ == 0 ? weak_equality::equivalent
- : weak_equality::nonequivalent;
- }
-
_LIBCPP_INLINE_VISIBILITY
constexpr operator partial_ordering() const noexcept {
return __value_ == 0 ? partial_ordering::equivalent
// conversions
_LIBCPP_INLINE_VISIBILITY
- constexpr operator weak_equality() const noexcept {
- return __value_ == 0 ? weak_equality::equivalent
- : weak_equality::nonequivalent;
- }
-
- _LIBCPP_INLINE_VISIBILITY
- constexpr operator strong_equality() const noexcept {
- return __value_ == 0 ? strong_equality::equal
- : strong_equality::nonequal;
- }
-
- _LIBCPP_INLINE_VISIBILITY
constexpr operator partial_ordering() const noexcept {
return __value_ == 0 ? partial_ordering::equivalent
: (__value_ < 0 ? partial_ordering::less : partial_ordering::greater);
// named comparison functions
_LIBCPP_INLINE_VISIBILITY
-constexpr bool is_eq(weak_equality __cmp) noexcept { return __cmp == 0; }
-
-_LIBCPP_INLINE_VISIBILITY
-constexpr bool is_neq(weak_equality __cmp) noexcept { return __cmp != 0; }
-
-_LIBCPP_INLINE_VISIBILITY
constexpr bool is_lt(partial_ordering __cmp) noexcept { return __cmp < 0; }
_LIBCPP_INLINE_VISIBILITY
enum _ClassifyCompCategory : unsigned{
_None,
- _WeakEq,
- _StrongEq,
_PartialOrd,
_WeakOrd,
_StrongOrd,
template <class _Tp>
_LIBCPP_INLINE_VISIBILITY
constexpr _ClassifyCompCategory __type_to_enum() noexcept {
- if (is_same_v<_Tp, weak_equality>)
- return _WeakEq;
- if (is_same_v<_Tp, strong_equality>)
- return _StrongEq;
if (is_same_v<_Tp, partial_ordering>)
return _PartialOrd;
if (is_same_v<_Tp, weak_ordering>)
++__seen[__type];
if (__seen[_None])
return _None;
- if (__seen[_WeakEq])
- return _WeakEq;
- if (__seen[_StrongEq] && (__seen[_PartialOrd] || __seen[_WeakOrd]))
- return _WeakEq;
- if (__seen[_StrongEq])
- return _StrongEq;
if (__seen[_PartialOrd])
return _PartialOrd;
if (__seen[_WeakOrd])
constexpr _CCC _Cat = __compute_comp_type(__type_kinds);
if constexpr (_Cat == _None)
return void();
- else if constexpr (_Cat == _WeakEq)
- return weak_equality::equivalent;
- else if constexpr (_Cat == _StrongEq)
- return strong_equality::equivalent;
else if constexpr (_Cat == _PartialOrd)
return partial_ordering::equivalent;
else if constexpr (_Cat == _WeakOrd)
template<class _Tp> constexpr strong_ordering strong_order(const _Tp& __lhs, const _Tp& __rhs);
template<class _Tp> constexpr weak_ordering weak_order(const _Tp& __lhs, const _Tp& __rhs);
template<class _Tp> constexpr partial_ordering partial_order(const _Tp& __lhs, const _Tp& __rhs);
-template<class _Tp> constexpr strong_equality strong_equal(const _Tp& __lhs, const _Tp& __rhs);
-template<class _Tp> constexpr weak_equality weak_equal(const _Tp& __lhs, const _Tp& __rhs);
#endif // _LIBCPP_STD_VER > 17
// [class.spaceship]p4: The 'common comparison type' U of a possibly-empty list
// of 'n' types T0, T1, ..., TN, is defined as follows:
int main(int, char**) {
- using WE = std::weak_equality;
- using SE = std::strong_equality;
using PO = std::partial_ordering;
using WO = std::weak_ordering;
using SO = std::strong_ordering;
- // [class.spaceship]p4.1: If any Ti is not a comparison category tpe, U is void.
+ // [cmp.common]p2: The member typedef-name type denotes the common comparison
+ /// type ([class.spaceship]) of Ts..., the expanded parameter pack, or void if
+ // any element of Ts is not a comparison category type.
{
test_cat<void, void>();
test_cat<void, int*>();
test_cat<void, SO, void, SO>();
}
- // [class.spaceship]p4.2: Otherwise, if at least on Ti is
- // std::weak_equality, or at least one Ti is std::strong_equality and at least
- // one Tj is std::partial_ordering or std::weak_ordering, U is std::weak_equality
- {
- test_cat<WE, WE>();
- test_cat<WE, SO, WE, SO>();
- test_cat<WE, SE, SO, PO>();
- test_cat<WE, WO, SO, SE>();
- }
-
- // [class.spaceship]p4.3: Otherwise, if at least one Ti is std::strong_equality,
- // U is std::strong_equality
- {
- test_cat<SE, SE>();
- test_cat<SE, SO, SE, SO>();
- }
-
- // [class.spaceship]p4.4: Otherwise, if at least one Ti is std::partial_ordering,
- // U is std::partial_ordering
+ // [class.spaceship]p4.1: If at least one Ti is std::partial_ordering, U is
+ // std::partial_ordering ([cmp.partialord]).
{
test_cat<PO, PO>();
test_cat<PO, SO, PO, SO>();
test_cat<PO, WO, PO, SO>();
}
- // [class.spaceship]p4.5: Otherwise, if at least one Ti is std::weak_ordering,
+ // [class.spaceship]p4.2: Otherwise, if at least one Ti is std::weak_ordering,
// U is std::weak_ordering
{
test_cat<WO, WO>();
test_cat<WO, SO, WO, SO>();
}
- // [class.spaceship]p4.6: Otherwise, U is std::strong_ordering. [Note: in
- // particular this is the result when n is 0. -- end note]
+ // [class.spaceship]p4.3: Otherwise, U is std::strong_ordering.
{
- test_cat<SO>(); // empty type list
test_cat<SO, SO>();
test_cat<SO, SO, SO>();
}
+ // [cmp.common]p2, note 2: This is std::strong_ordering if the expansion is empty.
+ // [class.spaceship]p4.3, note 2: In particular this is the result when n is 0.
+ {
+ test_cat<SO>(); // empty type list
+ }
+
return 0;
}
#endif
}
-constexpr bool test_conversion() {
- static_assert(std::is_convertible<const std::partial_ordering, std::weak_equality>::value, "");
- { // value == 0
- auto V = std::partial_ordering::equivalent;
- std::weak_equality WV = V;
- assert(WV == 0);
- }
- std::partial_ordering TestCases[] = {
- std::partial_ordering::less,
- std::partial_ordering::greater,
- std::partial_ordering::unordered
- };
- for (auto V : TestCases)
- { // value != 0
- std::weak_equality WV = V;
- assert(WV != 0);
- }
- return true;
-}
-
constexpr bool test_constexpr() {
auto& Eq = std::partial_ordering::equivalent;
auto& Less = std::partial_ordering::less;
int main(int, char**) {
test_static_members();
test_signatures();
- static_assert(test_conversion(), "conversion test failed");
static_assert(test_constexpr(), "constexpr test failed");
return 0;
+++ /dev/null
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-
-// <compare>
-
-// class strong_equality
-
-
-#include <compare>
-#include <type_traits>
-#include <cassert>
-
-#include "test_macros.h"
-
-const volatile void* volatile sink;
-
-void test_static_members() {
- DoNotOptimize(&std::strong_equality::equal);
- DoNotOptimize(&std::strong_equality::nonequal);
- DoNotOptimize(&std::strong_equality::equivalent);
- DoNotOptimize(&std::strong_equality::nonequivalent);
-}
-
-void test_signatures() {
- auto& Eq = std::strong_equality::equivalent;
-
- ASSERT_NOEXCEPT(Eq == 0);
- ASSERT_NOEXCEPT(0 == Eq);
- ASSERT_NOEXCEPT(Eq != 0);
- ASSERT_NOEXCEPT(0 != Eq);
-#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
- ASSERT_NOEXCEPT(0 <=> Eq);
- ASSERT_NOEXCEPT(Eq <=> 0);
- ASSERT_SAME_TYPE(decltype(Eq <=> 0), std::strong_equality);
- ASSERT_SAME_TYPE(decltype(0 <=> Eq), std::strong_equality);
-#endif
-}
-
-void test_conversion() {
- constexpr std::weak_equality res = std::strong_equality::equivalent;
- static_assert(res == 0, "");
- static_assert(std::is_convertible<const std::strong_equality&,
- std::weak_equality>::value, "");
- static_assert(res == 0, "expected equal");
-
- constexpr std::weak_equality neq_res = std::strong_equality::nonequivalent;
- static_assert(neq_res != 0, "expected not equal");
-}
-
-constexpr bool test_constexpr() {
- auto& Eq = std::strong_equality::equal;
- auto& NEq = std::strong_equality::nonequal;
- auto& Equiv = std::strong_equality::equivalent;
- auto& NEquiv = std::strong_equality::nonequivalent;
- assert((Eq == 0) == true);
- assert((0 == Eq) == true);
- assert((Equiv == 0) == true);
- assert((0 == Equiv) == true);
- assert((NEq == 0) == false);
- assert((0 == NEq) == false);
- assert((NEquiv == 0) == false);
- assert((0 == NEquiv) == false);
-
- assert((Eq != 0) == false);
- assert((0 != Eq) == false);
- assert((Equiv != 0) == false);
- assert((0 != Equiv) == false);
- assert((NEq != 0) == true);
- assert((0 != NEq) == true);
- assert((NEquiv != 0) == true);
- assert((0 != NEquiv) == true);
-
-#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
- std::strong_equality res = (Eq <=> 0);
- ((void)res);
- res = (0 <=> Eq);
- ((void)res);
-#endif
-
- return true;
-}
-
-int main(int, char**) {
- test_static_members();
- test_signatures();
- test_conversion();
- static_assert(test_constexpr(), "constexpr test failed");
-
- return 0;
-}
constexpr bool test_conversion() {
static_assert(std::is_convertible<const std::strong_ordering&,
- std::weak_equality>::value, "");
- { // value == 0
- auto V = std::strong_ordering::equivalent;
- std::weak_equality WV = V;
- assert(WV == 0);
- }
- std::strong_ordering WeakTestCases[] = {
- std::strong_ordering::less,
- std::strong_ordering::greater,
- };
- for (auto V : WeakTestCases)
- { // value != 0
- std::weak_equality WV = V;
- assert(WV != 0);
- }
- static_assert(std::is_convertible<const std::strong_ordering&,
- std::strong_equality>::value, "");
- { // value == 0
- auto V = std::strong_ordering::equivalent;
- std::strong_equality WV = V;
- assert(WV == 0);
- }
- { // value == 0
- auto V = std::strong_ordering::equal;
- std::strong_equality WV = V;
- assert(WV == 0);
- }
- std::strong_ordering StrongTestCases[] = {
- std::strong_ordering::less,
- std::strong_ordering::greater,
- };
- for (auto V : StrongTestCases)
- { // value != 0
- std::strong_equality WV = V;
- assert(WV != 0);
- }
-
- static_assert(std::is_convertible<const std::strong_ordering&,
std::partial_ordering>::value, "");
{ // value == 0
auto V = std::strong_ordering::equivalent;
+++ /dev/null
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-
-// <compare>
-
-// class weak_equality
-
-
-#include <compare>
-#include <cassert>
-#include "test_macros.h"
-
-const volatile void* volatile sink;
-
-void test_static_members() {
- DoNotOptimize(&std::weak_equality::equivalent);
- DoNotOptimize(&std::weak_equality::nonequivalent);
-}
-
-void test_signatures() {
- auto& Eq = std::weak_equality::equivalent;
-
- ASSERT_NOEXCEPT(Eq == 0);
- ASSERT_NOEXCEPT(0 == Eq);
- ASSERT_NOEXCEPT(Eq != 0);
- ASSERT_NOEXCEPT(0 != Eq);
-#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
- ASSERT_NOEXCEPT(0 <=> Eq);
- ASSERT_NOEXCEPT(Eq <=> 0);
- ASSERT_SAME_TYPE(decltype(Eq <=> 0), std::weak_equality);
- ASSERT_SAME_TYPE(decltype(0 <=> Eq), std::weak_equality);
-#endif
-}
-
-constexpr bool test_constexpr() {
- auto& Eq = std::weak_equality::equivalent;
- auto& NEq = std::weak_equality::nonequivalent;
- assert((Eq == 0) == true);
- assert((0 == Eq) == true);
- assert((NEq == 0) == false);
- assert((0 == NEq) == false);
-
- assert((Eq != 0) == false);
- assert((0 != Eq) == false);
- assert((NEq != 0) == true);
- assert((0 != NEq) == true);
-
-#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
- std::weak_equality res = (Eq <=> 0);
- ((void)res);
- res = (0 <=> Eq);
- ((void)res);
-#endif
-
- return true;
-}
-
-int main(int, char**) {
- test_static_members();
- test_signatures();
- static_assert(test_constexpr(), "constexpr test failed");
-
- return 0;
-}
constexpr bool test_conversion() {
static_assert(std::is_convertible<const std::weak_ordering&,
- std::weak_equality>::value, "");
- { // value == 0
- auto V = std::weak_ordering::equivalent;
- std::weak_equality WV = V;
- assert(WV == 0);
- }
- std::weak_ordering WeakTestCases[] = {
- std::weak_ordering::less,
- std::weak_ordering::greater,
- };
- for (auto V : WeakTestCases)
- { // value != 0
- std::weak_equality WV = V;
- assert(WV != 0);
- }
- static_assert(std::is_convertible<const std::weak_ordering&,
std::partial_ordering>::value, "");
{ // value == 0
auto V = std::weak_ordering::equivalent;
projects / platform / upstream / llvm.git / commitdiff