Struct sample::ring_buffer::Fixed

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

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.

extern crate sample;

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

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

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

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

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

Methods

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

pub fn len(&self) -> usize

The fixed length of the buffer.

extern crate sample;

use sample::ring_buffer;

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

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.

extern crate sample;

use sample::ring_buffer;

fn main() {
    let mut rb = 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]);
}

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.

extern crate sample;

use sample::ring_buffer;

fn main() {
    let mut rb = 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);
}

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.

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.

extern crate sample;

use sample::ring_buffer;

fn main() {
    let mut rb = 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);
}

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.

extern crate sample;

fn main() {
    let mut ring_buffer = sample::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][..], &[][..]));
}

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.

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

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

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

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

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.

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.

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

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

This method is unsafe as there is no guarantee that first < data.slice().len().

pub fn into_raw_parts(self) -> (usize, S)

Consumes the Fixed ring buffer and returns its parts:

• usize is an index into the first element of the buffer.
• S is the buffer data.

Trait Implementations

impl<S: Copy> Copy for Fixed<S>

impl<S: Clone> Clone for Fixed<S>

fn clone(&self) -> Fixed<S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: Debug> Debug for Fixed<S>

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

Formats the value using the given formatter.

impl<S: PartialEq> PartialEq for Fixed<S>

fn eq(&self, other: &Fixed<S>) -> bool

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

fn ne(&self, other: &Fixed<S>) -> bool

This method tests for !=.

impl<S: Eq> Eq for Fixed<S>

impl<S: Hash> Hash for Fixed<S>

fn hash<__HS: Hasher>(&self, state: &mut __HS)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where     H: Hasher,

Feeds a slice of this type into the given [Hasher].

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

fn from(data: S) -> Self

Construct a Fixed ring buffer from the given data slice.

**Panic!**s if the given data buffer is empty.

impl<S, T> FromIterator<T> for Fixed<S> where     S: Slice<Element = T> + FromIterator<T>,

fn from_iter<I>(iter: I) -> Self where     I: IntoIterator<Item = T>,

Creates a value from an iterator.

impl<S> Index<usize> for Fixed<S> where     S: Slice,

type Output = S::Element

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<S> IndexMut<usize> for Fixed<S> where     S: SliceMut,

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

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