Struct containers::collections::Vec

pub struct Vec<T, A: Alloc = NullAllocator> { /* fields omitted */ }

Growable array

Methods

impl<T, A: Alloc> Vec<T, A>

fn new_in(a: A) -> Vec<T, A>

Make a new array.

fn with_capacity_in(a: A, cap: usize) -> Option<Vec<T, A>>

Make a new array with enough room to hold at least cap elements.

Failures

Returns None if allocation fails.

unsafe fn set_length(&mut self, len: usize)

fn capacity(&self) -> usize

Return number of elements array can hold before reallocation.

unsafe fn storage_mut(&mut self) -> &mut [T]

fn reserve(&mut self, n_more: usize) -> bool

Make sure the array has enough room for at least n_more more elements, reallocating if need be.

Failures

Returns false if allocation fails, true otherwise.

fn relinquish(&mut self) -> bool

Relinquish memory so capacity = length.

fn insert(&mut self, k: usize, x: T) -> Result<(), T>

Insert element x at position k, shifting elements after k aftward one position to make room.

Failures

Returns Err(x) if allocation fails.

Panics

Panics if k is out of bounds.

fn delete(&mut self, k: usize) -> T

Delete element at position k and return it, shifting elements after k forward one position to fill the gap.

Panics

Panics if k is out of bounds.

fn delete_swap_last(&mut self, k: usize) -> T

Delete element at position k and move the last element into the gap.

Panics

Panics if k is out of bounds.

fn push(&mut self, x: T) -> Result<(), T>

Push x onto aft end of array.

Failures

Returns Err(x) if allocation fails.

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

Pop last element off end of array. Return None if array empty.

fn append<B: Alloc>(&mut self, xs: Vec<T, B>) -> Result<(), Vec<T, B>>

Append xs to the array.

Failures

Returns Err(xs) if allocation fails, in which case both self and xs are unmodified.

fn append_slice(&mut self, xs: &[T]) -> bool where
    T: Copy, 

Copy xs and append it to the array.

Failures

Returns false if allocation fails, in which case self is unmodified.

fn extend<Ts: IntoIterator<Item = T>>(
    &mut self,
    xs: Ts
) -> Result<(), Ts::IntoIter>

Add elements of xs to aft end of array.

Failures

Returns Err of remainder of xs if allocation fails.

fn from_iter_in<Ts: IntoIterator<Item = T>>(
    a: A,
    xs: Ts
) -> Result<Self, Ts::IntoIter>

Add elements of xs to aft end of array.

Failures

Returns Err of remainder of xs if allocation fails, in which case some elements may have been added to xs already.

fn truncate(&mut self, len: usize)

Shorten array to len and drop elements beyond.

fn from_raw(raw: RawVec<T, A>) -> Self

impl<T, A: Alloc + Default> Vec<T, A>

fn new() -> Self

Make a new array.

fn with_capacity(cap: usize) -> Option<Self>

Make a new array with enough room to hold at least cap elements.

Failures

Returns None if allocation fails.

fn from_iter<Ts: IntoIterator<Item = T>>(xs: Ts) -> Result<Self, Ts::IntoIter>

Add elements of xs to aft end of array.

Failures

Returns Err of remainder of xs if allocation fails, in which case some elements may have been added to xs already.

impl<T, A: Alloc + TryClone> Vec<T, A>

fn split_off(&mut self, k: usize) -> Option<Vec<T, A>>

Split off and return the segment of the array from k to the aft end, inclusive.

Failures

Returns None if allocation fails, in which case self is unmodified.

Panics

Panics if k is out of bounds.

Trait Implementations

impl<T: TryClone, A: Alloc + TryClone> TryClone for Vec<T, A>

type Error = Option<Either<A::Error, T::Error>>

fn try_clone(&self) -> Result<Self, Self::Error>

fn try_clone_from(&mut self, other: &Self) -> Result<(), Self::Error>

impl<T, A: Alloc> Drop for Vec<T, A>

fn drop(&mut self)

Executes the destructor for this type.

impl<T, A: Alloc + Default> Default for Vec<T, A>

fn default() -> Self

Returns the "default value" for a type.

impl<T: PartialEq, A: Alloc> PartialEq for Vec<T, A>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl<T: PartialOrd, A: Alloc> PartialOrd for Vec<T, A>

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

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl<T: Eq, A: Alloc> Eq for Vec<T, A>

impl<T: Ord, A: Alloc> Ord for Vec<T, A>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

impl<T, A: Alloc> Index<usize> for Vec<T, A>

type Output = <[T] as Index<usize>>::Output

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T, A: Alloc> IndexMut<usize> for Vec<T, A>

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

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

impl<T, A: Alloc> Index<Range<usize>> for Vec<T, A>

type Output = <[T] as Index<Range<usize>>>::Output

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T, A: Alloc> IndexMut<Range<usize>> for Vec<T, A>

fn index_mut(&mut self, k: Range<usize>) -> &mut Self::Output

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

impl<T, A: Alloc> Index<RangeTo<usize>> for Vec<T, A>

type Output = <[T] as Index<RangeTo<usize>>>::Output

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T, A: Alloc> IndexMut<RangeTo<usize>> for Vec<T, A>

fn index_mut(&mut self, k: RangeTo<usize>) -> &mut Self::Output

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

impl<T, A: Alloc> Index<RangeFrom<usize>> for Vec<T, A>

type Output = <[T] as Index<RangeFrom<usize>>>::Output

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T, A: Alloc> IndexMut<RangeFrom<usize>> for Vec<T, A>

fn index_mut(&mut self, k: RangeFrom<usize>) -> &mut Self::Output

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

impl<T, A: Alloc> Index<RangeFull> for Vec<T, A>

type Output = <[T] as Index<RangeFull>>::Output

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T, A: Alloc> IndexMut<RangeFull> for Vec<T, A>

fn index_mut(&mut self, k: RangeFull) -> &mut Self::Output

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

impl<T, A: Alloc> Borrow<[T]> for Vec<T, A>

fn borrow(&self) -> &[T]

Immutably borrows from an owned value.

impl<T, A: Alloc> BorrowMut<[T]> for Vec<T, A>

fn borrow_mut(&mut self) -> &mut [T]

Mutably borrows from an owned value.

impl<T, A: Alloc> Deref for Vec<T, A>

type Target = [T]

The resulting type after dereferencing.

fn deref(&self) -> &[T]

Dereferences the value.

impl<T, A: Alloc> DerefMut for Vec<T, A>

fn deref_mut(&mut self) -> &mut [T]

Mutably dereferences the value.

impl<T: Hash, A: Alloc> Hash for Vec<T, A>

fn hash<H: Hasher>(&self, h: &mut H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<T: Debug, A: Alloc> Debug for Vec<T, A>

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

Formats the value using the given formatter.

impl<T, A: Alloc> IntoIterator for Vec<T, A>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, A>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IntoIter<T, A>

Creates an iterator from a value.

impl<'a, T, A: Alloc> IntoIterator for &'a Vec<T, A>

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

Creates an iterator from a value.

impl<'a, T, A: Alloc> IntoIterator for &'a mut Vec<T, A>

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) -> IterMut<'a, T>

Creates an iterator from a value.