Struct RingBuffer 

pub struct RingBuffer<T, const N: usize> { /* private fields */ }

Fixed-capacity ring buffer.

A circular buffer that stores up to N-1 elements (one slot reserved for distinguishing full from empty). All operations are O(1) and allocation-free after construction.

Type Parameters

• T - The element type
• N - Buffer capacity (must be > 1; usable capacity is N-1)

Example

use laminar_core::alloc::RingBuffer;

let mut buffer: RingBuffer<u64, 4> = RingBuffer::new();

buffer.push(1).unwrap();
buffer.push(2).unwrap();
buffer.push(3).unwrap();
// buffer.push(4) would fail - only 3 slots usable

assert_eq!(buffer.pop(), Some(1));
assert_eq!(buffer.pop(), Some(2));

Thread Safety

This buffer is NOT thread-safe. For multi-threaded scenarios, use the SPSC queue in tpc::spsc.

Implementations

impl<T, const N: usize> RingBuffer<T, N>

pub fn new() -> Self

Create a new empty ring buffer.

Panics

Panics if N < 2 (need at least 2 slots for ring buffer semantics).

pub fn push(&mut self, item: T) -> Result<(), T>

Push an item onto the buffer.

Performance

O(1), no allocation.

Errors

Returns Err(item) if the buffer is full, giving back ownership of the item that couldn’t be inserted.

Example

use laminar_core::alloc::RingBuffer;

let mut buf: RingBuffer<i32, 4> = RingBuffer::new();
buf.push(1).unwrap();
buf.push(2).unwrap();
buf.push(3).unwrap();
assert!(buf.push(4).is_err()); // Full

pub fn pop(&mut self) -> Option<T>

Pop an item from the buffer.

Returns None if the buffer is empty.

Performance

O(1), no allocation.

Example

use laminar_core::alloc::RingBuffer;

let mut buf: RingBuffer<i32, 4> = RingBuffer::new();
buf.push(42).unwrap();
assert_eq!(buf.pop(), Some(42));
assert_eq!(buf.pop(), None);

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

Peek at the front item without removing it.

Returns None if the buffer is empty.

Performance

O(1), no allocation.

pub fn peek_mut(&mut self) -> Option<&mut T>

Get mutable reference to the front item without removing it.

pub fn is_empty(&self) -> bool

true when no items are buffered.

pub fn is_full(&self) -> bool

true when inserting would overwrite the oldest item.

pub fn len(&self) -> usize

Number of items currently buffered.

pub const fn capacity(&self) -> usize

Get the maximum usable capacity (N - 1).

pub fn clear(&mut self)

Clear all items from the buffer.

Drops all contained items and resets to empty state.

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

Iterate over items without consuming them.

Trait Implementations

impl<T: Debug, const N: usize> Debug for RingBuffer<T, N>

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

Formats the value using the given formatter.

impl<T, const N: usize> Default for RingBuffer<T, N>

fn default() -> Self

Returns the “default value” for a type.

impl<T, const N: usize> Drop for RingBuffer<T, N>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, T, const N: usize> IntoIterator for &'a RingBuffer<T, N>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = RingBufferIter<'a, T, N>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.