types/_val_class.hh

#ifndef WASMTIME_TYPES_VAL_CLASS_HH
#define WASMTIME_TYPES_VAL_CLASS_HH
 
#include <memory>
#include <wasm.h>
#include <wasmtime/engine.hh>
#include <wasmtime/types/val.h>
#include <wasmtime/val.h>
 
namespace wasmtime {
 
class RefType;
 
class ValType {
  friend class TableType;
  friend class GlobalType;
  friend class FuncType;
  struct deleter {
    void operator()(wasm_valtype_t *p) const { wasm_valtype_delete(p); }
  };
 
  std::unique_ptr<wasm_valtype_t, deleter> ptr;
 
public:
  class Ref {
    friend class ValType;
 
    const wasm_valtype_t *ptr;
 
  public:
    Ref(const wasm_valtype_t *ptr) : ptr(ptr) {}
    Ref(const ValType &ty) : Ref(ty.ptr.get()) {}
 
    bool operator==(const Ref &other) const {
      return wasmtime_wasm_valtype_equal(ptr, other.ptr);
    }
  };
 
  class ListRef {
    const wasm_valtype_vec_t *list;
 
  public:
    ListRef(const wasm_valtype_vec_t *list) : list(list) {}
 
    typedef const Ref *iterator;
 
    iterator begin() const {
      return reinterpret_cast<Ref *>(&list->data[0]); // NOLINT
    }
 
    iterator end() const {
      return reinterpret_cast<Ref *>(&list->data[list->size]); // NOLINT
    }
 
    size_t size() const { return list->size; }
  };
 
private:
  Ref ref;
  wasmtime_valtype_t wasmtime_ty;
  ValType(wasm_valtype_t *ptr) : ptr(ptr), ref(ptr) {
    wasmtime_valtype_new(ptr, &wasmtime_ty);
  }
  ValType(wasmtime_valtype_t *ty)
      : ptr(wasmtime_valtype_to_wasm(nullptr, ty)), ref(nullptr),
        wasmtime_ty(*ty) {
    ref = ptr.get();
  }
 
public:
  ValType(Ref other) : ValType(wasm_valtype_copy(other.ptr)) {}
  ValType(const ValType &other) : ValType(wasm_valtype_copy(other.ptr.get())) {}
  ValType &operator=(const ValType &other) {
    ptr.reset(wasm_valtype_copy(other.ptr.get()));
    ref = ptr.get();
    wasmtime_valtype_delete(&wasmtime_ty);
    wasmtime_valtype_clone(&other.wasmtime_ty, &wasmtime_ty);
    return *this;
  }
  ~ValType() { wasmtime_valtype_delete(&wasmtime_ty); }
  ValType(ValType &&other) : ptr(std::move(other.ptr)), ref(ptr.get()) {
    wasmtime_ty = other.wasmtime_ty;
    other.ref = nullptr;
    other.wasmtime_ty.kind = WASMTIME_VALTYPE_KIND_I32;
  }
  ValType &operator=(ValType &&other) {
    ptr = std::move(other.ptr);
    ref = ptr.get();
    wasmtime_ty = other.wasmtime_ty;
    other.ref = nullptr;
    other.wasmtime_ty.kind = WASMTIME_VALTYPE_KIND_I32;
    return *this;
  }
 
  static ValType i32() { return ValType(wasm_valtype_new(WASM_I32)); }
 
  static ValType i64() { return ValType(wasm_valtype_new(WASM_I64)); }
 
  static ValType f32() { return ValType(wasm_valtype_new(WASM_F32)); }
 
  static ValType f64() { return ValType(wasm_valtype_new(WASM_F64)); }
 
  static ValType v128() {
    wasmtime_valtype_t ty;
    ty.kind = WASMTIME_VALTYPE_KIND_V128;
    return ValType(&ty);
  }
 
  static ValType funcref() { return ValType(wasm_valtype_new(WASM_FUNCREF)); }
 
  static ValType externref() {
    return ValType(wasm_valtype_new(WASM_EXTERNREF));
  }
 
  static ValType anyref();
 
  static ValType exnref();
 
  ValType(const Engine &engine, const RefType &ref_type);
 
  Ref *operator->() { return &ref; }
  Ref *operator*() { return &ref; }
 
  bool operator==(const Ref &other) const {
    return wasmtime_wasm_valtype_equal(ptr.get(), other.ptr);
  }
 
  bool operator==(const ValType &other) const {
    return wasmtime_wasm_valtype_equal(ptr.get(), other.ptr.get());
  }
 
  const wasmtime_valtype_t *wasmtime_capi() const { return &wasmtime_ty; }
 
  const wasm_valtype_t *capi() const { return ptr.get(); }
 
  bool is_i32() const { return wasmtime_ty.kind == WASMTIME_VALTYPE_KIND_I32; }
 
  bool is_i64() const { return wasmtime_ty.kind == WASMTIME_VALTYPE_KIND_I64; }
 
  bool is_f32() const { return wasmtime_ty.kind == WASMTIME_VALTYPE_KIND_F32; }
 
  bool is_f64() const { return wasmtime_ty.kind == WASMTIME_VALTYPE_KIND_F64; }
 
  bool is_v128() const {
    return wasmtime_ty.kind == WASMTIME_VALTYPE_KIND_V128;
  }
 
  const RefType *as_ref() const;
};
 
}; // namespace wasmtime
 
#endif // WASMTIME_TYPES_VAL_CLASS_HH