use_awaitable.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_ASYNC_USE_AWAITABLE_HPP__
#define NEFORCE_CORE_ASYNC_USE_AWAITABLE_HPP__

 
#include "NeForce/core/async/async_result.hpp"
#ifdef NEFORCE_STANDARD_20
#    include "NeForce/core/async/coroutine.hpp"
#    include "NeForce/core/exception/exception_ptr.hpp"
#    include "NeForce/core/utility/tuple.hpp"
NEFORCE_BEGIN_NAMESPACE__


struct use_awaitable_t {};
constexpr use_awaitable_t use_awaitable{};

template <typename... Args>
class awaitable {
public:
    awaitable() = default;

    void set_value(Args... args) {
        data_ = _NEFORCE make_tuple(_NEFORCE move(args)...);
        ready_ = true;
        if (continuation_) {
            continuation_.resume();
        }
    }

    void set_exception(exception_ptr e) {
        exception_ = move(e);
        ready_ = true;
        if (continuation_) {
            continuation_.resume();
        }
    }
 
    NEFORCE_NODISCARD bool await_ready() const noexcept { return ready_; }
 
    void await_suspend(coroutine_handle<> h) noexcept { continuation_ = h; }
 
    auto await_resume() {
        if (exception_) {
            rethrow_exception(exception_);
        }
        if constexpr (sizeof...(Args) == 1) {
            return _NEFORCE move(_NEFORCE get<0>(data_));
        } else if constexpr (sizeof...(Args) == 0) {
            return;
        } else {
            return _NEFORCE move(data_);
        }
    }
 
private:
    tuple<Args...> data_{};
    bool ready_{false};
    exception_ptr exception_{nullptr};
    coroutine_handle<> continuation_{nullptr};
};
 
 
NEFORCE_BEGIN_INNER__
 
template <typename... Args>
struct awaitable_handler {
    shared_ptr<awaitable<Args...>> awaitable_;
 
    void operator()(Args... args) { awaitable_->set_value(_NEFORCE move(args)...); }
};
 
NEFORCE_END_INNER__
 
template <typename... Args>
struct async_result<use_awaitable_t, void(Args...)> {
    using handler_type = inner::awaitable_handler<Args...>;
    using return_type = awaitable<Args...>;
 
    shared_ptr<return_type> awaitable_;
    handler_type handler_;
 
    explicit async_result(use_awaitable_t /*unused*/) {
        awaitable_ = make_shared<return_type>();
        handler_.awaitable_ = awaitable_;
    }
 
    handler_type get_handler() { return handler_; }
 
    return_type get() { return _NEFORCE move(*awaitable_); }
};

template <>
class awaitable<void> {
public:
    struct promise_type;
 
private:
    struct state {
        bool ready_{false};
        exception_ptr exception_{nullptr};
        coroutine_handle<> continuation_{nullptr};
    };
    shared_ptr<state> state_;
 
    explicit awaitable(shared_ptr<state> s) :
    state_(move(s)) {}
 
public:
    awaitable() :
    state_(make_shared<state>()) {}

    void set_value() {
        state_->ready_ = true;
        if (state_->continuation_) {
            state_->continuation_.resume();
        }
    }

    void set_exception(exception_ptr e) {
        state_->exception_ = move(e);
        state_->ready_ = true;
        if (state_->continuation_) {
            state_->continuation_.resume();
        }
    }
 
    NEFORCE_NODISCARD bool await_ready() const noexcept { return state_->ready_; }
    void await_suspend(coroutine_handle<> h) noexcept { state_->continuation_ = h; }
 
    void await_resume() {
        if (state_->exception_) {
            rethrow_exception(state_->exception_);
        }
    }
};
 
struct awaitable<void>::promise_type {
    shared_ptr<awaitable<void>::state> state_;
 
    promise_type() :
    state_(make_shared<awaitable<void>::state>()) {}
 
    awaitable<void> get_return_object() { return awaitable<void>(state_); }
    suspend_never initial_suspend() noexcept { return {}; }
 
    auto final_suspend() noexcept {
        struct awaiter {
            shared_ptr<awaitable<void>::state> state;
            NEFORCE_NODISCARD bool await_ready() const noexcept { return false; }
            void await_suspend(coroutine_handle<> h) noexcept {
                state->ready_ = true;
                if (state->continuation_) {
                    state->continuation_.resume();
                }
                h.destroy();
            }
            void await_resume() noexcept {}
        };
        return awaiter{state_};
    }
 
    void return_void() noexcept {}
    void unhandled_exception() {
        state_->exception_ = current_exception();
        state_->ready_ = true;
    }
};
 // CompletionTokens
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_STANDARD_20
#endif // NEFORCE_CORE_ASYNC_USE_AWAITABLE_HPP__