result.h

Go to the documentation of this file.

 
#pragma once
 
#include <expected>
#include <string>
#include <utility>
 
#include <rex/types.h>
 
namespace rex {

enum class ErrorCategory : u8 {
  kNoError,
  kIO,
  kMemory, 
  kFormat, 
  kCrypto, 
  kCompression,
  kRuntime, 
  kPlatform,
  kConfig,
  kValidation, 
  kNotFound,
  kNotImplemented,
  kModule, 
};

struct Error {
  ErrorCategory category = ErrorCategory::kNoError;
  std::string message;
  int code = 0; 
 
  Error() = default;

  Error(ErrorCategory cat, std::string msg, int err_code = 0)
      : category(cat), message(std::move(msg)), code(err_code) {}
 
  static Error FromErrno(ErrorCategory cat, std::string msg, int errno_value) {
    return Error(cat, std::move(msg), errno_value);
  }

  [[nodiscard]] bool IsSuccess() const noexcept { return category == ErrorCategory::kNoError; }

  [[nodiscard]] std::string GetDescription() const {
    if (IsSuccess()) {
      return "Success";
    }
    std::string result = message;
    if (code != 0) {
      result += " (code " + std::to_string(code) + ")";
    }
    return result;
  }
};

template <typename T>
using Result = std::expected<T, Error>;

template <typename T>
[[nodiscard]] inline Result<T> Ok(T&& value) {
  return Result<T>(std::forward<T>(value));
}

[[nodiscard]] inline Result<void> Ok() {
  return Result<void>();
}

template <typename T = void>
inline auto Err(Error error) {
  if constexpr (std::is_void_v<T>) {
    return Result<void>(std::unexpected(std::move(error)));
  } else {
    return Result<T>(std::unexpected(std::move(error)));
  }
}

template <typename T = void>
inline auto Err(ErrorCategory category, std::string message, int code = 0) {
  return Err<T>(Error(category, std::move(message), code));
}
 
}  // namespace rex

#define REX_TRY_PASTE(a, b) a##b

#define REX_TRY_EXPAND_PASTE(a, b) REX_TRY_PASTE(a, b)

// NOLINTBEGIN(bugprone-macro-parentheses): decl is a declaration
#define REX_TRY(decl, expr)                                                               \
  auto REX_TRY_EXPAND_PASTE(_rex_try_, __LINE__) = (expr);                                \
  if (!REX_TRY_EXPAND_PASTE(_rex_try_, __LINE__)) {                                       \
    return std::unexpected(std::move(REX_TRY_EXPAND_PASTE(_rex_try_, __LINE__)).error()); \
  }                                                                                       \
  decl = *std::move(REX_TRY_EXPAND_PASTE(_rex_try_, __LINE__))
// NOLINTEND(bugprone-macro-parentheses)

#define REX_TRY_VOID(expr)                                        \
  do {                                                            \
    auto&& _rex_try_status = (expr);                              \
    if (!_rex_try_status) {                                       \
      return std::unexpected(std::move(_rex_try_status).error()); \
    }                                                             \
  } while (0)

#define REX_ERROR_IF(cond, error)    \
  do {                               \
    if (cond) {                      \
      return std::unexpected(error); \
    }                                \
  } while (0)