Struct ringbuffer_iteration::RingBuffer

pub struct RingBuffer<T: Copy + Clone, const N: usize> { /* fields omitted */ }

An implementation of a ring buffer data structure that creates a “lossy” queue. This is a simplified version of the generic heapless Queue with a few constraints relaxed:

• The Item type is at least Copy + Clone
• We do not care about overwritten data in the buffer. Should be able to write indefinitely without error.

An iterator is also defined for RingBuffer which implements Iterator, ExactSizeIterator, and DoubleEndedIterator. The iterator begins at the head of the ring buffer and iterates until it reaches the tail.

Also uses an internal flag overwriting to allow iteration over the last value in the ring buffer, giving the structure a capacity of N rather than the typical ringbuffer capacity of N-1.

Implementations

impl<T, const N: usize> RingBuffer<T, N> where
    T: Copy + Clone, 

pub fn new(backing_store: [T; N]) -> Self

pub fn is_empty(&self) -> bool

pub fn is_full(&self) -> bool

pub fn capacity(&self) -> usize

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

Add a new item to the ring buffer.

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

Pops the last item off of the ring buffer.

Trait Implementations

impl<'a, T, const N: usize> IntoIterator for &'a RingBuffer<T, N> where
    T: Copy + Clone, 

type Item = T

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.