Struct trait_based_collection::queue::Deque

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

A double-ended queue. This data structure is a combination of a Stack and a Queue. It allows to push and pop elements from both ends of the queue. This data structure implements both LIFO and FIFO. For more information, see the DequeCollection trait.

The default behavior for the Collection trait is to interpret the Deque as a FIFO queue.

Examples

use trait_based_collection::{prelude::*, Deque};

let mut deque = Deque::new_default();
deque.push_back(1);
deque.push_back(2);
deque.push_front(3);

assert_eq!(deque.pop_front(), Some(3));
assert_eq!(deque.pop_front(), Some(1));
assert_eq!(deque.pop_front(), Some(2));
assert_eq!(deque.pop_front(), None);

Trait Implementations

impl<'a, T> Collection<'a, T> for Deque<T>where
    T: 'a,

fn new_default() -> Self

Creates a new Collection with a default capacity.

fn add(&mut self, value: T)

Adds an item to the Collection.

fn remove(&mut self) -> Option<T>

Removes an item from the Collection.

fn peek(&self) -> Option<Self::ItemRef>

Returns an immutable reference of the item that will be removed next.

fn peek_mut(&'a mut self) -> Option<Self::ItemMut>

Returns a mutable reference of the item that will be removed next.

fn get(&'a self, index: usize) -> Option<Self::ItemRef>

Returns a immutable reference to the n-th item in the Collection.

fn get_mut(&'a mut self, index: usize) -> Option<Self::ItemMut>

Returns a mutable reference to the n-th item in the Collection.

fn len(&self) -> usize

Returns the number of items in the Collection.

fn with_capacity(capacity: usize) -> Selfwhere
    Self: Sized,

Creates a new Collection with a specific capacity.

fn with_approximate_capacity(approx_capacity: usize) -> Selfwhere
    Self: Sized,

Creates a new Collection with a capacity that is at least the specified capacity.

fn clear(&mut self)

Clears all items from the Collection while keeping the capacity.

fn is_empty(&self) -> bool

Checks if the Collection is empty.

impl<T: Debug> Debug for Deque<T>

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

Formats the value using the given formatter.

impl<T> Default for Deque<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'a, T> DequeCollection<'a, T> for Deque<T>where
    T: 'a,

fn push_front(&mut self, value: T)

Pushes a new element to the front of the queue.

fn pop_back(&mut self) -> Option<T>

Removes the element from the back of the queue.

fn peek_back(&self) -> Option<Self::ItemRef>

Returns a reference to the element at the back of the queue. This is the same as get with the index self.len() - 1.

fn peek_back_mut(&'a mut self) -> Option<Self::ItemMut>

Returns a mutable reference to the element at the back of the queue. This is the same as get_mut with the index self.len() - 1.

fn push_back(&mut self, value: T)

Pushes a new element to the back of the queue. This is the same as add.

fn pop_front(&mut self) -> Option<T>

Removes the element from the front of the queue. This is the same as remove.

fn peek_front(&'a self) -> Option<Self::ItemRef>

Returns a reference to the element at the front of the queue. This is the same as peek.

fn peek_front_mut(&'a mut self) -> Option<Self::ItemMut>

Returns a mutable reference to the element at the front of the queue. This is the same as peek_mut.

impl<T> Display for Deque<T>where
    T: Display,

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

Formats the value using the given formatter.

impl<T> Drop for Deque<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> Extend<T> for Deque<T>

fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

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 Deque<T>

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Creates a value from an iterator.

impl<T> Index<usize> for Deque<T>

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T> IndexMut<usize> for Deque<T>

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

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

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = DequeIter<'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 Deque<T>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = DequeIterMut<'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 Deque<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = DequeIntoIter<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> Iterators<'a, T> for Deque<T>where
    T: 'a,

type ItemRef = &'a T

The type of reference the immutable iterator (Iter) iterates over the items in the Collection. The reference is only valid for the duration of the iteration.

type ItemMut = &'a mut T

The type of mutable reference the mutable iterator (IterMut) iterates over the items in the Collection. The reference is only valid for the duration of the iteration.

type Iter = DequeIter<'a, T>

Which kind of iterator is returned by iter.

type IterMut = DequeIterMut<'a, T>

Which kind of iterator is returned by iter_mut.

fn iter(&'a self) -> Self::Iter

Creates an immutable iterator over the items in the Collection without consuming them.

fn iter_mut(&'a mut self) -> Self::IterMut

Creates a mutable iterator over the items in the Collection without consuming them.