Struct wasmer_types::SerializableModule

pub struct SerializableModule {
    pub compilation: SerializableCompilation,
    pub compile_info: CompileModuleInfo,
    pub data_initializers: Box<[OwnedDataInitializer]>,
    pub cpu_features: u64,
}

Serializable struct that is able to serialize from and to a ArtifactInfo.

Fields

compilation: SerializableCompilation

The main serializable compilation object

compile_info: CompileModuleInfo

Compilation informations

data_initializers: Box<[OwnedDataInitializer]>

Datas initializers

cpu_features: u64

CPU Feature flags for this compilation

Implementations

impl SerializableModule

pub fn serialize(&self) -> Result<Vec<u8>, SerializeError>

Serialize a Module into bytes The bytes will have the following format: RKYV serialization (any length) + POS (8 bytes)

pub unsafe fn deserialize(
    metadata_slice: &[u8]
) -> Result<Self, DeserializeError>

Deserialize a Module from a slice. The slice must have the following format: RKYV serialization (any length) + POS (8 bytes)

Safety

This method is unsafe since it deserializes data directly from memory. Right now we are not doing any extra work for validation, but rkyv has an option to do bytecheck on the serialized data before serializing (via rkyv::check_archived_value).

pub fn deserialize_from_archive(
    archived: &ArchivedSerializableModule
) -> Result<Self, DeserializeError>

Deserialize a compilation module from an archive

pub fn create_module_info(&self) -> ModuleInfo

Create a ModuleInfo for instantiation

pub fn features(&self) -> &Features

Returns the features for this Artifact

pub fn cpu_features(&self) -> EnumSet<CpuFeature>

Returns the CPU features for this Artifact

pub fn data_initializers(&self) -> &[OwnedDataInitializer]

Returns data initializers to pass to InstanceHandle::initialize

pub fn memory_styles(&self) -> &PrimaryMap<MemoryIndex, MemoryStyle>

Returns the memory styles associated with this Artifact.

pub fn table_styles(&self) -> &PrimaryMap<TableIndex, TableStyle>

Returns the table plans associated with this Artifact.

pub fn serialize_to_file(&self, path: &Path) -> Result<(), SerializeError>

Serializes an artifact into a file path

Trait Implementations

impl Archive for SerializableModulewhere
    SerializableCompilation: Archive,
    CompileModuleInfo: Archive,
    Box<[OwnedDataInitializer]>: Archive,
    u64: Archive,

type Archived = ArchivedSerializableModule

The archived representation of this type.

type Resolver = SerializableModuleResolver

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::Resolver,
    out: *mut Self::Archived
)

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

impl<__D: Fallible + ?Sized> Deserialize<SerializableModule, __D> for Archived<SerializableModule>where
    SerializableCompilation: Archive,
    Archived<SerializableCompilation>: Deserialize<SerializableCompilation, __D>,
    CompileModuleInfo: Archive,
    Archived<CompileModuleInfo>: Deserialize<CompileModuleInfo, __D>,
    Box<[OwnedDataInitializer]>: Archive,
    Archived<Box<[OwnedDataInitializer]>>: Deserialize<Box<[OwnedDataInitializer]>, __D>,
    u64: Archive,
    Archived<u64>: Deserialize<u64, __D>,

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

Deserializes using the given deserializer

impl<__S: Fallible + ?Sized> Serialize<__S> for SerializableModulewhere
    SerializableCompilation: Serialize<__S>,
    CompileModuleInfo: Serialize<__S>,
    Box<[OwnedDataInitializer]>: Serialize<__S>,
    u64: Serialize<__S>,

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

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