catch_as_failure.hpp

Go to the documentation of this file.

#pragma once
 
#include "concepts.hpp" // IWYU pragma: keep
#include "../detail/task_adapters/result_helpers.hpp"
 
namespace yorch {
 
template <typename Task>
struct catch_failure_task
    : detail::catch_failure_task_raw_result_base<Task>,
      detail::forwarded_task_output_base<Task>,
      detail::forwarded_task_output_protocol_base<Task> {
    Task task;
 
    constexpr explicit catch_failure_task(Task&& stored_task)
        noexcept(std::is_nothrow_move_constructible_v<Task>)
        : task(std::move(stored_task)) {}
 
    constexpr explicit catch_failure_task(const Task& stored_task)
        noexcept(std::is_nothrow_copy_constructible_v<Task>)
        : task(stored_task) {}
 
    template <typename Ctx, typename Prev>
        requires default_catchable_task<Task, Ctx, Prev>
    constexpr auto invoke_raw(exec_context<Ctx, Prev>& ec) noexcept {
        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>,
                      "Wrapped task raw_result_type must match invoke_raw(exec_context<...>&) return type");
        static_assert(detail::default_catch_supported_v<raw_result_t>,
                      "Default catch_as_failure only supports tasks returning void or step_result");
 
        try {
            if constexpr (std::is_void_v<raw_result_t>) {
                task.invoke_raw(ec);
                return step_result::success();
            } else {
                return task.invoke_raw(ec);
            }
        } catch (...) {
            return detail::default_catch_failure_result<raw_result_t>();
        }
    }
 
    template <typename Ctx, typename Prev, typename U = Task>
        requires direct_output_task<U, Ctx, Prev>
    constexpr step_result invoke_into(
        exec_context<Ctx, Prev>& ec,
        direct_out<detail::declared_task_output_t<U>> out) noexcept {
        try {
            return task.invoke_into(ec, out);
        } catch (...) {
            return step_result::failure();
        }
    }
};
 
template <typename Task, typename Policy>
struct catch_failure_with_policy_task
    : detail::catch_failure_with_policy_task_raw_result_base<Task, Policy>,
      detail::forwarded_task_output_base<Task>,
      detail::forwarded_task_output_protocol_base<Task> {
    Task task;
    Policy policy;
 
    constexpr catch_failure_with_policy_task(Task&& stored_task, Policy&& stored_policy)
        noexcept(std::is_nothrow_move_constructible_v<Task> &&
                 std::is_nothrow_move_constructible_v<Policy>)
        : task(std::move(stored_task)),
          policy(std::move(stored_policy)) {}
 
    constexpr catch_failure_with_policy_task(const Task& stored_task, const Policy& stored_policy)
        noexcept(std::is_nothrow_copy_constructible_v<Task> &&
                 std::is_nothrow_copy_constructible_v<Policy>)
        : task(stored_task),
          policy(stored_policy) {}
 
    template <typename Ctx, typename Prev>
        requires catch_policy_compatible_task<Task, Policy, Ctx, Prev>
    constexpr auto invoke_raw(exec_context<Ctx, Prev>& ec) noexcept {
        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>,
                      "Wrapped task raw_result_type must match invoke_raw(exec_context<...>&) return type");
        static_assert(detail::catch_policy_supported_v<raw_result_t, Policy>,
                      "catch_as_failure(task, policy) requires a noexcept fallback taking std::exception_ptr and returning a compatible result");
 
        try {
            if constexpr (std::is_void_v<raw_result_t>) {
                task.invoke_raw(ec);
                return detail::void_task_success_result<detail::policy_result_t<Policy>>();
            } else {
                return task.invoke_raw(ec);
            }
        } catch (...) {
            return detail::policy_catch_failure_result<raw_result_t>(policy, std::current_exception());
        }
    }
 
    template <typename Ctx, typename Prev, typename U = Task>
        requires catch_policy_compatible_direct_output_task<U, Policy, Ctx, Prev>
    constexpr step_result invoke_into(
        exec_context<Ctx, Prev>& ec,
        direct_out<detail::declared_task_output_t<U>> out) noexcept {
        try {
            return task.invoke_into(ec, out);
        } catch (...) {
            return std::invoke(policy, std::current_exception());
        }
    }
};
 
template <typename Task>
constexpr auto catch_as_failure(Task&& task) {
    return catch_failure_task<std::decay_t<Task>>{
        std::forward<Task>(task)
    };
}
 
template <typename Task, typename Policy>
constexpr auto catch_as_failure(Task&& task, Policy&& policy) {
    return catch_failure_with_policy_task<
        std::decay_t<Task>,
        std::decay_t<Policy>
    >{
        std::forward<Task>(task),
        std::forward<Policy>(policy)
    };
}
 
}  // namespace yorch