_store_class.hh

#ifndef WASMTIME_STORE_CLASS_HH
#define WASMTIME_STORE_CLASS_HH
 
#include <any>
#include <memory>
#include <optional>
#include <wasmtime/conf.h>
#include <wasmtime/engine.hh>
#include <wasmtime/error.hh>
#include <wasmtime/helpers.hh>
#include <wasmtime/store.h>
#include <wasmtime/wasi.hh>
 
namespace wasmtime {
 
class Caller;
class Tag;
class ExnRef;
class Trap;
 
enum class DeadlineKind {
  Continue = WASMTIME_UPDATE_DEADLINE_CONTINUE,
  Yield = WASMTIME_UPDATE_DEADLINE_YIELD,
};
 
class Store {
  WASMTIME_OWN_WRAPPER(Store, wasmtime_store);
 
private:
  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.capi(), nullptr, finalizer)) {}
 
  class Context {
    friend class Global;
    friend class Table;
    friend class Memory;
    friend class Func;
    friend class Instance;
    friend class Linker;
    friend class Val;
    friend class Store;
    friend class Tag;
    wasmtime_context_t *ptr;
 
  public:
    explicit Context(wasmtime_context_t *ptr) : ptr(ptr) {}
 
    Context(Store &store) : Context(wasmtime_store_context(store.ptr.get())) {}
    Context(Store *store) : Context(*store) {}
    Context(Caller &caller);
    Context(Caller *caller);
 
#ifdef WASMTIME_FEATURE_GC
    Result<std::monostate> gc() {
      auto *error = wasmtime_context_gc(ptr);
      if (error != nullptr) {
        return Error(error);
      }
      return std::monostate();
    }
#endif
 
    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.capi_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);
    }
 
#ifdef WASMTIME_FEATURE_GC
    inline Trap throw_exception(ExnRef exn);
 
    inline std::optional<ExnRef> take_exception();
 
    inline bool has_exception();
#endif // WASMTIME_FEATURE_GC
 
    const wasmtime_context_t *capi() const { return ptr; }
 
    wasmtime_context_t *capi() { 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);
  }
 
  template <typename F,
            std::enable_if_t<std::is_invocable_r_v<Result<DeadlineKind>, F,
                                                   Context, uint64_t &>,
                             bool> = true>
  void epoch_deadline_callback(F &&f) {
    wasmtime_store_epoch_deadline_callback(
        ptr.get(), raw_epoch_callback<std::remove_reference_t<F>>,
        std::make_unique<std::remove_reference_t<F>>(std::forward<F>(f))
            .release(),
        raw_epoch_finalizer<std::remove_reference_t<F>>);
  }
 
  Context context() { return this; }
 
#ifdef WASMTIME_FEATURE_GC
  Result<std::monostate> gc() { return context().gc(); }
#endif
 
private:
  template <typename F>
  static wasmtime_error_t *
  raw_epoch_callback(wasmtime_context_t *context, void *data,
                     uint64_t *epoch_deadline_delta,
                     wasmtime_update_deadline_kind_t *update_kind) {
    auto &callback = *static_cast<F *>(data);
    Context ctx(context);
    auto result = callback(ctx, *epoch_deadline_delta);
 
    if (!result) {
      return result.err().capi_release();
    }
    *update_kind = static_cast<wasmtime_update_deadline_kind_t>(result.ok());
    return nullptr;
  }
 
  template <typename F> static void raw_epoch_finalizer(void *data) {
    std::unique_ptr<F> _ptr(static_cast<F *>(data));
  }
};
 
} // namespace wasmtime
 
#endif // WASMTIME_STORE_CLASS_HH