task.h

Go to the documentation of this file.

#ifndef B6E7FCEC_A837_4D2C_B71A_E02D65C82406
#define B6E7FCEC_A837_4D2C_B71A_E02D65C82406

 
#include <cassert>
#include <coroutine>
#include <exception>
#include <memory>
#include <optional>
#include <type_traits>
#include <utility>
 
#include "detail.h"
#include "exceptions.h"

namespace wwa::coro {
 
template<typename Result>
class task;

 
namespace detail {
 
// NOLINTBEGIN(readability-convert-member-functions-to-static)
template<typename Promise>
struct promise_base {
    void unhandled_exception() noexcept { this->m_exception = std::current_exception(); }
 
    [[nodiscard]] constexpr auto initial_suspend() const noexcept { return std::suspend_always{}; }
 
    [[nodiscard]] constexpr auto final_suspend() const noexcept
    {
        struct nested_awaiter {
            [[nodiscard]] constexpr bool await_ready() const noexcept { return false; }
 
            [[nodiscard]] auto await_suspend(std::coroutine_handle<Promise> handle) const noexcept
            {
                const auto& promise = handle.promise();
                return promise.m_next ? promise.m_next : std::noop_coroutine();
            }
 
            void await_resume() const noexcept {}  // GCOVR_EXCL_LINE -- this method is not used
        };
 
        return nested_awaiter{};
    }
 
    void set_next(std::coroutine_handle<> next) noexcept { this->m_next = next; }
 
protected:
    void rethrow_if_exception() const
    {
        if (this->m_exception != nullptr) {
            std::rethrow_exception(this->m_exception);
        }
    }
 
private:
    std::coroutine_handle<> m_next;
    std::exception_ptr m_exception = nullptr;
 
    friend Promise;  

    promise_base() noexcept = default;
};
// NOLINTEND(readability-convert-member-functions-to-static)
 
template<typename T>
struct promise_type : promise_base<promise_type<T>> {
    using value_type = std::remove_reference_t<T>;
    using storage_type =
        std::conditional_t<std::is_lvalue_reference_v<T>, std::add_pointer_t<value_type>, std::optional<value_type>>;
    using reference = std::conditional_t<std::is_rvalue_reference_v<T>, T, std::add_lvalue_reference_t<value_type>>;
 
    auto get_return_object() { return task<T>{std::coroutine_handle<promise_type>::from_promise(*this)}; }

    void return_value(const T& res) noexcept(std::is_nothrow_copy_constructible_v<T>)
    requires(std::is_const_v<T> && !std::is_lvalue_reference_v<T>)
    {
        this->m_result.emplace(res);
    }

    void return_value(T res) noexcept(std::is_nothrow_move_constructible_v<T>)
    requires(!std::is_const_v<T> && !std::is_lvalue_reference_v<T>)
    {
        this->m_result = std::move(res);
    }

    void return_value(T& res) noexcept
    requires(std::is_lvalue_reference_v<T>)
    {
        this->m_result = std::addressof(res);
    }

    reference result_value()
    {
        this->rethrow_if_exception();
        if constexpr (std::is_lvalue_reference_v<T>) {
            if (this->m_result != nullptr) {
                return *this->m_result;
            }
        }
        else if (this->m_result.has_value()) {
            if constexpr (std::is_rvalue_reference_v<T>) {
                return std::move(this->m_result.value());
            }
            else {
                return this->m_result.value();
            }
        }
 
        throw bad_result_access("task<T> result accessed before it was set");
    }
 
private:
    storage_type m_result{};
};
 
template<>
struct promise_type<void> : promise_base<promise_type<void>> {
    task<void> get_return_object();
    void return_void() const noexcept {}
    void result_value() const { this->rethrow_if_exception(); }
};
 
}  // namespace detail


template<typename Result = void>
class [[nodiscard]] task {
public:
    using promise_type = detail::promise_type<Result>;

    task() noexcept = default;

    task(const task&)            = delete;
    task& operator=(const task&) = delete;

    task(task&& other) noexcept : m_coroutine(std::exchange(other.m_coroutine, nullptr)) {}

    task& operator=(task&& other) noexcept
    {
        if (this != std::addressof(other)) {
            if (this->m_coroutine) {
                this->m_coroutine.destroy();
            }
 
            this->m_coroutine = std::exchange(other.m_coroutine, nullptr);
        }
 
        return *this;
    }

    ~task()
    {
        if (this->m_coroutine) {
            this->m_coroutine.destroy();
        }
    }

    [[nodiscard]] constexpr bool is_ready() const noexcept { return detail::is_ready(this->m_coroutine); }

    // NOLINTNEXTLINE(modernize-use-nodiscard)
    bool resume() const
    {
        if (!this->is_ready()) {
            this->m_coroutine.resume();
        }
 
        return !this->is_ready();
    }

    bool destroy()
    {
        if (this->m_coroutine) {
            this->m_coroutine.destroy();
            this->m_coroutine = nullptr;
            return true;
        }
 
        return false;
    }

    using value_type = std::remove_reference_t<Result>;
    using reference =
        std::conditional_t<std::is_rvalue_reference_v<Result>, Result, std::add_lvalue_reference_t<value_type>>;
    using const_reference  = std::add_lvalue_reference_t<std::add_const_t<value_type>>;
    using rvalue_reference = std::add_rvalue_reference_t<std::remove_cv_t<value_type>>;

    reference result_value() &
    {
        detail::check_coroutine(this->m_coroutine);
 
        if constexpr (std::is_rvalue_reference_v<Result>) {
            return std::move(this->m_coroutine.promise().result_value());
        }
        else {
            return this->m_coroutine.promise().result_value();
        }
    }

    // NOLINTNEXTLINE(modernize-use-nodiscard)
    const_reference result_value() const&
    {
        detail::check_coroutine(this->m_coroutine);
        return this->m_coroutine.promise().result_value();
    }

    rvalue_reference result_value() &&
    {
        detail::check_coroutine(this->m_coroutine);
        return std::move(this->m_coroutine.promise().result_value());
    }

    auto operator co_await() const& noexcept
    {
        struct awaiter {
            [[nodiscard]] constexpr bool await_ready() const noexcept { return detail::is_ready(this->coroutine); }
 
            auto await_suspend(std::coroutine_handle<> awaiting) noexcept
            {
                this->coroutine.promise().set_next(awaiting);
                return this->coroutine;
            }
 
            decltype(auto) await_resume()
            {
                detail::check_coroutine(this->coroutine);
                auto& promise = this->coroutine.promise();
                if constexpr (std::is_rvalue_reference_v<Result>) {
                    return std::move(promise.result_value());
                }
                else {
                    return promise.result_value();
                }
            }
 
            // NOLINTNEXTLINE(misc-non-private-member-variables-in-classes)
            std::coroutine_handle<promise_type> coroutine;
        };
 
        return awaiter{this->m_coroutine};
    }

    auto operator co_await() && noexcept
    requires(!std::is_void_v<Result>)
    {
        struct awaiter {
            [[nodiscard]] constexpr bool await_ready() const noexcept { return detail::is_ready(this->coroutine); }
 
            auto await_suspend(std::coroutine_handle<> awaiting) noexcept
            {
                this->coroutine.promise().set_next(awaiting);
                return this->coroutine;
            }
 
            decltype(auto) await_resume()
            {
                detail::check_coroutine(this->coroutine);
                return std::move(this->coroutine.promise().result_value());
            }
 
            // NOLINTNEXTLINE(misc-non-private-member-variables-in-classes)
            std::coroutine_handle<promise_type> coroutine;
        };
 
        return awaiter{this->m_coroutine};
    }
 
private:
    std::coroutine_handle<promise_type> m_coroutine;  
 
    friend promise_type;  

    explicit task(std::coroutine_handle<promise_type> handle) : m_coroutine(handle) {}
};


 
inline task<void> detail::promise_type<void>::get_return_object()
{
    return task<void>{std::coroutine_handle<promise_type>::from_promise(*this)};
}

 
}  // namespace wwa::coro
 
#endif /* B6E7FCEC_A837_4D2C_B71A_E02D65C82406 */