chainable_result.hpp

Go to the documentation of this file.

#pragma once
 
#include <expected>
#include <memory>
#include <string>
#include <type_traits>
 
#include "porytiles/utilities/panic/panic.hpp"
#include "porytiles/utilities/result/error.hpp"
 
namespace porytiles {
 
template <typename T, typename E = FormattableError>
class ChainableResult {
  public:
    // NOLINTNEXTLINE(google-explicit-constructor)
    ChainableResult(T value) : result_{std::move(value)} {}
 
    // NOLINTNEXTLINE(google-explicit-constructor)
    ChainableResult(const E &error) : result_{std::unexpected{error}}
    {
        static_assert(std::is_base_of_v<Error, E>, "ChainableResult error type E must be derived from Error");
        error_chain_.push_back(std::make_unique<E>(error));
    }
 
    template <typename CauseT, typename CauseE>
    explicit ChainableResult(const E &error, const ChainableResult<CauseT, CauseE> &cause_result)
        : result_{std::unexpected{error}}
    {
        static_assert(std::is_base_of_v<Error, E>, "ChainableResult error type E must be derived from Error");
        error_chain_.push_back(std::make_unique<E>(result_.error()));
        add_cause(cause_result);
    }
 
    template <typename CauseT, typename CauseE>
    explicit ChainableResult(const ChainableResult<CauseT, CauseE> &cause_result) : result_{std::unexpected{E{}}}
    {
        static_assert(std::is_base_of_v<Error, E>, "ChainableResult error type E must be derived from Error");
        error_chain_.push_back(std::make_unique<E>(result_.error()));
        add_cause(cause_result);
    }
 
    /*
     * Move-only semantics
     */
    ChainableResult(ChainableResult &&) = default;
    ChainableResult &operator=(ChainableResult &&) = default;
    ChainableResult(const ChainableResult &) = delete;
    ChainableResult &operator=(const ChainableResult &) = delete;
 
    template <typename OtherT, typename OtherE>
    void add_cause(const ChainableResult<OtherT, OtherE> &cause_result)
    {
        assert_or_panic(!cause_result.has_value(), "cause_result has a value, but should have an error");
 
        // Clone errors from cause_result's chain since we can't move from const
        for (const std::unique_ptr<Error> &err : cause_result.chain()) {
            error_chain_.push_back(err->clone());
        }
    }
 
    [[nodiscard]] bool has_value() const
    {
        return result_.has_value();
    }
 
    [[nodiscard]] T &value() &
    {
        return result_.value();
    }
 
    [[nodiscard]] const T &value() const &
    {
        return result_.value();
    }
 
    [[nodiscard]] T &&value() &&
    {
        return std::move(result_).value();
    }
 
    [[nodiscard]] const E &error() const
    {
        return result_.error();
    }
 
    [[nodiscard]] const std::vector<std::unique_ptr<Error>> &chain() const
    {
        return error_chain_;
    }
 
  protected:
    // Protected default constructor for use by the void specialization
    ChainableResult() = default;
 
  private:
    std::expected<T, E> result_;
    std::vector<std::unique_ptr<Error>> error_chain_;
};
 
namespace detail {
// An empty struct to use as a placeholder for `void` in the ChainableResult specialization.
struct Empty {};
} // namespace detail
 
template <typename E>
class ChainableResult<void, E> : public ChainableResult<detail::Empty, E> {
    using Base = ChainableResult<detail::Empty, E>;
 
  public:
    ChainableResult() : Base{detail::Empty{}} {}
 
    ChainableResult(const E &error) : Base{error} {}
 
    template <typename CauseT, typename CauseE>
    explicit ChainableResult(const E &error, const ChainableResult<CauseT, CauseE> &cause_result)
        : Base{error, cause_result}
    {
    }
 
    template <typename CauseT, typename CauseE>
    explicit ChainableResult(const ChainableResult<CauseT, CauseE> &cause_result) : Base{cause_result}
    {
    }
 
    void value() &
    {
        Base::value();
    }
 
    void value() const &
    {
        Base::value();
    }
 
    void value() &&
    {
        std::move(*this).Base::value();
    }
};
 
#define PT_TRY_ASSIGN_CHAIN_ERR(var, expr, return_type, ...)                                                           \
    auto var##_result = (expr);                                                                                        \
    if (!var##_result.has_value()) {                                                                                   \
        return ChainableResult<return_type>{FormattableError{__VA_ARGS__}, var##_result};                              \
    }                                                                                                                  \
    auto var = std::move(var##_result).value();
 
#define PT_TRY_ASSIGN_PASS_ERR(var, expr, return_type)                                                                 \
    auto var##_result = (expr);                                                                                        \
    if (!var##_result.has_value()) {                                                                                   \
        return ChainableResult<return_type>{FormattableError{}, var##_result};                                         \
    }                                                                                                                  \
    auto var = std::move(var##_result).value();
 
#define PT_TRY_ASSIGN_PASS_SAME_ERR(var, expr)                                                                         \
    auto var##_result = (expr);                                                                                        \
    if (!var##_result.has_value()) {                                                                                   \
        return var##_result;                                                                                           \
    }                                                                                                                  \
    auto var = std::move(var##_result).value();
 
// Internal implementation detail - do not use directly
#define PT_DETAIL_TRY_CALL_CHAIN_ERR_EXPAND(expr, return_type, counter, ...)                                           \
    auto pt_try_call_result_##counter = (expr);                                                                        \
    if (!pt_try_call_result_##counter.has_value()) {                                                                   \
        return ChainableResult<return_type>{FormattableError{__VA_ARGS__}, pt_try_call_result_##counter};              \
    }
 
// Internal implementation detail - do not use directly
#define PT_DETAIL_TRY_CALL_CHAIN_ERR_IMPL(expr, return_type, counter, ...)                                             \
    PT_DETAIL_TRY_CALL_CHAIN_ERR_EXPAND(expr, return_type, counter, __VA_ARGS__)
 
#define PT_TRY_CALL_CHAIN_ERR(expr, return_type, ...)                                                                  \
    PT_DETAIL_TRY_CALL_CHAIN_ERR_IMPL(expr, return_type, __LINE__, __VA_ARGS__)
 
// Internal implementation detail - do not use directly
#define PT_DETAIL_TRY_CALL_PASS_ERR_EXPAND(expr, return_type, counter)                                                 \
    auto pt_try_call_result_##counter = (expr);                                                                        \
    if (!pt_try_call_result_##counter.has_value()) {                                                                   \
        return ChainableResult<return_type>{FormattableError{}, pt_try_call_result_##counter};                         \
    }
 
// Internal implementation detail - do not use directly
#define PT_DETAIL_TRY_CALL_PASS_ERR_IMPL(expr, return_type, counter)                                                   \
    PT_DETAIL_TRY_CALL_PASS_ERR_EXPAND(expr, return_type, counter)
 
#define PT_TRY_CALL_PASS_ERR(expr, return_type) PT_DETAIL_TRY_CALL_PASS_ERR_IMPL(expr, return_type, __LINE__)
 
// Internal implementation detail - do not use directly
#define PT_DETAIL_TRY_CALL_PASS_SAME_ERR_EXPAND(expr, counter)                                                         \
    auto pt_try_call_result_##counter = (expr);                                                                        \
    if (!pt_try_call_result_##counter.has_value()) {                                                                   \
        return pt_try_call_result_##counter;                                                                           \
    }
 
// Internal implementation detail - do not use directly
#define PT_DETAIL_TRY_CALL_PASS_SAME_ERR_IMPL(expr, counter) PT_DETAIL_TRY_CALL_PASS_SAME_ERR_EXPAND(expr, counter)
 
#define PT_TRY_CALL_PASS_SAME_ERR(expr) PT_DETAIL_TRY_CALL_PASS_SAME_ERR_IMPL(expr, __LINE__)
 
} // namespace porytiles