Struct Fixed

Source

pub struct Fixed<S> { /* private fields */ }

Expand description

A ring buffer with a fixed length.

AKA Circular buffer, cyclic buffer, FIFO queue.

Elements are pushed and popped from the buffer simultaneously in order to retain a consistent length.

A Fixed ring buffer can be created around any type with a slice to write to.

fn main() {
    // From a fixed size array.
    dasp_ring_buffer::Fixed::from([1, 2, 3, 4]);

    // From a Vec.
    dasp_ring_buffer::Fixed::from(vec![1, 2, 3, 4]);

    // From a Boxed slice.
    dasp_ring_buffer::Fixed::from(vec![1, 2, 3].into_boxed_slice());

    // From a mutably borrowed slice.
    let mut slice = [1, 2, 3, 4];
    dasp_ring_buffer::Fixed::from(&mut slice[..]);

    // An immutable ring buffer from an immutable slice.
    let slice = [1, 2, 3, 4];
    dasp_ring_buffer::Fixed::from(&slice[..]);
}

Implementations§

Source §

impl<S> Fixed<S>
where S: Slice,

Source

pub fn len(&self) -> usize

The fixed length of the buffer.

fn main() {
    let rb = dasp_ring_buffer::Fixed::from([0; 4]);
    assert_eq!(rb.len(), 4);
}

Source

pub fn push(&mut self, item: S::Element) -> S::Element
where S: SliceMut,

Push the given item onto the back of the queue and return the item at the front of the queue, ensuring that the length is retained.

fn main() {
    let mut rb = dasp_ring_buffer::Fixed::from([0, 1, 2, 3]);
    assert_eq!(rb.push(4), 0);
    assert_eq!(rb.push(5), 1);
    assert_eq!(rb.push(6), 2);
    assert_eq!(rb.push(7), 3);
    assert_eq!(rb.push(8), 4);
    assert_eq!([rb[0], rb[1], rb[2], rb[3]], [5, 6, 7, 8]);
}

Source

pub fn get(&self, index: usize) -> &S::Element

Borrows the item at the given index.

If index is out of range it will be looped around the length of the data slice.

fn main() {
    let mut rb = dasp_ring_buffer::Fixed::from([0, 1, 2]);
    assert_eq!(*rb.get(0), 0);
    assert_eq!(*rb.get(1), 1);
    assert_eq!(*rb.get(2), 2);
    assert_eq!(*rb.get(3), 0);
    assert_eq!(*rb.get(4), 1);
    assert_eq!(*rb.get(5), 2);
}

Source

pub fn get_mut(&mut self, index: usize) -> &mut S::Element
where S: SliceMut,

Mutably borrows the item at the given index.

If index is out of range it will be looped around the length of the data slice.

Source

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

Sets the index of the first element within the data slice.

If index is out of range it will be looped around the length of the data slice.

fn main() {
    let mut rb = dasp_ring_buffer::Fixed::from([0, 1, 2, 3]);
    assert_eq!(rb[0], 0);
    rb.set_first(2);
    assert_eq!(rb[0], 2);
    rb.set_first(5);
    assert_eq!(rb[0], 1);
}

Source

pub fn slices(&self) -> (&[S::Element], &[S::Element])

The start and end slices that make up the ring buffer.

These two slices chained together represent all elements within the buffer in order.

The first slice is always aligned contiguously behind the second slice.

fn main() {
    let mut ring_buffer = dasp_ring_buffer::Fixed::from([0; 4]);
    assert_eq!(ring_buffer.slices(), (&[0, 0, 0, 0][..], &[][..]));
    ring_buffer.push(1);
    ring_buffer.push(2);
    assert_eq!(ring_buffer.slices(), (&[0, 0][..], &[1, 2][..]));
    ring_buffer.push(3);
    ring_buffer.push(4);
    assert_eq!(ring_buffer.slices(), (&[1, 2, 3, 4][..], &[][..]));
}

Source

pub fn slices_mut(&mut self) -> (&mut [S::Element], &mut [S::Element])
where S: SliceMut,

The same as the slices method, but returns mutable slices instead.

Source

pub fn iter_loop(&self) -> Skip<Cycle<Iter<'_, S::Element>>>

Produce an iterator that repeatedly yields a reference to each element in the buffer.

Source

pub fn iter(&self) -> Take<Skip<Cycle<Iter<'_, S::Element>>>>

Produce an iterator that yields a reference to each element in the buffer.

Source

pub fn iter_mut( &mut self, ) -> Chain<IterMut<'_, S::Element>, IterMut<'_, S::Element>>
where S: SliceMut,

Produce an iterator that yields a mutable reference to each element in the buffer.

Source

pub fn from_raw_parts(first: usize, data: S) -> Self

Creates a Fixed ring buffer from its starting index and data buffer type.

**Panic!**s if the given index is out of range of the given data slice.

Note: This method should only be necessary if you require specifying a first index. Please see the ring_buffer::Fixed::from function for a simpler constructor that does not require a first index.

Source