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

Allow missing functions to be generated and instantiation to continue when required functions are not provided.

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 + Send + Sync, 

Create a new ImportObject which generates data from the provided state creator.

pub fn register<S, N>(
    &mut self,
    name: S,
    namespace: N
) -> Option<Box<dyn LikeNamespace>> where
    S: Into<String>,
    N: LikeNamespace + Send + '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 with_namespace<Func, InnerRet>(
    &self,
    namespace: &str,
    f: Func
) -> Option<InnerRet> where
    Func: FnOnce(&(dyn LikeNamespace + Send)) -> InnerRet,
    InnerRet: Sized, 

Apply a function on the namespace if it exists If your function can fail, consider using maybe_with_namespace

pub fn maybe_with_namespace<Func, InnerRet>(
    &self,
    namespace: &str,
    f: Func
) -> Option<InnerRet> where
    Func: FnOnce(&(dyn LikeNamespace + Send)) -> Option<InnerRet>,
    InnerRet: Sized, 

The same as with_namespace but takes a function that may fail

Usage:

fn get_export(imports: &ImportObject, namespace: &str, name: &str) -> Option<Export> {
    imports.maybe_with_namespace(namespace, |ns| ns.get_export(name))
}

pub fn clone_ref(&self) -> Self

Create a clone ref of this namespace.

Trait Implementations

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.

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.