Struct wasmer::Memory

pub struct Memory { /* private fields */ }

A WebAssembly memory instance.

A memory instance is the runtime representation of a linear memory. It consists of a vector of bytes and an optional maximum size.

The length of the vector always is a multiple of the WebAssembly page size, which is defined to be the constant 65536 – abbreviated 64Ki. Like in a memory type, the maximum size in a memory instance is given in units of this page size.

A memory created by the host or in WebAssembly code will be accessible and mutable from both host and WebAssembly.

Spec: https://webassembly.github.io/spec/core/exec/runtime.html#memory-instances

Implementations

impl Memory

pub fn new(
    store: &mut impl AsStoreMut,
    ty: MemoryType
) -> Result<Self, MemoryError>

Creates a new host Memory from the provided MemoryType.

This function will construct the Memory using the store BaseTunables.

Example

let m = Memory::new(&mut store, MemoryType::new(1, None, false)).unwrap();

pub fn new_from_existing(
    new_store: &mut impl AsStoreMut,
    memory: VMMemory
) -> Self

Create a memory object from an existing memory and attaches it to the store

pub fn ty(&self, store: &impl AsStoreRef) -> MemoryType

Returns the MemoryType of the Memory.

Example

let mt = MemoryType::new(1, None, false);
let m = Memory::new(&mut store, mt).unwrap();

assert_eq!(m.ty(&mut store), mt);

pub fn view<'a>(&'a self, store: &impl AsStoreRef) -> MemoryView<'a>

Creates a view into the memory that then allows for read and write

pub fn grow<IntoPages>(
    &self,
    store: &mut impl AsStoreMut,
    delta: IntoPages
) -> Result<Pages, MemoryError>where
    IntoPages: Into<Pages>,

Grow memory by the specified amount of WebAssembly Pages and return the previous memory size.

Example

let m = Memory::new(&mut store, MemoryType::new(1, Some(3), false)).unwrap();
let p = m.grow(&mut store, 2).unwrap();

assert_eq!(p, Pages(1));
assert_eq!(m.view(&mut store).size(), Pages(3));

Errors

Returns an error if memory can’t be grown by the specified amount of pages.

let m = Memory::new(&mut store, MemoryType::new(1, Some(1), false)).unwrap();

// This results in an error: `MemoryError::CouldNotGrow`.
let s = m.grow(&mut store, 1).unwrap();

pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool

Checks whether this Memory can be used with the given context.

pub fn try_clone(&self, store: &impl AsStoreRef) -> Option<VMMemory>

Attempts to clone this memory (if its clonable)

Trait Implementations

impl Clone for Memory

fn clone(&self) -> Memory

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Memory

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

Formats the value using the given formatter.

impl<'a> Exportable<'a> for Memory

fn get_self_from_extern(_extern: &'a Extern) -> Result<&'a Self, ExportError>

Implementation of how to get the export corresponding to the implementing type from an Instance by name.

impl From<Memory> for Extern

fn from(r: Memory) -> Self

Converts to this type from the input type.

impl PartialEq<Memory> for Memory

fn eq(&self, other: &Self) -> 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 Eq for Memory