Struct PopulatedVecDeque 

pub struct PopulatedVecDeque<T>(/* private fields */);

A populated double-ended queue implemented with a growable ring buffer. This type is guaranteed to contain at least one element, so the underlying VecDeque is guaranteed to be non-empty.

Implementations

impl<T> PopulatedVecDeque<T>

pub fn new(value: T) -> PopulatedVecDeque<T>

Creates a singleton populated deque i.e. a deque with a single element.

pub fn with_capacity(capacity: NonZeroUsize, value: T) -> PopulatedVecDeque<T>

Creates a populated deque with a single element and space for at least capacity elements.

pub fn inserted( vec_deque: VecDeque<T>, index: usize, value: T, ) -> PopulatedVecDeque<T>

Creates a populated deque with the given element inserted at the specified index.

use std::collections::VecDeque;
use std::num::NonZeroUsize;
use populated::PopulatedVecDeque;

let vec_deque = vec![1].into();
let vec_deque = PopulatedVecDeque::inserted(vec_deque, 0, 2);
assert_eq!(vec_deque.get(0), Some(&2));
assert_eq!(vec_deque.get(1), Some(&1));

pub fn get(&self, index: usize) -> Option<&T>

Provides a reference to the element at the given index.

Element at index 0 is the front of the queue.

pub fn get_mut(&mut self, index: usize) -> Option<&mut T>

Provides a mutable reference to the element at the given index.

Element at index 0 is the front of the queue.

pub fn swap(&mut self, i: usize, j: usize)

Swaps elements at indices i and j.

i and j may be equal.

Element at index 0 is the front of the queue.

pub fn into_inner(self) -> VecDeque<T>

pub fn pushed_back(vec_deque: VecDeque<T>, value: T) -> PopulatedVecDeque<T>

Constructs a PopulatedVecDeque from a VecDeque by pushing back a single element.

use std::collections::VecDeque;
use std::num::NonZeroUsize;
use populated::PopulatedVecDeque;

let vec_deque = VecDeque::from([1, 2, 3]);
let populated_vec_deque = PopulatedVecDeque::pushed_back(vec_deque, 42);
assert_eq!(populated_vec_deque.len(), NonZeroUsize::new(4).unwrap());
assert_eq!(populated_vec_deque.back(), &42);

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

Appends an element to the back of the deque.

pub fn pushed_front(value: T, vec_deque: VecDeque<T>) -> PopulatedVecDeque<T>

Constructs a PopulatedVecDeque from a VecDeque by pushing front a single element.

use std::collections::VecDeque;
use std::num::NonZeroUsize;
use populated::PopulatedVecDeque;

let vec_deque = VecDeque::from([1, 2, 3]);
let populated_vec_deque = PopulatedVecDeque::pushed_front(42, vec_deque);
assert_eq!(populated_vec_deque.len(), NonZeroUsize::new(4).unwrap());
assert_eq!(populated_vec_deque.front(), &42);

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

Prepends an element to the deque.

pub fn pop_back(self) -> (VecDeque<T>, T)

Removes the last element from the deque and returns it, along with the remaining deque.

pub fn pop_front(self) -> (T, VecDeque<T>)

Removes the first element and returns it, along with the remaining deque.

pub fn front(&self) -> &T

Provides a reference to the front element.

pub fn front_mut(&mut self) -> &mut T

Provides a mutable reference to the front element.

pub fn back(&self) -> &T

Provides a reference to the back element.

pub fn back_mut(&mut self) -> &mut T

Provides a mutable reference to the back element.

pub fn len(&self) -> NonZeroUsize

Returns number of elements in the populated deque.

pub fn capacity(&self) -> NonZeroUsize

Returns the number of elements the deque can hold without reallocating.

pub fn reserve(&mut self, additional: usize)

pub fn reserve_exact(&mut self, additional: usize)

pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>

pub fn try_reserve_exact( &mut self, additional: usize, ) -> Result<(), TryReserveError>

pub fn shrink_to_fit(&mut self)

pub fn shrink_to(&mut self, min_capacity: usize)

pub fn truncate(&mut self, len: NonZeroUsize)

pub fn truncate_into(self, len: usize) -> VecDeque<T>

Truncates the deque to the given length.

pub fn range(&self, range: impl RangeBounds<usize>) -> Iter<'_, T>

Returns an iterator that yields references to the values.

pub fn range_mut(&mut self, range: impl RangeBounds<usize>) -> IterMut<'_, T>

Returns an iterator that allows modifying each value. The iterator yields mutable references to the values.

pub fn clear(self) -> VecDeque<T>

Clears the deque, removing all values. Returns the cleared deque that is not populated.

pub fn insert(&mut self, index: usize, element: T)

Inserts an element at index within the deque, shifting all elements with indices greater than or equal to index towards the back.

Element at index 0 is the front of the queue.

pub fn remove(self, index: usize) -> (Option<T>, VecDeque<T>)

Removes and returns the element at index from the deque. Whichever end is closer to the removal point will be moved to make room, and all the affected elements will be moved to new positions. Returns None if index is out of bounds.

Element at index 0 is the front of the queue.

pub fn split_off(&mut self, at: NonZeroUsize) -> VecDeque<T>

Splits the deque into two at the given index.

Returns a newly allocated VecDeque. self contains elements [0, at), and the returned deque contains elements [at, len).

at must be non-zero to ensure that the deque being mutated stays populated.

Note that the capacity of self does not change.

Element at index 0 is the front of the queue.

pub fn split_into(self, at: usize) -> (VecDeque<T>, VecDeque<T>)

pub fn append(&mut self, other: &mut VecDeque<T>)

Moves all the elements of other into self, leaving other empty.

pub fn retain(self, f: impl FnMut(&T) -> bool) -> VecDeque<T>

Retains only the elements specified by the predicate.

In other words, remove all elements e for which f(&e) returns false. This method operates in place on the underlying VecDeque, visiting each element exactly once in the original order, and preserves the order of the retained elements.

Since there is no guarantee that all elements will not be removed, the method returns the underlying VecDeque.

pub fn retain_mut(self, f: impl FnMut(&mut T) -> bool) -> VecDeque<T>

Retains only the elements specified by the predicate.

In other words, remove all elements e for which f(&e) returns false. This method operates in place on the underlying VecDeque, visiting each element exactly once in the original order, and preserves the order of the retained elements.

Since there is no guarantee that all elements will not be removed, the method returns the underlying VecDeque.

pub fn resize_with(&mut self, new_len: NonZeroUsize, f: impl FnMut() -> T)

pub fn resize_with_into( self, new_len: usize, f: impl FnMut() -> T, ) -> VecDeque<T>

pub fn rotate_left(&mut self, n: usize)

Rotates the double-ended queue n places to the left.

Equivalently,

• Rotates item n into the first position.
• Pops the first n items and pushes them to the end.
• Rotates len() - n places to the right.

pub fn rotate_right(&mut self, n: usize)

Rotates the double-ended queue n places to the right.

Equivalently,

• Rotates the first item into position n.
• Pops the last n items and pushes them to the front.
• Rotates len() - n places to the left.

pub fn binary_search_by( &self, f: impl FnMut(&T) -> Ordering, ) -> Result<usize, usize>

Binary searches this PopulatedVecDeque with a comparator function.

The comparator function should return an order code that indicates whether its argument is Less, Equal or Greater the desired target. If the PopulatedVecDeque is not sorted or if the comparator function does not implement an order consistent with the sort order of the underlying VecDeque, the returned result is unspecified and meaningless.

If the value is found then Result::Ok is returned, containing the index of the matching element. If there are multiple matches, then any one of the matches could be returned. If the value is not found then Result::Err is returned, containing the index where a matching element could be inserted while maintaining sorted order.

See also binary_search, binary_search_by_key, and partition_point.

pub fn binary_search_by_key<K: Ord>( &self, key: &K, f: impl FnMut(&T) -> K, ) -> Result<usize, usize>

Binary searches this PopulatedVecDeque with a key extraction function.

Assumes that the deque is sorted by the key, for instance with make_contiguous().sort_by_key() using the same key extraction function. If the deque is not sorted by the key, the returned result is unspecified and meaningless.

If the value is found then Result::Ok is returned, containing the index of the matching element. If there are multiple matches, then any one of the matches could be returned. If the value is not found then Result::Err is returned, containing the index where a matching element could be inserted while maintaining sorted order.

See also binary_search, binary_search_by, and partition_point.

pub fn partition_point(&self, predicate: impl FnMut(&T) -> bool) -> usize

impl<T: PartialEq> PopulatedVecDeque<T>

pub fn contains(&self, x: &T) -> bool

Returns true if the deque contains an element equal to the given value.

This operation is O(n).

Note that if you have a sorted PopulatedVecDeque, binary_search may be faster.

impl<T: Ord> PopulatedVecDeque<T>

pub fn binary_search(&self, x: &T) -> Result<usize, usize>

Binary searches this PopulatedVecDeque for a given element. If the PopulatedVecDeque is not sorted, the returned result is unspecified and meaningless.

If the value is found then Result::Ok is returned, containing the index of the matching element. If there are multiple matches, then any one of the matches could be returned. If the value is not found then Result::Err is returned, containing the index where a matching element could be inserted while maintaining sorted order.

See also binary_search_by, binary_search_by_key, and partition_point.

impl<T: Clone> PopulatedVecDeque<T>

pub fn resize(&mut self, new_len: NonZeroUsize, value: T)

pub fn resize_into(self, new_len: usize, value: T) -> VecDeque<T>

impl<T> PopulatedVecDeque<T>

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

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

Trait Implementations

impl<T: Clone> Clone for PopulatedVecDeque<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for PopulatedVecDeque<T>

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

Formats the value using the given formatter.

impl<T> Extend<T> for PopulatedVecDeque<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> From<PopulatedVec<T>> for PopulatedVecDeque<T>

fn from(populated_vec: PopulatedVec<T>) -> PopulatedVecDeque<T>

Converts to this type from the input type.

impl<T> From<PopulatedVecDeque<T>> for VecDeque<T>

fn from(populated_vec_deque: PopulatedVecDeque<T>) -> VecDeque<T>

Converts to this type from the input type.

impl<T> FromPopulatedIterator<T> for PopulatedVecDeque<T>

fn from_populated_iter(iter: impl IntoPopulatedIterator<Item = T>) -> Self

Converts a PopulatedIterator into Self.

impl<T> Index<NonZero<usize>> for PopulatedVecDeque<T>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

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

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

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

impl<T> IndexMut<usize> for PopulatedVecDeque<T>

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

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

impl<'a, T> IntoIterator for &'a PopulatedVecDeque<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 PopulatedVecDeque<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 PopulatedVecDeque<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.

impl<'a, T> IntoPopulatedIterator for &'a PopulatedVecDeque<T>

type PopulatedIntoIter = PopulatedIter<'a, T>

fn into_populated_iter(self) -> PopulatedIter<'a, T>

Converts the type into a PopulatedIterator.

impl<'a, T> IntoPopulatedIterator for &'a mut PopulatedVecDeque<T>

type PopulatedIntoIter = PopulatedIterMut<'a, T>

fn into_populated_iter(self) -> PopulatedIterMut<'a, T>

Converts the type into a PopulatedIterator.

impl<T> IntoPopulatedIterator for PopulatedVecDeque<T>

type PopulatedIntoIter = PopulatedIntoIter<T>

fn into_populated_iter(self) -> PopulatedIntoIter<T>

Converts the type into a PopulatedIterator.

impl<T: Ord> Ord for PopulatedVecDeque<T>

fn cmp(&self, other: &PopulatedVecDeque<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq> PartialEq<PopulatedVecDeque<T>> for VecDeque<T>

fn eq(&self, other: &PopulatedVecDeque<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: PartialEq> PartialEq<VecDeque<T>> for PopulatedVecDeque<T>

fn eq(&self, other: &VecDeque<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: PartialEq> PartialEq for PopulatedVecDeque<T>

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

fn partial_cmp(&self, other: &PopulatedVecDeque<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> TryFrom<VecDeque<T>> for PopulatedVecDeque<T>

type Error = VecDeque<T>

The type returned in the event of a conversion error.

fn try_from(vec_deque: VecDeque<T>) -> Result<PopulatedVecDeque<T>, Self::Error>

Performs the conversion.

impl<T: Eq> Eq for PopulatedVecDeque<T>

impl<T> StructuralPartialEq for PopulatedVecDeque<T>