task.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "condy/coro.hpp"
#include "condy/detail/context.hpp"
#include "condy/detail/task.hpp"
#include "condy/runtime.hpp"
#include <coroutine>
#include <exception>
#include <utility>
 
namespace condy {

template <typename T = void, typename Allocator = void>
class [[nodiscard]] Task : public detail::TaskBase<T, Allocator> {
public:
    using Base = detail::TaskBase<T, Allocator>;
    using Base::Base;

    T wait() {
        auto handle = std::exchange(Base::handle_, nullptr);
        Base::wait_inner_(handle);
        auto exception = std::move(handle.promise()).exception();
        if (exception) [[unlikely]] {
            handle.destroy();
            std::rethrow_exception(exception);
        }
        T value = std::move(handle.promise()).value();
        handle.destroy();
        return std::move(value);
    }
};
 
template <typename Allocator>
class [[nodiscard]]
Task<void, Allocator> : public detail::TaskBase<void, Allocator> {
public:
    using Base = detail::TaskBase<void, Allocator>;
    using Base::Base;

    void wait() {
        auto handle = std::exchange(Base::handle_, nullptr);
        Base::wait_inner_(handle);
        auto exception = std::move(handle.promise()).exception();
        handle.destroy();
        if (exception) [[unlikely]] {
            std::rethrow_exception(exception);
        }
    }
};

template <typename T, typename Allocator>
inline Task<T, Allocator> co_spawn(Runtime &runtime,
                                   Coro<T, Allocator> coro) noexcept {
    auto handle = coro.release();
    auto &promise = handle.promise();
    promise.mark_running();
 
    runtime.schedule_internal(&promise);
    return {handle};
}

template <typename T, typename Allocator>
inline Task<T, Allocator> co_spawn(Coro<T, Allocator> coro) {
    auto *runtime = detail::Context::current().runtime();
    if (runtime == nullptr) [[unlikely]] {
        throw std::logic_error("No runtime to spawn coroutine task");
    }
    return co_spawn(*runtime, std::move(coro));
}

inline detail::SwitchAwaiter co_switch(Runtime &runtime) noexcept {
    return {&runtime};
}
 
} // namespace condy