Struct wasmbin::Module

pub struct Module {
    pub sections: Vec<Section>,
}

WebAssembly Module.

Unless you’re doing something very specific, this will be your entry point to the library as it represents the module as a whole. Check out its fields for nested structures.

Fields

sections: Vec<Section>

Module sections.

Note that the spec mandates a specific order in which sections must appear, but the representation here is currently a flat Vec<{enum}> for efficiency.

Use Module::find_std_section and Module::find_std_section_mut to find sections of the specific type and Module::find_or_insert_std_section to insert one in the correct position.

The section order will be checked both during decoding and encoding.

Implementations

impl Module

pub fn decode_from(r: impl Read) -> Result<Module, DecodeError>

Decode a module from an arbitrary input.

Example

use std::fs::File;
use std::io::BufReader;
use wasmbin::Module;

let file = File::open("module.wasm")?;
let mut reader = BufReader::new(file);
let module = Module::decode_from(reader)?;
println!("{module:#?}");

pub fn encode_into<W: Write>(&self, w: W) -> Result<W>

Encode the module into an arbitrary output.

Example

use std::fs::File;
use std::io::BufWriter;
use wasmbin::Module;

let file = File::create("module.wasm")?;
let mut writer = BufWriter::new(file);
module.encode_into(writer)?;

pub fn find_std_section<T: StdPayload>(&self) -> Option<&Blob<T>>

Find a standard section by its payload type.

Example

use wasmbin::{Module, sections::payload};

if let Some(imports) = module.find_std_section::<payload::Import>() {
   for import in imports.try_contents()? {
      println!("Module imports a {:?} from {}.{}", import.desc, import.path.module, import.path.name);
  }
}

pub fn find_std_section_mut<T: StdPayload>(&mut self) -> Option<&mut Blob<T>>

Find a standard section by its payload type and return a mutable reference.

Example

use wasmbin::Module;
use wasmbin::sections::{payload, Import, ImportPath, ImportDesc};

if let Some(imports) = module.find_std_section_mut::<payload::Import>() {
   for import in imports.try_contents_mut()? {
        // Compress references to the "env" module.
        if import.path.module == "env" {
            import.path.module = "a".to_owned();
       }
  }
}

pub fn find_or_insert_std_section<T: StdPayload>( &mut self, insert_callback: impl FnOnce() -> T ) -> &mut Blob<T>

Find a standard section by its payload type or insert it if it’s not present.

The section will be inserted in the correct position according to the spec and a mutable reference will be returned for further modification.

Example

use wasmbin::Module;
use wasmbin::sections::{payload, Import, ImportPath, ImportDesc};
use wasmbin::indices::TypeId;

module
.find_or_insert_std_section(|| payload::Import::default())
.try_contents_mut()?
.push(Import {
    path: ImportPath {
        module: "env".to_owned(),
        name: "my_func".to_owned(),
    },
    desc: ImportDesc::Func(TypeId::from(42)),
});

Trait Implementations

impl Clone for Module

fn clone(&self) -> Module

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Module

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

Formats the value using the given formatter.

impl Decode for Module

fn decode(r: &mut impl Read) -> Result<Self, DecodeError>

Decodes the value from the given reader.

impl Default for Module

fn default() -> Module

Returns the “default value” for a type.

impl Encode for Module

fn encode(&self, w: &mut impl Write) -> Result<()>

Encodes the value into the given writer.

impl Hash for Module

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Module

fn eq(&self, other: &Module) -> 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 Visit for Module

where Self: 'static,

fn visit_children<'a, VisitT: 'static, VisitE, VisitF: FnMut(&'a VisitT) -> Result<(), VisitE>>( &'a self, f: &mut VisitF ) -> Result<(), VisitError<VisitE>>

Traverse the children of this value with the provided callback.

fn visit_children_mut<VisitT: 'static, VisitE, VisitF: FnMut(&mut VisitT) -> Result<(), VisitE>>( &mut self, f: &mut VisitF ) -> Result<(), VisitError<VisitE>>

Traverse the children of this value mutably with the provided callback.

fn visit<'a, T: 'static, R: VisitResult, F: FnMut(&'a T) -> R>( &'a self, f: F ) -> Result<(), VisitError<R::Error>>

Traverse this value with the provided callback.

fn visit_mut<T: 'static, R: VisitResult, F: FnMut(&mut T) -> R>( &mut self, f: F ) -> Result<(), VisitError<R::Error>>

Traverse this value mutably with the provided callback.

impl Eq for Module

impl StructuralEq for Module

impl StructuralPartialEq for Module