Struct rbuf::RingBuf

pub struct RingBuf<T> { /* fields omitted */ }

A ring buffer for arbitrary but default-initializable data.

The ring buffer is always “full”, but may only contain “default” representations of the given type if nothing else has been inserted. There is no concept of a removing elements, only overwriting them with the default. Gaps or non-existent elements can be represented by having an element type Option<T>.

One implication of the above is that iteration will always yield as many elements as the ring buffer’s size.

Indexing into the ring buffer using bracket notation works in such a way that an index of 0 always accesses the least recently added element and an index of self.len() - 1 the most recently added one. Furthermore, indexes wrap around at the ring buffer’s end, meaning that an index of value self.len() would access the same element as index 0.

Implementations

impl<T> RingBuf<T> where
    T: Default, 

pub fn new(len: usize) -> Self

Create a new RingBuf of a fixed length as provided.

len must be greater than zero.

pub fn pop_front(&mut self) -> T

Pop the most recently added element from the ring buffer.

This operation will remove the ring buffer’s most recently added element and replace it with the default value of T. The formerly second most recently added element will be the ring buffer’s new “front”.

pub fn into_boxed_slice(self) -> Box<[T]>

Convert the RingBuf into a boxed slice of its contents.

impl<T> RingBuf<T>

pub fn from_vec(vec: Vec<T>) -> Self

Create a new RingBuf with data from a Vec.

Note that the vector’s first element is considered the oldest one, which means that the first read will access it and pushed data will overwrite it first. Note furthermore that the provided Vec is required to contain at least a single element.

pub const fn len(&self) -> usize

Retrieve the ring buffer’s length.

pub fn front(&self) -> &T

Retrieve the current “front” element, i.e., the element that got inserted most recently.

pub fn front_mut(&mut self) -> &mut T

Retrieve the current “front” element, i.e., the element that got inserted most recently.

pub fn front_idx(&self) -> usize

Retrieve the current “front” index, i.e., the index of the element that got inserted most recently.

Note that this index only has real relevance when accessing the underlying slice using deref. In particular, the index returned by this method should not be confused with those as expected by our Index implementation (as accessible through bracket syntax).

pub fn back(&self) -> &T

Retrieve the current “back” element, i.e., the element that got inserted the furthest in the past.

pub fn back_mut(&mut self) -> &mut T

Retrieve the current “back” element, i.e., the element that got inserted the furthest in the past.

pub fn back_idx(&self) -> usize

Retrieve the current “back” index, i.e., the index of the element that got inserted the furthest in the past.

Note that this index only has real relevance when accessing the underlying slice using deref. In particular, the index returned by this method should not be confused with those as expected by our Index implementation (as accessible through bracket syntax).

pub fn push_front(&mut self, elem: T)

Push an element into the ring buffer.

This operation will evict the ring buffer’s least recently added element (i.e., the element at the back) and replace it with the provided one. The newly pushed element will be considered the ring buffer’s new “front”.

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

Retrieve an iterator over the elements of the ring buffer.

pub fn iter_mut(&mut self) -> RingIterMut<'_, T>

Retrieve a mutating iterator over the elements of the ring buffer.

Trait Implementations

impl<T: Clone> Clone for RingBuf<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for RingBuf<T>

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

Formats the value using the given formatter.

impl<T> Deref for RingBuf<T>

type Target = [T]

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> DerefMut for RingBuf<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T> Index<usize> for RingBuf<T>

type Output = T

The returned type after indexing.

fn index(&self, idx: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T> IndexMut<usize> for RingBuf<T>

fn index_mut(&mut self, idx: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<T: PartialEq> PartialEq<RingBuf<T>> for RingBuf<T>

fn eq(&self, other: &RingBuf<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &RingBuf<T>) -> bool

This method tests for !=.

impl<T> StructuralPartialEq for RingBuf<T>