Struct CircularQueue 

pub struct CircularQueue<T, const INITCAP: usize = 64> { /* private fields */ }

A circular queue using a vector of options underneath. Can’t use an array because the size of the array is part of its type in Rust. The unused portions of the vector will hold value None. Look at the source code for details. This program was based on a roughly equivalent C++ Version.

Implementations

impl<T, const INITCAP: usize> CircularQueue<T, INITCAP>

pub const fn len(&self) -> usize

number of values in queue. This function can be called from a const context, which means it can be evaluated by the compiler, although this is unlikely since vectors are heap-allocated.

pub fn capacity(&self) -> usize

current capacity of queue

pub fn new() -> Self

creates an empty queue with default initial capacity defined by const generic INITCAP

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

inserts a value at the back of the queue, wrapping around to the right if necessary. Increases capacity if necessary.

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

inserts a value at the front of the queue, wrapping around to the left if necessary. Increases capacity if necessary.

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

returns (moves) value at back of the queue, if it exists.

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

returns (moves) value at front of the queue, if it exists.

pub fn mapfun<F: FnMut(&mut T)>(&mut self, f: F)

Maps mutable closure f over each value of the queue. The closure has the ability to mutate each value as well as mutate its environment (see the source for the test_main function).

pub fn iter<'lt>(&'lt self) -> Cqiter<'lt, T, INITCAP>

returns an immutable iterator, allows for x in queue.iter()

Trait Implementations

impl<T, const C: usize> Index<usize> for CircularQueue<T, C>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T, const C: usize> IndexMut<usize> for CircularQueue<T, C>

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

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

impl<'lt, T, const C: usize> IntoIterator for &'lt CircularQueue<T, C>

Implementing this trait means we can say for x in &queue, which is equivalent to for x in queue.iter().

type Item = &'lt T

The type of the elements being iterated over.

type IntoIter = Cqiter<'lt, T, C>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.