Struct wasmer_runtime_core::import::ImportObject

pub struct ImportObject {
    pub allow_missing_functions: bool,
    // some fields omitted
}

All of the import data used when instantiating.

It's suggested that you use the imports! macro instead of creating an ImportObject by hand.

Usage:

let import_object = imports! {
    "env" => {
        "foo" => func!(foo),
    },
};

fn foo(_: &mut Ctx, n: i32) -> i32 {
    n
}

Fields

allow_missing_functions: bool

Methods

impl ImportObject

pub fn new() -> Self

Create a new ImportObject.

pub fn new_with_data<F>(state_creator: F) -> Self where
    F: Fn() -> (*mut c_void, fn(_: *mut c_void)) + 'static, 

pub fn register<S, N>(
    &mut self,
    name: S,
    namespace: N
) -> Option<Box<dyn LikeNamespace>> where
    S: Into<String>,
    N: LikeNamespace + 'static, 

Register anything that implements LikeNamespace as a namespace.

Usage:

fn register(instance: Instance, namespace: Namespace) {
    let mut import_object = ImportObject::new();

    import_object.register("namespace0", instance);
    import_object.register("namespace1", namespace);
    // ...
}

pub fn get_namespace(
    &self,
    namespace: &str
) -> Option<Ref<dyn LikeNamespace + 'static>>

pub fn clone_ref(&self) -> Self

Trait Implementations

impl IntoIterator for ImportObject

type IntoIter = ImportObjectIterator

Which kind of iterator are we turning this into?

type Item = (String, String, Export)

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl Extend<(String, String, Export)> for ImportObject

fn extend<T: IntoIterator<Item = (String, String, Export)>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.