Struct CircularArray

pub struct CircularArray<const N: usize, T> { /* private fields */ }

A circular array that allows infinite pushes into a fixed-size array.

Implementations

impl<const N: usize, T> CircularArray<N, T>

where T: Copy + Default + Debug + Display,

pub fn new() -> Self

pub fn push(&mut self, item: T)

example

use circular_array::CircularArray;
#[test]
fn test_push() {
    let mut arr = CircularArray::<3, u32>::new();
    arr.push(1);
    arr.push(2);
    arr.push(3);
    assert_eq!(arr.to_array(), [1, 2, 3]);
    arr.push(4);
    assert_eq!(arr.to_array(), [2, 3, 4]);
}

pub fn to_array(&self) -> [T; N]

Examples

    use circular_array::CircularArray;
#[test]
    fn test_to_array() {
        let mut arr = CircularArray::<3, u32>::new();
        arr.push(1);
        arr.push(2);
        arr.push(3);
        assert_eq!(arr.to_array(), [1, 2, 3]);
        arr.push(4);
        assert_eq!(arr.to_array(), [2, 3, 4]);
    }

pub fn iter(&self) -> CircularArrayIter<'_, N, T>

example

use circular_array::CircularArray;
let mut arr = CircularArray::<3, u32>::new();
arr.push(1);
arr.push(2);
arr.push(3);
let mut iter: circular_array::iter::CircularArrayIter<3, u32> = arr.iter();
assert_eq!(iter.next(), Some(&1));
assert_eq!(iter.next(), Some(&2));
assert_eq!(iter.next(), Some(&3));
assert_eq!(iter.next(), None);

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

Example

use circular_array::CircularArray;
#[test]
fn test_last() {
    let mut arr = CircularArray::<3, u32>::new();
    assert_eq!(arr.last(), None);
    arr.push(1);
    assert_eq!(arr.last(), Some(1).as_ref());
    arr.push(2);
    arr.push(3);
    arr.push(4);
    assert_eq!(arr.last(), Some(4).as_ref());
}

pub fn len(&self) -> usize

Trait Implementations

impl<const N: usize, T: Debug> Debug for CircularArray<N, T>

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

Formats the value using the given formatter.

impl<T, const N: usize> Index<usize> for CircularArray<N, T>

where [T]: Index<usize>, T: Default + Copy,

type Output = <[T] as Index<usize>>::Output

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T, const N: usize> IndexMut<usize> for CircularArray<N, T>

where [T]: Index<usize>, T: Default + Copy, usize: Add<usize>,

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

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