Struct RollingBuffer 

pub struct RollingBuffer<T>
where
    T: Clone,
{ /* private fields */ }

RollingBuffer is a fixed size heap buffer that will override the beginning of the buffer when it is full RollingBuffer is a very simple Vec wrapper that only uses safe code.

[‘size’]: size is the maximum number of elements that the buffer can hold [‘vec’]: vec is the underlying Vec that stores the elements of the buffer [‘last_removed’]: last_removed is the last element that was removed from the buffer [‘count’]: count is the number of elements in the buffer as if the buffer was Vec

Trait Implementations

impl<T> Clone for RollingBuffer<T>

where T: Clone + Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for RollingBuffer<T>

where T: Clone + Debug,

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

Formats the value using the given formatter.

impl<T> Default for RollingBuffer<T>

where T: Clone + Default,

fn default() -> RollingBuffer<T>

Returns the “default value” for a type.

impl<T> Rolling<T> for RollingBuffer<T>

where T: Clone + Default,

fn new(size: usize) -> Self

Creates a new RollingBuffer with the given size and initial value (aka none) If the size is 0, the buffer will behave as a normal Vec

fn push(&mut self, value: T)

Adds an element to the buffer, overriding the beginning of the buffer when it is full Here using “safe code”, but it is essentially unsafe ptr::write()

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

Get the element at the given index, as if the buffer was a Vec

buffer of size 3, adding 1,2,3,4 and asking for the element at index 3 will return 4. Asking for index 0 will return None since this element was overriden already. Example:

let mut buffer = RollingBuffer::<i32>::new(3, 0);
buffer.push(1);
buffer.push(2);
buffer.push(3);
buffer.push(4);
assert_eq!(buffer.get(3), Some(&4));
assert_eq!(buffer.get(0), None);

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

Returns an option containing a reference to the first element in the rolling data.

If no elements have been added (count is zero), it returns None. Otherwise, it returns a reference to the last added element. The index calculation considers the possibility of wrapping around when the number of elements added exceeds the size of the vec.

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

Last added element’s mutable reference.

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

Returns the theoretical first element.

Example:

let mut buffer = RollingBuffer::<i32>::new(3);
buffer.push(1);
buffer.push(2);
buffer.push(3);
buffer.push(4);
assert_eq!(buffer.first(), Some(&2));

fn len(&self) -> usize

Returns theoretical len as if it was a Vec.

fn size(&self) -> usize

Returns the maximum number of elements that can be stored.

fn raw(&self) -> &Vec<T>

Returns the underlying vector as it is stored inside the RollingBuffer.

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

Returns the last removed element. Can be very useful if needed for debugging or other purposes.

fn count(&self) -> usize

Returns ‘expected’ number of elements as if the RollingBuffer was a Vec. i.e. the number of elements that would be in the Vec if it was not a RollingBuffer.

fn is_empty(&self) -> bool

Returns true if the RollingBuffer is empty.

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

Creates a new Vec, which contains all elements in the RollingBuffer in correct order.