Struct RingBuffer 

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

Efficient ring buffer for streaming data.

A fixed-capacity circular buffer that overwrites the oldest elements when full. Provides O(1) push operations and maintains temporal ordering.

Example

let mut buffer = RingBuffer::<f64>::new(100);
for i in 0..150 {
    buffer.push(i as f64);
}
// Buffer now contains 50..150, oldest data was overwritten
assert_eq!(buffer.len(), 100);
assert_eq!(buffer.get(0), Some(&50.0)); // Oldest remaining

Implementations

impl<T: Clone + Default> RingBuffer<T>

pub fn new(capacity: usize) -> Self

Create a new ring buffer with the specified capacity.

Panics

Panics if capacity is 0.

pub fn from_vec(data: Vec<T>, capacity: usize) -> Self

Create a new ring buffer with initial data.

If the data exceeds capacity, only the last capacity elements are kept.

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

Push a single item to the buffer.

O(1) operation. If the buffer is full, the oldest element is overwritten.

pub fn extend<I: IntoIterator<Item = T>>(&mut self, items: I)

Extend the buffer with multiple items.

More efficient than calling push repeatedly.

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

Get an item by logical index (0 = oldest item).

Returns None if the index is out of bounds.

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

Get a mutable reference to an item by logical index.

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

Get the most recent item (newest).

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

Get the oldest item.

pub fn len(&self) -> usize

Get the current number of elements.

pub fn is_empty(&self) -> bool

Check if the buffer is empty.

pub fn capacity(&self) -> usize

Get the maximum capacity.

pub fn has_wrapped(&self) -> bool

Check if the buffer has wrapped (oldest data was overwritten).

pub fn total_written(&self) -> u64

Get the total number of items ever written.

pub fn is_full(&self) -> bool

Check if the buffer is full.

pub fn clear(&mut self)

Clear all elements from the buffer.

pub fn iter(&self) -> RingBufferIter<'_, T>

Iterate over elements in order (oldest to newest).

pub fn as_slices(&self) -> (&[T], Option<&[T]>)

Get the data as one or two contiguous slices.

This is useful for efficient GPU uploads. If the buffer hasn’t wrapped, returns a single slice. If wrapped, returns two slices that together contain all data in order (oldest to newest).

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

Get a contiguous slice containing all data (may allocate).

If the buffer hasn’t wrapped, this returns a reference to the internal slice. Otherwise, it allocates and returns a new Vec.

Trait Implementations

impl<T: Clone> Clone for RingBuffer<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for RingBuffer<T>

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

Formats the value using the given formatter.

impl<T> Default for RingBuffer<T>

where T: Clone + Default,

fn default() -> Self

Returns the “default value” for a type.