Struct circular_queue::CircularQueue

pub struct CircularQueue<T> { /* fields omitted */ }

A circular buffer-like queue.

Methods

impl<T> CircularQueue<T>

pub fn with_capacity(capacity: usize) -> Self

Constructs a new, empty CircularQueue<T> with the requested capacity.

Examples

use circular_queue::CircularQueue;

let mut queue: CircularQueue<i32> = CircularQueue::with_capacity(5);

pub fn len(&self) -> usize

Returns the current number of elements in the queue.

Examples

use circular_queue::CircularQueue;

let mut queue = CircularQueue::with_capacity(5);
queue.push(1);
queue.push(2);
queue.push(3);

assert_eq!(queue.len(), 3);

pub fn is_empty(&self) -> bool

Returns true if the queue contains no elements.

Examples

use circular_queue::CircularQueue;

let mut queue = CircularQueue::with_capacity(5);
assert!(queue.is_empty());

queue.push(1);
assert!(!queue.is_empty());

pub fn capacity(&self) -> usize

Returns the capacity of the queue.

Examples

use circular_queue::CircularQueue;

let queue: CircularQueue<i32> = CircularQueue::with_capacity(5);
assert_eq!(queue.capacity(), 5);

pub fn clear(&mut self)

Clears the queue.

Examples

use circular_queue::CircularQueue;

let mut queue = CircularQueue::with_capacity(5);
queue.push(1);
queue.push(2);
queue.push(3);

queue.clear();
assert_eq!(queue.len(), 0);

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

Pushes a new element into the queue.

Once the capacity is reached, pushing new items will overwrite old ones.

Examples

use circular_queue::CircularQueue;

let mut queue = CircularQueue::with_capacity(3);
queue.push(1);
queue.push(2);
queue.push(3);
queue.push(4);

assert_eq!(queue.len(), 3);

let mut iter = queue.iter();

assert_eq!(iter.next(), Some(&4));
assert_eq!(iter.next(), Some(&3));
assert_eq!(iter.next(), Some(&2));

pub fn iter(&self) -> Iter<T>

Returns an iterator over the queue's contents.

The iterator goes from the most recently pushed items to the oldest ones.

Examples

use circular_queue::CircularQueue;

let mut queue = CircularQueue::with_capacity(3);
queue.push(1);
queue.push(2);
queue.push(3);
queue.push(4);

let mut iter = queue.iter();

assert_eq!(iter.next(), Some(&4));
assert_eq!(iter.next(), Some(&3));
assert_eq!(iter.next(), Some(&2));

pub fn iter_mut(&mut self) -> IterMut<T>

Returns a mutable iterator over the queue's contents.

The iterator goes from the most recently pushed items to the oldest ones.

Examples

use circular_queue::CircularQueue;

let mut queue = CircularQueue::with_capacity(3);
queue.push(1);
queue.push(2);
queue.push(3);
queue.push(4);

let mut iter = queue.iter_mut();

assert_eq!(iter.next(), Some(&mut 4));
assert_eq!(iter.next(), Some(&mut 3));
assert_eq!(iter.next(), Some(&mut 2));

pub fn asc_iter(&self) -> AscIter<T>

Returns an ascending iterator over the queue's contents.

The iterator goes from the least recently pushed items to the newest ones.

Examples

use circular_queue::CircularQueue;

let mut queue = CircularQueue::with_capacity(3);
queue.push(1);
queue.push(2);
queue.push(3);
queue.push(4);

let mut iter = queue.asc_iter();

assert_eq!(iter.next(), Some(&2));
assert_eq!(iter.next(), Some(&3));
assert_eq!(iter.next(), Some(&4));

pub fn asc_iter_mut(&mut self) -> AscIterMut<T>

Returns a mutable ascending iterator over the queue's contents.

The iterator goes from the least recently pushed items to the newest ones.

Examples

use circular_queue::CircularQueue;

let mut queue = CircularQueue::with_capacity(3);
queue.push(1);
queue.push(2);
queue.push(3);
queue.push(4);

let mut iter = queue.asc_iter_mut();

assert_eq!(iter.next(), Some(&mut 2));
assert_eq!(iter.next(), Some(&mut 3));
assert_eq!(iter.next(), Some(&mut 4));

Trait Implementations

impl<T: Clone> Clone for CircularQueue<T>

fn clone(&self) -> CircularQueue<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for CircularQueue<T>

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

Formats the value using the given formatter.

impl<T: Eq> Eq for CircularQueue<T>

impl<T: PartialEq> PartialEq<CircularQueue<T>> for CircularQueue<T>

fn eq(&self, other: &CircularQueue<T>) -> bool

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

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.