Struct lv2_atom::space::SpaceHead

pub struct SpaceHead<'a> { /* fields omitted */ }

A mutable space that dynamically allocates memory.

This space uses a linked list of SpaceElements to allocate memory. Every time allocate is called, a new element is appended to the list and a new byte slice is created.

In order to use this space and retrieve the written data once it was written, you create a SpaceElement and create a new head with it. Then, you use the head like any other MutSpace and when you're done, you retrieve the written data by either calling to_vec or iter.

Usage example

// URID cache creation is omitted.
let urids: AtomURIDCollection = map.populate_collection().unwrap();

// Creating the first element in the list and the writing head.
let mut element = SpaceElement::default();
let mut head = SpaceHead::new(&mut element);

// Writing an integer.
(&mut head as &mut dyn MutSpace).init(urids.int, 42).unwrap();

// Retrieving a continuos vector with the written data and verifying it's contents.
let written_data: Vec<u8> = element.to_vec();
let atom = UnidentifiedAtom::new(Space::from_slice(written_data.as_ref()));
assert_eq!(42, atom.read(urids.int, ()).unwrap());

Implementations

impl<'a> SpaceHead<'a>

pub fn new(element: &'a mut SpaceElement) -> Self

Create a new head that references the given element.

Trait Implementations

impl<'a> MutSpace<'a> for SpaceHead<'a>

fn allocate(
    &mut self,
    size: usize,
    apply_padding: bool
) -> Option<(usize, &'a mut [u8])>

Try to allocate memory on the internal data slice.

fn write_raw(
    &mut self,
    data: &[u8],
    apply_padding: bool
) -> Option<&'a mut [u8]>

Try to write data to the internal data slice.