promise.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_ASYNC_PROMISE_HPP__
#define NEFORCE_CORE_ASYNC_PROMISE_HPP__

 
#include "NeForce/core/async/future.hpp"
NEFORCE_BEGIN_NAMESPACE__



template <typename Res>
class promise {
    static_assert(!is_array_v<Res>, "result type must not be an array");
    static_assert(!is_function_v<Res>, "result type must not be a function");
    static_assert(is_destructible_v<Res>, "result type must be destructible");
 
public:
    using state_type = inner::__future_base::state_base;         
    using result_type = inner::__future_base::basic_result<Res>; 
    using ptr_type = inner::__future_base::Ptr<result_type>;     
 
private:
    shared_ptr<state_type> future_ptr; 
    ptr_type storage;                  
 
    template <typename T, typename U>
    friend struct inner::__future_base::state_base::setter;

    NEFORCE_NODISCARD state_type& state() const {
        inner::__future_base::state_base::check(future_ptr);
        return *future_ptr;
    }
 
public:
    promise() :
    future_ptr(_NEFORCE make_shared<state_type>()),
    storage(new result_type()) {}

    promise(promise&& other) noexcept :
    future_ptr(_NEFORCE move(other.future_ptr)),
    storage(_NEFORCE move(other.storage)) {}

    promise& operator=(promise&& other) noexcept {
        promise(_NEFORCE move(other)).swap(*this);
        return *this;
    }
 
    promise(const promise&) = delete;            
    promise& operator=(const promise&) = delete; 

    ~promise() {
        if (static_cast<bool>(future_ptr) && !future_ptr.unique()) {
            future_ptr->break_promise(_NEFORCE move(storage));
        }
    }

    void swap(promise& other) noexcept {
        future_ptr.swap(other.future_ptr);
        storage.swap(other.storage);
    }

    future<Res> get_future() { return future<Res>(future_ptr); }

    void set_value(Res&& value) { state().set_result(state_type::create_setter(this, _NEFORCE forward<Res>(value))); }

    void set_exception(exception_ptr exception) { state().set_result(state_type::create_setter(exception, this)); }

    void set_value_at_thread_exit(Res&& value) {
        state().set_delayed_result(state_type::create_setter(this, _NEFORCE forward<Res>(value)), future_ptr);
    }

    void set_exception_at_thread_exit(exception_ptr exception) {
        state().set_delayed_result(state_type::create_setter(exception, this), future_ptr);
    }
};

template <typename Res>
class promise<Res&> {
public:
    using state_type = inner::__future_base::state_base;          
    using result_type = inner::__future_base::basic_result<Res&>; 
    using ptr_type = inner::__future_base::Ptr<result_type>;      
 
private:
    shared_ptr<state_type> future_ptr; 
    ptr_type storage;                  
 
    template <typename T, typename U>
    friend struct inner::__future_base::state_base::setter;
 
    NEFORCE_NODISCARD state_type& state() const {
        inner::__future_base::state_base::check(future_ptr);
        return *future_ptr;
    }
 
public:
    promise() :
    future_ptr(_NEFORCE make_shared<state_type>()),
    storage(new result_type()) {}

    promise(promise&& other) noexcept :
    future_ptr(_NEFORCE move(other.future_ptr)),
    storage(_NEFORCE move(other.storage)) {}

    promise& operator=(promise&& other) noexcept {
        promise(_NEFORCE move(other)).swap(*this);
        return *this;
    }
 
    promise(const promise&) = delete;            
    promise& operator=(const promise&) = delete; 

    ~promise() {
        if (static_cast<bool>(future_ptr) && !future_ptr.unique()) {
            future_ptr->break_promise(_NEFORCE move(storage));
        }
    }

    void swap(promise& other) noexcept {
        future_ptr.swap(other.future_ptr);
        storage.swap(other.storage);
    }

    future<Res&> get_future() { return future<Res&>(future_ptr); }

    void set_value(Res& value) { state().set_result(state_type::create_setter(this, value)); }

    void set_exception(exception_ptr exception) { state().set_result(state_type::create_setter(exception, this)); }

    void set_value_at_thread_exit(Res& value) {
        state().set_delayed_result(state_type::create_setter(this, value), future_ptr);
    }

    void set_exception_at_thread_exit(exception_ptr exception) {
        state().set_delayed_result(state_type::create_setter(exception, this), future_ptr);
    }
};

template <>
class promise<void> {
public:
    using state_type = inner::__future_base::state_base;          
    using result_type = inner::__future_base::basic_result<void>; 
    using ptr_type = inner::__future_base::Ptr<result_type>;      
 
private:
    shared_ptr<state_type> future_ptr; 
    ptr_type storage;                  
 
    template <typename T, typename U>
    friend struct inner::__future_base::state_base::setter;
 
    NEFORCE_NODISCARD state_type& state() const {
        inner::__future_base::state_base::check(future_ptr);
        return *future_ptr;
    }
 
public:
    promise() :
    future_ptr(_NEFORCE make_shared<state_type>()),
    storage(new result_type()) {}

    promise(promise&& other) noexcept :
    future_ptr(_NEFORCE move(other.future_ptr)),
    storage(_NEFORCE move(other.storage)) {}

    promise& operator=(promise&& other) noexcept {
        promise(_NEFORCE move(other)).swap(*this);
        return *this;
    }
 
    promise(const promise&) = delete;            
    promise& operator=(const promise&) = delete; 

    ~promise() {
        if (static_cast<bool>(future_ptr) && !future_ptr.unique()) {
            future_ptr->break_promise(_NEFORCE move(storage));
        }
    }

    void swap(promise& other) noexcept {
        future_ptr.swap(other.future_ptr);
        storage.swap(other.storage);
    }

    NEFORCE_NODISCARD future<void> get_future() const { return future<void>(future_ptr); }

    void set_value() { state().set_result(state_type::create_setter(this)); }

    void set_exception(exception_ptr exception) { state().set_result(state_type::create_setter(exception, this)); }

    void set_value_at_thread_exit() { state().set_delayed_result(state_type::create_setter(this), future_ptr); }

    void set_exception_at_thread_exit(exception_ptr exception) {
        state().set_delayed_result(state_type::create_setter(exception, this), future_ptr);
    }
};

NEFORCE_BEGIN_INNER__

template <typename PtrT, typename Func, typename>
struct __future_base::task_setter {
    PtrT* result_ptr;   
    Func* function_ptr; 

    PtrT operator()() const noexcept {
        try {
            (*result_ptr)->set((*function_ptr)());
        } catch (...) {
            (*result_ptr)->error_ptr = _NEFORCE current_exception();
        }
        return _NEFORCE move(*result_ptr);
    }
};

template <typename PtrT, typename Func>
struct __future_base::task_setter<PtrT, Func, void> {
    PtrT* result_ptr;   
    Func* function_ptr; 
 
    PtrT operator()() const noexcept {
        try {
            (*function_ptr)();
        } catch (...) {
            (*result_ptr)->error_ptr = current_exception();
        }
        return _NEFORCE move(*result_ptr);
    }
};

template <typename Res, typename... Args>
class __future_base::task_state_base<Res(Args...)> : public __future_base::state_base {
public:
    using result_type = Res;                               
    using PtrType = __future_base::Ptr<basic_result<Res>>; 
 
    PtrType result_storage; 

    template <typename Alloc>
    task_state_base(const Alloc& alloc) :
    result_storage(allocate_result<Res>(alloc)) {}

    virtual void run(Args&&... args) = 0;

    virtual void run_delayed(Args&&... args, weak_ptr<state_base> self) = 0;

    virtual shared_ptr<task_state_base> reset() = 0;
};

template <typename Func, typename Alloc, typename Res, typename... Args>
class __future_base::task_state<Func, Alloc, Res(Args...)> final : public __future_base::task_state_base<Res(Args...)> {
public:
    template <typename Func2>
    task_state(Func2&& func, const Alloc& alloc) :
    task_state_base<Res(Args...)>(alloc),
    impl(_NEFORCE forward<Func2>(func), alloc) {}
 
private:
    void run(Args&&... args) override {
        auto bound_func = [&]() -> Res {
            return _NEFORCE invoke_r<Res>(impl.function_ptr, _NEFORCE forward<Args>(args)...);
        };
        state_base::set_result(__future_base::create_task_setter(this->result_storage, bound_func));
    }
 
    void run_delayed(Args&&... args, weak_ptr<state_base> self) override {
        auto bound_function = [&]() -> Res {
            return _NEFORCE invoke_r<Res>(impl.function_ptr, _NEFORCE forward<Args>(args)...);
        };
        state_base::set_delayed_result(__future_base::create_task_setter(this->result_storage, bound_function),
                                       _NEFORCE move(self));
    }
 
    shared_ptr<task_state_base<Res(Args...)>> reset() override;

    struct Impl : Alloc {
        Func function_ptr;
 
        template <typename Func2>
        Impl(Func2&& func, const Alloc& alloc) :
        Alloc(alloc),
        function_ptr(_NEFORCE forward<Func2>(func)) {}
    } impl;
};

template <typename Sign, typename Func, typename Alloc = _NEFORCE allocator<int>>
static shared_ptr<__future_base::task_state_base<Sign>> create_task_state(Func&& func, const Alloc& alloc = Alloc()) {
    using State = __future_base::task_state<decay_t<Func>, Alloc, Sign>;
    return _NEFORCE allocate_shared<State>(alloc, _NEFORCE forward<Func>(func), alloc);
}

template <typename Func, typename Alloc, typename Res, typename... Args>
shared_ptr<__future_base::task_state_base<Res(Args...)>> __future_base::task_state<Func, Alloc, Res(Args...)>::reset() {
    return inner::create_task_state<Res(Args...)>(_NEFORCE move(impl.function_ptr), static_cast<Alloc&>(impl));
}
 
NEFORCE_END_INNER__
 // Async
 // AsyncComponents
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_ASYNC_PROMISE_HPP__