Struct wasmer_runtime_fl::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.

Implementations

impl ImportObject

pub fn new() -> ImportObject

Create a new ImportObject.

pub fn new_with_data<F>(state_creator: F) -> ImportObject 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 + 'static, Global>> where
    N: LikeNamespace + Send + 'static,
    S: Into<String>, 

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, 

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>, 

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 contains_namespace(&self, name: &str) -> bool

Returns true if the ImportObject contains namespace with the provided name.

Trait Implementations

impl Clone for ImportObject

pub fn clone(&self) -> ImportObject

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

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

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

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

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.

pub fn into_iter(self) -> <ImportObject as IntoIterator>::IntoIter

Creates an iterator from a value.