Enum tinywasm_types::ImportKind

pub enum ImportKind {
    Function(TypeAddr),
    Table(TableType),
    Memory(MemoryType),
    Global(GlobalType),
}

Variants

Function(TypeAddr)

Table(TableType)

Memory(MemoryType)

Global(GlobalType)

Trait Implementations

impl Archive for ImportKind

where TypeAddr: Archive, TableType: Archive, MemoryType: Archive, GlobalType: Archive,

type Archived = ArchivedImportKind

The archived representation of this type.

type Resolver = ImportKindResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

unsafe fn resolve( &self, pos: usize, resolver: <Self as Archive>::Resolver, out: *mut <Self as Archive>::Archived )

Creates the archived version of this value at the given position and writes it to the given output.

impl Clone for ImportKind

fn clone(&self) -> ImportKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ImportKind

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

Formats the value using the given formatter.

impl<__D: Fallible + ?Sized> Deserialize<ImportKind, __D> for Archived<ImportKind>

where TypeAddr: Archive, Archived<TypeAddr>: Deserialize<TypeAddr, __D>, TableType: Archive, Archived<TableType>: Deserialize<TableType, __D>, MemoryType: Archive, Archived<MemoryType>: Deserialize<MemoryType, __D>, GlobalType: Archive, Archived<GlobalType>: Deserialize<GlobalType, __D>,

fn deserialize(&self, deserializer: &mut __D) -> Result<ImportKind, __D::Error>

Deserializes using the given deserializer

impl From<&ImportKind> for ExternalKind

fn from(kind: &ImportKind) -> Self

Converts to this type from the input type.

impl PartialEq for ImportKind

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<__S: Fallible + ?Sized> Serialize<__S> for ImportKind

where TypeAddr: Serialize<__S>, TableType: Serialize<__S>, MemoryType: Serialize<__S>, GlobalType: Serialize<__S>,

fn serialize( &self, serializer: &mut __S ) -> Result<<Self as Archive>::Resolver, __S::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl StructuralPartialEq for ImportKind