Struct ringbuffer::GenericRingBuffer

pub struct GenericRingBuffer<T, Cap: ArrayLength<T>> { /* fields omitted */ }

The GenericRingBuffer struct is a RingBuffer implementation which does not require alloc. However it does depend on the typenum crate, to provide compile time integers without needing nightly rust. Unfortunately this is the only way to provide a compile time ringbuffer which does not require nightly rust like ConstGenericRingBuffer. Once const-generics are stable this struct will be depricated.

GenericRingBuffer allocates the ringbuffer on the stack, and the size must be known at compile time through typenum.

Example

use ringbuffer::{RingBuffer, GenericRingBuffer};
use ringbuffer::typenum; // for numbers as types in stable rust

let mut buffer = GenericRingBuffer::<_, typenum::U2>::new();

// First entry of the buffer is now 5.
buffer.push(5);

// The last item we pushed is 5
assert_eq!(buffer.get(-1), Some(&5));

// Second entry is now 42.
buffer.push(42);

assert_eq!(buffer.peek(), Some(&5));
assert!(buffer.is_full());

// Because capacity is reached the next push will be the first item of the buffer.
buffer.push(1);
assert_eq!(buffer.to_vec(), vec![42, 1]);

Implementations

impl<T: Default, Cap: ArrayLength<T>> GenericRingBuffer<T, Cap>

It is only possible to create a Generic RingBuffer if the type T in it implements Default. This is because the array needs to be allocated at compile time, and needs to be filled with some default value to avoid unsafe.

pub fn new() -> Self

Creates a new RingBuffer. The method is here for compatibility with the alloc version of RingBuffer. This method simply creates a default ringbuffer. The capacity is given as a type parameter.

Trait Implementations

impl<T: Debug, Cap: Debug + ArrayLength<T>> Debug for GenericRingBuffer<T, Cap>

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

Formats the value using the given formatter.

impl<T: Default, Cap: ArrayLength<T>> Default for GenericRingBuffer<T, Cap>

fn default() -> Self

Creates a buffer with a capacity specified through the Cap type parameter.

impl<T: Eq, Cap: Eq + ArrayLength<T>> Eq for GenericRingBuffer<T, Cap>

impl<RB: 'static + Default, Cap: ArrayLength<RB>> FromIterator<RB> for GenericRingBuffer<RB, Cap>

fn from_iter<T: IntoIterator<Item = RB>>(iter: T) -> Self

Creates a value from an iterator.

impl<T: 'static + Default, Cap: ArrayLength<T>> Index<isize> for GenericRingBuffer<T, Cap>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T: 'static + Default, Cap: ArrayLength<T>> IndexMut<isize> for GenericRingBuffer<T, Cap>

fn index_mut(&mut self, index: isize) -> &mut Self::Output

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

impl<T: PartialEq, Cap: PartialEq + ArrayLength<T>> PartialEq<GenericRingBuffer<T, Cap>> for GenericRingBuffer<T, Cap>

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

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

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

This method tests for !=.

impl<T: 'static + Default, Cap: ArrayLength<T>> RingBuffer<T> for GenericRingBuffer<T, Cap>

fn len(&self) -> usize

Returns the length of the internal buffer. This length grows up to the capacity and then stops growing. This is because when the length is reached, new items are appended at the start.

fn clear(&mut self)

Empties the buffer entirely. Sets the length to 0 but keeps the capacity allocated.

fn capacity(&self) -> usize

Returns the capacity of the buffer.

fn push(&mut self, e: T)

Pushes a value onto the buffer. Cycles around if capacity is reached.

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

Gets a value relative to the current index. 0 is the next index to be written to with push. -1 and down are the last elements pushed and 0 and up are the items that were pushed the longest ago.

unsafe fn get_mut_impl(&mut self, index: isize) -> Option<&mut T>

Gets a value relative to the current index mutably. 0 is the next index to be written to with push. -1 and down are the last elements pushed and 0 and up are the items that were pushed the longest ago.

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

Gets a value relative to the start of the array (rarely useful, usually you want Self::get)

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

Gets a value mutably relative to the start of the array (rarely useful, usually you want Self::get_mut)

fn is_empty(&self) -> bool

Returns true if the buffer is entirely empty. This is currently only true when nothing has ever been pushed, or when the Self::clear function is called. This might change when the pop function is added with issue #21

fn is_full(&self) -> bool

Returns true when the length of the ringbuffer equals the capacity. This happens whenever more elements than capacity have been pushed to the buffer.

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

Gets a value relative to the current index mutably. 0 is the next index to be written to with push. -1 and down are the last elements pushed and 0 and up are the items that were pushed the longest ago.

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

Returns the value at the current index. This is the value that will be overwritten by the next push and also the value pushed the longest ago. (alias of Self::front)

fn back(&self) -> Option<&T>

Returns the value at the back of the queue. This is the item that was pushed most recently.

fn front(&self) -> Option<&T>

Returns the value at the back of the queue. This is the value that will be overwritten by the next push and also the value pushed the longest ago. (alias of peek)

fn back_mut(&mut self) -> Option<&mut T>

Returns a mutable reference to the value at the back of the queue. This is the item that was pushed most recently.

fn front_mut(&mut self) -> Option<&mut T>

Returns a mutable reference to the value at the back of the queue. This is the value that will be overwritten by the next push. (alias of peek)

fn iter(&self) -> RingBufferIterator<'_, T, Self>

Creates an iterator over the buffer starting from the latest push. Creates an iterator over the buffer starting from the item pushed the longest ago, and ending at the element most recently pushed.

fn iter_mut(&mut self) -> RingBufferMutIterator<'_, T, Self>

Creates a mutable iterator over the buffer starting from the latest push. Creates a mutable iterator over the buffer starting from the item pushed the longest ago, and ending at the element most recently pushed.

fn to_vec(&self) -> Vec<T> where
    T: Clone, 

Converts the buffer to a vector. This Copies all elements in the ringbuffer.

fn contains(&self, elem: &T) -> bool where
    T: PartialEq, 

Returns true if elem is in the ringbuffer.

impl<T, Cap: ArrayLength<T>> StructuralEq for GenericRingBuffer<T, Cap>

impl<T, Cap: ArrayLength<T>> StructuralPartialEq for GenericRingBuffer<T, Cap>