result.hpp

Go to the documentation of this file.

#pragma once
 
#include <boost/describe.hpp>
#include <boost/describe/enum_to_string.hpp>
#include <boost/outcome.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/stringize.hpp>
#include <filesystem>  // IWYU pragma: export
#include <optional>
#include <string>
#include <system_error>
 
#include "utils.hpp"  // IWYU pragma: export
 
namespace stax::result {
 
template <typename T>
struct is_error_enum : std::false_type {};
 
template <typename T>
concept IsErrorCode = requires { make_error_code(T{}); };
 
class Err {
 public:
  template <IsErrorCode T>
  Err(const T& ec, const std::optional<std::string>& msg = {})
      : ec_(make_error_code(ec)), extra_msg_(msg) {}
 
  Err(const std::error_code& ec, const std::optional<std::string>& msg = {})
      : ec_(ec), extra_msg_(msg) {}
 
  template <IsErrorCode T>
  auto operator==(const T& ec) const {
    return ec_ == make_error_code(ec);
  }
 
  template <IsErrorCode T>
  auto operator!=(const T& ec) const {
    return !(ec_ == ec);
  }
 
  auto Code() {
    return ec_;
  }
 
  auto message() {
    return extra_msg_;
  }
 
 private:
  std::error_code ec_;
  std::optional<std::string> extra_msg_;
 
  BOOST_DESCRIBE_CLASS(Err, (), (), (), (ec_, extra_msg_));
};
 
inline auto Ok() {
  return boost::outcome_v2::success();
}
 
}  // namespace stax::result
 
namespace stax {
 
template <typename T>
using result_t =
    boost::outcome_v2::result<T, result::Err,
                              boost::outcome_v2::policy::terminate>;
 
}
 
#define DEFINE_ERROR_IMPL(module_name, ERROR_ENUM)                      \
  class ERROR_ENUM##_category_t : public std::error_category {          \
   public:                                                              \
    const char* name() const noexcept override {                        \
      return (module_name BOOST_PP_STRINGIZE(_##ERROR_ENUM));           \
    }                                                                   \
    std::string message(int32_t e) const override {                     \
      const auto ec = static_cast<ERROR_ENUM>(e);                       \
      return boost::describe::enum_to_string(ec, "");                   \
    }                                                                   \
  };                                                                    \
  inline auto ERROR_ENUM##_category()->const ERROR_ENUM##_category_t& { \
    static const ERROR_ENUM##_category_t e_cat{};                       \
    return e_cat;                                                       \
  }                                                                     \
  inline auto make_error_code(ERROR_ENUM ec) -> std::error_code {       \
    return {static_cast<int32_t>(ec), ERROR_ENUM##_category()};         \
  }
 
#define DEFINE_ERROR(module_name, name, ...) \
  BOOST_DEFINE_ENUM_CLASS(name, __VA_ARGS__) \
  DEFINE_ERROR_IMPL(module_name, name)
 
#define RESULT_UNIQUE_NAME() BOOST_PP_CAT(__result_, __COUNTER__)
 
#define TRY_RESULT(...) BOOST_OUTCOME_TRY(__VA_ARGS__)
 
#define TRY_RESULT_IMPL(unique_name, expr, alt) \
  auto unique_name = expr;                      \
  alt
 
#define TRY_RESULT_OR(expr, alt) \
  TRY_RESULT_IMPL(RESULT_UNIQUE_NAME(), expr, alt)
 
// inline const std::string mod = GET_MODULE_NAME()