errors.hpp

Go to the documentation of this file.

#pragma once
 
#include <fmt/core.h>
#include <fmt/format.h>
#include <fmt/ostream.h>
 
#include <boost/preprocessor.hpp>
#include <optional>
#include <system_error>
#include <tl/expected.hpp>
 
#include "enums.hpp"
#include "macros.hpp"
 
namespace wren {
 
class Err {
 public:
  template <typename T>
  Err(T error) : error_code_(make_error_code(error)) {}
  Err(std::error_code const& ec) : error_code_(ec) {}
  Err(int32_t ec, std::error_category const& e_cat)
      : error_code_(ec, e_cat) {}
 
  [[nodiscard]] auto error() const { return error_code_; }
 
  [[nodiscard]] auto message() const { return error_code_.message(); }
 
  [[nodiscard]] auto extra_msg() const { return extra_message_; }
 
 private:
  std::error_code error_code_;
  std::optional<std::string> extra_message_;
};
 
// struct error_code : public std::error_code {
//   error_code(int32_t ec, std::error_category const& cat)
//       : ::error_code(ec, cat) {}
 
//   error_code(std::error_code ec) : std::error_code(ec) {}
 
//   friend auto operator<<(std::ostream& os, error_code const& ec)
//       -> std::ostream& {
//     return os << ec.category().name() << " : " << ec.message();
//   }
// };
 
template <typename T>
using expected = tl::expected<T, Err>;
 
}  // namespace wren
 
template <>
struct fmt::formatter<wren::Err> : fmt::formatter<std::string> {
  auto format(wren::Err, fmt::format_context& ctx) const
      -> decltype(ctx.out());
};
 
#define DEFINE_ERROR_IMPL(CAT_NAME, ERROR_ENUM)                     \
  class ERROR_ENUM##_category_t : public std::error_category {      \
   public:                                                          \
    [[nodiscard]] auto name() const noexcept -> const char* final { \
      return CAT_NAME;                                              \
    }                                                               \
    [[nodiscard]] auto message(int32_t c) const                     \
        -> std::string final {                                      \
      auto e = static_cast<ERROR_ENUM>(c);                          \
      using namespace boost::describe;                              \
      return std::string{enum_to_string(e)};                        \
    }                                                               \
  };                                                                \
  inline auto ERROR_ENUM##_category()                               \
      -> const ERROR_ENUM##_category_t& {                           \
    static const ERROR_ENUM##_category_t kC;                        \
    return kC;                                                      \
  }                                                                 \
  inline auto make_error_code(ERROR_ENUM ec) -> std::error_code {   \
    return {static_cast<int32_t>(ec), ERROR_ENUM##_category()};     \
  }
 
#define DEFINE_ERROR(cat_name, name, ...)     \
  BOOST_DEFINE_ENUM_CLASS(name, __VA_ARGS__); \
  DEFINE_ERROR_IMPL(cat_name, name)
 
#define RESULT_UNIQUE_NAME() BOOST_PP_CAT(__result_tmp, __COUNTER__)
 
#define TRY_RESULT_IMPL(unique, expr) \
  auto unique = (expr);               \
  if (!(unique).has_value())          \
    return tl::make_unexpected(unique.error());
 
#define TRY_RESULT_1(unique, expr) TRY_RESULT_IMPL(unique, expr)
#define TRY_RESULT_2(unique, out, expr) \
  TRY_RESULT_IMPL(unique, expr)         \
  out = (unique).value();
 
#define TRY_RESULT(...)                       \
  BOOST_PP_OVERLOAD(TRY_RESULT_, __VA_ARGS__) \
  (RESULT_UNIQUE_NAME(), __VA_ARGS__)
 
#define TRY_RESULT_VOID_IMPL(unique, expr) \
  auto unique = (expr);                    \
  if (!(unique).has_value()) return;
 
#define TRY_RESULT_VOID_1(unique, expr) \
  TRY_RESULT_VOID_IMPL(unique, expr)
#define TRY_RESULT_VOID_2(unique, out, expr) \
  TRY_RESULT_VOID_IMPL(unique, expr)         \
  out = (unique).value();
#define TRY_RESULT_VOID(...)                       \
  BOOST_PP_OVERLOAD(TRY_RESULT_VOID_, __VA_ARGS__) \
  (RESULT_UNIQUE_NAME(), __VA_ARGS__)
 
// NOLINTNEXTLINE
#define ERR_VAL_OR(out, err, on_err)         \
  const auto LINEIZE(res, __LINE__) = err;   \
  if (!LINEIZE(res, __LINE__).has_value()) { \
    on_err                                   \
  }                                          \
  out = LINEIZE(res, __LINE__).value();
 
// NOLINTNEXTLINE
#define ERR_VOID_OR(err, on_err)             \
  const auto LINEIZE(res, __LINE__) = err;   \
  if (!LINEIZE(res, __LINE__).has_value()) { \
    on_err                                   \
  }