Struct containers::collections::Vec

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

Growable array

Implementations

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

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

Make a new array.

pub 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.

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

pub fn capacity(&self) -> usize

Return number of elements array can hold before reallocation.

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

pub 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.

pub fn relinquish(&mut self) -> bool

Relinquish memory so capacity = length.

pub 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.

pub 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.

pub 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.

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

Push x onto aft end of array.

Failures

Returns Err(x) if allocation fails.

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

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

pub 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.

pub 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.

pub 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.

pub 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.

pub fn from_slice_in(a: A, xs: &[T]) -> Option<Self> where
    T: Copy, 

Make of a slice.

Failures

Returns None if allocation fails.

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

Shorten array to len and drop elements beyond.

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

pub fn drain<R>(&mut self, r: R) -> Drain<'_, T, A> where
    Self: IndexMut<R, Output = [T]>, 

pub fn drain_filter<R, F>(
    &mut self,
    range: R,
    filter: F
) -> DrainFilter<'_, T, F, A> where
    Self: IndexMut<R, Output = [T]>,
    F: FnMut(usize, &mut T) -> bool, 

pub unsafe fn alloc_mut(&mut self) -> &mut A

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

pub fn new() -> Self

Make a new array.

pub 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.

pub 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.

pub fn from_slice(xs: &[T]) -> Option<Self> where
    T: Copy, 

Make of a slice.

Failures

Returns None if allocation fails.

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

pub 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, 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: 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 + Default> Default for Vec<T, A>

fn default() -> Self

Returns the “default value” for a type.

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, A: Alloc> Drop for Vec<T, A>

fn drop(&mut self)

Executes the destructor for this type.

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

fn from(xs: Box<[T], A>) -> Self

Performs the conversion.

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

fn from(xs: Vec<T, A>) -> Self

Performs the conversion.

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, 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> 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> 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> 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> 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<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> 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> 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> 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> 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> 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.

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.

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

Restrict a value to a certain interval.

impl<T: PartialEq, A: Alloc> PartialEq<Vec<T, A>> 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<Vec<T, A>> 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: 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: Eq, A: Alloc> Eq for Vec<T, A>