packaged_task.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_ASYNC_PACKAGED_TASK_HPP__
#define NEFORCE_CORE_ASYNC_PACKAGED_TASK_HPP__

 
#include "NeForce/core/async/promise.hpp"
#include "NeForce/core/async/thread.hpp"
NEFORCE_BEGIN_NAMESPACE__



template <typename Res, typename... Args>
class packaged_task<Res(Args...)> {
    using StateType = inner::__future_base::task_state_base<Res(Args...)>; 
 
    shared_ptr<StateType> state_ptr; 
 
public:
    packaged_task() noexcept {}

    template <typename Func, typename = enable_if_t<!is_same_v<packaged_task, remove_cvref_t<Func>>>>
    explicit packaged_task(Func&& function) :
    state_ptr(inner::create_task_state<Res(Args...)>(_NEFORCE forward<Func>(function))) {}

    ~packaged_task() {
        if (static_cast<bool>(state_ptr) && !state_ptr.unique()) {
            state_ptr->break_promise(_NEFORCE move(state_ptr->result_storage));
        }
    }
 
    packaged_task(const packaged_task&) = delete;            
    packaged_task& operator=(const packaged_task&) = delete; 

    packaged_task(packaged_task&& other) noexcept { this->swap(other); }

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

    void swap(packaged_task& other) noexcept { state_ptr.swap(other.state_ptr); }

    bool valid() const noexcept { return static_cast<bool>(state_ptr); }

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

    void operator()(Args... args) {
        inner::__future_base::state_base::check(state_ptr);
        state_ptr->run(_NEFORCE forward<Args>(args)...);
    }

    void make_ready_at_thread_exit(Args... args) {
        inner::__future_base::state_base::check(state_ptr);
        state_ptr->run_delayed(_NEFORCE forward<Args>(args)..., state_ptr);
    }

    void reset() {
        inner::__future_base::state_base::check(state_ptr);
        packaged_task temp;
        temp.state_ptr = state_ptr;
        state_ptr = state_ptr->reset();
    }
};
 
#ifdef NEFORCE_STANDARD_17
template <typename Res, typename... Args>
packaged_task(Res (*)(Args...)) -> packaged_task<Res(Args...)>;
 
template <typename Func, typename Sign = typename inner::__function_guide_helper<decltype(&Func::operator())>::type>
packaged_task(Func) -> packaged_task<Sign>;
#endif
 

NEFORCE_BEGIN_INNER__

template <typename BoundFunc, typename Res>
class __future_base::deferred_state final : public __future_base::state_base {
private:
    using PtrType = __future_base::Ptr<basic_result<Res>>;
 
    PtrType result_storage;
    BoundFunc function;
 
    void complete_async() override { state_base::set_result(create_task_setter(result_storage, function), true); }
 
    bool is_deferred_future() const override { return true; }
 
public:
    template <typename... Args>
    explicit deferred_state(Args&&... args) :
    result_storage(new basic_result<Res>()),
    function(_NEFORCE forward<Args>(args)...) {}
};

class __future_base::async_state_common : public __future_base::state_base {
protected:
    _NEFORCE thread thread;
    _NEFORCE once_flag once_flag;
 
    ~async_state_common() override = default;
 
    void complete_async() override { join(); }
 
    void join() { _NEFORCE call_once(once_flag, &_NEFORCE thread::join, &thread); }
};

template <typename Func, typename Res>
class __future_base::async_state_impl final : public __future_base::async_state_common {
private:
    using PtrType = __future_base::Ptr<basic_result<Res>>;
 
    PtrType result_storage;
    Func function;
 
    void run() {
        try {
            state_base::set_result(__future_base::create_task_setter(result_storage, function));
        } catch (...) {
            if (static_cast<bool>(result_storage)) {
                state_base::break_promise(_NEFORCE move(result_storage));
            }
            throw;
        }
    }
 
public:
    template <typename... Args>
    explicit async_state_impl(Args&&... args) :
    result_storage(new basic_result<Res>()),
    function(_NEFORCE forward<Args>(args)...) {
        thread = _NEFORCE thread{&async_state_impl::run, this};
    }
 
    ~async_state_impl() override {
        if (thread.joinable()) {
            thread.join();
        }
    }
};
 
NEFORCE_END_INNER__
 // Async
 // AsyncComponents
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_ASYNC_PACKAGED_TASK_HPP__