component/component.hh

Go to the documentation of this file.

 
#ifndef WASMTIME_COMPONENT_COMPONENT_HH
#define WASMTIME_COMPONENT_COMPONENT_HH
 
#include <wasmtime/conf.h>
 
#ifdef WASMTIME_FEATURE_COMPONENT_MODEL
 
#include <memory>
#include <optional>
#include <string_view>
#include <vector>
#include <wasmtime/component/component.h>
#include <wasmtime/component/types/component.hh>
#include <wasmtime/engine.hh>
#include <wasmtime/error.hh>
#include <wasmtime/span.hh>
#include <wasmtime/wat.hh>
 
namespace wasmtime {
namespace component {
 
class ExportIndex {
  WASMTIME_CLONE_WRAPPER(ExportIndex, wasmtime_component_export_index);
};
 
class Component {
  WASMTIME_CLONE_WRAPPER(Component, wasmtime_component);
 
#ifdef WASMTIME_FEATURE_COMPILER
 
#ifdef WASMTIME_FEATURE_WAT
  static Result<Component> compile(Engine &engine, std::string_view wat) {
    auto wasm = wat2wasm(wat);
    if (!wasm) {
      return wasm.err();
    }
    auto bytes = wasm.ok();
    return compile(engine, bytes);
  }
#endif // WASMTIME_FEATURE_WAT
 
  static Result<Component> compile(Engine &engine, Span<uint8_t> wasm) {
    wasmtime_component_t *ret = nullptr;
    auto *error =
        wasmtime_component_new(engine.capi(), wasm.data(), wasm.size(), &ret);
    if (error != nullptr) {
      return Error(error);
    }
    return Component(ret);
  }
#endif // WASMTIME_FEATURE_COMPILER
 
  static Result<Component> deserialize(Engine &engine, Span<uint8_t> wasm) {
    wasmtime_component_t *ret = nullptr;
    auto *error = wasmtime_component_deserialize(engine.capi(), wasm.data(),
                                                 wasm.size(), &ret);
    if (error != nullptr) {
      return Error(error);
    }
    return Component(ret);
  }
 
  static Result<Component> deserialize_file(Engine &engine,
                                            const std::string &path) {
    wasmtime_component_t *ret = nullptr;
    auto *error =
        wasmtime_component_deserialize_file(engine.capi(), path.c_str(), &ret);
    if (error != nullptr) {
      return Error(error);
    }
    return Component(ret);
  }
 
#ifdef WASMTIME_FEATURE_COMPILER
  Result<std::vector<uint8_t>> serialize() const {
    wasm_byte_vec_t bytes;
    auto *error = wasmtime_component_serialize(ptr.get(), &bytes);
    if (error != nullptr) {
      return Error(error);
    }
    std::vector<uint8_t> ret;
    Span<uint8_t> raw(reinterpret_cast<uint8_t *>(bytes.data), bytes.size);
    ret.assign(raw.begin(), raw.end());
    wasm_byte_vec_delete(&bytes);
    return ret;
  }
#endif // WASMTIME_FEATURE_COMPILER
 
  std::optional<ExportIndex> export_index(ExportIndex *instance,
                                          std::string_view name) {
    auto ret = wasmtime_component_get_export_index(
        capi(), instance ? instance->capi() : nullptr, name.data(),
        name.size());
    if (ret) {
      return ExportIndex(ret);
    }
    return std::nullopt;
  };
 
  ComponentType type() const {
    return ComponentType(wasmtime_component_type(ptr.get()));
  }
};
 
} // namespace component
} // namespace wasmtime
 
#endif // WASMTIME_FEATURE_COMPONENT_MODEL
 
#endif // WASMTIME_COMPONENT_COMPONENT_HH