result.hpp

Go to the documentation of this file.

#pragma once
#include <type_traits>
#include <utility>
 
#include "assert.hpp"
#include "detail/storage/maybe_storage.hpp"
 
namespace yorch {
 
enum class step_status : unsigned char {
    success,
    failure,
    retry,
    abort_branch,
    abort_execution,
};
 
struct step_result {
    step_status status = step_status::success;
 
    [[nodiscard]] static constexpr step_result success() noexcept {
        return {step_status::success};
    }
 
    [[nodiscard]] static constexpr step_result failure() noexcept {
        return {step_status::failure};
    }
 
    [[nodiscard]] static constexpr step_result retry() noexcept {
        return {step_status::retry};
    }
 
    [[nodiscard]] static constexpr step_result abort_branch() noexcept {
        return {step_status::abort_branch};
    }
 
    [[nodiscard]] static constexpr step_result abort_execution() noexcept {
        return {step_status::abort_execution};
    }
 
    [[nodiscard]] constexpr bool ok() const noexcept {
        return status == step_status::success;
    }
 
    [[nodiscard]] constexpr explicit operator bool() const noexcept {
        return ok();
    }
};
 
template <typename T>
struct task_result {
    static_assert(!std::is_reference_v<T>,
                  "yorch::task_result<T> does not support reference types");
    static_assert(!std::is_void_v<T>,
                  "yorch::task_result<void> is not supported; use `void` for success-only tasks or `yorch::step_result` for status-only tasks");
 
public:
    using value_type = T;
 
    task_result() = delete;
    task_result(const task_result&) = default;
    task_result(task_result&&) = default;
    task_result& operator=(const task_result&) = default;
    task_result& operator=(task_result&&) = default;
    ~task_result() = default;
 
    step_result step {}; // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes)
 
    template <typename U>
    [[nodiscard]] static constexpr task_result success(U&& value)
        noexcept(std::is_nothrow_constructible_v<T, U&&>) {
        return task_result(step_result::success(), std::forward<U>(value));
    }
 
    [[nodiscard]] static constexpr task_result failure() noexcept {
        return from_step(step_result::failure());
    }
 
    [[nodiscard]] static constexpr task_result retry() noexcept {
        return from_step(step_result::retry());
    }
 
    [[nodiscard]] static constexpr task_result abort_branch() noexcept {
        return from_step(step_result::abort_branch());
    }
 
    [[nodiscard]] static constexpr task_result abort_execution() noexcept {
        return from_step(step_result::abort_execution());
    }
 
    [[nodiscard]] static constexpr task_result from_step(step_result s) noexcept {
        YORCH_ASSERT(!s.ok() &&
                     "yorch::task_result<T>::from_step(...) requires a non-success status");
        return task_result(s);
    }
 
    [[nodiscard]] constexpr bool has_value() const noexcept {
        return value_.has_value();
    }
 
    [[nodiscard]] constexpr T& value() & noexcept {
        return value_.get();
    }
 
    [[nodiscard]] constexpr const T& value() const& noexcept {
        return value_.get();
    }
 
    [[nodiscard]] constexpr T&& value() && noexcept {
        return std::move(value_).get();
    }
 
private:
    constexpr explicit task_result(step_result s) noexcept
        : step(s) {}
 
    template <typename U>
    constexpr task_result(step_result s, U&& value)
        noexcept(std::is_nothrow_constructible_v<T, U&&>)
        : step(s) {
        value_.emplace(std::forward<U>(value));
    }
 
    detail::maybe_storage<T> value_ {};
};
 
template <typename T>
struct is_task_result : std::false_type {};
 
template <typename T>
struct is_task_result<task_result<T>> : std::true_type {};
 
template <typename T>
inline constexpr bool is_task_result_v =
    is_task_result<std::remove_cvref_t<T>>::value;
 
template <typename T>
struct task_result_value;
 
template <typename T>
struct task_result_value<task_result<T>> {
    using type = T;
};
 
template <typename T>
using task_result_value_t =
    typename task_result_value<std::remove_cvref_t<T>>::type;
 
}  // namespace yorch