helpers.hh

#ifndef WASMTIME_HELPERS_HH
#define WASMTIME_HELPERS_HH
 
#include <memory>
 
#define WASMTIME_OWN_WRAPPER(name, capi_type)                                  \
public:                                                                        \
                                                                          \
  using Raw = capi_type##_t;                                                   \
                                                                               \
private:                                                                       \
  struct deleter {                                                             \
    void operator()(Raw *p) const { capi_type##_delete(p); }                   \
  };                                                                           \
                                                                               \
  std::unique_ptr<Raw, deleter> ptr;                                           \
                                                                               \
public:                                                                        \
                                                                          \
  explicit name(Raw *raw) : ptr(raw) {}                                        \
                                                                               \
  ~name() = default;                                                           \
                                                                               \
                                                                          \
  name(name &&other) = default;                                                \
                                                                               \
                                                                          \
  name &operator=(name &&other) = default;                                     \
                                                                               \
                                                                          \
  const Raw *capi() const { return ptr.get(); }                                \
                                                                               \
                                                                          \
  Raw *capi() { return ptr.get(); }                                            \
                                                                               \
                                                                          \
  Raw *capi_release() { return ptr.release(); }                                \
                                                                               \
                                                                          \
  static const name *from_capi(Raw *const *capi) {                             \
    static_assert(sizeof(name) == sizeof(void *));                             \
    return reinterpret_cast<const name *>(capi);                               \
  }
 
#define WASMTIME_CLONE_WRAPPER(name, capi_type)                                \
  WASMTIME_OWN_WRAPPER(name, capi_type)                                        \
                                                                               \
public:                                                                        \
                                                                          \
  name(const name &other) : ptr(capi_type##_clone(other.ptr.get())) {}         \
                                                                               \
                                                                          \
  name &operator=(const name &other) {                                         \
    ptr.reset(capi_type##_clone(other.ptr.get()));                             \
    return *this;                                                              \
  }
 
#define WASMTIME_CLONE_EQUAL_WRAPPER(name, capi_type)                          \
  WASMTIME_CLONE_WRAPPER(name, capi_type)                                      \
                                                                               \
                                                                          \
  bool operator==(const name &other) const {                                   \
    return capi_type##_equal(ptr.get(), other.ptr.get());                      \
  }                                                                            \
                                                                               \
                                                                          \
  bool operator!=(const name &other) const { return !(*this == other); }
 
#endif // WASMTIME_HELPERS_HH