Struct trait_based_collection::stack::ArrayStack

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

A fixed-size stack capable of expanding when needed. It is implemented using Vec, so the elements are stored contiguously in memory. The main difference between this and a Stack is that this one does not use nodes.

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::*, ArrayStack};

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

assert_eq!(stack.len(), 2);
assert_eq!(stack.remove(), Some(2));
assert_eq!(stack.remove(), Some(1));
assert_eq!(stack.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: 'a> Collection<'a, T> for ArrayStack<T>

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 len(&self) -> usize

Returns the number of items in the Collection.

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 is_empty(&self) -> bool

Checks if the Collection is empty.

impl<T: Debug> Debug for ArrayStack<T>

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

Formats the value using the given formatter.

impl<T> Default for ArrayStack<T>

fn default() -> Self

Returns the “default value” for a type.

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

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

Formats the value using the given formatter.

impl<T> Drop for ArrayStack<T>

fn drop(&mut self)

Executes the destructor for this type.

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

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

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

Creates a value from an iterator.

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

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

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

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

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Rev<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 ArrayStack<T>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = Rev<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 ArrayStack<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = ArrayStackIntoIter<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: 'a> Iterators<'a, T> for ArrayStack<T>

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 = Rev<Iter<'a, T>>

Which kind of iterator is returned by iter.

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