Struct CircularQueue

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

A circular buffer-like queue.

Implementations

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 is_full(&self) -> bool

Returns true if the queue is full.

Examples

use circular_queue::CircularQueue;

let mut queue = CircularQueue::with_capacity(5);

assert!(!queue.is_full());

queue.push(1);
queue.push(2);
queue.push(3);
queue.push(4);
queue.push(5);

assert!(queue.is_full());

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) -> Popped<T>

Pushes a new element into the queue.

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

In case an old value is overwritten, it will be returned.

Examples

use circular_queue::CircularQueue;

let mut queue = CircularQueue::with_capacity(3);

queue.push(1);
queue.push(2);

assert_eq!(queue.push(3), None);
assert_eq!(queue.push(4), Some(1));

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));

pub fn into_vec(self) -> Vec<T>

Converts the queue into a Vec<T> going 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 v = queue.into_vec();

assert_eq!(v, vec![4, 3, 2]);

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<'de, T> Deserialize<'de> for CircularQueue<T>

where T: Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<CircularQueue<T>, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> From<CircularQueue<T>> for Vec<T>

fn from(queue: CircularQueue<T>) -> Self

Converts to this type from the input type.

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

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Serialize for CircularQueue<T>

where T: Serialize,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

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