Struct circular_array::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,

pub fn new() -> Self

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

example

    #[test]
    #[allow(non_snake_case)]
    fn test_Index_and_IndexMut() {
            let mut arr = CircularArray::<3, u32>::new();
            arr.push(0);
            arr.push(0);
            arr.push(0);
            arr.push(0);
            arr.push(0);
            arr[0] = 1;
            arr[1] = 2;
            arr[2] = 3;
            assert_eq!(arr[0], 1);
            assert_eq!(arr[1], 2);
            assert_eq!(arr[2], 3);
        }

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

Examples

    #[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]);
    }

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.