error.hh

Go to the documentation of this file.

 
#ifndef WASMTIME_ERROR_HH
#define WASMTIME_ERROR_HH
 
#include <memory>
#include <optional>
#include <string>
#include <variant>
#include <wasmtime/error.h>
 
namespace wasmtime {
 
class Trace;
 
class Error {
  struct deleter {
    void operator()(wasmtime_error_t *p) const { wasmtime_error_delete(p); }
  };
 
  std::unique_ptr<wasmtime_error_t, deleter> ptr;
 
public:
  Error(wasmtime_error_t *error) : ptr(error) {}
 
  Error(const std::string &s) : ptr(wasmtime_error_new(s.c_str())) {}
 
  std::string message() const {
    wasm_byte_vec_t msg_bytes;
    wasmtime_error_message(ptr.get(), &msg_bytes);
    auto ret = std::string(msg_bytes.data, msg_bytes.size);
    wasm_byte_vec_delete(&msg_bytes);
    return ret;
  }
 
  std::optional<int32_t> i32_exit() const {
    int32_t status = 0;
    if (wasmtime_error_exit_status(ptr.get(), &status)) {
      return status;
    }
    return std::nullopt;
  }
 
  Trace trace() const;
 
  wasmtime_error_t *release() {
    return ptr.release();
  }
};
 
inline std::ostream &operator<<(std::ostream &os, const Error &e) {
  os << e.message();
  return os;
}
 
template <typename T, typename E = Error> class [[nodiscard]] Result {
  std::variant<T, E> data;
 
public:
  Result(T t) : data(std::move(t)) {}
  Result(E e) : data(std::move(e)) {}
 
  explicit operator bool() const { return data.index() == 0; }
 
  E &&err() { return std::get<E>(std::move(data)); }
  const E &&err() const { return std::get<E>(std::move(data)); }
 
  T &&ok() { return std::get<T>(std::move(data)); }
  const T &&ok() const { return std::get<T>(std::move(data)); }
 
  T unwrap() {
    if (*this) {
      return this->ok();
    }
    unwrap_failed();
  }
 
private:
  [[noreturn]] void unwrap_failed() {
    fprintf(stderr, "error: %s\n", this->err().message().c_str()); // NOLINT
    std::abort();
  }
};
 
} // namespace wasmtime
 
#endif // WASMTIME_ERROR_HH