Merge pull request #4 from BlackMATov/dev

Dev

invoke.hpp

@@ -1,242 +0,0 @@
-#pragma once
-
-#include <tuple>
-#include <utility>
-#include <functional>
-#include <type_traits>
-
-#define INVOKE_HPP_NOEXCEPT_RETURN(...) \
-    noexcept(noexcept(__VA_ARGS__)) { return __VA_ARGS__; }
-
-#define INVOKE_HPP_NOEXCEPT_DECLTYPE_RETURN(...) \
-    noexcept(noexcept(__VA_ARGS__)) -> decltype (__VA_ARGS__) { return __VA_ARGS__; }
-
-//
-// void_t
-//
-
-namespace invoke_hpp
-{
-    namespace impl
-    {
-        template < typename... Args >
-        struct make_void {
-            using type = void;
-        };
-    }
-
-    template < typename... Args >
-    using void_t = typename impl::make_void<Args...>::type;
-}
-
-//
-// is_reference_wrapper
-//
-
-namespace invoke_hpp
-{
-    namespace impl
-    {
-        template < typename T >
-        struct is_reference_wrapper_impl
-        : std::false_type {};
-
-        template < typename U >
-        struct is_reference_wrapper_impl<std::reference_wrapper<U>>
-        : std::true_type {};
-    }
-
-    template < typename T >
-    struct is_reference_wrapper
-    : impl::is_reference_wrapper_impl<std::remove_cv_t<T>> {};
-}
-
-//
-// invoke
-//
-
-namespace invoke_hpp
-{
-    namespace impl
-    {
-        //
-        // invoke_member_object_impl
-        //
-
-        template
-        <
-            typename Base, typename F, typename Derived,
-            typename std::enable_if_t<std::is_base_of<Base, std::decay_t<Derived>>::value, int> = 0
-        >
-        constexpr auto invoke_member_object_impl(F Base::* f, Derived&& ref)
-        INVOKE_HPP_NOEXCEPT_DECLTYPE_RETURN(
-            std::forward<Derived>(ref).*f)
-
-        template
-        <
-            typename Base, typename F, typename RefWrap,
-            typename std::enable_if_t<is_reference_wrapper<std::decay_t<RefWrap>>::value, int> = 0
-        >
-        constexpr auto invoke_member_object_impl(F Base::* f, RefWrap&& ref)
-        INVOKE_HPP_NOEXCEPT_DECLTYPE_RETURN(
-            ref.get().*f)
-
-        template
-        <
-            typename Base, typename F, typename Pointer,
-            typename std::enable_if_t<
-                !std::is_base_of<Base, std::decay_t<Pointer>>::value &&
-                !is_reference_wrapper<std::decay_t<Pointer>>::value
-            , int> = 0
-        >
-        constexpr auto invoke_member_object_impl(F Base::* f, Pointer&& ptr)
-        INVOKE_HPP_NOEXCEPT_DECLTYPE_RETURN(
-            (*std::forward<Pointer>(ptr)).*f)
-
-        //
-        // invoke_member_function_impl
-        //
-
-        template
-        <
-            typename Base, typename F, typename Derived, typename... Args,
-            typename std::enable_if_t<std::is_base_of<Base, std::decay_t<Derived>>::value, int> = 0
-        >
-        constexpr auto invoke_member_function_impl(F Base::* f, Derived&& ref, Args&&... args)
-        INVOKE_HPP_NOEXCEPT_DECLTYPE_RETURN(
-            (std::forward<Derived>(ref).*f)(std::forward<Args>(args)...))
-
-        template
-        <
-            typename Base, typename F, typename RefWrap, typename... Args,
-            typename std::enable_if_t<is_reference_wrapper<std::decay_t<RefWrap>>::value, int> = 0
-        >
-        constexpr auto invoke_member_function_impl(F Base::* f, RefWrap&& ref, Args&&... args)
-        INVOKE_HPP_NOEXCEPT_DECLTYPE_RETURN(
-            (ref.get().*f)(std::forward<Args>(args)...))
-
-        template
-        <
-            typename Base, typename F, typename Pointer, typename... Args,
-            typename std::enable_if_t<
-                !std::is_base_of<Base, std::decay_t<Pointer>>::value &&
-                !is_reference_wrapper<std::decay_t<Pointer>>::value
-            , int> = 0
-        >
-        constexpr auto invoke_member_function_impl(F Base::* f, Pointer&& ptr, Args&&... args)
-        INVOKE_HPP_NOEXCEPT_DECLTYPE_RETURN(
-            ((*std::forward<Pointer>(ptr)).*f)(std::forward<Args>(args)...))
-    }
-
-    template
-    <
-        typename F, typename... Args,
-        typename std::enable_if_t<!std::is_member_pointer<std::decay_t<F>>::value, int> = 0
-    >
-    constexpr auto invoke(F&& f, Args&&... args)
-    INVOKE_HPP_NOEXCEPT_DECLTYPE_RETURN(
-        std::forward<F>(f)(std::forward<Args>(args)...))
-
-    template
-    <
-        typename F, typename T,
-        typename std::enable_if_t<std::is_member_object_pointer<std::decay_t<F>>::value, int> = 0
-    >
-    constexpr auto invoke(F&& f, T&& t)
-    INVOKE_HPP_NOEXCEPT_DECLTYPE_RETURN(
-        impl::invoke_member_object_impl(std::forward<F>(f), std::forward<T>(t)))
-
-    template
-    <
-        typename F, typename... Args,
-        typename std::enable_if_t<std::is_member_function_pointer<std::decay_t<F>>::value, int> = 0
-    >
-    constexpr auto invoke(F&& f, Args&&... args)
-    INVOKE_HPP_NOEXCEPT_DECLTYPE_RETURN(
-        impl::invoke_member_function_impl(std::forward<F>(f), std::forward<Args>(args)...))
-}
-
-//
-// invoke_result
-//
-
-namespace invoke_hpp
-{
-    namespace impl
-    {
-        struct invoke_result_impl_tag {};
-
-        template < typename Void, typename F, typename... Args >
-        struct invoke_result_impl {};
-
-        template < typename F, typename... Args >
-        struct invoke_result_impl<void_t<invoke_result_impl_tag, decltype(invoke_hpp::invoke(std::declval<F>(), std::declval<Args>()...))>, F, Args...> {
-            using type = decltype(invoke_hpp::invoke(std::declval<F>(), std::declval<Args>()...));
-        };
-    }
-
-    template < typename F, typename... Args >
-    struct invoke_result
-    : impl::invoke_result_impl<void, F, Args...> {};
-
-    template < typename F, typename... Args >
-    using invoke_result_t = typename invoke_result<F, Args...>::type;
-}
-
-//
-// is_invocable
-//
-
-namespace invoke_hpp
-{
-    namespace impl
-    {
-        struct is_invocable_r_impl_tag {};
-
-        template < typename Void, typename R, typename F, typename... Args >
-        struct is_invocable_r_impl
-        : std::false_type {};
-
-        template < typename R, typename F, typename... Args >
-        struct is_invocable_r_impl<void_t<is_invocable_r_impl_tag, invoke_result_t<F, Args...>>, R, F, Args...>
-        : std::conditional_t<
-            std::is_void<R>::value,
-            std::true_type,
-            std::is_convertible<invoke_result_t<F, Args...>, R>> {};
-    }
-
-    template < typename R, typename F, typename... Args >
-    struct is_invocable_r
-    : impl::is_invocable_r_impl<void, R, F, Args...> {};
-
-    template < typename F, typename... Args >
-    using is_invocable = is_invocable_r<void, F, Args...>;
-}
-
-//
-// apply
-//
-
-namespace invoke_hpp
-{
-    namespace impl
-    {
-        template < typename F, typename Tuple, std::size_t... I >
-        constexpr decltype(auto) apply_impl(F&& f, Tuple&& args, std::index_sequence<I...>)
-        INVOKE_HPP_NOEXCEPT_RETURN(
-            invoke_hpp::invoke(
-                std::forward<F>(f),
-                std::get<I>(std::forward<Tuple>(args))...))
-    }
-
-    template < typename F, typename Tuple >
-    constexpr decltype(auto) apply(F&& f, Tuple&& args)
-    INVOKE_HPP_NOEXCEPT_RETURN(
-        impl::apply_impl(
-            std::forward<F>(f),
-            std::forward<Tuple>(args),
-            std::make_index_sequence<std::tuple_size<std::decay_t<Tuple>>::value>()))
-}
-
-#undef INVOKE_HPP_NOEXCEPT_RETURN
-#undef INVOKE_HPP_NOEXCEPT_DECLTYPE_RETURN

promise.hpp

@@ -15,7 +15,254 @@
 #include <functional>
 #include <type_traits>
 
-#include "invoke.hpp"
+//
+// invoke.hpp
+// https://github.com/BlackMATov/invoke.hpp
+//
+
+namespace promise_hpp
+{
+    #define INVOKE_HPP_NOEXCEPT_RETURN(...) \
+        noexcept(noexcept(__VA_ARGS__)) { return __VA_ARGS__; }
+
+    #define INVOKE_HPP_NOEXCEPT_DECLTYPE_RETURN(...) \
+        noexcept(noexcept(__VA_ARGS__)) -> decltype (__VA_ARGS__) { return __VA_ARGS__; }
+
+    //
+    // void_t
+    //
+
+    namespace invoke_hpp
+    {
+        namespace impl
+        {
+            template < typename... Args >
+            struct make_void {
+                using type = void;
+            };
+        }
+
+        template < typename... Args >
+        using void_t = typename impl::make_void<Args...>::type;
+    }
+
+    //
+    // is_reference_wrapper
+    //
+
+    namespace invoke_hpp
+    {
+        namespace impl
+        {
+            template < typename T >
+            struct is_reference_wrapper_impl
+            : std::false_type {};
+
+            template < typename U >
+            struct is_reference_wrapper_impl<std::reference_wrapper<U>>
+            : std::true_type {};
+        }
+
+        template < typename T >
+        struct is_reference_wrapper
+        : impl::is_reference_wrapper_impl<std::remove_cv_t<T>> {};
+    }
+
+    //
+    // invoke
+    //
+
+    namespace invoke_hpp
+    {
+        namespace impl
+        {
+            //
+            // invoke_member_object_impl
+            //
+
+            template
+            <
+                typename Base, typename F, typename Derived,
+                typename std::enable_if_t<std::is_base_of<Base, std::decay_t<Derived>>::value, int> = 0
+            >
+            constexpr auto invoke_member_object_impl(F Base::* f, Derived&& ref)
+            INVOKE_HPP_NOEXCEPT_DECLTYPE_RETURN(
+                std::forward<Derived>(ref).*f)
+
+            template
+            <
+                typename Base, typename F, typename RefWrap,
+                typename std::enable_if_t<is_reference_wrapper<std::decay_t<RefWrap>>::value, int> = 0
+            >
+            constexpr auto invoke_member_object_impl(F Base::* f, RefWrap&& ref)
+            INVOKE_HPP_NOEXCEPT_DECLTYPE_RETURN(
+                ref.get().*f)
+
+            template
+            <
+                typename Base, typename F, typename Pointer,
+                typename std::enable_if_t<
+                    !std::is_base_of<Base, std::decay_t<Pointer>>::value &&
+                    !is_reference_wrapper<std::decay_t<Pointer>>::value
+                , int> = 0
+            >
+            constexpr auto invoke_member_object_impl(F Base::* f, Pointer&& ptr)
+            INVOKE_HPP_NOEXCEPT_DECLTYPE_RETURN(
+                (*std::forward<Pointer>(ptr)).*f)
+
+            //
+            // invoke_member_function_impl
+            //
+
+            template
+            <
+                typename Base, typename F, typename Derived, typename... Args,
+                typename std::enable_if_t<std::is_base_of<Base, std::decay_t<Derived>>::value, int> = 0
+            >
+            constexpr auto invoke_member_function_impl(F Base::* f, Derived&& ref, Args&&... args)
+            INVOKE_HPP_NOEXCEPT_DECLTYPE_RETURN(
+                (std::forward<Derived>(ref).*f)(std::forward<Args>(args)...))
+
+            template
+            <
+                typename Base, typename F, typename RefWrap, typename... Args,
+                typename std::enable_if_t<is_reference_wrapper<std::decay_t<RefWrap>>::value, int> = 0
+            >
+            constexpr auto invoke_member_function_impl(F Base::* f, RefWrap&& ref, Args&&... args)
+            INVOKE_HPP_NOEXCEPT_DECLTYPE_RETURN(
+                (ref.get().*f)(std::forward<Args>(args)...))
+
+            template
+            <
+                typename Base, typename F, typename Pointer, typename... Args,
+                typename std::enable_if_t<
+                    !std::is_base_of<Base, std::decay_t<Pointer>>::value &&
+                    !is_reference_wrapper<std::decay_t<Pointer>>::value
+                , int> = 0
+            >
+            constexpr auto invoke_member_function_impl(F Base::* f, Pointer&& ptr, Args&&... args)
+            INVOKE_HPP_NOEXCEPT_DECLTYPE_RETURN(
+                ((*std::forward<Pointer>(ptr)).*f)(std::forward<Args>(args)...))
+        }
+
+        template
+        <
+            typename F, typename... Args,
+            typename std::enable_if_t<!std::is_member_pointer<std::decay_t<F>>::value, int> = 0
+        >
+        constexpr auto invoke(F&& f, Args&&... args)
+        INVOKE_HPP_NOEXCEPT_DECLTYPE_RETURN(
+            std::forward<F>(f)(std::forward<Args>(args)...))
+
+        template
+        <
+            typename F, typename T,
+            typename std::enable_if_t<std::is_member_object_pointer<std::decay_t<F>>::value, int> = 0
+        >
+        constexpr auto invoke(F&& f, T&& t)
+        INVOKE_HPP_NOEXCEPT_DECLTYPE_RETURN(
+            impl::invoke_member_object_impl(std::forward<F>(f), std::forward<T>(t)))
+
+        template
+        <
+            typename F, typename... Args,
+            typename std::enable_if_t<std::is_member_function_pointer<std::decay_t<F>>::value, int> = 0
+        >
+        constexpr auto invoke(F&& f, Args&&... args)
+        INVOKE_HPP_NOEXCEPT_DECLTYPE_RETURN(
+            impl::invoke_member_function_impl(std::forward<F>(f), std::forward<Args>(args)...))
+    }
+
+    //
+    // invoke_result
+    //
+
+    namespace invoke_hpp
+    {
+        namespace impl
+        {
+            struct invoke_result_impl_tag {};
+
+            template < typename Void, typename F, typename... Args >
+            struct invoke_result_impl {};
+
+            template < typename F, typename... Args >
+            struct invoke_result_impl<void_t<invoke_result_impl_tag, decltype(invoke_hpp::invoke(std::declval<F>(), std::declval<Args>()...))>, F, Args...> {
+                using type = decltype(invoke_hpp::invoke(std::declval<F>(), std::declval<Args>()...));
+            };
+        }
+
+        template < typename F, typename... Args >
+        struct invoke_result
+        : impl::invoke_result_impl<void, F, Args...> {};
+
+        template < typename F, typename... Args >
+        using invoke_result_t = typename invoke_result<F, Args...>::type;
+    }
+
+    //
+    // is_invocable
+    //
+
+    namespace invoke_hpp
+    {
+        namespace impl
+        {
+            struct is_invocable_r_impl_tag {};
+
+            template < typename Void, typename R, typename F, typename... Args >
+            struct is_invocable_r_impl
+            : std::false_type {};
+
+            template < typename R, typename F, typename... Args >
+            struct is_invocable_r_impl<void_t<is_invocable_r_impl_tag, invoke_result_t<F, Args...>>, R, F, Args...>
+            : std::conditional_t<
+                std::is_void<R>::value,
+                std::true_type,
+                std::is_convertible<invoke_result_t<F, Args...>, R>> {};
+        }
+
+        template < typename R, typename F, typename... Args >
+        struct is_invocable_r
+        : impl::is_invocable_r_impl<void, R, F, Args...> {};
+
+        template < typename F, typename... Args >
+        using is_invocable = is_invocable_r<void, F, Args...>;
+    }
+
+    //
+    // apply
+    //
+
+    namespace invoke_hpp
+    {
+        namespace impl
+        {
+            template < typename F, typename Tuple, std::size_t... I >
+            constexpr decltype(auto) apply_impl(F&& f, Tuple&& args, std::index_sequence<I...>)
+            INVOKE_HPP_NOEXCEPT_RETURN(
+                invoke_hpp::invoke(
+                    std::forward<F>(f),
+                    std::get<I>(std::forward<Tuple>(args))...))
+        }
+
+        template < typename F, typename Tuple >
+        constexpr decltype(auto) apply(F&& f, Tuple&& args)
+        INVOKE_HPP_NOEXCEPT_RETURN(
+            impl::apply_impl(
+                std::forward<F>(f),
+                std::forward<Tuple>(args),
+                std::make_index_sequence<std::tuple_size<std::decay_t<Tuple>>::value>()))
+    }
+
+    #undef INVOKE_HPP_NOEXCEPT_RETURN
+    #undef INVOKE_HPP_NOEXCEPT_DECLTYPE_RETURN
+}
+
+//
+// promise.hpp
+// https://github.com/BlackMATov/promise.hpp
+//
 
 namespace promise_hpp
 {
@@ -133,6 +380,29 @@ namespace promise_hpp
         promise()
         : state_(std::make_shared<state>()) {}
 
+        promise(const promise&) noexcept = default;
+        promise& operator=(const promise&) noexcept = default;
+
+        void swap(promise& other) noexcept {
+            state_.swap(other.state_);
+        }
+
+        std::size_t hash() const noexcept {
+            return std::hash<state*>()(state_.get());
+        }
+
+        friend bool operator<(const promise& l, const promise& r) noexcept {
+            return l.state_ < r.state_;
+        }
+
+        friend bool operator==(const promise& l, const promise& r) noexcept {
+            return l.state_ == r.state_;
+        }
+
+        friend bool operator!=(const promise& l, const promise& r) noexcept {
+            return l.state_ != r.state_;
+        }
+
         template < typename ResolveF
                  , typename ResolveFR = invoke_hpp::invoke_result_t<ResolveF,T> >
         std::enable_if_t<
@@ -439,6 +709,29 @@ namespace promise_hpp
         promise()
         : state_(std::make_shared<state>()) {}
 
+        promise(const promise&) noexcept = default;
+        promise& operator=(const promise&) noexcept = default;
+
+        void swap(promise& other) noexcept {
+            state_.swap(other.state_);
+        }
+
+        std::size_t hash() const noexcept {
+            return std::hash<state*>()(state_.get());
+        }
+
+        friend bool operator<(const promise& l, const promise& r) noexcept {
+            return l.state_ < r.state_;
+        }
+
+        friend bool operator==(const promise& l, const promise& r) noexcept {
+            return l.state_ == r.state_;
+        }
+
+        friend bool operator!=(const promise& l, const promise& r) noexcept {
+            return l.state_ != r.state_;
+        }
+
         template < typename ResolveF
                  , typename ResolveFR = invoke_hpp::invoke_result_t<ResolveF> >
         std::enable_if_t<
@@ -714,6 +1007,15 @@ namespace promise_hpp
         };
     };
 
+    //
+    // swap
+    //
+
+    template < typename T >
+    void swap(promise<T>& l, promise<T>& r) noexcept {
+        l.swap(r);
+    }
+
     //
     // make_promise
     //
@@ -860,3 +1162,15 @@ namespace promise_hpp
             std::end(container));
     }
 }
+
+namespace std
+{
+    template < typename T >
+    struct hash<promise_hpp::promise<T>>
+        : std::unary_function<promise_hpp::promise<T>, std::size_t>
+    {
+        std::size_t operator()(const promise_hpp::promise<T>& p) const noexcept {
+            return p.hash();
+        }
+    };
+}

tests.cpp

@@ -104,6 +104,52 @@ TEST_CASE("is_promise_r") {
 }
 
 TEST_CASE("promise") {
+    SECTION("basic") {
+        {
+            auto p1 = pr::promise<int>();
+            auto p2 = pr::promise<int>();
+            REQUIRE_FALSE(p1 == p2);
+            REQUIRE(p1 != p2);
+
+            REQUIRE((p1 < p2 || p2 < p1));
+            REQUIRE(p1.hash() != p2.hash());
+            REQUIRE(p1.hash() == std::hash<pr::promise<int>>()(p1));
+        }
+        {
+            auto p1 = pr::promise<void>();
+            auto p2 = pr::promise<void>();
+            REQUIRE_FALSE(p1 == p2);
+            REQUIRE(p1 != p2);
+
+            REQUIRE((p1 < p2 || p2 < p1));
+            REQUIRE(p1.hash() != p2.hash());
+            REQUIRE(p1.hash() == std::hash<pr::promise<void>>()(p1));
+        }
+        {
+            auto p1 = pr::promise<int>();
+            auto p2 = pr::promise<int>();
+            auto p3 = p1;
+            REQUIRE(p1 == p3);
+            p3 = p2;
+            REQUIRE(p2 == p3);
+        }
+        {
+            auto p1 = pr::promise<int>();
+            auto p2 = pr::promise<int>();
+            auto p3 = p1;
+            p1.swap(p2);
+            REQUIRE(p2 == p3);
+            REQUIRE_FALSE(p1 == p3);
+        }
+        {
+            auto p1 = pr::promise<void>();
+            auto p2 = pr::promise<void>();
+            auto p3 = p1;
+            p1.swap(p2);
+            REQUIRE(p2 == p3);
+            REQUIRE_FALSE(p1 == p3);
+        }
+    }
     SECTION("resolved") {
         {
             int check_42_int = 0;