component/types/val.hh

Go to the documentation of this file.

 
#ifndef WASMTIME_COMPONENT_TYPES_VAL_HH
#define WASMTIME_COMPONENT_TYPES_VAL_HH
 
#include <wasmtime/conf.h>
 
#ifdef WASMTIME_FEATURE_COMPONENT_MODEL
 
#include <memory>
#include <optional>
#include <string_view>
#include <wasmtime/component/types/val.h>
#include <wasmtime/helpers.hh>
 
namespace wasmtime {
namespace component {
 
class ValType;
 
class ListType {
  WASMTIME_CLONE_EQUAL_WRAPPER(ListType, wasmtime_component_list_type);
 
  ValType element() const;
};
 
class RecordType {
  WASMTIME_CLONE_EQUAL_WRAPPER(RecordType, wasmtime_component_record_type);
 
  size_t field_count() const {
    return wasmtime_component_record_type_field_count(ptr.get());
  }
 
  std::optional<std::pair<std::string_view, ValType>>
  field_nth(size_t nth) const;
};
 
class TupleType {
  WASMTIME_CLONE_EQUAL_WRAPPER(TupleType, wasmtime_component_tuple_type);
 
  size_t types_count() const {
    return wasmtime_component_tuple_type_types_count(ptr.get());
  }
 
  std::optional<ValType> types_nth(size_t nth) const;
};
 
class VariantType {
  WASMTIME_CLONE_EQUAL_WRAPPER(VariantType, wasmtime_component_variant_type);
 
  size_t case_count() const {
    return wasmtime_component_variant_type_case_count(ptr.get());
  }
 
  std::optional<std::pair<std::string_view, std::optional<ValType>>>
  case_nth(size_t nth) const;
};
 
class EnumType {
  WASMTIME_CLONE_EQUAL_WRAPPER(EnumType, wasmtime_component_enum_type);
 
  size_t names_count() const {
    return wasmtime_component_enum_type_names_count(ptr.get());
  }
 
  std::optional<std::string_view> names_nth(size_t nth) const {
    const char *name_ptr = nullptr;
    size_t name_len = 0;
    if (wasmtime_component_enum_type_names_nth(ptr.get(), nth, &name_ptr,
                                               &name_len)) {
      return std::string_view(name_ptr, name_len);
    }
    return std::nullopt;
  }
};
 
class OptionType {
  WASMTIME_CLONE_EQUAL_WRAPPER(OptionType, wasmtime_component_option_type);
 
  ValType ty() const;
};
 
class ResultType {
  WASMTIME_CLONE_EQUAL_WRAPPER(ResultType, wasmtime_component_result_type);
 
  std::optional<ValType> ok() const;
 
  std::optional<ValType> err() const;
};
 
class FlagsType {
  WASMTIME_CLONE_EQUAL_WRAPPER(FlagsType, wasmtime_component_flags_type);
 
  size_t names_count() const {
    return wasmtime_component_flags_type_names_count(ptr.get());
  }
 
  std::optional<std::string_view> names_nth(size_t nth) const {
    const char *name_ptr = nullptr;
    size_t name_len = 0;
    if (wasmtime_component_flags_type_names_nth(ptr.get(), nth, &name_ptr,
                                                &name_len)) {
      return std::string_view(name_ptr, name_len);
    }
    return std::nullopt;
  }
};
 
class ResourceType {
  WASMTIME_CLONE_EQUAL_WRAPPER(ResourceType, wasmtime_component_resource_type);
 
public:
  explicit ResourceType(uint32_t ty)
      : ptr(wasmtime_component_resource_type_new_host(ty)) {}
};
 
class FutureType {
  WASMTIME_CLONE_EQUAL_WRAPPER(FutureType, wasmtime_component_future_type);
 
  std::optional<ValType> ty() const;
};
 
class StreamType {
  WASMTIME_CLONE_EQUAL_WRAPPER(StreamType, wasmtime_component_stream_type);
 
  std::optional<ValType> ty() const;
};
 
class ValType {
  wasmtime_component_valtype_t ty;
 
  static ValType new_kind(wasmtime_component_valtype_kind_t kind) {
    wasmtime_component_valtype_t ty;
    ty.kind = kind;
    return ValType(std::move(ty));
  }
 
public:
  explicit ValType(wasmtime_component_valtype_t &&ty) {
    this->ty = ty;
    ty.kind = WASMTIME_COMPONENT_VALTYPE_BOOL;
  }
 
  ValType(const ValType &other) {
    wasmtime_component_valtype_clone(&other.ty, &ty);
  }
 
  ValType &operator=(const ValType &other) {
    wasmtime_component_valtype_delete(&ty);
    wasmtime_component_valtype_clone(&other.ty, &ty);
    return *this;
  }
 
  ValType(ValType &&other) : ty(other.ty) {
    other.ty.kind = WASMTIME_COMPONENT_VALTYPE_BOOL;
  }
 
  ValType &operator=(ValType &&other) {
    wasmtime_component_valtype_delete(&ty);
    ty = other.ty;
    other.ty.kind = WASMTIME_COMPONENT_VALTYPE_BOOL;
    return *this;
  }
 
  ~ValType() { wasmtime_component_valtype_delete(&ty); }
 
  static const ValType *from_capi(const wasmtime_component_valtype_t *capi) {
    static_assert(sizeof(ValType) == sizeof(wasmtime_component_valtype_t));
    return reinterpret_cast<const ValType *>(capi);
  }
 
  bool operator==(const ValType &other) const {
    return wasmtime_component_valtype_equal(&ty, &other.ty);
  }
 
  bool operator!=(const ValType &other) const { return !(*this == other); }
 
  static ValType new_bool() {
    return ValType::new_kind(WASMTIME_COMPONENT_VALTYPE_BOOL);
  }
 
  static ValType new_s8() {
    return ValType::new_kind(WASMTIME_COMPONENT_VALTYPE_S8);
  }
 
  static ValType new_s16() {
    return ValType::new_kind(WASMTIME_COMPONENT_VALTYPE_S16);
  }
 
  static ValType new_s32() {
    return ValType::new_kind(WASMTIME_COMPONENT_VALTYPE_S32);
  }
 
  static ValType new_s64() {
    return ValType::new_kind(WASMTIME_COMPONENT_VALTYPE_S64);
  }
 
  static ValType new_u8() {
    return ValType::new_kind(WASMTIME_COMPONENT_VALTYPE_U8);
  }
 
  static ValType new_u16() {
    return ValType::new_kind(WASMTIME_COMPONENT_VALTYPE_U16);
  }
 
  static ValType new_u32() {
    return ValType::new_kind(WASMTIME_COMPONENT_VALTYPE_U32);
  }
 
  static ValType new_u64() {
    return ValType::new_kind(WASMTIME_COMPONENT_VALTYPE_U64);
  }
 
  static ValType new_f32() {
    return ValType::new_kind(WASMTIME_COMPONENT_VALTYPE_F32);
  }
 
  static ValType new_f64() {
    return ValType::new_kind(WASMTIME_COMPONENT_VALTYPE_F64);
  }
 
  static ValType new_char() {
    return ValType::new_kind(WASMTIME_COMPONENT_VALTYPE_CHAR);
  }
 
  static ValType new_string() {
    return ValType::new_kind(WASMTIME_COMPONENT_VALTYPE_STRING);
  }
 
  ValType(ListType list) {
    ty.kind = WASMTIME_COMPONENT_VALTYPE_LIST;
    ty.of.list = list.capi_release();
  }
 
  ValType(RecordType record) {
    ty.kind = WASMTIME_COMPONENT_VALTYPE_RECORD;
    ty.of.record = record.capi_release();
  }
 
  ValType(TupleType tuple) {
    ty.kind = WASMTIME_COMPONENT_VALTYPE_TUPLE;
    ty.of.tuple = tuple.capi_release();
  }
 
  ValType(VariantType variant) {
    ty.kind = WASMTIME_COMPONENT_VALTYPE_VARIANT;
    ty.of.variant = variant.capi_release();
  }
 
  ValType(EnumType enum_) {
    ty.kind = WASMTIME_COMPONENT_VALTYPE_ENUM;
    ty.of.enum_ = enum_.capi_release();
  }
 
  ValType(OptionType option) {
    ty.kind = WASMTIME_COMPONENT_VALTYPE_OPTION;
    ty.of.option = option.capi_release();
  }
 
  ValType(ResultType result) {
    ty.kind = WASMTIME_COMPONENT_VALTYPE_RESULT;
    ty.of.result = result.capi_release();
  }
 
  ValType(FlagsType flags) {
    ty.kind = WASMTIME_COMPONENT_VALTYPE_FLAGS;
    ty.of.flags = flags.capi_release();
  }
 
  static ValType new_own(ResourceType own) {
    wasmtime_component_valtype_t ty;
    ty.kind = WASMTIME_COMPONENT_VALTYPE_OWN;
    ty.of.own = own.capi_release();
    return ValType(std::move(ty));
  }
 
  static ValType new_borrow(ResourceType borrow) {
    wasmtime_component_valtype_t ty;
    ty.kind = WASMTIME_COMPONENT_VALTYPE_BORROW;
    ty.of.borrow = borrow.capi_release();
    return ValType(std::move(ty));
  }
 
  ValType(FutureType future) {
    ty.kind = WASMTIME_COMPONENT_VALTYPE_FUTURE;
    ty.of.future = future.capi_release();
  }
 
  ValType(StreamType stream) {
    ty.kind = WASMTIME_COMPONENT_VALTYPE_STREAM;
    ty.of.stream = stream.capi_release();
  }
 
  wasmtime_component_valtype_kind_t kind() const { return ty.kind; }
 
  bool is_bool() const { return ty.kind == WASMTIME_COMPONENT_VALTYPE_BOOL; }
 
  bool is_s8() const { return ty.kind == WASMTIME_COMPONENT_VALTYPE_S8; }
 
  bool is_s16() const { return ty.kind == WASMTIME_COMPONENT_VALTYPE_S16; }
 
  bool is_s32() const { return ty.kind == WASMTIME_COMPONENT_VALTYPE_S32; }
 
  bool is_s64() const { return ty.kind == WASMTIME_COMPONENT_VALTYPE_S64; }
 
  bool is_u8() const { return ty.kind == WASMTIME_COMPONENT_VALTYPE_U8; }
 
  bool is_u16() const { return ty.kind == WASMTIME_COMPONENT_VALTYPE_U16; }
 
  bool is_u32() const { return ty.kind == WASMTIME_COMPONENT_VALTYPE_U32; }
 
  bool is_u64() const { return ty.kind == WASMTIME_COMPONENT_VALTYPE_U64; }
 
  bool is_f32() const { return ty.kind == WASMTIME_COMPONENT_VALTYPE_F32; }
 
  bool is_f64() const { return ty.kind == WASMTIME_COMPONENT_VALTYPE_F64; }
 
  bool is_char() const { return ty.kind == WASMTIME_COMPONENT_VALTYPE_CHAR; }
 
  bool is_string() const {
    return ty.kind == WASMTIME_COMPONENT_VALTYPE_STRING;
  }
 
  bool is_list() const { return ty.kind == WASMTIME_COMPONENT_VALTYPE_LIST; }
 
  bool is_record() const {
    return ty.kind == WASMTIME_COMPONENT_VALTYPE_RECORD;
  }
 
  bool is_tuple() const { return ty.kind == WASMTIME_COMPONENT_VALTYPE_TUPLE; }
 
  bool is_variant() const {
    return ty.kind == WASMTIME_COMPONENT_VALTYPE_VARIANT;
  }
 
  bool is_enum() const { return ty.kind == WASMTIME_COMPONENT_VALTYPE_ENUM; }
 
  bool is_option() const {
    return ty.kind == WASMTIME_COMPONENT_VALTYPE_OPTION;
  }
 
  bool is_result() const {
    return ty.kind == WASMTIME_COMPONENT_VALTYPE_RESULT;
  }
 
  bool is_flags() const { return ty.kind == WASMTIME_COMPONENT_VALTYPE_FLAGS; }
 
  bool is_own() const { return ty.kind == WASMTIME_COMPONENT_VALTYPE_OWN; }
 
  bool is_borrow() const {
    return ty.kind == WASMTIME_COMPONENT_VALTYPE_BORROW;
  }
 
  bool is_future() const {
    return ty.kind == WASMTIME_COMPONENT_VALTYPE_FUTURE;
  }
 
  bool is_stream() const {
    return ty.kind == WASMTIME_COMPONENT_VALTYPE_STREAM;
  }
 
  bool is_error_context() const {
    return ty.kind == WASMTIME_COMPONENT_VALTYPE_ERROR_CONTEXT;
  }
 
  const ListType &list() const {
    assert(is_list());
    return *ListType::from_capi(&ty.of.list);
  }
 
  const RecordType &record() const {
    assert(is_record());
    return *RecordType::from_capi(&ty.of.record);
  }
 
  const TupleType &tuple() const {
    assert(is_tuple());
    return *TupleType::from_capi(&ty.of.tuple);
  }
 
  const VariantType &variant() const {
    assert(is_variant());
    return *VariantType::from_capi(&ty.of.variant);
  }
 
  const EnumType &enum_() const {
    assert(is_enum());
    return *EnumType::from_capi(&ty.of.enum_);
  }
 
  const OptionType &option() const {
    assert(is_option());
    return *OptionType::from_capi(&ty.of.option);
  }
 
  const ResultType &result() const {
    assert(is_result());
    return *ResultType::from_capi(&ty.of.result);
  }
 
  const FlagsType &flags() const {
    assert(is_flags());
    return *FlagsType::from_capi(&ty.of.flags);
  }
 
  const ResourceType &own() const {
    assert(is_own());
    return *ResourceType::from_capi(&ty.of.own);
  }
 
  const ResourceType &borrow() const {
    assert(is_borrow());
    return *ResourceType::from_capi(&ty.of.borrow);
  }
 
  const FutureType &future() const {
    assert(is_future());
    return *FutureType::from_capi(&ty.of.future);
  }
 
  const StreamType &stream() const {
    assert(is_stream());
    return *StreamType::from_capi(&ty.of.stream);
  }
 
  const wasmtime_component_valtype_t *capi() const { return &ty; }
  wasmtime_component_valtype_t *capi() { return &ty; }
};
 
inline ValType ListType::element() const {
  wasmtime_component_valtype_t type_ret;
  wasmtime_component_list_type_element(ptr.get(), &type_ret);
  return ValType(std::move(type_ret));
}
 
inline std::optional<std::pair<std::string_view, ValType>>
RecordType::field_nth(size_t nth) const {
  const char *name_ptr = nullptr;
  size_t name_len = 0;
  wasmtime_component_valtype_t type_ret;
  if (wasmtime_component_record_type_field_nth(ptr.get(), nth, &name_ptr,
                                               &name_len, &type_ret)) {
    return std::make_pair(std::string_view(name_ptr, name_len),
                          ValType(std::move(type_ret)));
  }
  return std::nullopt;
}
 
inline std::optional<ValType> TupleType::types_nth(size_t nth) const {
  wasmtime_component_valtype_t type_ret;
  if (wasmtime_component_tuple_type_types_nth(ptr.get(), nth, &type_ret)) {
    return ValType(std::move(type_ret));
  }
  return std::nullopt;
}
 
inline std::optional<std::pair<std::string_view, std::optional<ValType>>>
VariantType::case_nth(size_t nth) const {
  const char *name_ptr = nullptr;
  size_t name_len = 0;
  bool has_payload = false;
  wasmtime_component_valtype_t payload_ret;
  if (!wasmtime_component_variant_type_case_nth(
          ptr.get(), nth, &name_ptr, &name_len, &has_payload, &payload_ret)) {
    return std::nullopt;
  }
  return std::make_pair(
      std::string_view(name_ptr, name_len),
      has_payload ? std::optional<ValType>(ValType(std::move(payload_ret)))
                  : std::nullopt);
}
 
inline ValType OptionType::ty() const {
  wasmtime_component_valtype_t type_ret;
  wasmtime_component_option_type_ty(ptr.get(), &type_ret);
  return ValType(std::move(type_ret));
}
 
inline std::optional<ValType> ResultType::ok() const {
  wasmtime_component_valtype_t type_ret;
  if (wasmtime_component_result_type_ok(ptr.get(), &type_ret)) {
    return ValType(std::move(type_ret));
  }
  return std::nullopt;
}
 
inline std::optional<ValType> ResultType::err() const {
  wasmtime_component_valtype_t type_ret;
  if (wasmtime_component_result_type_err(ptr.get(), &type_ret)) {
    return ValType(std::move(type_ret));
  }
  return std::nullopt;
}
 
inline std::optional<ValType> FutureType::ty() const {
  wasmtime_component_valtype_t type_ret;
  if (wasmtime_component_future_type_ty(ptr.get(), &type_ret)) {
    return ValType(std::move(type_ret));
  }
  return std::nullopt;
}
 
inline std::optional<ValType> StreamType::ty() const {
  wasmtime_component_valtype_t type_ret;
  if (wasmtime_component_stream_type_ty(ptr.get(), &type_ret)) {
    return ValType(std::move(type_ret));
  }
  return std::nullopt;
}
 
} // namespace component
} // namespace wasmtime
 
#endif // WASMTIME_FEATURE_COMPONENT_MODEL
 
#endif // WASMTIME_COMPONENT_TYPES_VAL_HH