types/table.hh

Go to the documentation of this file.

 
#ifndef WASMTIME_TYPES_TABLE_HH
#define WASMTIME_TYPES_TABLE_HH
 
#include <optional>
#include <wasmtime/error.hh>
#include <wasmtime/table.h>
#include <wasmtime/types/val.hh>
 
namespace wasmtime {
 
class TableType {
  friend class Table;
 
  struct deleter {
    void operator()(wasm_tabletype_t *p) const { wasm_tabletype_delete(p); }
  };
 
  std::unique_ptr<wasm_tabletype_t, deleter> ptr;
 
public:
  class Ref {
    friend class TableType;
 
    const wasm_tabletype_t *ptr;
 
  public:
    Ref(const wasm_tabletype_t *ptr) : ptr(ptr) {}
    Ref(const TableType &ty) : Ref(ty.ptr.get()) {}
 
    uint64_t min() const { return wasmtime_tabletype_minimum(ptr); }
 
    std::optional<uint64_t> max() const {
      uint64_t max = 0;
      if (wasmtime_tabletype_maximum(ptr, &max)) {
        return max;
      }
      return std::nullopt;
    }
 
    bool is_64() const { return wasmtime_tabletype_is64(ptr); }
 
    ValType::Ref element() const { return wasm_tabletype_element(ptr); }
  };
 
private:
  Ref ref;
  TableType(wasm_tabletype_t *ptr) : ptr(ptr), ref(ptr) {}
 
public:
  static Result<TableType> create(ValType ty, uint32_t min,
                                  std::optional<uint32_t> max = std::nullopt) {
    wasm_limits_t limits;
    limits.min = min;
    limits.max = max.value_or(wasm_limits_max_default);
    wasm_tabletype_t *ptr = wasm_tabletype_new(ty.ptr.release(), &limits);
    if (ptr == nullptr) {
      return Error("invalid table type");
    }
    return TableType(ptr);
  }
  TableType(Ref other) : TableType(wasm_tabletype_copy(other.ptr)) {}
  TableType(const TableType &other)
      : TableType(wasm_tabletype_copy(other.ptr.get())) {}
  TableType &operator=(const TableType &other) {
    ptr.reset(wasm_tabletype_copy(other.ptr.get()));
    ref = ptr.get();
    return *this;
  }
  ~TableType() = default;
  TableType(TableType &&other) = default;
  TableType &operator=(TableType &&other) = default;
 
  Ref *operator->() { return &ref; }
  Ref *operator*() { return &ref; }
};
 
}; // namespace wasmtime
 
#endif // WASMTIME_TYPES_TABLE_HH