async_result.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_ASYNC_ASYNC_RESULT_HPP__
#define NEFORCE_CORE_ASYNC_ASYNC_RESULT_HPP__

 
#include "NeForce/core/async/promise.hpp"
#include "NeForce/core/exception/exception_ptr.hpp"
#include "NeForce/core/exception/system_exception.hpp"
#include "NeForce/core/functional/function.hpp"
#include "NeForce/core/memory/shared_ptr.hpp"
NEFORCE_BEGIN_NAMESPACE__


struct use_future_t {};
struct detached_t {};
struct deferred_t {};

constexpr use_future_t use_future{};
constexpr detached_t detached{};
constexpr deferred_t deferred{};

template <typename Token, typename Signature>
struct async_result {
    using handler_type = Token; 
    using return_type = void;   
 
    Token token_; 
 
    explicit async_result(Token& t) :
    token_(move(t)) {}
 
    handler_type get_handler() { return move(token_); }
    void get() {}
};

NEFORCE_BEGIN_INNER__
 
template <typename... Args>
struct future_handler {
    shared_ptr<promise<tuple<Args...>>> promise_;
 
    void operator()(Args... args) { promise_->set_value(make_tuple(move(args)...)); }
};
 
template <>
struct future_handler<error_code> {
    shared_ptr<promise<void>> promise_;
 
    void operator()(error_code ec) {
        if (ec) {
            promise_->set_exception(_NEFORCE make_exception_ptr(system_exception(ec)));
        } else {
            promise_->set_value();
        }
    }
};
 
template <>
struct future_handler<error_code, size_t> {
    shared_ptr<promise<size_t>> promise_;
 
    void operator()(error_code ec, size_t n) {
        if (ec) {
            promise_->set_exception(_NEFORCE make_exception_ptr(system_exception(ec)));
        } else {
            promise_->set_value(n);
        }
    }
};
 
NEFORCE_END_INNER__
 
template <>
struct async_result<use_future_t, void(error_code)> {
    using handler_type = inner::future_handler<error_code>;
    using return_type = future<void>;
    handler_type handler_;
    explicit async_result(use_future_t /*unused*/) { handler_.promise_ = make_shared<promise<void>>(); }
    handler_type get_handler() { return handler_; }
    return_type get() { return handler_.promise_->get_future(); }
};
 
template <>
struct async_result<use_future_t, void(error_code, size_t)> {
    using handler_type = inner::future_handler<error_code, size_t>;
    using return_type = future<size_t>;
    handler_type handler_;
    explicit async_result(use_future_t /*unused*/) { handler_.promise_ = make_shared<promise<size_t>>(); }
    handler_type get_handler() { return handler_; }
    return_type get() { return handler_.promise_->get_future(); }
};
 
template <typename... Args>
struct async_result<detached_t, void(Args...)> {
    struct detached_handler {
        function<void(Args...)> inner_;
 
        void operator()(Args... args) {
            try {
                inner_(args...);
                // NOLINTNEXTLINE(bugprone-empty-catch)
            } catch (...) {
                // ignore
            }
        }
    };
 
    using handler_type = detached_handler;
    using return_type = void;
 
    explicit async_result(detached_t /*unused*/) {}
    handler_type get_handler() {
        return detached_handler{[](Args...) {}};
    }
    void get() {}
};
 // CompletionTokens
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_ASYNC_ASYNC_RESULT_HPP__