types/_structref_class.hh

#ifndef WASMTIME_TYPES_STRUCTREF_CLASS_HH
#define WASMTIME_TYPES_STRUCTREF_CLASS_HH
 
#include <wasmtime/conf.h>
 
#ifdef WASMTIME_FEATURE_GC
 
#include <memory>
#include <vector>
#include <wasmtime/engine.hh>
#include <wasmtime/error.hh>
#include <wasmtime/types/_val_class.hh>
#include <wasmtime/types/structref.h>
 
namespace wasmtime {
 
class StorageType {
  wasmtime_storage_type_t ty;
 
  StorageType(wasmtime_storage_type_kind_t kind) { ty.kind = kind; }
 
public:
  StorageType(const StorageType &other) {
    wasmtime_storage_type_clone(&other.ty, &ty);
  }
  StorageType &operator=(const StorageType &other) {
    return *this = StorageType(other);
  }
  ~StorageType() { wasmtime_storage_type_delete(&ty); }
  StorageType(StorageType &&other) {
    ty = other.ty;
    other.ty.kind = WASMTIME_STORAGE_TYPE_KIND_I8;
  }
  StorageType &operator=(StorageType &&other) {
    wasmtime_storage_type_delete(&ty);
    ty = other.ty;
    other.ty.kind = WASMTIME_STORAGE_TYPE_KIND_I8;
    return *this;
  }
 
  StorageType(const ValType &ty);
 
  static StorageType i8() { return StorageType(WASMTIME_STORAGE_TYPE_KIND_I8); }
 
  static StorageType i16() {
    return StorageType(WASMTIME_STORAGE_TYPE_KIND_I16);
  }
 
  const wasmtime_storage_type_t *capi() const { return &ty; }
 
  bool is_i8() const { return ty.kind == WASMTIME_STORAGE_TYPE_KIND_I8; }
 
  bool is_i16() const { return ty.kind == WASMTIME_STORAGE_TYPE_KIND_I16; }
 
  std::optional<ValType::Ref> as_valtype() const {
    if (ty.kind == WASMTIME_STORAGE_TYPE_KIND_VALTYPE)
      return ty.valtype;
    return std::nullopt;
  }
};
 
class FieldType {
  wasmtime_field_type_t ty;
 
public:
  FieldType(wasmtime_field_type ty) : ty(ty) {}
 
  FieldType(const FieldType &other) {
    wasmtime_field_type_clone(&other.ty, &ty);
  }
  FieldType &operator=(const FieldType &other) {
    return *this = FieldType(other);
  }
  ~FieldType() { wasmtime_field_type_delete(&ty); }
  FieldType(FieldType &&other) {
    ty = other.ty;
    other.ty.storage.kind = WASMTIME_STORAGE_TYPE_KIND_I8;
  }
  FieldType &operator=(FieldType &&other) {
    wasmtime_field_type_delete(&ty);
    ty = other.ty;
    other.ty.storage.kind = WASMTIME_STORAGE_TYPE_KIND_I8;
    return *this;
  }
 
  FieldType(bool is_mutable, const StorageType &ty) {
    this->ty.mutable_ = is_mutable;
    wasmtime_storage_type_clone(ty.capi(), &this->ty.storage);
  }
 
  static FieldType mut_(const StorageType &ty) { return FieldType(true, ty); }
 
  static FieldType const_(const StorageType &ty) {
    return FieldType(false, ty);
  }
 
  bool is_mutable() const { return ty.mutable_; }
 
  const StorageType &storage_type() const {
    static_assert(sizeof(StorageType) == sizeof(wasmtime_storage_type_t));
    return *reinterpret_cast<const StorageType *>(&ty.storage);
  }
 
  const wasmtime_field_type_t *capi() const { return &ty; }
};
 
class StructType {
#define wasmtime_struct_type_clone wasmtime_struct_type_copy
  WASMTIME_CLONE_WRAPPER(StructType, wasmtime_struct_type)
#undef wasmtime_struct_type_clone
 
  static Result<StructType> create(const Engine &engine,
                                   const std::vector<FieldType> &fields) {
    static_assert(sizeof(FieldType) == sizeof(wasmtime_field_type_t));
    wasmtime_struct_type_t *result = nullptr;
    auto error = wasmtime_struct_type_new(
        engine.capi(),
        reinterpret_cast<const wasmtime_field_type_t *>(fields.data()),
        fields.size(), &result);
    if (error)
      return Error(error);
    return StructType(result);
  }
 
  size_t num_fields() const {
    return wasmtime_struct_type_num_fields(ptr.get());
  }
 
  std::optional<FieldType> field(size_t index) const {
    if (index >= wasmtime_struct_type_num_fields(ptr.get()))
      return std::nullopt;
    wasmtime_field_type_t ty;
    wasmtime_struct_type_field(ptr.get(), index, &ty);
    return FieldType(ty);
  }
};
 
} // namespace wasmtime
 
#endif // WASMTIME_FEATURE_GC
 
#endif // WASMTIME_TYPES_STRUCTREF_CLASS_HH