Enum wasmtime_environ::Initializer

pub enum Initializer {
    Import {
        module: String,
        field: Option<String>,
        index: EntityIndex,
    },
    AliasParentModule(ModuleIndex),
    AliasInstanceExport {
        instance: InstanceIndex,
        export: usize,
    },
    Instantiate {
        module: ModuleIndex,
        args: Vec<EntityIndex>,
    },
    DefineModule(usize),
}

Initialization routines for creating an instance, encompassing imports, modules, instances, aliases, etc.

Variants

Import

An imported item is required to be provided.

Fields of Import

module: String

Module name of this import

field: Option<String>

Optional field name of this import

index: EntityIndex

Where this import will be placed, which also has type information about the import.

AliasParentModule(ModuleIndex)

A module from the parent's declared modules is inserted into our own index space.

AliasInstanceExport

A module from the parent's declared modules is inserted into our own index space.

Fields of AliasInstanceExport

instance: InstanceIndexexport: usize

Instantiate

A module is being instantiated with previously configured intializers as arguments.

Fields of Instantiate

module: ModuleIndex

The module that this instance is instantiating.

args: Vec<EntityIndex>

The arguments provided to instantiation.

DefineModule(usize)

A module is defined into the module index space, and which module is being defined is specified by the index payload.

Trait Implementations

impl Clone for Initializer

pub fn clone(&self) -> Initializer

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Initializer

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Initializer

pub fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Serialize for Initializer

pub fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.