traits.hpp

Go to the documentation of this file.

#pragma once
 
#include <concepts> // IWYU pragma: keep
#include <exception>
#include <type_traits>
#include <utility>
 
#include "../../context.hpp"
#include "../../result.hpp"
#include "../task/traits.hpp" // IWYU pragma: keep
 
namespace yorch::detail {
 
template <typename Task, typename Ctx, typename Prev>
using raw_task_result_t =
    decltype(std::declval<Task>().invoke_raw(std::declval<exec_context<Ctx, Prev>&>()));
 
template <typename R>
inline constexpr bool default_catch_supported_v =
    std::is_void_v<R> ||
    std::is_same_v<R, step_result>;
 
template <typename Policy, typename = void>
struct policy_result;
 
template <typename Policy>
struct policy_result<Policy, std::void_t<std::invoke_result_t<Policy&, const std::exception_ptr&>>> {
    using type = std::invoke_result_t<Policy&, const std::exception_ptr&>;
};
 
template <typename Policy>
using policy_result_t = typename policy_result<Policy>::type;
 
template <typename Task, typename = void>
struct declared_task_raw_result;
 
template <typename Task>
struct declared_task_raw_result<
    Task,
    std::void_t<typename std::remove_cvref_t<Task>::raw_result_type>
> {
    using type = typename std::remove_cvref_t<Task>::raw_result_type;
};
 
template <typename Task>
using declared_task_raw_result_t = typename declared_task_raw_result<Task>::type;
 
template <typename Task, typename Ctx, typename Prev, typename = void>
struct declared_task_raw_result_matches_invoke_raw : std::true_type {};
 
template <typename Task, typename Ctx, typename Prev>
struct declared_task_raw_result_matches_invoke_raw<
    Task,
    Ctx,
    Prev,
    std::void_t<declared_task_raw_result_t<Task>>
> : std::bool_constant<
        std::same_as<
            raw_task_result_t<Task&, Ctx, Prev>,
            declared_task_raw_result_t<Task>>> {};
 
template <typename Task, typename Ctx, typename Prev>
inline constexpr bool declared_task_raw_result_matches_invoke_raw_v =
    declared_task_raw_result_matches_invoke_raw<Task, Ctx, Prev>::value;
 
template <typename Task, typename = void>
struct catch_failure_task_raw_result_base {};
 
template <typename Task>
struct catch_failure_task_raw_result_base<
    Task,
    std::void_t<declared_task_raw_result_t<Task>>
> {
    using inner_type = declared_task_raw_result_t<Task>;
    using raw_result_type = std::conditional_t<std::is_void_v<inner_type>, step_result, inner_type>;
};
 
template <typename Task, typename Policy, typename = void>
struct catch_failure_with_policy_task_raw_result_base {};
 
template <typename Task, typename Policy>
struct catch_failure_with_policy_task_raw_result_base<
    Task,
    Policy,
    std::void_t<
        declared_task_raw_result_t<Task>,
        policy_result_t<std::remove_cvref_t<Policy>>
    >
> {
    using inner_type = declared_task_raw_result_t<Task>;
    using policy_type = policy_result_t<std::remove_cvref_t<Policy>>;
    using raw_result_type = std::conditional_t<std::is_void_v<inner_type>, policy_type, inner_type>;
};
 
template <typename Task, typename = void>
struct retry_task_raw_result_base {};
 
template <typename Task>
struct retry_task_raw_result_base<
    Task,
    std::void_t<declared_task_raw_result_t<Task>>
> {
    using raw_result_type = declared_task_raw_result_t<Task>;
};
 
template <typename R, typename Policy, typename = void>
struct catch_policy_supported : std::false_type {};
 
template <typename R, typename Policy>
struct catch_policy_supported<
    R,
    Policy,
    std::void_t<std::invoke_result_t<Policy&, const std::exception_ptr&>>>
    : std::bool_constant<
          std::is_nothrow_invocable_v<Policy&, const std::exception_ptr&> &&
          (std::is_void_v<R>
               ? std::is_same_v<policy_result_t<Policy>, step_result>
               : (!std::is_reference_v<R> &&
                  std::is_convertible_v<policy_result_t<Policy>, R>))> {};
 
template <typename R, typename Policy>
inline constexpr bool catch_policy_supported_v =
    catch_policy_supported<R, Policy>::value;
 
}  // namespace yorch::detail