task.hpp

Go to the documentation of this file.

#pragma once
 
#include <type_traits>
#include <utility>
 
#include "../detail/executor/result.hpp"
#include "../detail/task_adapters/traits.hpp"
#include "../slots/direct_out.hpp"
#include "concepts.hpp" // IWYU pragma: keep
 
namespace yorch {
 
template <typename Task, typename Ctx, typename Prev = no_prev>
    requires executable_task<Task, Ctx, Prev>
[[nodiscard]] constexpr step_result run_task(Task&& task, exec_context<Ctx, Prev>& ec)
    noexcept(
        noexcept(std::forward<Task>(task).invoke_raw(ec)) &&
        (std::is_void_v<detail::raw_task_result_t<Task&&, Ctx, Prev>> ||
         noexcept(detail::normalize_task_result(
             std::forward<Task>(task).invoke_raw(ec)))))
{
    using raw_result_t = detail::raw_task_result_t<Task&&, Ctx, Prev>;
 
    static_assert(detail::declared_task_raw_result_matches_invoke_raw_v<Task, Ctx, Prev>,
                  "Task raw_result_type must match invoke_raw(exec_context<...>&) return type");
 
    if constexpr (std::is_void_v<raw_result_t>) {
        std::forward<Task>(task).invoke_raw(ec);
        return step_result::success();
    } else {
        return detail::normalize_task_result(
            std::forward<Task>(task).invoke_raw(ec)
        );
    }
}
 
template <typename Task, typename Ctx, typename Prev = no_prev>
    requires executable_direct_output_task<Task, Ctx, Prev>
[[nodiscard]] constexpr step_result run_task_into(
    Task&& task,
    exec_context<Ctx, Prev>& ec,
    direct_out<detail::declared_task_output_t<Task>> out)
    noexcept(noexcept(std::forward<Task>(task).invoke_into(ec, out)))
{
    const auto step = std::forward<Task>(task).invoke_into(ec, out);
 
    if (step.ok()) {
        YORCH_ASSERT(out.has_value());
    } else if (out.has_value()) {
        out.destroy();
    }
 
    return step;
}
 
} // namespace yorch