Future.h

Go to the documentation of this file.

 
#pragma once
#include "detail/FutureSharedState.h"
#include "catapult/utils/NonCopyable.h"
 
namespace catapult { namespace thread {
 
    template<typename T>
    class future : public utils::MoveOnly {
    public:
        future() = default;
 
        explicit future(const std::shared_ptr<detail::shared_state<T>>& pState) : m_pState(pState)
        {}
 
    public:
        bool valid() {
            return !!m_pState;
        }
 
        bool is_ready() const {
            return m_pState->is_ready();
        }
 
        T get() {
            return m_pState->get();
        }
 
        template<
                typename TContinuation,
                typename TResultType = std::invoke_result_t<TContinuation, future<T>&&>
        >
        auto then(TContinuation continuation) {
            if constexpr (!std::is_same_v<TResultType, void>) {
                auto pResultState = std::make_shared<detail::shared_state<TResultType>>();
                m_pState->set_continuation([pResultState, continuation](const auto& pState) {
                    try {
                        pResultState->set_value(continuation(future<T>(pState)));
                    } catch (...) {
                        pResultState->set_exception(std::current_exception());
                    }
                });
 
                return future<TResultType>(pResultState);
            } else {
                return then([continuation](auto&& future) {
                    continuation(std::move(future));
                    return true;
                });
            }
        }
 
    private:
        std::shared_ptr<detail::shared_state<T>> m_pState;
    };
 
    template<typename T>
    class promise : public utils::MoveOnly {
    public:
        promise()
                : m_pState(std::make_shared<detail::shared_state<T>>())
                , m_pIsFutureCreated(std::make_unique<std::atomic_flag>()) {
            m_pIsFutureCreated->clear(std::memory_order_release);
        }
 
    public:
        bool valid() {
            return !!m_pState;
        }
 
        future<T> get_future() {
            if (m_pIsFutureCreated->test_and_set(std::memory_order_acquire))
                throw std::future_error(std::future_errc::future_already_retrieved);
 
            return future<T>(m_pState);
        }
 
    public:
        void set_value(T&& value) {
            m_pState->set_value(std::move(value));
        }
 
        void set_exception(std::exception_ptr pException) {
            m_pState->set_exception(pException);
        }
 
    private:
        std::shared_ptr<detail::shared_state<T>> m_pState;
        std::unique_ptr<std::atomic_flag> m_pIsFutureCreated;
    };
 
    template<typename T>
    future<T> make_ready_future(T&& value) {
        auto pState = std::make_shared<detail::shared_state<T>>();
        pState->set_value(std::move(value));
        return future<T>(pState);
    }
 
    template<typename T, typename E>
    future<T> make_exceptional_future(E ex) {
        auto pState = std::make_shared<detail::shared_state<T>>();
        pState->set_exception(std::make_exception_ptr(ex));
        return future<T>(pState);
    }
}}