[CXX-2625] More type traits + invoke()

src/bsoncxx/include/CMakeLists.txt

@@ -59,6 +59,7 @@ set_dist_list(src_bsoncxx_include_DIST
     bsoncxx/v_noabi/bsoncxx/stdx/make_unique.hpp
     bsoncxx/v_noabi/bsoncxx/stdx/optional.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
     bsoncxx/v_noabi/bsoncxx/string/view_or_value.hpp
     bsoncxx/v_noabi/bsoncxx/types.hpp

src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/builder/basic/impl.hpp

@@ -16,7 +16,7 @@
 
 #include <bsoncxx/builder/basic/sub_array.hpp>
 #include <bsoncxx/builder/basic/sub_document.hpp>
-#include <bsoncxx/util/functor.hpp>
+#include <bsoncxx/stdx/type_traits.hpp>
 
 #include <bsoncxx/config/prelude.hpp>
 
@@ -27,31 +27,26 @@ namespace basic {
 namespace impl {
 
 template <typename T>
-using takes_document = typename util::is_functor<T, void(sub_document)>;
-
-template <typename T>
-using takes_array = typename util::is_functor<T, void(sub_array)>;
-
-template <typename T>
-BSONCXX_INLINE typename std::enable_if<takes_document<T>::value, void>::type generic_append(
-    core* core, T&& func) {
+BSONCXX_INLINE detail::requires_t<void, detail::is_invocable<T, sub_document>>  //
+generic_append(core* core, T&& func) {
     core->open_document();
-    func(sub_document(core));
+    detail::invoke(std::forward<T>(func), sub_document(core));
     core->close_document();
 }
 
-template <typename T>
-BSONCXX_INLINE typename std::enable_if<takes_array<T>::value, void>::type generic_append(core* core,
-                                                                                         T&& func) {
+template <typename T, typename Placeholder = void>  // placeholder 'void' for VS2015 compat
+BSONCXX_INLINE detail::requires_t<void, detail::is_invocable<T, sub_array>>  //
+generic_append(core* core, T&& func) {
     core->open_array();
-    func(sub_array(core));
+    detail::invoke(std::forward<T>(func), sub_array(core));
     core->close_array();
 }
 
-template <typename T>
-BSONCXX_INLINE
-    typename std::enable_if<!takes_document<T>::value && !takes_array<T>::value, void>::type
-    generic_append(core* core, T&& t) {
+template <typename T, typename = void, typename = void>
+BSONCXX_INLINE detail::requires_not_t<void,  //
+                                      detail::is_invocable<T, sub_document>,
+                                      detail::is_invocable<T, sub_array>>
+generic_append(core* core, T&& t) {
     core->append(std::forward<T>(t));
 }
 

src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/builder/basic/sub_document.hpp

@@ -18,6 +18,7 @@
 #include <bsoncxx/builder/concatenate.hpp>
 #include <bsoncxx/builder/core.hpp>
 #include <bsoncxx/stdx/string_view.hpp>
+#include <bsoncxx/stdx/type_traits.hpp>
 
 #include <bsoncxx/config/prelude.hpp>
 
@@ -59,8 +60,7 @@ class sub_document {
     // Appends a basic::kvp where the key is a non-owning string view.
     //
     template <typename K, typename V>
-    BSONCXX_INLINE typename std::enable_if<
-        std::is_same<typename std::decay<K>::type, stdx::string_view>::value>::type
+    BSONCXX_INLINE detail::requires_t<void, detail::is_alike<K, stdx::string_view>>  //
     append_(std::tuple<K, V>&& t) {
         _core->key_view(std::forward<K>(std::get<0>(t)));
         impl::value_append(_core, std::forward<V>(std::get<1>(t)));
@@ -70,8 +70,7 @@ class sub_document {
     // Appends a basic::kvp where the key is an owning STL string.
     //
     template <typename K, typename V>
-    BSONCXX_INLINE typename std::enable_if<
-        std::is_same<typename std::decay<K>::type, std::string>::value>::type
+    BSONCXX_INLINE detail::requires_t<void, detail::is_alike<K, std::string>>  //
     append_(std::tuple<K, V>&& t) {
         _core->key_owned(std::forward<K>(std::get<0>(t)));
         impl::value_append(_core, std::forward<V>(std::get<1>(t)));

src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/builder/core.hpp

@@ -18,6 +18,7 @@
 #include <stdexcept>
 #include <type_traits>
 
+#include "bsoncxx/stdx/type_traits.hpp"
 #include <bsoncxx/array/value.hpp>
 #include <bsoncxx/array/view.hpp>
 #include <bsoncxx/document/value.hpp>
@@ -508,7 +509,7 @@ class BSONCXX_API core {
     ///
     template <typename T>
     BSONCXX_INLINE core& append(T* v) {
-        static_assert(std::is_same<typename std::remove_const<T>::type, char>::value,
+        static_assert(detail::is_alike<T, char>::value,
                       "append is disabled for non-char pointer types");
         append(types::b_string{v});
 

src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/builder/stream/array_context.hpp

@@ -19,7 +19,7 @@
 #include <bsoncxx/builder/core.hpp>
 #include <bsoncxx/builder/stream/closed_context.hpp>
 #include <bsoncxx/builder/stream/helpers.hpp>
-#include <bsoncxx/util/functor.hpp>
+#include <bsoncxx/stdx/type_traits.hpp>
 
 #include <bsoncxx/config/prelude.hpp>
 
@@ -67,11 +67,10 @@ class array_context {
     ///   The value to append
     ///
     template <class T>
-    BSONCXX_INLINE typename std::enable_if<
-        !(util::is_functor<T, void(array_context<>)>::value ||
-          util::is_functor<T, void(single_context)>::value ||
-          std::is_same<typename std::remove_reference<T>::type, const finalize_type>::value),
-        array_context>::type&
+    BSONCXX_INLINE detail::requires_not_t<array_context&,
+                                          detail::is_invocable<T, array_context<>>,
+                                          detail::is_invocable<T, single_context>,
+                                          detail::is_alike<T, finalize_type>>
     operator<<(T&& t) {
         _core->append(std::forward<T>(t));
         return *this;
@@ -86,11 +85,12 @@ class array_context {
     ///   The callback to invoke
     ///
     template <typename Func>
-    BSONCXX_INLINE typename std::enable_if<(util::is_functor<Func, void(array_context<>)>::value ||
-                                            util::is_functor<Func, void(single_context)>::value),
-                                           array_context>::type&
-    operator<<(Func&& func) {
-        func(*this);
+    BSONCXX_INLINE
+        detail::requires_t<array_context&,
+                           detail::disjunction<detail::is_invocable<Func, array_context>,
+                                               detail::is_invocable<Func, single_context>>>
+        operator<<(Func&& func) {
+        detail::invoke(std::forward<Func>(func), *this);
         return *this;
     }
 
@@ -105,12 +105,10 @@ class array_context {
     /// @return A value type which holds the complete bson document.
     ///
     template <typename T>
-    BSONCXX_INLINE typename std::enable_if<
-        std::is_same<base, closed_context>::value &&
-            std::is_same<typename std::remove_reference<T>::type, const finalize_type>::value,
-        // TODO(MSVC): This should just be 'array::value', but
-        // VS2015U1 can't resolve the name.
-        bsoncxx::array::value>::type
+    BSONCXX_INLINE detail::requires_t<bsoncxx::array::value,
+                                      std::is_same<base, closed_context>,
+                                      detail::is_alike<T, finalize_type>>
+    // VS2015U1 can't resolve the name.
     operator<<(T&&) {
         return _core->extract_array();
     }

src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/builder/stream/key_context.hpp

@@ -19,7 +19,7 @@
 #include <bsoncxx/builder/stream/closed_context.hpp>
 #include <bsoncxx/builder/stream/value_context.hpp>
 #include <bsoncxx/stdx/string_view.hpp>
-#include <bsoncxx/util/functor.hpp>
+#include <bsoncxx/stdx/type_traits.hpp>
 
 #include <bsoncxx/config/prelude.hpp>
 
@@ -108,10 +108,9 @@ class key_context {
     ///   The callback to invoke
     ///
     template <typename T>
-    BSONCXX_INLINE
-        typename std::enable_if<util::is_functor<T, void(key_context<>)>::value, key_context>::type&
-        operator<<(T&& func) {
-        func(*this);
+    BSONCXX_INLINE detail::requires_t<key_context&, detail::is_invocable<T, key_context>>  //
+    operator<<(T&& func) {
+        detail::invoke(std::forward<T>(func), *this);
         return *this;
     }
 
@@ -126,12 +125,9 @@ class key_context {
     /// @return A value type which holds the complete bson document.
     ///
     template <typename T>
-    BSONCXX_INLINE typename std::enable_if<
-        std::is_same<base, closed_context>::value &&
-            std::is_same<typename std::remove_reference<T>::type, const finalize_type>::value,
-        // TODO(MSVC): This should just be 'document::value', but
-        // VS2015U1 can't resolve the name.
-        bsoncxx::document::value>::type
+    BSONCXX_INLINE detail::requires_t<bsoncxx::document::value,
+                                      std::is_same<base, closed_context>,
+                                      detail::is_alike<T, finalize_type>>
     operator<<(T&&) {
         return _core->extract_document();
     }

src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/builder/stream/value_context.hpp

@@ -18,7 +18,7 @@
 #include <bsoncxx/builder/stream/array_context.hpp>
 #include <bsoncxx/builder/stream/closed_context.hpp>
 #include <bsoncxx/builder/stream/helpers.hpp>
-#include <bsoncxx/util/functor.hpp>
+#include <bsoncxx/stdx/type_traits.hpp>
 
 #include <bsoncxx/config/prelude.hpp>
 
@@ -63,9 +63,8 @@ class value_context {
     ///   The value to append
     ///
     template <class T>
-    BSONCXX_INLINE
-        typename std::enable_if<!util::is_functor<T, void(single_context)>::value, base>::type
-        operator<<(T&& t) {
+    BSONCXX_INLINE detail::requires_not_t<base, detail::is_invocable<T, single_context>>  //
+    operator<<(T&& t) {
         _core->append(std::forward<T>(t));
         return unwrap();
     }
@@ -78,10 +77,9 @@ class value_context {
     ///   The callback to invoke
     ///
     template <typename T>
-    BSONCXX_INLINE
-        typename std::enable_if<util::is_functor<T, void(single_context)>::value, base>::type
-        operator<<(T&& func) {
-        func(*this);
+    BSONCXX_INLINE detail::requires_t<base, detail::is_invocable<T, single_context>>  //
+    operator<<(T&& func) {
+        detail::invoke(std::forward<T>(func), *this);
         return unwrap();
     }
 

src/bsoncxx/include/bsoncxx/v_noabi/bsoncxx/document/value.hpp

@@ -16,7 +16,9 @@
 
 #include <cstdlib>
 #include <memory>
+#include <type_traits>
 
+#include "bsoncxx/stdx/type_traits.hpp"
 #include <bsoncxx/array/view.hpp>
 #include <bsoncxx/document/view.hpp>
 
@@ -84,8 +86,7 @@ class BSONCXX_API value {
     /// @param t
     ///   A user-defined object to serialize into a BSON object.
     ///
-    template <typename T,
-              typename std::enable_if<!std::is_same<T, typename array::view>::value, int>::type = 0>
+    template <typename T, detail::requires_not_t<int, std::is_same<T, array::view>> = 0>
     explicit value(const T& t) : value({}) {
         to_bson(t, *this);
     }

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

@@ -19,6 +19,8 @@
 #include <type_traits>
 #include <utility>
 
+#include "./type_traits.hpp"
+
 #include <bsoncxx/config/prelude.hpp>
 
 namespace bsoncxx {