New operators.hpp utilities

Author: vector-of-bool

src/bsoncxx/include/CMakeLists.txt

@@ -58,6 +58,7 @@ set_dist_list(src_bsoncxx_include_DIST
     bsoncxx/v_noabi/bsoncxx/oid.hpp
     bsoncxx/v_noabi/bsoncxx/stdx/make_unique.hpp
     bsoncxx/v_noabi/bsoncxx/stdx/optional.hpp
+    bsoncxx/v_noabi/bsoncxx/stdx/operators.hpp
     bsoncxx/v_noabi/bsoncxx/stdx/string_view.hpp
     bsoncxx/v_noabi/bsoncxx/stdx/type_traits.hpp
     bsoncxx/v_noabi/bsoncxx/string/to_string.hpp

src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/stdx/operators.hpp

@@ -0,0 +1,165 @@
+#pragma once
+
+#include <cstddef>
+#include <functional>
+#include <type_traits>
+
+#include "./type_traits.hpp"
+
+#include <bsoncxx/config/prelude.hpp>
+
+namespace bsoncxx {
+inline namespace v_noabi {
+namespace detail {
+
+/**
+ * @brief Detect whether two types are equality-comparable.
+ *
+ * Requires L == R, L != R, R == L, and R != L
+ */
+template <typename L, typename R, typename = void>
+struct is_equality_comparable : std::false_type {};
+
+template <typename L, typename R>
+struct is_equality_comparable<
+    L,
+    R,
+    void_t<decltype(std::declval<const_reference_t<L>>() == std::declval<const_reference_t<R>>()),
+           decltype(std::declval<const_reference_t<L>>() != std::declval<const_reference_t<R>>()),
+           decltype(std::declval<const_reference_t<R>>() == std::declval<const_reference_t<L>>()),
+           decltype(std::declval<const_reference_t<R>>() != std::declval<const_reference_t<L>>())>>
+    : std::true_type {};
+
+/**
+ * @brief Callable object and tag type for equality comparison
+ *
+ */
+struct equal_to {
+    template <typename L, typename R>
+    constexpr requires_t<bool, is_equality_comparable<L, R>>  //
+    operator()(L&& l, R&& r) const noexcept(noexcept(l == r)) {
+        return l == r;
+    }
+};
+
+/**
+ * @brief Derive from this class to define ADL-only operator== and operator!= on the basis of
+ * an ADL-only tag_invoke(equal_to, l, r)
+ */
+class equality_operators {
+    template <typename Left, typename Other>
+    constexpr friend auto operator==(const Left& self, const Other& other)
+        bsoncxx_returns(tag_invoke(equal_to{}, self, other));
+
+    template <typename Left, typename Other>
+    constexpr friend auto operator!=(const Left& self, const Other& other)
+        bsoncxx_returns(!tag_invoke(equal_to{}, self, other));
+};
+
+/**
+ * @brief Very basic impl of C++20 std::strong_ordering
+ *
+ * We don't need other weaker orderings yet, so this is all that we have
+ */
+class strong_ordering {
+    signed char _c;
+    struct _construct {};
+
+    constexpr strong_ordering(_construct, signed char c) noexcept : _c(c) {}
+
+   public:
+    static const strong_ordering less;
+    static const strong_ordering greater;
+    static const strong_ordering equivalent;
+    static const strong_ordering equal;
+
+    constexpr strong_ordering(std::nullptr_t) noexcept : strong_ordering(_construct{}, 0) {}
+
+    constexpr bool operator==(strong_ordering o) const noexcept {
+        return _c == o._c;
+    }
+    constexpr bool operator!=(strong_ordering o) const noexcept {
+        return !(*this == o);
+    }
+
+#define DEFOP(Op)                                               \
+    constexpr bool operator Op(std::nullptr_t) const noexcept { \
+        return _c Op 0;                                         \
+    }                                                           \
+    static_assert(true, "")
+    DEFOP(<);
+    DEFOP(>);
+    DEFOP(<=);
+    DEFOP(>=);
+#undef DEFOP
+};
+
+#ifdef __GNUC__
+#define psuedo_inline [[gnu::weak]]
+#elif defined _MSC_VER
+#define psuedo_inline __declspec(selectany)
+#else
+#define pseudo_inline
+#endif
+
+psuedo_inline const strong_ordering strong_ordering::less =
+    strong_ordering(strong_ordering::_construct{}, -1);
+psuedo_inline const strong_ordering strong_ordering::greater =
+    strong_ordering(strong_ordering::_construct{}, 1);
+psuedo_inline const strong_ordering strong_ordering::equivalent =
+    strong_ordering(strong_ordering::_construct{}, 0);
+psuedo_inline const strong_ordering strong_ordering::equal =
+    strong_ordering(strong_ordering::_construct{}, 0);
+
+#undef psuedo_inline
+
+/**
+ * @brief Implements a three-way comparison between two objects. That is, in
+ * a single operation, determine whether the left operand is less-than, greater-than,
+ * or equal-to the right-hand operand.
+ */
+struct compare_three_way {
+    template <typename L,
+              typename R,
+              typename = decltype(std::declval<L>() < std::declval<R>()),
+              typename = decltype(std::declval<L>() == std::declval<R>())>
+    constexpr static strong_ordering impl(L const& l, R const& r, rank<1>) {
+        return (l < r) ? strong_ordering::less
+                       : (l == r ? strong_ordering::equal  //
+                                 : strong_ordering::greater);
+    }
+
+    template <typename L,
+              typename R,
+              typename = decltype(tag_invoke(
+                  std::declval<compare_three_way>(), std::declval<L>(), std::declval<R>()))>
+    constexpr strong_ordering impl(L const& l, R const& r, rank<2>) const {
+        return tag_invoke(*this, l, r);
+    }
+
+    template <typename L, typename R>
+    constexpr auto operator()(L const& l, R const& r) const
+        bsoncxx_returns((impl)(l, r, rank<2>{}));
+};
+
+/**
+ * @brief Inherit to define ADL-visible ordering operators based on an ADL-visible
+ * implementation of tag_invoke(compare_three_way, l, r)
+ */
+struct ordering_operators {
+#define DEFOP(Oper)                                             \
+    template <typename L, typename R>                           \
+    constexpr friend auto operator Oper(const L& l, const R& r) \
+        bsoncxx_returns(tag_invoke(compare_three_way{}, l, r) Oper 0)
+    DEFOP(<);
+    DEFOP(>);
+    DEFOP(<=);
+    DEFOP(>=);
+#undef DEFOP
+};
+
+}  // namespace detail
+}  // namespace v_noabi
+}  // namespace bsoncxx
+
+#include <bsoncxx/config/postlude.hpp>