Struct BufferPool 

pub struct BufferPool<T: Buffer> { /* private fields */ }

A pool of reusable memory buffers to optimize memory allocation for Sv2 message frames.

Manages memory slices across three pool modes: back (default), front, and system memory. It reuses preallocated memory slices, minimizing the need for frequent memory allocation. The pool is thread-safe, using atomic state tracking.

Type T implements the Buffer trait, which defines how memory is handled in the buffer pool. BufferFromSystemMemory is used as the default system memory allocator.

Implementations

impl BufferPool<BufferFromSystemMemory>

pub fn new(capacity: usize) -> Self

Creates a new BufferPool with the specified memory capacity, in bytes.

Initializes the buffer pool with pre-allocated memory (inner_memory) and sets the pool mode to the back. The buffer pool uses BufferFromSystemMemory as a fallback when the buffer sections are full.

impl<T: Buffer> BufferPool<T>

pub fn is_front_mode(&self) -> bool

Checks if the buffer pool is operating in the front mode.

This mode indicates that the back of the buffer pool has been filled and the system is now using the front section for memory allocation. Returns true if the pool is in front mode, otherwise false.

pub fn is_back_mode(&self) -> bool

Checks if the buffer pool is operating in the back mode.

The back mode is the default state, where the buffer pool first tries to allocate memory. Returns true if the pool is in back mode, otherwise false.

pub fn is_alloc_mode(&self) -> bool

Checks if the buffer pool is operating in the system memory allocation mode.

This mode is used when both the back and front sections of the buffer pool are full, leading the system to allocate memory from the heap, which has performance trade-offs. Returns true if the pool is in alloc mode, otherwise false.

Trait Implementations

impl<T: Buffer> Buffer for BufferPool<T>

type Slice = Slice

The type of slice that the buffer uses.

fn reserve(&mut self, len: usize) -> &mut [u8]

Makes room for len more bytes after the data written so far and returns that space, without counting any of it as written.

fn commit(&mut self, len: usize)

Counts the first len bytes of the last reservation as written, and ends that reservation.

fn get_data_owned(&mut self) -> Self::Slice

Provides ownership of a slice in the buffer pool to the caller and updates the buffer pool’s state by modifying the position in shared_state that the slice occupies. The pool now points to the next set of uninitialized space.

fn frame(&self) -> &[u8]

Returns the committed bytes of the frame being written, without transferring ownership of the buffer.

fn frame_mut(&mut self) -> &mut [u8]

Returns the committed bytes of the frame being written, mutably, without transferring ownership of the buffer.

fn len(&self) -> usize

Returns the size of the written portion of the buffer. This is useful for tracking how much of the buffer has been filled with data. The number of bytes currently written in the buffer is returned.

fn truncate(&mut self, len: usize)

Drops the committed bytes past len, like Vec::truncate: a len at or past the committed length changes nothing, so the frame can only shrink.

fn is_empty(&self) -> bool

Returns true if the buffer is empty, false otherwise.

impl<T: Debug + Buffer> Debug for BufferPool<T>

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

Formats the value using the given formatter.