Struct queue::Queue

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

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

Methods

impl<T: Clone> Queue<T>

fn new() -> Queue<T>

Constructs a new Queue<T>.

Example

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

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

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

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

Forcefully ad 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"));

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

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

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

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

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, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.