Struct satrs::pool::StaticMemoryPool

pub struct StaticMemoryPool { /* private fields */ }

Available on crate feature alloc only.

Pool implementation providing sub-pools with fixed size memory blocks.

This is a simple memory pool implementation which pre-allocates all subpools using a given pool configuration. After the pre-allocation, no dynamic memory allocation will be performed during run-time. This makes the implementation suitable for real-time applications and embedded environments.

The subpool bucket sizes only denote the maximum possible data size being stored inside them and the pool implementation will still track the size of the data stored inside it. The implementation will generally determine the best fitting subpool for given data to add. Currently, the pool does not support spilling to larger subpools if the closest fitting subpool is full. This might be added in the future.

Transactions with the pool are done using a generic address type. Adding any data to the pool will yield a store address. Modification and read operations are done using a reference to a store address. Deletion will consume the store address.

Implementations

impl StaticMemoryPool

pub fn new(cfg: StaticPoolConfig) -> StaticMemoryPool

Create a new local pool from the given configuration. This function will sanitize the given configuration as well.

Trait Implementations

impl PoolProvider for StaticMemoryPool

fn add(&mut self, data: &[u8]) -> Result<PoolAddr, PoolError>

Add new data to the pool. The provider should attempt to reserve a memory block with the appropriate size and then copy the given data to the block. Yields a PoolAddr which can be used to access the data stored in the pool

fn free_element<W: FnMut(&mut [u8])>( &mut self, len: usize, writer: W ) -> Result<PoolAddr, PoolError>

The provider should attempt to reserve a free memory block with the appropriate size first. It then executes a user-provided closure and passes a mutable reference to that memory block to the closure. This allows the user to write data to the memory block. The function should yield a PoolAddr which can be used to access the data stored in the pool.

fn modify<U: FnMut(&mut [u8])>( &mut self, addr: &PoolAddr, updater: U ) -> Result<(), PoolError>

Modify data added previously using a given PoolAddr. The provider should use the store address to determine if a memory block exists for that address. If it does, it should call the user-provided closure and pass a mutable reference to the memory block to the closure. This allows the user to modify the memory block.

fn read(&self, addr: &PoolAddr, buf: &mut [u8]) -> Result<usize, PoolError>

The provider should copy the data from the memory block to the user-provided buffer if it exists.

fn delete(&mut self, addr: PoolAddr) -> Result<(), PoolError>

Delete data inside the pool given a PoolAddr.

fn has_element_at(&self, addr: &PoolAddr) -> Result<bool, PoolError>

fn len_of_data(&self, addr: &PoolAddr) -> Result<usize, PoolError>

Retrieve the length of the data at the given store address.

fn read_as_vec(&self, addr: &PoolAddr) -> Result<Vec<u8>, PoolError>

impl PoolProviderWithGuards for StaticMemoryPool

fn modify_with_guard(&mut self, addr: PoolAddr) -> PoolRwGuard<'_, Self>

This function behaves like PoolProvider::modify, but consumes the provided address and returns a RAII conformant guard object.

fn read_with_guard(&mut self, addr: PoolAddr) -> PoolGuard<'_, Self>

This function behaves like PoolProvider::read, but consumes the provided address and returns a RAII conformant guard object.