aboutsummaryrefslogtreecommitdiffhomepage
path: root/absl/types/compare.h
diff options
context:
space:
mode:
Diffstat (limited to 'absl/types/compare.h')
-rw-r--r--absl/types/compare.h150
1 files changed, 99 insertions, 51 deletions
diff --git a/absl/types/compare.h b/absl/types/compare.h
index 50361d6..a213e0b 100644
--- a/absl/types/compare.h
+++ b/absl/types/compare.h
@@ -79,79 +79,72 @@ enum class ord : value_type { less = -1, greater = 1 };
enum class ncmp : value_type { unordered = -127 };
+// Define macros to allow for creation or emulation of C++17 inline variables
+// based on whether the feature is supported. Note: we can't use
+// ABSL_INTERNAL_INLINE_CONSTEXPR here because the variables here are of
+// incomplete types so they need to be defined after the types are complete.
+#ifdef __cpp_inline_variables
+
+#define ABSL_COMPARE_INLINE_BASECLASS_DECL(name)
+
+#define ABSL_COMPARE_INLINE_SUBCLASS_DECL(type, name) \
+ static const type name
+
+#define ABSL_COMPARE_INLINE_INIT(type, name, init) \
+ inline constexpr type type::name(init)
+
+#else // __cpp_inline_variables
+
+#define ABSL_COMPARE_INLINE_BASECLASS_DECL(name) \
+ ABSL_CONST_INIT static const T name
+
+#define ABSL_COMPARE_INLINE_SUBCLASS_DECL(type, name)
+
+#define ABSL_COMPARE_INLINE_INIT(type, name, init) \
+ template <typename T> \
+ const T compare_internal::type##_base<T>::name(init)
+
+#endif // __cpp_inline_variables
+
// These template base classes allow for defining the values of the constants
// in the header file (for performance) without using inline variables (which
// aren't available in C++11).
template <typename T>
struct weak_equality_base {
- ABSL_CONST_INIT static const T equivalent;
- ABSL_CONST_INIT static const T nonequivalent;
+ ABSL_COMPARE_INLINE_BASECLASS_DECL(equivalent);
+ ABSL_COMPARE_INLINE_BASECLASS_DECL(nonequivalent);
};
-template <typename T>
-const T weak_equality_base<T>::equivalent(eq::equivalent);
-template <typename T>
-const T weak_equality_base<T>::nonequivalent(eq::nonequivalent);
template <typename T>
struct strong_equality_base {
- ABSL_CONST_INIT static const T equal;
- ABSL_CONST_INIT static const T nonequal;
- ABSL_CONST_INIT static const T equivalent;
- ABSL_CONST_INIT static const T nonequivalent;
+ ABSL_COMPARE_INLINE_BASECLASS_DECL(equal);
+ ABSL_COMPARE_INLINE_BASECLASS_DECL(nonequal);
+ ABSL_COMPARE_INLINE_BASECLASS_DECL(equivalent);
+ ABSL_COMPARE_INLINE_BASECLASS_DECL(nonequivalent);
};
-template <typename T>
-const T strong_equality_base<T>::equal(eq::equal);
-template <typename T>
-const T strong_equality_base<T>::nonequal(eq::nonequal);
-template <typename T>
-const T strong_equality_base<T>::equivalent(eq::equivalent);
-template <typename T>
-const T strong_equality_base<T>::nonequivalent(eq::nonequivalent);
template <typename T>
struct partial_ordering_base {
- ABSL_CONST_INIT static const T less;
- ABSL_CONST_INIT static const T equivalent;
- ABSL_CONST_INIT static const T greater;
- ABSL_CONST_INIT static const T unordered;
+ ABSL_COMPARE_INLINE_BASECLASS_DECL(less);
+ ABSL_COMPARE_INLINE_BASECLASS_DECL(equivalent);
+ ABSL_COMPARE_INLINE_BASECLASS_DECL(greater);
+ ABSL_COMPARE_INLINE_BASECLASS_DECL(unordered);
};
-template <typename T>
-const T partial_ordering_base<T>::less(ord::less);
-template <typename T>
-const T partial_ordering_base<T>::equivalent(eq::equivalent);
-template <typename T>
-const T partial_ordering_base<T>::greater(ord::greater);
-template <typename T>
-const T partial_ordering_base<T>::unordered(ncmp::unordered);
template <typename T>
struct weak_ordering_base {
- ABSL_CONST_INIT static const T less;
- ABSL_CONST_INIT static const T equivalent;
- ABSL_CONST_INIT static const T greater;
+ ABSL_COMPARE_INLINE_BASECLASS_DECL(less);
+ ABSL_COMPARE_INLINE_BASECLASS_DECL(equivalent);
+ ABSL_COMPARE_INLINE_BASECLASS_DECL(greater);
};
-template <typename T>
-const T weak_ordering_base<T>::less(ord::less);
-template <typename T>
-const T weak_ordering_base<T>::equivalent(eq::equivalent);
-template <typename T>
-const T weak_ordering_base<T>::greater(ord::greater);
template <typename T>
struct strong_ordering_base {
- ABSL_CONST_INIT static const T less;
- ABSL_CONST_INIT static const T equal;
- ABSL_CONST_INIT static const T equivalent;
- ABSL_CONST_INIT static const T greater;
+ ABSL_COMPARE_INLINE_BASECLASS_DECL(less);
+ ABSL_COMPARE_INLINE_BASECLASS_DECL(equal);
+ ABSL_COMPARE_INLINE_BASECLASS_DECL(equivalent);
+ ABSL_COMPARE_INLINE_BASECLASS_DECL(greater);
};
-template <typename T>
-const T strong_ordering_base<T>::less(ord::less);
-template <typename T>
-const T strong_ordering_base<T>::equal(eq::equal);
-template <typename T>
-const T strong_ordering_base<T>::equivalent(eq::equivalent);
-template <typename T>
-const T strong_ordering_base<T>::greater(ord::greater);
} // namespace compare_internal
@@ -162,6 +155,9 @@ class weak_equality
friend struct compare_internal::weak_equality_base<weak_equality>;
public:
+ ABSL_COMPARE_INLINE_SUBCLASS_DECL(weak_equality, equivalent);
+ ABSL_COMPARE_INLINE_SUBCLASS_DECL(weak_equality, nonequivalent);
+
// Comparisons
friend constexpr bool operator==(
weak_equality v, compare_internal::OnlyLiteralZero<>) noexcept {
@@ -183,6 +179,10 @@ class weak_equality
private:
compare_internal::value_type value_;
};
+ABSL_COMPARE_INLINE_INIT(weak_equality, equivalent,
+ compare_internal::eq::equivalent);
+ABSL_COMPARE_INLINE_INIT(weak_equality, nonequivalent,
+ compare_internal::eq::nonequivalent);
class strong_equality
: public compare_internal::strong_equality_base<strong_equality> {
@@ -191,6 +191,11 @@ class strong_equality
friend struct compare_internal::strong_equality_base<strong_equality>;
public:
+ ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_equality, equal);
+ ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_equality, nonequal);
+ ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_equality, equivalent);
+ ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_equality, nonequivalent);
+
// Conversion
constexpr operator weak_equality() const noexcept { // NOLINT
return value_ == 0 ? weak_equality::equivalent
@@ -217,6 +222,13 @@ class strong_equality
private:
compare_internal::value_type value_;
};
+ABSL_COMPARE_INLINE_INIT(strong_equality, equal, compare_internal::eq::equal);
+ABSL_COMPARE_INLINE_INIT(strong_equality, nonequal,
+ compare_internal::eq::nonequal);
+ABSL_COMPARE_INLINE_INIT(strong_equality, equivalent,
+ compare_internal::eq::equivalent);
+ABSL_COMPARE_INLINE_INIT(strong_equality, nonequivalent,
+ compare_internal::eq::nonequivalent);
class partial_ordering
: public compare_internal::partial_ordering_base<partial_ordering> {
@@ -234,6 +246,11 @@ class partial_ordering
}
public:
+ ABSL_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, less);
+ ABSL_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, equivalent);
+ ABSL_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, greater);
+ ABSL_COMPARE_INLINE_SUBCLASS_DECL(partial_ordering, unordered);
+
// Conversion
constexpr operator weak_equality() const noexcept { // NOLINT
return value_ == 0 ? weak_equality::equivalent
@@ -292,6 +309,13 @@ class partial_ordering
private:
compare_internal::value_type value_;
};
+ABSL_COMPARE_INLINE_INIT(partial_ordering, less, compare_internal::ord::less);
+ABSL_COMPARE_INLINE_INIT(partial_ordering, equivalent,
+ compare_internal::eq::equivalent);
+ABSL_COMPARE_INLINE_INIT(partial_ordering, greater,
+ compare_internal::ord::greater);
+ABSL_COMPARE_INLINE_INIT(partial_ordering, unordered,
+ compare_internal::ncmp::unordered);
class weak_ordering
: public compare_internal::weak_ordering_base<weak_ordering> {
@@ -302,6 +326,10 @@ class weak_ordering
friend struct compare_internal::weak_ordering_base<weak_ordering>;
public:
+ ABSL_COMPARE_INLINE_SUBCLASS_DECL(weak_ordering, less);
+ ABSL_COMPARE_INLINE_SUBCLASS_DECL(weak_ordering, equivalent);
+ ABSL_COMPARE_INLINE_SUBCLASS_DECL(weak_ordering, greater);
+
// Conversions
constexpr operator weak_equality() const noexcept { // NOLINT
return value_ == 0 ? weak_equality::equivalent
@@ -365,6 +393,11 @@ class weak_ordering
private:
compare_internal::value_type value_;
};
+ABSL_COMPARE_INLINE_INIT(weak_ordering, less, compare_internal::ord::less);
+ABSL_COMPARE_INLINE_INIT(weak_ordering, equivalent,
+ compare_internal::eq::equivalent);
+ABSL_COMPARE_INLINE_INIT(weak_ordering, greater,
+ compare_internal::ord::greater);
class strong_ordering
: public compare_internal::strong_ordering_base<strong_ordering> {
@@ -375,6 +408,11 @@ class strong_ordering
friend struct compare_internal::strong_ordering_base<strong_ordering>;
public:
+ ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, less);
+ ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, equal);
+ ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, equivalent);
+ ABSL_COMPARE_INLINE_SUBCLASS_DECL(strong_ordering, greater);
+
// Conversions
constexpr operator weak_equality() const noexcept { // NOLINT
return value_ == 0 ? weak_equality::equivalent
@@ -446,6 +484,16 @@ class strong_ordering
private:
compare_internal::value_type value_;
};
+ABSL_COMPARE_INLINE_INIT(strong_ordering, less, compare_internal::ord::less);
+ABSL_COMPARE_INLINE_INIT(strong_ordering, equal, compare_internal::eq::equal);
+ABSL_COMPARE_INLINE_INIT(strong_ordering, equivalent,
+ compare_internal::eq::equivalent);
+ABSL_COMPARE_INLINE_INIT(strong_ordering, greater,
+ compare_internal::ord::greater);
+
+#undef ABSL_COMPARE_INLINE_BASECLASS_DECL
+#undef ABSL_COMPARE_INLINE_SUBCLASS_DECL
+#undef ABSL_COMPARE_INLINE_INIT
namespace compare_internal {
// We also provide these comparator adapter functions for internal absl use.
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-17 06:15:36 +0000