Struct linked_lists_rs::queue::Queue

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

Queue Struct

Implementations

impl<T> Queue<T>

pub fn new() -> Self

Creates a new Queue

Example

Creating a new Queue of i32

use linked_lists_rs::queue::Queue;
let queue: Queue<i32> = Queue::new();

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

Push a new value on the end of the Queue

Example

let mut queue = Queue::new();

queue.push(5);

assert_eq!(Some(5), queue.pop());

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

Pops and return the value on the front of the Queue Returns None if the Queue is empty

Example

let mut queue = Queue::new();

queue.push(5);

assert_eq!(Some(5), queue.pop());
assert_eq!(None, queue.pop());

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

Return a reference to the value on the front of the Queue Returns None if the Queue is empty

Example

let mut queue = Queue::new();

queue.push(5);

assert_eq!(Some(&5), queue.peek());
assert_eq!(Some(5), queue.pop());
assert_eq!(None, queue.peek());

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

Return a mutable reference to the value on the front of the Queue Returns None if the Queue is empty

Example

let mut queue = Queue::new();

queue.push(5);

assert_eq!(Some(&mut 5), queue.peek_mut());
queue.peek_mut().map(|mut v| *v *= 5);
assert_eq!(Some(25), queue.pop());
assert_eq!(None, queue.peek_mut());

impl<T> Queue<T>

pub fn into_iter(self) -> IntoIter<T>

Iterator to the Queue Consumes the data structure on iteration

Example

let mut queue = Queue::new();

// Insert values into the queue
for x in [1, 2, 3] {
    queue.push(x);
}

// Iterate the queue and verify its values
for (i, x) in std::iter::zip(queue, [1, 2, 3]) {
    assert_eq!(i, x);
}

impl<T> Queue<T>

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

Reference Iterator to the Queue

Example

let mut queue = Queue::new();

// Insert values into the stack
for x in [1, 2, 3] {
    queue.push(x);
}

// Use iter to iterate the stack and verify its values
for (i, x) in std::iter::zip(&queue, [1, 2, 3]) {
    assert_eq!(i, &x);
}

// Stack is not consumed
assert_eq!(Some(&1), queue.peek());

impl<T> Queue<T>

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

Mutable Reference Iterator to the Queue

Example

let mut queue = Queue::new();

// Insert values into the stack
for x in [1, 2, 3] {
    queue.push(x);
}

// Use iter_mut to iterate the stack and mutate it's values
for i in &mut queue {
    *i *= 2;
}

// Assert values mutate as expected
for x in [2, 4, 6] {
    assert_eq!(Some(x), queue.pop());
}

Trait Implementations

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

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

Formats the value using the given formatter.

impl<T> Drop for Queue<T>

fn drop(&mut self)

Executes the destructor for this type.

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

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?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

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

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> IntoIterator for Queue<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.