Struct Memory 

pub struct Memory(/* private fields */);

Newtype wrapper around wasmer::Memory.

Implementations

impl Memory

pub fn new(inner: Memory) -> Self

Create a wasm_runtime_layer::Memory-compatible Memory from a wasmer::Memory.

pub fn into_inner(self) -> Memory

Consume a Memory to obtain the inner wasmer::Memory.

Methods from Deref<Target = Memory>

pub fn as_sys(&self) -> &Memory

Convert a reference to self into a reference to crate::backend::sys::memory::Memory.

pub fn as_sys_mut(&mut self) -> &mut Memory

Convert a mutable reference to self into a mutable reference to crate::backend::sys::memory::Memory.

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>(&self, store: &'a (impl AsStoreRef + ?Sized)) -> MemoryView<'a>

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

pub fn size(&self, store: &impl AsStoreRef) -> Pages

Retrieve the size of the memory in pages.

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 grow_at_least( &self, store: &mut impl AsStoreMut, min_size: u64, ) -> Result<(), MemoryError>

Grows the memory to at least a minimum size.

Note

If the memory is already big enough for the min size this function does nothing.

pub fn reset(&self, store: &mut impl AsStoreMut) -> Result<(), MemoryError>

Resets the memory back to zero length

pub fn copy_to_store( &self, store: &impl AsStoreRef, new_store: &mut impl AsStoreMut, ) -> Result<Memory, MemoryError>

Attempts to duplicate this memory (if its clonable) in a new store (copied memory)

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, ) -> Result<VMMemory, MemoryError>

Attempt to create a new reference to the underlying memory; this new reference can then be used within a different store (from the same implementer).

Errors

Fails if the underlying memory is not clonable.

pub fn share_in_store( &self, store: &impl AsStoreRef, new_store: &mut impl AsStoreMut, ) -> Result<Memory, MemoryError>

Attempts to clone this memory (if its clonable) in a new store (cloned memory will be shared between those that clone it)

pub fn as_shared(&self, store: &impl AsStoreRef) -> Option<SharedMemory>

Get a SharedMemory.

Only returns Some(_) if the memory is shared, and if the target backend supports shared memory operations.

See SharedMemory and its methods for more information.

Trait Implementations

impl AsMut<Memory> for Memory

fn as_mut(&mut self) -> &mut Memory

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsMut<Memory> for Memory

fn as_mut(&mut self) -> &mut Memory

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<Memory> for Memory

fn as_ref(&self) -> &Memory

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<Memory> for Memory

fn as_ref(&self) -> &Memory

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Memory

fn clone(&self) -> Memory

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Deref for Memory

type Target = Memory

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for Memory

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl From<Memory> for Memory

fn from(inner: Memory) -> Self

Converts to this type from the input type.

impl From<Memory> for Memory

fn from(wrapper: Memory) -> Self

Converts to this type from the input type.

impl RefCast for Memory

type From = Memory

fn ref_cast(_from: &Self::From) -> &Self

fn ref_cast_mut(_from: &mut Self::From) -> &mut Self

impl WasmMemory<Engine> for Memory

fn new(ctx: impl AsContextMut<Engine>, ty: MemoryType) -> Result<Self>

Creates a new linear memory to the store.

fn ty(&self, ctx: impl AsContext<Engine>) -> MemoryType

Returns the memory type of the linear memory.

fn grow(&self, ctx: impl AsContextMut<Engine>, additional: u32) -> Result<u32>

Grows the linear memory by the given amount of new pages.

fn current_pages(&self, ctx: impl AsContext<Engine>) -> u32

Returns the amount of pages in use by the linear memory.

fn read( &self, ctx: impl AsContext<Engine>, offset: usize, buffer: &mut [u8], ) -> Result<()>

Reads n bytes from memory[offset..offset+n] into buffer where n is the length of buffer.

fn write( &self, ctx: impl AsContextMut<Engine>, offset: usize, buffer: &[u8], ) -> Result<()>

Writes n bytes to memory[offset..offset+n] from buffer where n if the length of buffer.