result.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstddef>
#include <type_traits>
#include <utility>
 
#include "../../assert.hpp"
#include "../../result.hpp"
 
namespace yorch::detail {
 
template <typename R>
[[nodiscard]] constexpr step_result normalize_task_result(R&& r) { // NOLINT(readability-identifier-length)
    using raw_t = std::remove_cvref_t<R>;
 
    if constexpr (std::is_same_v<raw_t, step_result>) {
        return std::forward<R>(r);
    } else if constexpr (is_task_result_v<raw_t>) {
        return std::forward<R>(r).step;
    } else {
        static_cast<void>(r);
        return step_result::success();
    }
}
 
template <typename R>
[[nodiscard]] constexpr step_result extract_step_result(R&& r) { // NOLINT(readability-identifier-length)
    return normalize_task_result(std::forward<R>(r));
}
 
template <std::size_t I, typename Slots, typename Raw>
[[nodiscard]] constexpr bool store_node_output(Slots& slots, Raw& raw) {
    using raw_t = std::remove_cvref_t<Raw>;
 
    if constexpr (std::is_void_v<raw_t> ||
                  std::is_same_v<raw_t, step_result>) {
        static_cast<void>(slots);
        static_cast<void>(raw);
        return false;
    } else if constexpr (is_task_result_v<raw_t>) {
        if (raw.step.ok()) {
            YORCH_ASSERT(raw.has_value() &&
                         "Successful task_result<T> must carry a payload before slot storage");
            slots.template emplace<I>(std::move(raw).value());
            return true;
        }
 
        return false;
    } else {
        slots.template emplace<I>(std::move(raw));
        return true;
    }
}
 
template <typename Slots, std::size_t I>
struct node_slot_guard {
    Slots& slots;
    bool armed = false;
 
    constexpr explicit node_slot_guard(Slots& stored_slots) noexcept
        : slots(stored_slots) {}
 
    node_slot_guard(const node_slot_guard&) = delete;
    node_slot_guard& operator=(const node_slot_guard&) = delete;
    node_slot_guard(node_slot_guard&&) = delete;
    node_slot_guard& operator=(node_slot_guard&&) = delete;
 
    constexpr void arm() noexcept {
        armed = true;
    }
 
    ~node_slot_guard() {
        if (armed) {
            slots.template destroy<I>();
        }
    }
};
 
template <std::size_t I, typename Slots>
[[nodiscard]] constexpr step_result finalize_direct_output_step(Slots& slots, step_result step) {
    if (step.ok()) {
        YORCH_ASSERT(slots.template has_value<I>() &&
                     "Direct-output tasks returning success must construct their payload");
    } else {
        slots.template destroy<I>();
    }
 
    return step;
}
 
} // namespace yorch::detail