[CXX-2625] Bring our own optional<T>

src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/config/postlude.hpp

@@ -95,3 +95,5 @@ static_assert(false, "BSONCXX_ENUM must be undef'ed");
 #pragma pop_macro("BSONCXX_IF_GCC")
 #pragma pop_macro("BSONCXX_IF_CLANG")
 #pragma pop_macro("BSONCXX_IF_GNU_LIKE")
+
+#pragma pop_macro("BSONCXX_FWD")

src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/config/prelude.hpp

@@ -45,6 +45,8 @@
 #undef _bsoncxxDisableWarningImpl_for_MSVC
 #pragma push_macro("_bsoncxxDisableWarningImpl_for_GNU")
 #undef _bsoncxxDisableWarningImpl_for_GNU
+#pragma push_macro("BSONCXX_FWD")
+#undef BSONCXX_FWD
 
 // compiler.hpp
 #pragma push_macro("BSONCXX_INLINE")

src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/config/util.hpp

@@ -131,3 +131,6 @@
 
 #define _bsoncxxDisableWarningImpl_for_MSVC(...) \
     BSONCXX_IF_MSVC(BSONCXX_PRAGMA(warning(disable : __VA_ARGS__)))
+
+#define BSONCXX_FWD(...) static_cast<decltype(__VA_ARGS__)&&>(__VA_ARGS__)
+

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

@@ -114,6 +114,11 @@ class strong_ordering {
     DEFOP(<=);
     DEFOP(>=);
 #pragma pop_macro("DEFOP")
+
+    // nonstd: Swap greater/less values
+    constexpr strong_ordering inverted() const noexcept {
+        return *this < 0 ? greater : *this > 0 ? less : *this;
+    }
 };
 
 #pragma push_macro("INLINE_VAR")
@@ -151,8 +156,8 @@ struct compare_three_way {
               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);
+    constexpr static strong_ordering impl(L const& l, R const& r, rank<2>) {
+        return tag_invoke(compare_three_way{}, l, r);
     }
 
     template <typename L, typename R>
@@ -165,19 +170,56 @@ struct compare_three_way {
  * implementation of tag_invoke(compare_three_way, l, r)
  */
 struct ordering_operators {
+    template <typename L, typename R>
+    constexpr static auto impl(const L& l, const R& r, rank<1>)
+        BSONCXX_RETURNS(tag_invoke(compare_three_way{}, l, r));
+
+    template <typename L, typename R>
+    constexpr static auto impl(const L& l, const R& r, rank<0>)
+        BSONCXX_RETURNS(tag_invoke(compare_three_way{}, r, l).inverted());
+
 #pragma push_macro("DEFOP")
 #undef DEFOP
 #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)
+        BSONCXX_RETURNS(ordering_operators::impl(l, r, rank<1>{}) Oper 0)
     DEFOP(<);
     DEFOP(>);
     DEFOP(<=);
     DEFOP(>=);
 #pragma pop_macro("DEFOP")
 };
 
+template <typename T, typename U>
+std::false_type is_partially_ordered_with_f(rank<0>);
+
+template <typename T, typename U>
+auto is_partially_ordered_with_f(rank<1>,
+                                 const T& l = soft_declval<T>(),
+                                 const U& r = soft_declval<U>())  //
+    -> true_t<decltype(l > r),
+              decltype(l < r),
+              decltype(l >= r),
+              decltype(l <= r),
+              decltype(r < l),
+              decltype(r > l),
+              decltype(r <= l),
+              decltype(r >= l)>;
+
+template <typename T, typename U>
+struct is_partially_ordered_with : decltype(is_partially_ordered_with_f<T, U>(rank<1>{})) {};
+
+template <typename T>
+struct is_totally_ordered
+    : conjunction<is_equality_comparable<T>, is_partially_ordered_with<T, T>> {};
+
+template <typename T, typename U>
+struct is_totally_ordered_with : conjunction<is_totally_ordered<T>,
+                                             is_totally_ordered<U>,
+                                             is_equality_comparable<T, U>,
+                                             is_partially_ordered_with<T, U>> {};
+
 }  // namespace detail
 }  // namespace bsoncxx