Struct ImportObject

pub struct ImportObject {
    pub allow_missing_functions: bool,
    /* private fields */
}

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

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

Trait Implementations

impl Clone for ImportObject

fn clone(&self) -> ImportObject

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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.

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.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.