Struct Queue

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

A first in, first out queue built around Vec.

An optional capacity can be set (or changed) to ensure the Queue never grows past a certain size. If the capacity is not specified (ie set to None) then the Queue will grow as needed. If you’re worried about memory allocation, set a capacity and the necessary memory will be allocated at that time. Otherwise memory could be allocated, deallocated and reallocated as the Queue changes size.

The only requirement of the type used is that it implements the Clone trait.

Example

use queue::Queue;

let mut q = Queue::with_capacity(5);

for i in 0..5 {
	q.queue(i).unwrap();
}

for i in 0..5 {
	assert_eq!(q.dequeue(), Some(i));
}

Implementations

impl<T: Clone> Queue<T>

pub fn new() -> Queue<T>

Constructs a new Queue<T>.

Example

let mut q: Queue<String> = Queue::new();

pub fn with_capacity(cap: usize) -> Queue<T>

Constructs a new Queue<T> with a specified capacity.

Example

let mut q: Queue<String> = Queue::with_capacity(20);

pub fn queue(&mut self, item: T) -> Result<usize, ()>

Add an item to the end of the Queue. Returns Ok(usize) with the new length of the Queue, or Err(()) if there is no more room.

Example

let mut q = Queue::new();
q.queue("hello").unwrap();
assert_eq!(q.peek(), Some("hello"));

pub fn force_queue(&mut self, item: T) -> usize

Forcefully add an item to the end of the Queue. If the Queue is at capacity, the first item will be removed to make room. Returns usize with the new length of the Queue.

Example

let mut q = Queue::with_capacity(1);
q.queue("hello").unwrap();
let _ = q.force_queue("world");
assert_eq!(q.peek(), Some("world"));

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

Remove the next item from the Queue. Returns Option<T> so it will return either Some(T) or None depending on if there’s anything in the Queue to get.

Example

let mut q = Queue::new();
q.queue("hello").unwrap();
q.queue("world").unwrap();
assert_eq!(q.dequeue(), Some("hello"));

pub fn vec(&self) -> &Vec<T>

Return a &Vec<T> for the Queue<T>.

Example

let mut q = Queue::new();
q.queue(1).unwrap();
q.queue(2).unwrap();
q.queue(3).unwrap();
assert_eq!(&vec![1, 2, 3], q.vec());

pub fn peek(&self) -> Option<T>

Peek at the next item in the Queue, if there’s something there.

Example

let mut q = Queue::new();
q.queue(12).unwrap();
assert_eq!(q.peek(), Some(12));

pub fn len(&self) -> usize

The number of items currently in the Queue.

Example

let mut q = Queue::with_capacity(8);
q.queue(1).unwrap();
q.queue(2).unwrap();
assert_eq!(q.len(), 2);

pub fn is_empty(&self) -> bool

Check if the Queue is empty.

Example

let mut q = Queue::new();
assert_eq!(q.is_empty(), true);
q.queue(1).unwrap();
assert_eq!(q.is_empty(), false);

pub fn capacity(&self) -> Option<usize>

Query the capacity for a Queue. If there is no capacity set (the Queue can grow as needed) then None will be returned, otherwise it will be Some(usize).

Example

let q: Queue<u8> = Queue::with_capacity(12);
assert_eq!(q.capacity(), Some(12));

pub fn set_capacity<C: Into<Option<usize>>>(&mut self, cap: C) -> Result<(), ()>

Modify the capacity of a Queue. If set to None, the Queue will grow automatically, as needed. Otherwise, it will be limited to the specified number of items. If there are more items in the Queue than the requested capacity, Err(()) will be returned, otherwise the operation will succeed and Ok(()) will be returned. If the capacity is shrunk, the underlying Vec will be shrunk also, which would free up whatever extra memory was allocated for the Queue.

Example

let mut q: Queue<u8> = Queue::new();
q.set_capacity(12).unwrap();
q.set_capacity(None).unwrap();

Trait Implementations

impl<T: Clone> Clone for Queue<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Queue<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Queue<T>

fn default() -> Queue<T>

Returns the “default value” for a type.

impl<T: Clone> From<Vec<T>> for Queue<T>

fn from(v: Vec<T>) -> Queue<T>

Constructs a new Queue<T> from a Vec<T>.

Example

let q = Queue::from(vec![1, 2, 3]);