Struct trait_based_collection::queue::CircularDeque

pub struct CircularDeque<T> {
    pub mode: ExpansionMode,
    /* private fields */
}

A circular deque capable of expanding its capacity when needed. It is implemented using Vec, so the elements are stored contiguously in memory. The main difference between this and a Deque is that this one does not use nodes. This data structure implements both LIFO and FIFO.

Depending on the expansion mode, once the capacity is reached, the deque will behave differently depending on the mode. For more information, see the ExpansionMode documentation.

Examples

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

let mut deque = CircularDeque::with_mode(2, ExpansionMode::Ignore);
deque.add(1);
deque.add(2);
deque.add(3);

assert_eq!(deque.len(), 2);
assert_eq!(deque.remove(), Some(1));
assert_eq!(deque.remove(), Some(2));
assert_eq!(deque.remove(), None);

Fields

mode: ExpansionMode

The current mode of expansion of the deque that determinate the behaviour the collection is full. See ExpansionMode for more information.

Trait Implementations

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

fn new_default() -> Self

Creates a new Collection with a default capacity.

fn with_capacity(capacity: usize) -> Self

Creates a new Collection with a specific capacity.

fn with_approximate_capacity(approx_capacity: usize) -> Self

Creates a new Collection with a capacity that is at least the specified 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 clear(&mut self)

Clears all items from the Collection while keeping the capacity.

fn peek(&'a 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 is_empty(&self) -> bool

Checks if the Collection is empty.

impl<T: Debug> Debug for CircularDeque<T>

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

Formats the value using the given formatter.

impl<T> Default for CircularDeque<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'a, T> DequeCollection<'a, T> for CircularDeque<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(&'a 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 CircularDeque<T>where
    T: Display,

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

Formats the value using the given formatter.

impl<T> Drop for CircularDeque<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> Extend<T> for CircularDeque<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<'a, T> FixedSizeCollection<'a, T> for CircularDeque<T>where
    T: 'a,

fn with_mode(capacity: usize, mode: ExpansionMode) -> Self

Creates a new fixed size Collection with the specified capacity and ExpansionMode.

fn capacity(&self) -> usize

Returns the maximum amount of items that the collection can hold without expanding.

fn expand(&mut self, extra_size: usize)

Expands the capacity of the collection by at least the specified amount. This amount or more will be dded to the capacity.

fn mode(&self) -> &ExpansionMode

Returns the ExpansionMode of the collection . This is used to determine how the collection will behave when it is full.

fn is_full(&self) -> bool

Checks if the number of items in the FixedSizeCollection is equal to the capacity.

impl<T> FromIterator<T> for CircularDeque<T>

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

Creates a value from an iterator.

impl<T> Index<usize> for CircularDeque<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 CircularDeque<T>

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

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

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

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = CircularDequeIter<'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 CircularDeque<T>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = CircularDequeIterMut<'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 CircularDeque<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = CircularDequeIntoIter<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 CircularDeque<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 = CircularDequeIter<'a, T>

Which kind of iterator is returned by iter.

type IterMut = CircularDequeIterMut<'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.