Struct LocalRingBuffer 

pub struct LocalRingBuffer<T> { /* private fields */ }

Single-threaded ring buffer optimized for maximum performance

LocalRingBuffer uses VecDeque directly without synchronization primitives, providing optimal performance for single-threaded contexts.

For multi-threaded scenarios requiring concurrent access, use the thread-safe RingBuffer type (defined below in this module) which wraps the buffer in Arc<RwLock> for safe concurrent access.

Implementations

impl<T: Copy + Default> LocalRingBuffer<T>

pub fn new(capacity: usize) -> Self

Create new local ring buffer with given capacity

pub fn push(&mut self, value: T)

Push value to buffer, overwriting oldest if full

pub fn sliding_window(&self, size: usize) -> Vec<T>

Get sliding window of last N elements

Performance

Efficiently accesses the last N elements with direct indexing. Time complexity: O(k) where k is the window size.

pub fn get(&self, index: usize) -> Option<T>

Get a single element by index (0 = oldest, len-1 = newest)

pub fn last(&self) -> Option<T>

Get the most recent element

pub fn first(&self) -> Option<T>

Get the oldest element

pub fn len(&self) -> usize

Get current size of buffer

pub fn is_empty(&self) -> bool

Check if buffer is empty

pub fn clear(&mut self)

Clear the buffer

pub fn capacity(&self) -> usize

Get capacity of the buffer

pub fn to_vec(&self) -> Vec<T>

Convert to vector (for testing/debugging)

pub fn iter(&self) -> impl Iterator<Item = &T>

Get an iterator over the buffer elements (oldest to newest)

pub fn sliding_window_into(&self, size: usize, dest: &mut [T]) -> usize

Zero-allocation sliding window - writes into pre-allocated buffer

Performance

This method avoids heap allocation by writing directly into the provided buffer. For streaming applications processing millions of ticks, this eliminates allocation overhead completely.

Arguments

• size - Number of elements to read (from the most recent)
• dest - Pre-allocated destination buffer (must have sufficient capacity)

Returns

Number of elements written to destination

pub fn sliding_window_slices(&self, size: usize) -> (&[T], &[T])

Get the N most recent elements as contiguous slices

Since VecDeque may store data in two non-contiguous slices, this returns both slices that comprise the last N elements. For many use cases, this avoids allocation entirely.

Returns

Tuple of (first_slice, second_slice) - second may be empty

pub fn get_recent_samples(&self, count: usize, dest: &mut [T]) -> usize

Get the most recent N samples for circular convolution

Optimized for MODWT streaming where we need the last filter_len samples for computing a single new coefficient.

Returns

Number of samples copied (may be less than filter_len if buffer not full)

Trait Implementations

impl<T: Clone> Clone for LocalRingBuffer<T>

fn clone(&self) -> LocalRingBuffer<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for LocalRingBuffer<T>

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

Formats the value using the given formatter.