Struct Import 

pub struct Import { /* private fields */ }

Each import is labeled by a two-level name space, consisting of a 𝗆𝗈𝖽𝗎𝗅𝖾 name and a 𝗇𝖺𝗆𝖾 for an entity within that module. Importable definitions are functions, tables, memories, and globals. Each import is specified by a descriptor with a respective type that a definition provided during instantiation is required to match. Every import defines an index in the respective index space. In each index space, the indices of imports go before the first index of any definition contained in the module itself.

See https://webassembly.github.io/spec/core/syntax/modules.html#imports

Examples

Table

use wasm_ast::{Import, ImportDescription, Name, TableType, Limit, ReferenceType};

let module = "system";
let name = "functions";
let kind = TableType::new( ReferenceType::Function,Limit::unbounded(1));
let description = ImportDescription::Table(kind.clone());
let import = Import::new(module.into(), name.into(), description.clone());

assert_eq!(import, Import::table(module.into(), name.into(), kind));
assert_eq!(import.module(), &Name::new(String::from(module)));
assert_eq!(import.name(), &Name::new(String::from(name)));
assert_eq!(import.description(), &description);

Memory

use wasm_ast::{Import, ImportDescription, Name, MemoryType, Limit};

let module = "system";
let name = "io";
let kind = Limit::bounded(1, 2).into();
let description = ImportDescription::Memory(kind);
let import = Import::new(module.into(), name.into(), description.clone());

assert_eq!(import, Import::memory(module.into(), name.into(), kind));
assert_eq!(import.module(), &Name::new(String::from(module)));
assert_eq!(import.name(), &Name::new(String::from(name)));
assert_eq!(import.description(), &description);

Function

use wasm_ast::{Import, ImportDescription, Name};

let module = "system";
let name = "print";
let description = ImportDescription::Function(42);
let import = Import::new(module.into(), name.into(), description.clone());

assert_eq!(import, Import::function(module.into(), name.into(), 42));
assert_eq!(import.module(), &Name::new(String::from(module)));
assert_eq!(import.name(), &Name::new(String::from(name)));
assert_eq!(import.description(), &description);

Global

use wasm_ast::{Import, ImportDescription, Name, GlobalType, ValueType};

let module = "system";
let name = "counter";
let kind = GlobalType::mutable(ValueType::I64);
let description = ImportDescription::Global(kind.clone());
let import = Import::new(module.into(), name.into(), description.clone());

assert_eq!(import, Import::global(module.into(), name.into(), kind));
assert_eq!(import.module(), &Name::new(String::from(module)));
assert_eq!(import.name(), &Name::new(String::from(name)));
assert_eq!(import.description(), &description);

Implementations

impl Import

pub fn new(module: Name, name: Name, description: ImportDescription) -> Self

Creates a new import.

pub fn table(module: Name, name: Name, table_kind: TableType) -> Self

Create a new instance of an Import with the given name and description for a table.

pub fn memory(module: Name, name: Name, memory_kind: MemoryType) -> Self

Create a new instance of an Import with the given name and description for a memory.

pub fn function(module: Name, name: Name, function_kind: TypeIndex) -> Self

Create a new instance of an Import with the given name and description for a function.

pub fn global(module: Name, name: Name, global_kind: GlobalType) -> Self

Create a new instance of an Import with the given name and description for a global.

pub fn module(&self) -> &Name

The name of the module (i.e.m namespace).

pub fn name(&self) -> &Name

The name of the import.

pub fn description(&self) -> &ImportDescription

The description of the import.

Trait Implementations

impl Clone for Import

fn clone(&self) -> Import

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Import

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

Formats the value using the given formatter.

impl PartialEq for Import

fn eq(&self, other: &Import) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Import

impl StructuralPartialEq for Import