store.hh

Go to the documentation of this file.

 
#ifndef WASMTIME_STORE_HH
#define WASMTIME_STORE_HH
 
#include <any>
#include <memory>
#include <optional>
#include <wasmtime/conf.h>
#include <wasmtime/engine.hh>
#include <wasmtime/error.hh>
#include <wasmtime/store.h>
#include <wasmtime/wasi.hh>
 
namespace wasmtime {
 
class Caller;
 
class Store {
  struct deleter {
    void operator()(wasmtime_store_t *p) const { wasmtime_store_delete(p); }
  };
 
  std::unique_ptr<wasmtime_store_t, deleter> ptr;
 
  static void finalizer(void *ptr) {
    std::unique_ptr<std::any> _ptr(static_cast<std::any *>(ptr));
  }
 
public:
  explicit Store(Engine &engine)
      : ptr(wasmtime_store_new(engine.ptr.get(), nullptr, finalizer)) {}
 
  class Context {
    friend class Global;
    friend class Table;
    friend class Memory;
    friend class Func;
    friend class Instance;
    friend class Linker;
    friend class ExternRef;
    friend class AnyRef;
    friend class Val;
    friend class Store;
    wasmtime_context_t *ptr;
 
    Context(wasmtime_context_t *ptr) : ptr(ptr) {}
 
  public:
    Context(Store &store) : Context(wasmtime_store_context(store.ptr.get())) {}
    Context(Store *store) : Context(*store) {}
    Context(Caller &caller);
    Context(Caller *caller);
 
    void gc() { wasmtime_context_gc(ptr); }
 
    Result<std::monostate> set_fuel(uint64_t fuel) {
      auto *error = wasmtime_context_set_fuel(ptr, fuel);
      if (error != nullptr) {
        return Error(error);
      }
      return std::monostate();
    }
 
    Result<uint64_t> get_fuel() const {
      uint64_t fuel = 0;
      auto *error = wasmtime_context_get_fuel(ptr, &fuel);
      if (error != nullptr) {
        return Error(error);
      }
      return fuel;
    }
 
    void set_data(std::any data) const {
      finalizer(static_cast<std::any *>(wasmtime_context_get_data(ptr)));
      wasmtime_context_set_data(
          ptr, std::make_unique<std::any>(std::move(data)).release());
    }
 
    std::any &get_data() const {
      return *static_cast<std::any *>(wasmtime_context_get_data(ptr));
    }
 
#ifdef WASMTIME_FEATURE_WASI
    Result<std::monostate> set_wasi(WasiConfig config) {
      auto *error = wasmtime_context_set_wasi(ptr, config.ptr.release());
      if (error != nullptr) {
        return Error(error);
      }
      return std::monostate();
    }
#endif // WASMTIME_FEATURE_WASI
 
    void set_epoch_deadline(uint64_t ticks_beyond_current) {
      wasmtime_context_set_epoch_deadline(ptr, ticks_beyond_current);
    }
 
    wasmtime_context_t *raw_context() { return ptr; }
  };
 
  void limiter(int64_t memory_size, int64_t table_elements, int64_t instances,
               int64_t tables, int64_t memories) {
    wasmtime_store_limiter(ptr.get(), memory_size, table_elements, instances,
                           tables, memories);
  }
 
  Context context() { return this; }
};
 
} // namespace wasmtime
 
#endif // WASMTIME_STORE_HH