component/types/component.hh

Go to the documentation of this file.

 
#ifndef WASMTIME_COMPONENT_TYPES_COMPONENT_HH
#define WASMTIME_COMPONENT_TYPES_COMPONENT_HH
 
#include <wasmtime/conf.h>
 
#ifdef WASMTIME_FEATURE_COMPONENT_MODEL
 
#include <memory>
#include <optional>
#include <string>
#include <wasmtime/component/types/component.h>
#include <wasmtime/engine.hh>
#include <wasmtime/helpers.hh>
#include <wasmtime/types/func.hh>
 
namespace wasmtime {
 
namespace component {
 
class ComponentItem;
class ComponentExtern;
 
class ComponentType {
  WASMTIME_CLONE_WRAPPER(ComponentType, wasmtime_component_type);
 
  size_t import_count(const Engine &engine) const {
    return wasmtime_component_type_import_count(capi(), engine.capi());
  }
 
  std::optional<ComponentExtern> import_get(const Engine &engine,
                                            std::string_view name) const;
 
  std::optional<std::pair<std::string_view, ComponentExtern>>
  import_nth(const Engine &engine, size_t nth) const;
 
  size_t export_count(const Engine &engine) const {
    return wasmtime_component_type_export_count(capi(), engine.capi());
  }
 
  std::optional<ComponentExtern> export_get(const Engine &engine,
                                            std::string_view name) const;
 
  std::optional<std::pair<std::string_view, ComponentExtern>>
  export_nth(const Engine &engine, size_t nth) const;
};
 
class ComponentInstanceType;
class ModuleType;
class FuncType;
class ResourceType;
class ValType;
 
class ComponentItem {
  wasmtime_component_item_t item;
 
public:
  explicit ComponentItem(wasmtime_component_item_t &&item) : item(item) {
    item.kind = WASMTIME_COMPONENT_ITEM_TYPE;
    item.of.type.kind = WASMTIME_COMPONENT_VALTYPE_BOOL;
  }
 
  ComponentItem(const ComponentItem &other) {
    wasmtime_component_item_clone(&other.item, &item);
  }
 
  ComponentItem &operator=(const ComponentItem &other) {
    wasmtime_component_item_delete(&item);
    wasmtime_component_item_clone(&other.item, &item);
    return *this;
  }
 
  ComponentItem(ComponentItem &&other) : item(other.item) {
    other.item.kind = WASMTIME_COMPONENT_ITEM_TYPE;
    other.item.of.type.kind = WASMTIME_COMPONENT_VALTYPE_BOOL;
  }
 
  ComponentItem &operator=(ComponentItem &&other) {
    wasmtime_component_item_delete(&item);
    item = other.item;
    other.item.kind = WASMTIME_COMPONENT_ITEM_TYPE;
    other.item.of.type.kind = WASMTIME_COMPONENT_VALTYPE_BOOL;
    return *this;
  }
 
  ~ComponentItem() { wasmtime_component_item_delete(&item); }
 
  bool is_component() const {
    return item.kind == WASMTIME_COMPONENT_ITEM_COMPONENT;
  }
 
  bool is_component_instance() const {
    return item.kind == WASMTIME_COMPONENT_ITEM_COMPONENT_INSTANCE;
  }
 
  bool is_module() const { return item.kind == WASMTIME_COMPONENT_ITEM_MODULE; }
 
  bool is_component_func() const {
    return item.kind == WASMTIME_COMPONENT_ITEM_COMPONENT_FUNC;
  }
 
  bool is_resource() const {
    return item.kind == WASMTIME_COMPONENT_ITEM_RESOURCE;
  }
 
  bool is_core_func() const {
    return item.kind == WASMTIME_COMPONENT_ITEM_CORE_FUNC;
  }
 
  bool is_type() const { return item.kind == WASMTIME_COMPONENT_ITEM_TYPE; }
 
  const ComponentType &component() const {
    assert(is_component());
    return *ComponentType::from_capi(&item.of.component);
  }
 
  const ComponentInstanceType &component_instance() const;
 
  const ModuleType &module() const;
 
  const FuncType &component_func() const;
 
  const ResourceType &resource() const;
 
  wasmtime::FuncType::Ref core_func() const {
    assert(is_core_func());
    return item.of.core_func;
  }
 
  const ValType &type() const;
};
 
class ComponentExtern {
  WASMTIME_CLONE_WRAPPER(ComponentExtern, wasmtime_component_extern);
 
  ComponentItem type() const;
 
  std::optional<std::string_view> implements() const {
    size_t len = 0;
    const char *ptr = wasmtime_component_extern_implements(capi(), &len);
    if (ptr == nullptr) {
      return std::nullopt;
    }
    return std::string_view(ptr, len);
  }
 
  bool is_implements(std::string_view name) const {
    return wasmtime_component_extern_is_implements(capi(), name.data(),
                                                   name.size());
  }
 
  std::optional<std::string_view> external_id() const {
    size_t len = 0;
    const char *ptr = wasmtime_component_extern_external_id(capi(), &len);
    if (ptr == nullptr) {
      return std::nullopt;
    }
    return std::string_view(ptr, len);
  }
};
 
} // namespace component
} // namespace wasmtime
 
#include <wasmtime/component/types/func.hh>
#include <wasmtime/component/types/instance.hh>
#include <wasmtime/component/types/module.hh>
#include <wasmtime/component/types/val.hh>
 
inline wasmtime::component::ComponentItem
wasmtime::component::ComponentExtern::type() const {
  wasmtime_component_item_t item;
  wasmtime_component_extern_type(capi(), &item);
  return wasmtime::component::ComponentItem(std::move(item));
}
 
inline std::optional<wasmtime::component::ComponentExtern>
wasmtime::component::ComponentType::import_get(const wasmtime::Engine &engine,
                                               std::string_view name) const {
  wasmtime_component_extern_t *e;
  bool found = wasmtime_component_type_import_get(capi(), engine.capi(),
                                                  name.data(), name.size(), &e);
  if (!found) {
    return std::nullopt;
  }
  return wasmtime::component::ComponentExtern(e);
}
 
inline std::optional<
    std::pair<std::string_view, wasmtime::component::ComponentExtern>>
wasmtime::component::ComponentType::import_nth(const wasmtime::Engine &engine,
                                               size_t nth) const {
  wasmtime_component_extern_t *e;
  const char *name_data;
  size_t name_size;
  bool found = wasmtime_component_type_import_nth(capi(), engine.capi(), nth,
                                                  &name_data, &name_size, &e);
  if (!found) {
    return std::nullopt;
  }
  return std::make_pair(std::string_view(name_data, name_size),
                        wasmtime::component::ComponentExtern(e));
}
 
inline std::optional<wasmtime::component::ComponentExtern>
wasmtime::component::ComponentType::export_get(const wasmtime::Engine &engine,
                                               std::string_view name) const {
  wasmtime_component_extern_t *e;
  bool found = wasmtime_component_type_export_get(capi(), engine.capi(),
                                                  name.data(), name.size(), &e);
  if (!found) {
    return std::nullopt;
  }
  return wasmtime::component::ComponentExtern(e);
}
 
inline std::optional<
    std::pair<std::string_view, wasmtime::component::ComponentExtern>>
wasmtime::component::ComponentType::export_nth(const wasmtime::Engine &engine,
                                               size_t nth) const {
  wasmtime_component_extern_t *e;
  const char *name_data;
  size_t name_size;
  bool found = wasmtime_component_type_export_nth(capi(), engine.capi(), nth,
                                                  &name_data, &name_size, &e);
  if (!found) {
    return std::nullopt;
  }
  return std::make_pair(std::string_view(name_data, name_size),
                        wasmtime::component::ComponentExtern(e));
}
 
inline const wasmtime::component::ComponentInstanceType &
wasmtime::component::ComponentItem::component_instance() const {
  assert(is_component_instance());
  return *ComponentInstanceType::from_capi(&item.of.component_instance);
}
 
inline const wasmtime::component::ModuleType &
wasmtime::component::ComponentItem::module() const {
  assert(is_module());
  return *ModuleType::from_capi(&item.of.module);
}
 
inline const wasmtime::component::FuncType &
wasmtime::component::ComponentItem::component_func() const {
  assert(is_component_func());
  return *FuncType::from_capi(&item.of.component_func);
}
 
inline const wasmtime::component::ResourceType &
wasmtime::component::ComponentItem::resource() const {
  assert(is_resource());
  return *ResourceType::from_capi(&item.of.resource);
}
 
inline const wasmtime::component::ValType &
wasmtime::component::ComponentItem::type() const {
  assert(is_type());
  return *ValType::from_capi(&item.of.type);
}
 
#endif // WASMTIME_FEATURE_COMPONENT_MODEL
 
#endif // WASMTIME_COMPONENT_TYPES_COMPONENT_HH