types/memory.hh

Go to the documentation of this file.

 
#ifndef WASMTIME_TYPES_MEMORY_HH
#define WASMTIME_TYPES_MEMORY_HH
 
#include <memory>
#include <optional>
#include <wasm.h>
#include <wasmtime/error.hh>
#include <wasmtime/memory.h>
 
namespace wasmtime {
 
class MemoryType {
  friend class Memory;
 
  struct deleter {
    void operator()(wasm_memorytype_t *p) const {
      assert(p != nullptr);
      wasm_memorytype_delete(p);
    }
  };
 
  std::unique_ptr<wasm_memorytype_t, deleter> ptr;
 
public:
  class Ref {
    friend class MemoryType;
 
    const wasm_memorytype_t *ptr;
 
  private:
    Ref() : ptr(nullptr) {}
 
  public:
    Ref(const wasm_memorytype_t *ptr) : ptr(ptr) {}
    Ref(const MemoryType &ty) : Ref(ty.ptr.get()) {}
 
    uint64_t min() const { return wasmtime_memorytype_minimum(ptr); }
 
    std::optional<uint64_t> max() const {
      uint64_t max = 0;
      auto present = wasmtime_memorytype_maximum(ptr, &max);
      if (present) {
        return max;
      }
      return std::nullopt;
    }
 
    bool is_64() const { return wasmtime_memorytype_is64(ptr); }
 
    bool is_shared() const { return wasmtime_memorytype_isshared(ptr); }
 
    uint64_t page_size() const { return wasmtime_memorytype_page_size(ptr); }
 
    uint8_t page_size_log2() const {
      return wasmtime_memorytype_page_size_log2(ptr);
    }
  };
 
private:
  Ref ref;
  MemoryType(wasm_memorytype_t *ptr) : ptr(ptr), ref(ptr) {}
 
public:
  static Result<MemoryType> create(uint32_t min,
                                   std::optional<uint32_t> max = std::nullopt) {
    return Builder().min(min).max(max).build();
  }
 
  static Result<MemoryType>
  create64(uint64_t min, std::optional<uint64_t> max = std::nullopt) {
    return Builder().min(min).max(max).memory64(true).build();
  }
 
  MemoryType(Ref other) : MemoryType(wasm_memorytype_copy(other.ptr)) {}
  MemoryType(const MemoryType &other)
      : MemoryType(wasm_memorytype_copy(other.ptr.get())) {}
  MemoryType &operator=(const MemoryType &other) {
    ptr.reset(wasm_memorytype_copy(other.ptr.get()));
    ref = ptr.get();
    return *this;
  }
  ~MemoryType() = default;
  MemoryType(MemoryType &&other) = default;
  MemoryType &operator=(MemoryType &&other) = default;
 
  Ref *operator->() { return &ref; }
  Ref *operator*() { return &ref; }
 
  class Builder {
    uint64_t _min;
    std::optional<uint64_t> _max;
    bool _memory64;
    bool _shared;
    uint8_t _page_size_log2;
 
  public:
    Builder()
        : _min(0), _memory64(false), _shared(false), _page_size_log2(16) {}
 
    Builder &min(uint64_t min) {
      _min = min;
      return *this;
    }
 
    Builder &max(std::optional<uint64_t> max) {
      _max = max;
      return *this;
    }
 
    Builder &memory64(bool enable) {
      _memory64 = enable;
      return *this;
    }
 
    Builder &shared(bool enable) {
      _shared = enable;
      return *this;
    }
 
    Builder &page_size_log2(uint8_t page_size_log2) {
      _page_size_log2 = page_size_log2;
      return *this;
    }
 
    Result<MemoryType> build() const {
      wasm_memorytype_t *p = nullptr;
      auto *err = wasmtime_memorytype_new(
          _min, _max.has_value(), _max.has_value() ? *_max : 0, _memory64,
          _shared, _page_size_log2, &p);
      if (err != nullptr) {
        return Error(err);
      }
      assert(p != nullptr);
      return MemoryType(p);
    }
  };
};
 
}; // namespace wasmtime
 
#endif // WASMTIME_TYPES_MEMORY_HH