qcorotask.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2021 Daniel Vrátil <dvratil@kde.org>
//
// SPDX-License-Identifier: MIT
 
// Only used by a KDDW Flutter build and only by the tests
 
#pragma once
 
#include "concepts_p.h"
#include "coroutine.h"
 
#include <atomic>
#include <cassert>
#include <memory>
#include <optional>
#include <type_traits>
#include <variant>
#include <vector>
 
namespace QCoro {
 
template<typename T = void>
class Task;
 
namespace detail {
 
template<typename T>
struct awaiter_type;
 
template<typename T>
using awaiter_type_t = typename awaiter_type<T>::type;
 
class TaskFinalSuspend {
public:
 
    explicit TaskFinalSuspend(const std::vector<std::coroutine_handle<>> &awaitingCoroutines)
        : mAwaitingCoroutines(awaitingCoroutines) {}
 
 
    bool await_ready() const noexcept {
        return false;
    }
 
 
    template<typename Promise>
    void await_suspend(std::coroutine_handle<Promise> finishedCoroutine) noexcept {
        auto &promise = finishedCoroutine.promise();
 
        for (auto &awaiter : mAwaitingCoroutines) {
            awaiter.resume();
        }
        mAwaitingCoroutines.clear();
 
        // The handle will be destroyed here only if the associated Task has already been destroyed
        if (promise.setDestroyHandle()) {
            finishedCoroutine.destroy();
        }
    }
 
 
    constexpr void await_resume() const noexcept {}
 
private:
    std::vector<std::coroutine_handle<>> mAwaitingCoroutines;
};
 
 
class TaskPromiseBase {
public:
 
    std::suspend_never initial_suspend() const noexcept {
        return {};
    }
 
 
    auto final_suspend() const noexcept {
        return TaskFinalSuspend{mAwaitingCoroutines};
    }
 
 
    template<typename T, typename Awaiter = QCoro::detail::awaiter_type_t<std::remove_cvref_t<T>>>
    auto await_transform(T &&value) {
        return Awaiter{value};
    }
 
 
    template<typename T>
    auto await_transform(QCoro::Task<T> &&task) {
        return std::forward<QCoro::Task<T>>(task);
    }
 
    template<typename T>
    auto &await_transform(QCoro::Task<T> &task) {
        return task;
    }
 
    template<Awaitable T>
    auto &&await_transform(T &&awaitable) {
        return std::forward<T>(awaitable);
    }
 
    template<Awaitable T>
    auto &await_transform(T &awaitable) {
        return awaitable;
    }
 
 
    void addAwaitingCoroutine(std::coroutine_handle<> awaitingCoroutine) {
        mAwaitingCoroutines.push_back(awaitingCoroutine);
    }
 
    bool hasAwaitingCoroutine() const {
        return !mAwaitingCoroutines.empty();
    }
 
    bool setDestroyHandle() noexcept {
        return mDestroyHandle.exchange(true, std::memory_order_acq_rel);
    }
 
private:
    friend class TaskFinalSuspend;
 
    std::vector<std::coroutine_handle<>> mAwaitingCoroutines;
 
    std::atomic<bool> mDestroyHandle{false};
};
 
 
template<typename T>
class TaskPromise final : public TaskPromiseBase {
public:
    explicit TaskPromise() = default;
    ~TaskPromise() = default;
 
    Task<T> get_return_object() noexcept;
 
 
    void unhandled_exception() {
        mValue = std::current_exception();
    }
 
 
    void return_value(T &&value) noexcept {
        mValue.template emplace<T>(std::forward<T>(value));
    }
 
    void return_value(const T &value) noexcept {
        mValue = value;
    }
 
    template<typename U>
        requires QCoro::concepts::constructible_from<T, U>
    void return_value(U &&value) noexcept {
        mValue = std::move(value);
    }
 
    template<typename U>
        requires QCoro::concepts::constructible_from<T, U>
    void return_value(const U &value) noexcept {
        mValue = value;
    }
 
 
    T &result() & {
        if (std::holds_alternative<std::exception_ptr>(mValue)) {
            assert(std::get<std::exception_ptr>(mValue) != nullptr);
            std::rethrow_exception(std::get<std::exception_ptr>(mValue));
        }
 
        return std::get<T>(mValue);
    }
 
    T &&result() && {
        if (std::holds_alternative<std::exception_ptr>(mValue)) {
            assert(std::get<std::exception_ptr>(mValue) != nullptr);
            std::rethrow_exception(std::get<std::exception_ptr>(mValue));
        }
 
        return std::move(std::get<T>(mValue));
    }
 
private:
    std::variant<std::monostate, T, std::exception_ptr> mValue;
};
 
template<>
class TaskPromise<void> final : public TaskPromiseBase {
public:
    // Constructor.
    explicit TaskPromise() = default;
 
    ~TaskPromise() = default;
 
    Task<void> get_return_object() noexcept;
 
    void unhandled_exception() {
        mException = std::current_exception();
    }
 
    void return_void() noexcept {};
 
 
    void result() {
        if (mException) {
            std::rethrow_exception(mException);
        }
    }
 
private:
    std::exception_ptr mException;
};
 
template<typename Promise>
class TaskAwaiterBase {
public:
    bool await_ready() const noexcept {
        return !mAwaitedCoroutine || mAwaitedCoroutine.done();
    }
 
 
    void await_suspend(std::coroutine_handle<> awaitingCoroutine) noexcept {
        mAwaitedCoroutine.promise().addAwaitingCoroutine(awaitingCoroutine);
    }
 
protected:
 
    TaskAwaiterBase(std::coroutine_handle<Promise> awaitedCoroutine)
        : mAwaitedCoroutine(awaitedCoroutine) {}
 
    std::coroutine_handle<Promise> mAwaitedCoroutine = {};
};
 
template<typename T>
struct isTask : std::false_type {
    using return_type = T;
};
 
template<typename T>
struct isTask<QCoro::Task<T>> : std::true_type {
    using return_type = typename QCoro::Task<T>::value_type;
};
 
template<typename T>
constexpr bool isTask_v = isTask<T>::value;
 
} // namespace detail
 
 
template<typename T>
class Task {
public:
    using promise_type = detail::TaskPromise<T>;
    using value_type = T;
 
    explicit Task() noexcept = default;
 
 
    explicit Task(std::coroutine_handle<promise_type> coroutine) : mCoroutine(coroutine) {}
 
    Task(const Task &) = delete;
    Task &operator=(const Task &) = delete;
 
    Task(Task &&other) noexcept : mCoroutine(other.mCoroutine) {
        other.mCoroutine = nullptr;
    }
 
    Task &operator=(Task &&other) noexcept {
        if (std::addressof(other) != this) {
            if (mCoroutine) {
                // The coroutine handle will be destroyed only after TaskFinalSuspend
                if (mCoroutine.promise().setDestroyHandle()) {
                    mCoroutine.destroy();
                }
            }
 
            mCoroutine = other.mCoroutine;
            other.mCoroutine = nullptr;
        }
        return *this;
    }
 
    ~Task() {
        if (!mCoroutine)
            return;
 
        // The coroutine handle will be destroyed only after TaskFinalSuspend
        if (mCoroutine.promise().setDestroyHandle()) {
            mCoroutine.destroy();
        }
    };
 
 
    bool isReady() const {
        return !mCoroutine || mCoroutine.done();
    }
 
 
    auto operator co_await() const noexcept {
        class TaskAwaiter : public detail::TaskAwaiterBase<promise_type> {
        public:
            TaskAwaiter(std::coroutine_handle<promise_type> awaitedCoroutine)
                : detail::TaskAwaiterBase<promise_type>{awaitedCoroutine} {}
 
            /*
             * \return the result from the coroutine's promise, factically the
             * value co_returned by the coroutine. */
            auto await_resume() {
                assert(this->mAwaitedCoroutine != nullptr);
                if constexpr (!std::is_void_v<T>) {
                    return std::move(this->mAwaitedCoroutine.promise().result());
                } else {
                    // Wil re-throw exception, if any is stored
                    this->mAwaitedCoroutine.promise().result();
                }
            }
        };
 
        return TaskAwaiter{mCoroutine};
    }
 
 
    template<typename ThenCallback>
        requires(std::is_invocable_v<ThenCallback> ||
                 (!std::is_void_v<T> && std::is_invocable_v<ThenCallback, T>))
    auto then(ThenCallback &&callback) {
        // Provide a custom error handler that simply re-throws the current exception
        return thenImpl(std::forward<ThenCallback>(callback), [](const auto &) { throw; });
    }
 
    template<typename ThenCallback, typename ErrorCallback>
        requires((std::is_invocable_v<ThenCallback> ||
                  (!std::is_void_v<T> && std::is_invocable_v<ThenCallback, T>)) &&
                 std::is_invocable_v<ErrorCallback, const std::exception &>)
    auto then(ThenCallback &&callback, ErrorCallback &&errorCallback) {
        return thenImpl(std::forward<ThenCallback>(callback),
                        std::forward<ErrorCallback>(errorCallback));
    }
 
private:
    template<typename ThenCallback, typename... Args>
    auto invokeCb(ThenCallback &&callback, [[maybe_unused]] Args &&...args) {
        if constexpr (std::is_invocable_v<ThenCallback, Args...>) {
            return callback(std::forward<Args>(args)...);
        } else {
            return callback();
        }
    }
 
    template<typename ThenCallback, typename Arg>
    struct cb_invoke_result
        : std::conditional_t<std::is_invocable_v<ThenCallback>, std::invoke_result<ThenCallback>,
                             std::invoke_result<ThenCallback, Arg>> {};
 
    template<typename ThenCallback>
    struct cb_invoke_result<ThenCallback, void> : std::invoke_result<ThenCallback> {};
 
    template<typename ThenCallback, typename Arg>
    using cb_invoke_result_t = typename cb_invoke_result<ThenCallback, Arg>::type;
 
    template<typename R, typename ErrorCallback,
             typename U = typename detail::isTask<R>::return_type>
    auto handleException(ErrorCallback &errCb, const std::exception &exception) -> U {
        errCb(exception);
        if constexpr (!std::is_void_v<U>) {
            return U{};
        }
    }
 
    template<typename ThenCallback, typename ErrorCallback,
             typename R = cb_invoke_result_t<ThenCallback, T>>
    auto thenImpl(ThenCallback &&thenCallback, ErrorCallback &&errorCallback)
        -> std::conditional_t<detail::isTask_v<R>, R, Task<R>> {
        auto thenCb = std::forward<ThenCallback>(thenCallback);
        auto errCb = std::forward<ErrorCallback>(errorCallback);
        if constexpr (std::is_void_v<value_type>) {
            try {
                co_await *this;
            } catch (const std::exception &e) {
                co_return handleException<R>(errCb, e);
            }
            if constexpr (detail::isTask_v<R>) {
                co_return co_await invokeCb(thenCb);
            } else {
                co_return invokeCb(thenCb);
            }
        } else {
            std::optional<T> value;
            try {
                value = co_await *this;
            } catch (const std::exception &e) {
                co_return handleException<R>(errCb, e);
            }
            if constexpr (detail::isTask_v<R>) {
                co_return co_await invokeCb(thenCb, std::move(*value));
            } else {
                co_return invokeCb(thenCb, std::move(*value));
            }
        }
    }
 
private:
 
    std::coroutine_handle<promise_type> mCoroutine = {};
};
 
namespace detail {
 
template<typename T>
inline Task<T> TaskPromise<T>::get_return_object() noexcept {
    return Task<T>{std::coroutine_handle<TaskPromise>::from_promise(*this)};
}
 
Task<void> inline TaskPromise<void>::get_return_object() noexcept {
    return Task<void>{std::coroutine_handle<TaskPromise>::from_promise(*this)};
}
 
template<typename T>
concept TaskConvertible = requires(T v, TaskPromiseBase t) {
                              { t.await_transform(v) };
                          };
 
template<typename T>
struct awaitable_return_type {
    using type = std::decay_t<decltype(std::declval<T>().await_resume())>;
};
 
template<QCoro::detail::has_member_operator_coawait T>
struct awaitable_return_type<T> {
    using type = std::decay_t<
        typename awaitable_return_type<decltype(std::declval<T>().operator co_await())>::type>;
};
 
template<QCoro::detail::has_nonmember_operator_coawait T>
struct awaitable_return_type<T> {
    using type = std::decay_t<
        typename awaitable_return_type<decltype(operator co_await(std::declval<T>()))>::type>;
};
 
template<Awaitable Awaitable>
using awaitable_return_type_t = typename detail::awaitable_return_type<Awaitable>::type;
 
template<typename Awaitable>
    requires TaskConvertible<Awaitable>
using convertible_awaitable_return_type_t =
    typename detail::awaitable_return_type<decltype(std::declval<TaskPromiseBase>().await_transform(
        Awaitable()))>::type;
 
template<typename Awaitable>
    requires TaskConvertible<Awaitable>
auto toTask(Awaitable &&future)
    -> QCoro::Task<detail::convertible_awaitable_return_type_t<Awaitable>> {
    co_return co_await future;
}
 
struct WaitContext {
    // QEventLoop loop;
    bool coroutineFinished = false;
    std::exception_ptr exception;
};
 
} // namespace detail
 
template<typename T, typename QObjectSubclass, typename Callback>
    requires detail::TaskConvertible<T> &&
             (std::is_invocable_v<Callback> ||
              std::is_invocable_v<Callback, detail::convertible_awaitable_return_type_t<T>> ||
              std::is_invocable_v<Callback, QObjectSubclass *> ||
              std::is_invocable_v<Callback, QObjectSubclass *,
                                  detail::convertible_awaitable_return_type_t<T>>) &&
             (!detail::isTask_v<T>)
void connect(T &&future, QObjectSubclass *context, Callback func) {
    auto task = detail::toTask(std::move(future));
    connect(std::move(task), context, func);
}
 
} // namespace QCoro