Struct rotating_buffer::RotatingBuffer

pub struct RotatingBuffer<T: Default + Copy, const S: usize> {
    pub inner: [T; S],
    // some fields omitted
}

Fields

inner: [T; S]

Implementations

impl<T: Default + Copy, const S: usize> RotatingBuffer<T, S>

pub fn new() -> RotatingBuffer<T, S>

pub fn as_slice(&self) -> &[T]

Extracts slice with the length of the buffer’s internally tracked size

Example

let mut buf = RotatingBuffer::<u128, 20>::new();
assert_eq!(buf.as_slice().len(), 0);

buf.add_len(15);
assert_eq!(buf.as_slice().len(), 15);

pub fn get_append_only(&mut self) -> &mut [T]

Returns a mutable slice with the length of the currently “unused” allocation of the buffer

Example

let mut buf = RotatingBuffer::<u8, 5>::new();
buf.add_len(3);

assert_eq!(buf.get_append_only().len(), 2);
buf.get_append_only()[0] = 50;
assert_eq!(buf.inner, [0, 0, 0, 50, 0]);

pub fn is_empty(&self) -> bool

Returns true if the buffer’s internal size is 0

pub fn len(&self) -> usize

Returns internally tracked length

pub fn capacity(&self) -> usize

Returns the capacity of this buffer

pub fn resize(&mut self, new_len: usize)

Manually set the internal size of the buffer

Panics

Panics if the new size is bigger than its capacity

pub fn add_len(&mut self, new_len: usize) -> usize

Add to the current internal length of the buffer

Example

let mut buf = RotatingBuffer::<u8, 5>::new();
assert_eq!(buf.len(), 0);

buf.add_len(3);
assert_eq!(buf.len(), 3);
buf.add_len(1);
assert_eq!(buf.len(), 4);

pub fn rotate_right_and_resize(&mut self, k: usize)

Rotates the buffer contents in place (see core::slice::rotate_right) and subsequently changes the buffer’s internal length to however much was rotated

Example

let mut buf = RotatingBuffer::<bool, 5>::new();
buf.get_append_only()[3] = true;
buf.add_len(5);

buf.rotate_right_and_resize(2);
assert_eq!(buf.as_slice()[0], true);
assert_eq!(buf.len(), 2);

pub fn rotate_right_and_resize_at(&mut self, index: usize)

Rotate and resize buffer by supplying an index rather than a length

Example

let mut buf = RotatingBuffer::<bool, 5>::new();
buf.get_append_only()[3] = true;
buf.add_len(5);

buf.rotate_right_and_resize_at(3);
assert_eq!(buf.as_slice()[0], true);
assert_eq!(buf.len(), 2);

Trait Implementations

impl<T: Clone + Default + Copy, const S: usize> Clone for RotatingBuffer<T, S>

fn clone(&self) -> RotatingBuffer<T, S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Default + Copy, const S: usize> Debug for RotatingBuffer<T, S>

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

Formats the value using the given formatter.

impl<T: Default + Copy, const S: usize> Default for RotatingBuffer<T, S>

Maybe just to allow RotatingBuffer<RotatingBuffer<T, S>, S> 😄

Example

let mut buf = RotatingBuffer::<RotatingBuffer<u8, 10>, 5>::new();
buf.add_len(2);
let slice = buf.as_slice();
assert_eq!(slice[0].inner, slice[1].inner);

But why!

fn default() -> Self

Returns the “default value” for a type.

impl<T: Copy + Default, const S: usize> Copy for RotatingBuffer<T, S>