Trait LinearMemory 

pub trait LinearMemory {
    // Required methods
    fn len(&self) -> usize;
    fn grow_to(&mut self, new_len: usize) -> Result<(), Trap>;
    fn read(&self, addr: usize, dst: &mut [u8]) -> usize;
    fn write(&mut self, addr: usize, src: &[u8]) -> usize;

    // Provided methods
    fn is_empty(&self) -> bool { ... }
    fn write_all(&mut self, addr: usize, src: &[u8]) -> Option<()> { ... }
    fn fill(&mut self, addr: usize, len: usize, val: u8) -> Option<()> { ... }
    fn copy_within(&mut self, dst: usize, src: usize, len: usize) -> Option<()> { ... }
    fn read_exact(&self, addr: usize, dst: &mut [u8]) -> Option<()> { ... }
    fn read_vec(&self, addr: usize, len: usize) -> Option<Vec<u8>> { ... }
    fn read_8(&self, base: u64, offset: u64) -> Result<u8, Trap> { ... }
    fn read_16(&self, base: u64, offset: u64) -> Result<[u8; 2], Trap> { ... }
    fn read_32(&self, base: u64, offset: u64) -> Result<[u8; 4], Trap> { ... }
    fn read_64(&self, base: u64, offset: u64) -> Result<[u8; 8], Trap> { ... }
    fn read_128(&self, base: u64, offset: u64) -> Result<[u8; 16], Trap> { ... }
    fn write_8(&mut self, base: u64, offset: u64, byte: u8) -> Result<(), Trap> { ... }
    fn write_16(
        &mut self,
        base: u64,
        offset: u64,
        bytes: [u8; 2],
    ) -> Result<(), Trap> { ... }
    fn write_32(
        &mut self,
        base: u64,
        offset: u64,
        bytes: [u8; 4],
    ) -> Result<(), Trap> { ... }
    fn write_64(
        &mut self,
        base: u64,
        offset: u64,
        bytes: [u8; 8],
    ) -> Result<(), Trap> { ... }
    fn write_128(
        &mut self,
        base: u64,
        offset: u64,
        bytes: [u8; 16],
    ) -> Result<(), Trap> { ... }
}

Memory backend types and traits. Backend storage for a linear memory

This is a low-level trait that abstracts over the actual storage mechanism for linear memory. This will probably change in the future to allow more efficient implementations. See MemoryBackend for a higher-level interface to configuring memory storage.

Required Methods

fn len(&self) -> usize

Returns the current memory length in bytes.

fn grow_to(&mut self, new_len: usize) -> Result<(), Trap>

Grows the memory to new_len bytes.

The runtime only calls this with lengths that are exact multiples of the Wasm page size for the owning memory.

fn read(&self, addr: usize, dst: &mut [u8]) -> usize

Reads up to dst.len() bytes starting at addr and returns the number of bytes read.

Backends may return fewer bytes than requested even when more data is available. This lets non-contiguous backends stop at a natural boundary such as the end of a chunk.

fn write(&mut self, addr: usize, src: &[u8]) -> usize

Writes up to src.len() bytes starting at addr and returns the number of bytes written.

Backends may return fewer bytes than requested even when more space is available. This lets non-contiguous backends stop at a natural boundary such as the end of a chunk.

Provided Methods

fn is_empty(&self) -> bool

Returns true if the memory is empty.

fn write_all(&mut self, addr: usize, src: &[u8]) -> Option<()>

Writes all bytes in src starting at addr, or returns None if any byte could not be written.

fn fill(&mut self, addr: usize, len: usize, val: u8) -> Option<()>

Fills the range [addr, addr + len) with val.

fn copy_within(&mut self, dst: usize, src: usize, len: usize) -> Option<()>

Copies len bytes from src to dst within the same memory.

fn read_exact(&self, addr: usize, dst: &mut [u8]) -> Option<()>

Reads exactly dst.len() bytes starting at addr.

fn read_vec(&self, addr: usize, len: usize) -> Option<Vec<u8>>

Reads len bytes starting at addr into a newly allocated buffer.

fn read_8(&self, base: u64, offset: u64) -> Result<u8, Trap>

Reads exactly 1 byte at the effective address base + offset.

fn read_16(&self, base: u64, offset: u64) -> Result<[u8; 2], Trap>

Reads exactly 2 bytes at the effective address base + offset.

fn read_32(&self, base: u64, offset: u64) -> Result<[u8; 4], Trap>

Reads exactly 4 bytes at the effective address base + offset.

fn read_64(&self, base: u64, offset: u64) -> Result<[u8; 8], Trap>

Reads exactly 8 bytes at the effective address base + offset.

fn read_128(&self, base: u64, offset: u64) -> Result<[u8; 16], Trap>

Reads exactly 16 bytes at the effective address base + offset.

fn write_8(&mut self, base: u64, offset: u64, byte: u8) -> Result<(), Trap>

Writes exactly 1 byte at the effective address base + offset.

fn write_16( &mut self, base: u64, offset: u64, bytes: [u8; 2], ) -> Result<(), Trap>

Writes exactly 2 bytes at the effective address base + offset.

fn write_32( &mut self, base: u64, offset: u64, bytes: [u8; 4], ) -> Result<(), Trap>

Writes exactly 4 bytes at the effective address base + offset.

fn write_64( &mut self, base: u64, offset: u64, bytes: [u8; 8], ) -> Result<(), Trap>

Writes exactly 8 bytes at the effective address base + offset.

fn write_128( &mut self, base: u64, offset: u64, bytes: [u8; 16], ) -> Result<(), Trap>

Writes exactly 16 bytes at the effective address base + offset.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl LinearMemory for LazyLinearMemory

impl LinearMemory for PagedMemory

impl LinearMemory for VecMemory