Struct 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 UniversalArtifactInfo.

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

Trait Implementations

impl Archive for SerializableModule

where 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 MemoryUsage for SerializableModule

fn size_of_val(&self, visited: &mut dyn MemoryUsageTracker) -> usize

Returns the size of the referenced value in bytes.

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

where 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.