Struct CyclicArray 

pub struct CyclicArray<T> { /* private fields */ }

Basic circular buffer, or what Goodrich and Kloss call a circular deque.

This implementation allows push and pop from both ends of the buffer and supports insert and remove from arbitrary offsets.

Unlike the VecDeque in the standard library, this array has a fixed size and will panic if a push is performed while the array is already full.

Implementations

impl<T> CyclicArray<T>

pub fn new(capacity: usize) -> Self

Construct a new cyclic array with the given capacity.

pub fn combine(a: CyclicArray<T>, b: CyclicArray<T>) -> Self

Take the elements from the two other cyclic arrays into a new cyclic array with the combined capacity.

pub fn from(capacity: usize, other: CyclicArray<T>) -> Self

Take the elements from the other cyclic array into a new cyclic array with the given capacity.

pub fn split(self) -> (CyclicArray<T>, CyclicArray<T>)

Split this cyclic buffer into two equal sized buffers.

The second buffer may be empty if all elements fit within the first buffer.

pub fn push_back(&mut self, value: T)

Appends an element to the back of the cyclic array.

Panic

Panics if the buffer is already full.

pub fn push_front(&mut self, value: T)

Prepends an element to the front of the cyclic array.

Panic

Panics if the buffer is already full.

pub fn pop_back(&mut self) -> Option<T>

Removes the last element and returns it, or None if the cyclic array is empty.

pub fn pop_front(&mut self) -> Option<T>

Removes the first element and returns it, or None if the cyclic array is empty.

pub fn insert(&mut self, index: usize, value: T)

Inserts an element at position index within the array, possibly shifting some elements to the left or the right as needed.

pub fn remove(&mut self, index: usize) -> T

Removes and returns the element at position index within the array, shifting some elements to the left or to the right.

pub fn get(&self, index: usize) -> Option<&T>

Provides a reference to the element at the given index.

pub fn get_mut(&mut self, index: usize) -> Option<&mut T>

Returns a mutable reference to an element.

pub fn clear(&mut self)

Clears the cyclic array, removing and dropping all values.

pub fn len(&self) -> usize

Return the number of elements in the array.

pub fn capacity(&self) -> usize

Returns the total number of elements the cyclic array can hold.

pub fn is_empty(&self) -> bool

Returns true if the array has a length of 0.

pub fn is_full(&self) -> bool

Returns true if the array has a length equal to its capacity.

Trait Implementations

impl<T> Default for CyclicArray<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> Display for CyclicArray<T>

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

Formats the value using the given formatter.

impl<T> Drop for CyclicArray<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> Index<usize> for CyclicArray<T>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> IndexMut<usize> for CyclicArray<T>

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

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