task.hpp

Go to the documentation of this file.

#pragma once
 
#ifdef __cpp_lib_coroutine
#include <coroutine>
#endif
#include <exception>
#include <type_traits>
 
#include "detail/function_result.hpp"
#include "detail/is_instance_of.hpp"
#include "detail/task_future.hpp"
#include "task_error.hpp"
#include "task_state.hpp"
 
namespace dispatch_queue {
 
#ifdef __cpp_exceptions
    #define DISPATCH_QUEUE_THROW_OR(err_msg, body) throw task_error(err_msg)
#else
    #define DISPATCH_QUEUE_THROW_OR(err_msg, body) body
#endif

template<typename T>
class task {
public:
    using value_type = T;

    task() = default;
    task(std::shared_ptr<detail::task_future<T>> future)
        : future(future)
    {
    }

    static task create_pending() {
        return detail::task_future<T>::create_pending();
    }

    template<typename U = T, typename = typename std::enable_if<std::is_void<U>::value>::type>
    static task create_ready() {
        return detail::task_future<T>::create_ready();
    }

    template<typename U = T, typename = typename std::enable_if<not std::is_void<U>::value>::type>
    static task create_ready(U&& value) {
        return detail::task_future<T>::create_ready(std::move(value));
    }

    static task create_failed(std::exception_ptr exception) {
        return detail::task_future<T>::create_failed(exception);
    }

    bool valid() const {
        return (bool)future;
    }
 
#ifdef __cpp_concepts
    template<typename F>
    requires (detail::is_instance_of<T, task>::value)
    auto then(F&& f) const {
        if (future) {
            task value_this = *this;
            auto nested_future = detail::task_future<detail::function_result<F, T>>::create_pending();
            future->then([=] {
                value_this.get().then([=](const auto& t) {
                    nested_future->do_work(f, t);
                });
            });
            return to_task(nested_future);
        }
        else {
            using future_t = detail::task_future<detail::function_result<F, T>>;
            DISPATCH_QUEUE_THROW_OR("task is invalid", {
                auto work = std::bind(f, T{});
                auto future = future_t::create(std::move(work));
                return to_task(future);
            });
        }
    }
#endif

    template<typename F>
    auto then(F&& f) const {
        if (future) {
            task value_this = *this;
            return to_task(future->then([=] {
                return f(value_this);
            }));
        }
        else {
            using future_t = detail::task_future<detail::function_result<F, task>>;
            DISPATCH_QUEUE_THROW_OR("task is invalid", {
                auto work = std::bind(f, *this);
                auto future = future_t::create(std::move(work));
                return to_task(future);
            });
        }
    }

    T get() const {
        if (future) {
            return future->get();
        }
        else {
            DISPATCH_QUEUE_THROW_OR("task is invalid", return T{});
        }
    }

    template<typename U = T, typename = typename std::enable_if<std::is_void<U>::value>::type>
    void set_value() {
        if (future) {
            if (!future->set_value()) {
                DISPATCH_QUEUE_THROW_OR("task is not pending", return);
            }
        }
        else {
            DISPATCH_QUEUE_THROW_OR("task is invalid", return);
        }
    }

    template<typename U = T, typename = typename std::enable_if<not std::is_void<U>::value>::type>
    void set_value(U&& value) {
        if (future) {
            if (!future->set_value(std::move(value))) {
                DISPATCH_QUEUE_THROW_OR("task is not pending", return);
            }
        }
        else {
            DISPATCH_QUEUE_THROW_OR("task is invalid", return);
        }
    }

    task_state get_state() const {
        if (future) {
            return future->get_state();
        }
        else {
            return task_state::invalid;
        }
    }

    std::exception_ptr get_exception() const {
        if (future) {
            return future->get_exception();
        }
        else {
            return std::make_exception_ptr(task_error("task is invalid"));
        }
    }

    void set_exception(std::exception_ptr exception) {
        if (future) {
            if (!future->set_exception(exception)) {
                DISPATCH_QUEUE_THROW_OR("task is not pending", return);
            }
        }
        else {
            DISPATCH_QUEUE_THROW_OR("task is invalid", return);
        }
    }

    void wait() const {
        if (future) {
            future->wait();
        }
        else {
            DISPATCH_QUEUE_THROW_OR("task is invalid", return);
        }
    }

    template<class Rep, class Period>
    bool wait_for(const std::chrono::duration<Rep, Period>& timeout_duration) const {
        if (future) {
            return future->wait_for(timeout_duration);
        }
        else {
            DISPATCH_QUEUE_THROW_OR("task is invalid", return false);
        }
    }

    template<class Clock, class Duration>
    bool wait_until(const std::chrono::time_point<Clock, Duration>& timeout_time) const {
        if (future) {
            return future->wait_until(timeout_time);
        }
        else {
            DISPATCH_QUEUE_THROW_OR("task is invalid", return false);
        }
    }

    operator task<void>() const {
        switch (get_state()) {
            case task_state::pending: {
                auto void_future = detail::task_future<void>::create_pending();
                then([=](const task& t) {
                    if (auto exception = t.get_exception()) {
                        void_future->set_exception(exception);
                    }
                    else {
                        void_future->set_value();
                    }
                });
                return to_task(void_future);
            }
 
            case task_state::ready:
                return task<void>::create_ready();
 
            case task_state::failed:
                return task<void>::create_failed(get_exception());
 
            default:
                return {};
        }
    }

    template<typename U, typename = typename std::enable_if<std::is_convertible<T, U>::value>::type>
    explicit operator task<U>() const {
        switch (get_state()) {
            case task_state::pending: {
                auto u_future = detail::task_future<U>::create_pending();
                then([=](const task& t) {
                    if (auto exception = t.get_exception()) {
                        u_future->set_exception(exception);
                    }
                    else {
                        U u_value = (U) t.get();
                        u_future->set_value(std::move(u_value));
                    }
                });
                return to_task(u_future);
            }
 
            case task_state::ready: {
                U u_value = (U) get();
                return task<U>::create_ready(std::move(u_value));
            }
 
            case task_state::failed:
                return task<U>::create_failed(get_exception());
 
            default:
                return {};
        }
    }
 
#ifdef __cpp_lib_coroutine
private:
    class task_awaiter {
    public:
        task_awaiter(const task<T>& t) : t(t) {}
        task_awaiter(task<T>&& t) : t(std::move(t)) {}
 
        bool await_ready() const noexcept {
            return t.get_state() != task_state::pending;
        }
 
        void await_suspend(std::coroutine_handle<> cont) const {
            t.then([cont](auto&&) {
                cont();
                if (cont.done()) {
                    cont.destroy();
                }
            });
        }
 
        T await_resume() {
            return t.get();
        }
 
    private:
        task<T> t;
    };
 
public:
    task_awaiter operator co_await() const {
        return task_awaiter(*this);
    }
#endif
 
private:
    std::shared_ptr<detail::task_future<T>> future;

    template<typename U>
    static task<U> to_task(std::shared_ptr<detail::task_future<U>> future) {
        return task<U>(future);
    }
};
 
} // end namespace dispatch_queue