Struct wasmer::Imports

pub struct Imports { /* private fields */ }

All of the import data used when instantiating.

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

Usage:

use wasmer::{Store, Exports, Module, Instance, imports, Imports, Function, FunctionEnvMut};

let host_fn = Function::new_typed(&mut store, foo);
let import_object: Imports = imports! {
    "env" => {
        "foo" => host_fn,
    },
};

let instance = Instance::new(&mut store, &module, &import_object).expect("Could not instantiate module.");

fn foo(n: i32) -> i32 {
    n
}

Implementations

impl Imports

pub fn new() -> Self

Create a new Imports.

pub fn get_export(&self, module: &str, name: &str) -> Option<Extern>

Gets an export given a module and a name

Usage

let mut import_object = Imports::new();
import_object.get_export("module", "name");

pub fn contains_namespace(&self, name: &str) -> bool

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

pub fn register_namespace(
    &mut self,
    ns: &str,
    contents: impl IntoIterator<Item = (String, Extern)>
)

Register a list of externs into a namespace.

Usage:

let mut exports = Exports::new();
exports.insert("memory", memory);

let mut import_object = Imports::new();
import_object.register_namespace("env", exports);
// ...

pub fn define(&mut self, ns: &str, name: &str, val: impl Into<Extern>)

Add a single import with a namespace ns and name name.

Usage

use wasmer::{StoreMut, Imports, Function, FunctionEnvMut};
fn foo(n: i32) -> i32 {
    n
}
let mut import_object = Imports::new();
import_object.define("env", "foo", Function::new_typed(&mut store, foo));

pub fn get_namespace_exports(&self, name: &str) -> Option<Exports>

Returns the contents of a namespace as an Exports.

Returns None if the namespace doesn’t exist.

pub fn imports_for_module(
    &self,
    module: &Module
) -> Result<Vec<Extern>, LinkError>

Resolve and return a vector of imports in the order they are defined in the module’s source code.

This means the returned Vec<Extern> might be a subset of the imports contained in self.

Trait Implementations

impl Clone for Imports

fn clone(&self) -> Imports

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Imports

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Imports

fn default() -> Imports

Returns the “default value” for a type.

impl Extend<((String, String), Extern)> for Imports

fn extend<T: IntoIterator<Item = ((String, String), Extern)>>(&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 &Imports

type IntoIter = IntoIter<(String, String), Extern>

Which kind of iterator are we turning this into?

type Item = ((String, String), Extern)

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.