import.hh

Go to the documentation of this file.

 
#ifndef WASMTIME_TYPES_IMPORT_HH
#define WASMTIME_TYPES_IMPORT_HH
 
#include <string_view>
#include <wasm.h>
#include <wasmtime/helpers.hh>
 
namespace wasmtime {
 
class ImportType {
#define wasm_importtype_clone wasm_importtype_copy
  WASMTIME_CLONE_WRAPPER(ImportType, wasm_importtype);
#undef wasm_importtype_clone
 
  class Ref {
    friend class ExternType;
 
    const wasm_importtype_t *ptr;
 
    // TODO: can this circle be broken another way?
    const wasm_externtype_t *raw_type() const {
      return wasm_importtype_type(ptr);
    }
 
  public:
    Ref(const wasm_importtype_t *ptr) : ptr(ptr) {}
 
    std::string_view module() const {
      const auto *name = wasm_importtype_module(ptr);
      return std::string_view(name->data, name->size);
    }
 
    std::string_view name() const {
      const auto *name = wasm_importtype_name(ptr);
      return std::string_view(name->data, name->size);
    }
  };
 
  Ref ref() const { return Ref(ptr.get()); }
 
  class List {
    friend class Module;
    wasm_importtype_vec_t list;
 
  public:
    List() : list{} {
      list.size = 0;
      list.data = nullptr;
    }
    List(const List &other) = delete;
    List(List &&other) noexcept : list(other.list) { other.list.size = 0; }
    ~List() {
      if (list.size > 0) {
        wasm_importtype_vec_delete(&list);
      }
    }
 
    List &operator=(const List &other) = delete;
    List &operator=(List &&other) noexcept {
      std::swap(list, other.list);
      return *this;
    }
 
    typedef const Ref *iterator;
    iterator begin() const {
      return reinterpret_cast<iterator>(&list.data[0]); // NOLINT
    }
    iterator end() const {
      return reinterpret_cast<iterator>(&list.data[list.size]); // NOLINT
    }
    size_t size() const { return list.size; }
  };
};
 
}; // namespace wasmtime
 
#endif // WASMTIME_TYPES_IMPORT_HH