Struct Queue 

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

A FIFO queue backed by VecDeque.

Provides O(1) enqueue and dequeue operations. Iteration order is front-to-back (i.e. the next element to be dequeued comes first).

Examples

use graph_collections::Queue;

let mut queue: Queue<u32> = Queue::new();
queue.enqueue(1);
queue.enqueue(2);
queue.enqueue(3);

assert_eq!(queue.front(), Some(&1));
assert_eq!(queue.dequeue(), Some(1));
assert_eq!(queue.len(), 2);

Implementations

impl<T> Queue<T>

pub fn new() -> Queue<T>

Creates a new, empty queue.

Examples

use graph_collections::Queue;

let queue: Queue<u32> = Queue::new();
assert!(queue.is_empty());

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

Creates a new, empty queue with at least the given capacity pre-allocated, avoiding reallocations for the first capacity pushes.

Examples

use graph_collections::Queue;

let mut queue: Queue<u32> = Queue::with_capacity(16);
assert!(queue.is_empty());

impl<T> Queue<T>

pub fn is_empty(&self) -> bool

Returns true if the queue contains no elements.

Examples

use graph_collections::Queue;

let mut queue: Queue<u32> = Queue::new();
assert!(queue.is_empty());
queue.enqueue(1);
assert!(!queue.is_empty());

pub fn len(&self) -> usize

Returns the number of elements in the queue.

Examples

use graph_collections::Queue;

let mut queue: Queue<u32> = Queue::new();
assert_eq!(queue.len(), 0);
queue.enqueue(42);
assert_eq!(queue.len(), 1);

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

Returns a reference to the element at the front of the queue (the next one to be dequeued), or None if the queue is empty.

Examples

use graph_collections::Queue;

let mut queue: Queue<u32> = Queue::new();
assert_eq!(queue.front(), None);
queue.enqueue(1);
queue.enqueue(2);
assert_eq!(queue.front(), Some(&1));

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

Returns a reference to the element at the back of the queue (the most recently enqueued one), or None if the queue is empty.

Examples

use graph_collections::Queue;

let mut queue: Queue<u32> = Queue::new();
assert_eq!(queue.back(), None);
queue.enqueue(1);
queue.enqueue(2);
assert_eq!(queue.back(), Some(&2));

pub fn enqueue(&mut self, element: T)

Adds element to the back of the queue.

Examples

use graph_collections::Queue;

let mut queue: Queue<u32> = Queue::new();
queue.enqueue(1);
queue.enqueue(2);
assert_eq!(queue.front(), Some(&1));
assert_eq!(queue.back(),  Some(&2));

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

Removes and returns the element at the front of the queue, or None if the queue is empty.

Examples

use graph_collections::Queue;

let mut queue: Queue<u32> = Queue::new();
assert_eq!(queue.dequeue(), None);
queue.enqueue(1);
queue.enqueue(2);
assert_eq!(queue.dequeue(), Some(1));
assert_eq!(queue.dequeue(), Some(2));
assert_eq!(queue.dequeue(), None);

pub fn clear(&mut self)

Removes all elements from the queue.

Examples

use graph_collections::Queue;

let mut queue: Queue<u32> = Queue::new();
queue.enqueue(1);
queue.enqueue(2);
queue.clear();
assert!(queue.is_empty());

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

Returns a front-to-back iterator over references to the elements.

The queue is not modified.

Examples

use graph_collections::Queue;

let mut queue: Queue<u32> = Queue::new();
queue.enqueue(1);
queue.enqueue(2);
queue.enqueue(3);

let values: Vec<u32> = queue.iter().copied().collect();
assert_eq!(values, [1, 2, 3]);

Trait Implementations

impl<T> Clone for Queue<T>

where T: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Queue<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for Queue<T>

fn default() -> Queue<T>

Returns the “default value” for a type.

impl<T> Extend<T> for Queue<T>

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = T>,

Enqueues all elements produced by the iterator.

Examples

use graph_collections::Queue;

let mut queue: Queue<u32> = Queue::new();
queue.extend([1, 2, 3]);
assert_eq!(queue.len(), 3);

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<T> FromIterator<T> for Queue<T>

fn from_iter<I>(iter: I) -> Queue<T>

where I: IntoIterator<Item = T>,

Builds a Queue from any iterator. Elements are enqueued in iteration order.

Examples

use graph_collections::Queue;

let queue: Queue<u32> = (1..=3).collect();
assert_eq!(queue.front(), Some(&1));
assert_eq!(queue.len(),   3);

impl<'a, T> IntoIterator for &'a Queue<T>

Borrowing iterator: for x in &queue

fn into_iter(self) -> <&'a Queue<T> as IntoIterator>::IntoIter

Iterates over references to elements front-to-back without consuming the queue.

Examples

use graph_collections::Queue;

let queue: Queue<u32> = (1..=3).collect();
let sum: u32 = (&queue).into_iter().sum();
assert_eq!(sum, 6);
assert_eq!(queue.len(), 3); // queue is still alive

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

impl<T> IntoIterator for Queue<T>

Consuming iterator: for x in queue

fn into_iter(self) -> <Queue<T> as IntoIterator>::IntoIter

Consumes the queue and yields elements front-to-back.

Examples

use graph_collections::Queue;

let queue: Queue<u32> = (1..=3).collect();
let values: Vec<u32> = queue.into_iter().collect();
assert_eq!(values, [1, 2, 3]);

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

impl<T> PartialEq for Queue<T>

where T: PartialEq,

fn eq(&self, other: &Queue<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> Eq for Queue<T>

where T: Eq,

impl<T> StructuralPartialEq for Queue<T>