# [−] [src] Struct wasmi::ModuleInstance

    pub struct ModuleInstance { /* fields omitted */ }

A module instance is the runtime representation of a module.

It is created by instantiating a module, and collects runtime representations of all entities that are imported or defined by the module, namely:

- functions,
- memories,
- tables,
- globals,

In order to instantiate a module you need to provide entities to satisfy every module's imports (i.e. wasm modules don't have optional imports).

After module is instantiated you can start invoking it's exported functions with `invoke_export`.

## Methods

### `impl ModuleInstance` [src]

#### `pub fn globals<'a>(&self) -> Ref<Vec<GlobalRef>>` [src]

Access all globals. This is a non-standard API so it's unlikely to be portable to other engines.

#### `pub fn with_externvals<'a, 'i, I: Iterator<Item = &'i ExternVal>>(
loaded_module: &'a Module,
extern_vals: I
) -> Result<NotStartedModuleRef<'a>, Error>` [src]

Instantiate a module with given external values as imports.

See new for details.

#### `pub fn new<'m, I: ImportResolver>(
loaded_module: &'m Module,
imports: &I
) -> Result<NotStartedModuleRef<'m>, Error>` [src]

Instantiate a module.

Note that in case of successful instantiation this function returns a reference to a module which `start` function is not called. In order to complete instantiatiation `start` function must be called. However, there are situations where you might need to do additional setup before calling `start` function. For such sitations this separation might be useful.

See `NotStartedModuleRef` for details.

# Errors

Returns `Err` if the module cannot be instantiated.

This can happen if one of the imports can't be satisfied (e.g module isn't registered in `imports` resolver) or there is a mismatch between requested import and provided (e.g. module requested memory with no maximum size limit, however, was provided memory with the maximum size limit).

# Examples

    use wasmi::{ModuleInstance, ImportsBuilder, NopExternals};

    // ModuleInstance::new returns instance which `start` function isn't called.
    let not_started = ModuleInstance::new(
        &module,
        &ImportsBuilder::default()
    )?;
    // Call `start` function if any.
    let instance = not_started.run_start(&mut NopExternals)?;

If you sure that the module doesn't have `start` function you can use `assert_no_start` to get instantiated module without calling `start` function.

    use wasmi::{ModuleInstance, ImportsBuilder, NopExternals};

    // This will panic if the module actually contain `start` function.
    let not_started = ModuleInstance::new(
        &module,
        &ImportsBuilder::default()
    )?.assert_no_start();

#### `pub fn invoke_export<E: Externals>(
&self,
func_name: &str,
args: &[RuntimeValue],
externals: &mut E
) -> Result<Option<RuntimeValue>, Error>` [src]

Invoke exported function by a name.

This function finds exported function by a name, and calls it with provided arguments and external state.

# Errors

Returns `Err` if:

- there are no export with a given name or this export is not a function,
- given arguments doesn't match to function signature,
- trap occurred at the execution time,

# Examples

Invoke a function that takes two numbers and returns sum of them.

    assert_eq!(
        instance.invoke_export(
            "add",
            &[RuntimeValue::I32(5), RuntimeValue::I32(3)],
            &mut NopExternals,
        ).expect("failed to execute export"),
        Some(RuntimeValue::I32(8)),
    );

#### `pub fn invoke_export_with_stack<E: Externals>(
&self,
func_name: &str,
args: &[RuntimeValue],
externals: &mut E,
stack_recycler: &mut StackRecycler
) -> Result<Option<RuntimeValue>, Error>` [src]

Invoke exported function by a name using recycled stacks.

# Errors

Same as `invoke_export`.

#### `pub fn export_by_name(&self, name: &str) -> Option<ExternVal>` [src]

Find export by a name.

Returns `None` if there is no export with such name.

## Trait Implementations

### `impl Debug for ModuleInstance` [src]

#### `fn fmt(&self, f: &mut Formatter) -> Result` [src]

Formats the value using the given formatter. Read more

## Auto Trait Implementations

### `impl !Send for ModuleInstance`

### `impl !Sync for ModuleInstance`

### `impl Unpin for ModuleInstance`

### `impl !UnwindSafe for ModuleInstance`

### `impl !RefUnwindSafe for ModuleInstance`

## Blanket Implementations

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `fn into(self) -> U` [src]

Performs the conversion.

### `impl<T> From<T> for T` [src]

#### `fn from(t: T) -> T` [src]

Performs the conversion.

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>` [src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>` [src]

Performs the conversion.

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `fn borrow(&self) -> &T` [src]

Immutably borrows from an owned value. Read more

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `fn borrow_mut(&mut self) -> &mut T` [src]

Mutably borrows from an owned value. Read more

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `fn type_id(&self) -> TypeId` [src]

Gets the `TypeId` of `self`. Read more

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)