except.h

Go to the documentation of this file.

// Copyright (c) Space-ng, inc. All rights reserved.
 
#pragma once
#include <boost/stacktrace.hpp>
#include <fmt/format.h>
#include <fmt/ostream.h>
#include <tl/expected.hpp>
 
#include <stdexcept>
 
namespace sol3::log {
 
//
//
class ExceptionBase : public std::runtime_error {
 public:
  explicit ExceptionBase(
      std::string const& short_message,
      char const* file_name,
      int line_number,
      char const* function_name,
      boost::stacktrace::stacktrace stacktrace =
          boost::stacktrace::stacktrace{});
  std::string short_message;
  boost::stacktrace::stacktrace stacktrace;
  char const* file_name;
  int line_number;
  char const* function_name;
};
 
class ContractViolation : public ExceptionBase {
 public:
  explicit ContractViolation(
      std::string const& message,
      char const* file_name,
      int line_number,
      char const* function_name,
      boost::stacktrace::stacktrace stacktrace =
          boost::stacktrace::stacktrace{});
};
 
class InvalidResource : public ExceptionBase {
 public:
  explicit InvalidResource(
      std::string const& message,
      char const* file_name,
      int line_number,
      char const* function_name,
      boost::stacktrace::stacktrace stacktrace =
          boost::stacktrace::stacktrace{});
};
 
namespace details {
 
template <class TWrapper, class TException>
struct UnwrapImpl {
  static auto impl(
      TWrapper&& wrapper,  // NOLINT
      char const* file,
      int line,
      char const* func,
      std::string msg) -> decltype(*std::forward<TWrapper>(wrapper)) {
    if (!bool(wrapper)) {
      throw TException(msg, file, line, func);
    }
    return *std::forward<TWrapper>(wrapper);
  }
};
 
template <class TT, class TE, class TException>
struct UnwrapImpl<tl::expected<TT, TE>, TException> {
  template <class TExpected>
  static auto impl(
      TExpected&& expected,  
      char const* file,
      int line,
      char const* func,
      std::string msg) -> decltype(*std::forward<TExpected>(expected)) {
    if (!bool(expected)) {
      msg += fmt::format("\nUnexpected: {}", expected.error());
      throw TException(msg, file, line, func);
    }
    return *std::forward<TExpected>(expected);
  }
};
 
template <class TT, class TE, class TException>
struct UnwrapImpl<tl::expected<TT, TE>&, TException>
    : UnwrapImpl<tl::expected<TT, TE>, TException> {};
 
template <class TT, class TE, class TException>
struct UnwrapImpl<tl::expected<TT, TE> const&, TException>
    : UnwrapImpl<tl::expected<TT, TE>, TException> {};
 
template <class TT, class TE, class TException>
struct UnwrapImpl<tl::expected<TT, TE>&&, TException>
    : UnwrapImpl<tl::expected<TT, TE>, TException> {};
 
template <class TContainer, class TKey, class TException>
auto checkedGetFromAssociativeContainer(
    TContainer& container,
    TKey const& key,
    char const* container_cstr,
    char const* key_cstr,
    char const* file,
    int line,
    char const* func,
    std::string msg) -> decltype(*(container.find(key))) {
  auto it = container.find(key);
  if (it == container.end()) {
    msg += fmt::format(
        "SOL3_GET key `{}` (={}) not in associative container `{}` of "
        "size "
        "`{}`",
        key_cstr,
        key,
        container_cstr,
        container.size());
    throw TException(msg, file, line, func);
  }
 
  return *it;
}
 
template <class TContainer, class TException>
auto checkedAtContiguousContainer(
    TContainer& container,
    size_t index,
    char const* container_cstr,
    char const* index_cstr,
    char const* file,
    int line,
    char const* func,
    std::string msg) -> decltype(container[index]) {
  if (index >= container.size()) {
    msg += fmt::format(
        "SOL3_AT index `{}` (={}) not in contiguous container `{}` of "
        "size "
        "`{}`",
        index_cstr,
        index,
        container_cstr,
        container.size());
    throw TException(msg, file, line, func);
  }
  return container[index];
}
 
}  // namespace details
}  // namespace sol3::log
 
#define SOL3_THROW(TException, ...) /* NOLINT*/ \
  throw TException(                             \
      ::fmt::format(__VA_ARGS__),               \
      __FILE__,                                 \
      __LINE__,                                 \
      (char const*)(__PRETTY_FUNCTION__))
 
//
//
//
//
#define SOL3_UNWRAP_OR_THROW(expression, TException)                          \
  ::sol3::log::details::UnwrapImpl<decltype((expression)), TException>::impl( \
      std::forward<decltype((expression))>(expression),                       \
      __FILE__,                                                               \
      __LINE__,                                                               \
      (char const*)(__PRETTY_FUNCTION__),                                     \
      ::fmt::format(                                                          \
          "[SOL3_UNWRAP_OR_THROW] called unwrap on an invalid `{}`",          \
          #expression))
 
// NOLINTNEXTLINE: macro because we want __FILE__ and __LINE__
#define SOL3_UNWRAP(expression) \
  SOL3_UNWRAP_OR_THROW(expression, ::sol3::log::ContractViolation)
 
// NOLINTNEXTLINE: macro because we want __FILE__ and __LINE__
#define SOL3_PANIC(...)               \
  SOL3_THROW(                         \
      ::sol3::log::ContractViolation, \
      "SOL3_PANIC({})",               \
      ::fmt::format(__VA_ARGS__));
 
#define SOL3_EXPECT(condition, ...)       \
  do {                                    \
    if (!(condition)) {                   \
      SOL3_THROW(                         \
          ::sol3::log::ContractViolation, \
          "SOL3_EXPECT({}, {})",          \
          #condition,                     \
          ::fmt::format(__VA_ARGS__));    \
    }                                     \
  } while (0)
 
#define SOL3_IMPL_EXPECT_OP(symbol, name_str, lhs, rhs, ...) \
  do {                                                       \
    if (!((lhs)symbol(rhs))) {                               \
      SOL3_THROW(                                            \
          ::sol3::log::ContractViolation,                    \
          "SOL3_EXPECT_{}({} {} {})\n{}\nvs.\n{}\n{}",       \
          name_str,                                          \
          #lhs,                                              \
          #symbol,                                           \
          #rhs,                                              \
          lhs,                                               \
          rhs,                                               \
          ::fmt::format(__VA_ARGS__));                       \
    }                                                        \
  } while (false)
 
#define SOL3_EXPECT_EQ(lhs, rhs, ...) /*NOLINT*/ \
  SOL3_IMPL_EXPECT_OP(==, "EQ", lhs, rhs, __VA_ARGS__)
 
#define SOL3_EXPECT_NE(lhs, rhs, ...) /*NOLINT*/ \
  SOL3_IMPL_EXPECT_OP(!=, "NE", lhs, rhs, __VA_ARGS__)
 
#define SOL3_EXPECT_LE(lhs, rhs, ...) /*NOLINT*/ \
  SOL3_IMPL_EXPECT_OP(<=, "LE", lhs, rhs, __VA_ARGS__)
 
#define SOL3_EXPECT_LT(lhs, rhs, ...) /*NOLINT*/ \
  SOL3_IMPL_EXPECT_OP(<, "LT", lhs, rhs, __VA_ARGS__)
 
#define SOL3_EXPECT_GE(lhs, rhs, ...) /*NOLINT*/ \
  SOL3_IMPL_EXPECT_OP(>=, "GE", lhs, rhs, __VA_ARGS__)
 
#define SOL3_EXPECT_GT(lhs, rhs, ...) /*NOLINT*/ \
  SOL3_IMPL_EXPECT_OP(>, "GT", lhs, rhs, __VA_ARGS__)
 
//
// NOLINTNEXTLINE: macro because we want __FILE__ and __LINE__
#define SOL3_GET_OR_THROW(associative_container, key, TException, ...) \
  ::sol3::log::details::checkedGetFromAssociativeContainer<            \
      decltype((associative_container)),                               \
      decltype((key)),                                                 \
      TException>(                                                     \
      associative_container,                                           \
      key,                                                             \
      #associative_container,                                          \
      #key,                                                            \
      __FILE__,                                                        \
      __LINE__,                                                        \
      __func__, /*NOLINT*/                                             \
      ::fmt::format(__VA_ARGS__))
 
//
// NOLINTNEXTLINE: macro because we want __FILE__ and __LINE__
#define SOL3_GET(associative_container, key, ...) \
  SOL3_GET_OR_THROW(                              \
      associative_container, key, ::sol3::log::ContractViolation, __VA_ARGS__)
 
// NOLINTNEXTLINE: macro because we want __FILE__ and __LINE__
#define SOL3_AT_OR_THROW(contiguous_container, index, TException, ...) \
  ::sol3::log::details::checkedAtContiguousContainer<                  \
      decltype((contiguous_container)),                                \
      TException>(                                                     \
      contiguous_container,                                            \
      index,                                                           \
      #contiguous_container,                                           \
      #index,                                                          \
      __FILE__,                                                        \
      __LINE__,                                                        \
      __func__, /*NOLINT*/                                             \
      ::fmt::format(__VA_ARGS__))
 
// NOLINTNEXTLINE: macro because we want __FILE__ and __LINE__
#define SOL3_AT(contiguous_container, index, ...) \
  SOL3_AT_OR_THROW(                               \
      contiguous_container,                       \
      index,                                      \
      ::sol3::log::ContractViolation,             \
      __VA_ARGS__)