Struct generic_vec::GenericVec

#[repr(C)]pub struct GenericVec<T, S: ?Sized + Storage<T>> { /* fields omitted */ }

A vector type that can be backed up by a variety of different backends including slices, arrays, and the heap.

Implementations

impl<T, S: Storage<T>> GenericVec<T, S>

pub fn with_storage(storage: S) -> Self

Create a new empty GenericVec with the given backend

impl<T, S: StorageWithCapacity<T>> GenericVec<T, S>

pub fn with_capacity(capacity: usize) -> Self

Create a new empty GenericVec with the backend with at least the given capacity

impl<T> GenericVec<T, Heap<T>>

pub const fn new() -> Self

Create a new empty HeapVec

impl<'a, T> GenericVec<T, Uninit<&'a mut [MaybeUninit<T>]>>

pub fn new(slice: &'a mut [MaybeUninit<T>]) -> Self

Create a new empty SliceVec

impl<'a, T: Copy> GenericVec<T, Init<&'a mut [T]>>

pub fn new(slice: &'a mut [T]) -> Self

Create a new full InitSliceVec

impl<T, S: Storage<T>> GenericVec<T, S>

pub fn into_raw_parts(self) -> (usize, S)

Convert a GenericVec into a length-storage pair

pub unsafe fn from_raw_parts(len: usize, storage: S) -> Self

Create a GenericVec from a length-storage pair

Safety

the length must be less than raw.capacity() and all elements in the range 0..length, must be initialized

Panic

If the given storage cannot hold type T, then this method will panic

impl<T, S: ?Sized + Storage<T>> GenericVec<T, S>

pub fn as_ptr(&self) -> *const T

Returns a shared raw pointer to the vector's buffer.

It's not safe to write to this pointer except for values inside of an UnsafeCell

pub fn as_mut_ptr(&mut self) -> *mut T

Returns a unique raw pointer to the vector's buffer.

pub fn len(&self) -> usize

Returns the number of elements in the vector

pub fn capacity(&self) -> usize

Returns the number of elements the vector can hold without reallocating or panicing.

pub fn is_empty(&self) -> bool

Returns true if and only if the vector contains no elements.

pub fn is_full(&self) -> bool

Returns true if and only if the vector's length is equal to it's capacity.

pub fn remaining_capacity(&self) -> usize

Returns the length of the spare capacity of the GenericVec

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

Set the length of a vector

Safety

• new_len must be less than or equal to capacity().
• The elements at old_len..new_len must be initialized.

pub fn set_len(&mut self, len: usize) where
    S: StorageInit<T>, 

Set the length of a vector

pub fn as_slice(&self) -> &[T]

Extracts a slice containing the entire vector.

Equivalent to &s[..].

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

Extracts a mutable slice containing the entire vector.

Equivalent to &mut s[..].

pub fn storage(&self) -> &S

Returns the underlying raw buffer

pub unsafe fn storage_mut(&mut self) -> &mut S

Returns the underlying raw buffer

Safety

You must not replace the raw buffer

pub fn spare_capacity_mut(&mut self) -> SliceVec<'_, T>

Returns the remaining spare capacity of the vector as a slice of [MaybeUninit<T>] or [T]

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

Reserve enough space for at least additional elements

Panics

May panic or abort if it isn't possible to allocate enough space for additional more elements

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

Try to reserve enough space for at least additional elements, and returns Err(_) if it's not possible to reserve enough space

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

Shortens the vector, keeping the first len elements and dropping the rest.

If len is greater than the vector's current length, this has no effect.

Note that this method has no effect on the allocated capacity of the vector.

pub fn grow(&mut self, additional: usize, value: T) where
    T: Clone, 

Grows the GenericVec in-place by additional elements.

This method requires T to implement Clone, in order to be able to clone the passed value. If you need more flexibility (or want to rely on Default instead of Clone), use GenericVec::grow_with.

pub fn grow_with<F>(&mut self, additional: usize, value: F) where
    F: FnMut() -> T, 

Grows the GenericVec in-place by additional elements.

This method uses a closure to create new values on every push. If you'd rather Clone a given value, use GenericVec::resize. If you want to use the Default trait to generate values, you can pass Default::default as the second argument.

pub fn clear(&mut self)

Clears the vector, removing all values.

Note that this method has no effect on the allocated capacity of the vector.

pub fn push(&mut self, value: T) -> &mut T

Appends an element to the back of a collection.

Panic

May panic or reallocate if the collection is full

pub fn insert(&mut self, index: usize, value: T) -> &mut T

Inserts an element at position index within the vector, shifting all elements after it to the right.

Panics

• May panic or reallocate if the collection is full
• Panics if index > len.

pub fn pop(&mut self) -> T

Removes the last element from a vector and returns it

Panics

Panics if the collection is empty

pub fn remove(&mut self, index: usize) -> T

Removes and returns the element at position index within the vector, shifting all elements after it to the left.

Panics

Panics if index is out of bounds.

pub fn swap_remove(&mut self, index: usize) -> T

Removes an element from the vector and returns it.

The removed element is replaced by the last element of the vector.

This does not preserve ordering, but is O(1).

Panics

Panics if index is out of bounds.

pub fn try_push(&mut self, value: T) -> Result<&mut T, T>

Tries to append an element to the back of a collection. Returns the Err(value) if the collection is full

Guaranteed to not panic/abort/allocate

pub fn try_insert(&mut self, index: usize, value: T) -> Result<&mut T, T>

Inserts an element at position index within the vector, shifting all elements after it to the right. Returns the Err(value) if the collection is full or index is out of bounds

Guaranteed to not panic/abort/allocate

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

Removes the last element from a vector and returns it, Returns None if the collection is empty

Guaranteed to not panic/abort/allocate

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

Removes and returns the element at position index within the vector, shifting all elements after it to the left. Returns None if collection is empty or index is out of bounds.

Guaranteed to not panic/abort/allocate

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

Removes an element from the vector and returns it. Returns None if collection is empty or index is out of bounds.

The removed element is replaced by the last element of the vector.

This does not preserve ordering, but is O(1).

Guaranteed to not panic/abort/allocate

pub unsafe fn push_unchecked(&mut self, value: T) -> &mut T

Appends an element to the back of a collection.

Safety

the collection must not be full

pub unsafe fn insert_unchecked(&mut self, index: usize, value: T) -> &mut T

Inserts an element at position index within the vector, shifting all elements after it to the right.

Safety

• the collection is must not be full
• hte index must be in bounds

pub unsafe fn pop_unchecked(&mut self) -> T

Removes the last element from a vector and returns it

Safety

the collection must not be empty

pub unsafe fn remove_unchecked(&mut self, index: usize) -> T

Removes and returns the element at position index within the vector, shifting all elements after it to the left.

Safety

the collection must not be empty, and index must be in bounds

pub unsafe fn swap_remove_unchecked(&mut self, index: usize) -> T

Removes an element from the vector and returns it.

The removed element is replaced by the last element of the vector.

This does not preserve ordering, but is O(1).

Safety

the index must be in bounds

pub fn split_off<B>(&mut self, index: usize) -> GenericVec<T, B> where
    B: StorageWithCapacity<T>, 

Splits the collection into two at the given index.

Returns a newly allocated vector containing the elements in the range [at, len). After the call, the original vector will be left containing the elements [0, at) with its previous capacity unchanged.

pub fn split_off_into<B: ?Sized>(
    &mut self,
    index: usize,
    other: &mut GenericVec<T, B>
) where
    B: Storage<T>, 

Splits the collection into two at the given index.

Appends the elements from the range [at, len) to other. After the call, the original vector will be left containing the elements [0, at) with its previous capacity unchanged.

pub fn convert<B: StorageWithCapacity<T>>(self) -> GenericVec<T, B> where
    S: Sized, 

Convert the backing buffer type, and moves all the elements in self to the new vector

pub fn raw_drain<R>(&mut self, range: R) -> RawDrain<'_, T, S> where
    R: RangeBounds<usize>, 

Creates a raw drain that can be used to remove elements in the specified range. Usage of RawDrain is unsafe because it doesn't do any checks because is meant to be a low level tool to implement fancier iterators, like GenericVec::drain, GenericVec::drain_filter, or GenericVec::splice.

Panic

Panics if the starting point is greater than the end point or if the end point is greater than the length of the vector.

pub fn drain<R>(&mut self, range: R) -> Drain<'_, T, S> where
    R: RangeBounds<usize>, 

Creates a draining iterator that removes the specified range in the vector and yields the removed items.

When the iterator is dropped, all elements in the range are removed from the vector, even if the iterator was not fully consumed. If the iterator is not dropped (with mem::forget for example), it is unspecified how many elements are removed.

Panic

Panics if the starting point is greater than the end point or if the end point is greater than the length of the vector.

pub fn drain_filter<R, F>(&mut self, range: R, f: F) -> DrainFilter<'_, T, S, F> where
    R: RangeBounds<usize>,
    F: FnMut(&mut T) -> bool, 

Creates an iterator which uses a closure to determine if an element should be removed.

If the closure returns true, then the element is removed and yielded. If the closure returns false, the element will remain in the vector and will not be yielded by the iterator.

pub fn splice<R, I>(
    &mut self,
    range: R,
    replace_with: I
) -> Splice<'_, T, S, I::IntoIter> where
    R: RangeBounds<usize>,
    I: IntoIterator<Item = T>, 

Creates a splicing iterator that replaces the specified range in the vector with the given replace_with iterator and yields the removed items. replace_with does not need to be the same length as range.

range is removed even if the iterator is not consumed until the end.

It is unspecified how many elements are removed from the vector if the Splice value is leaked.

The input iterator replace_with is only consumed when the Splice value is dropped

pub fn retain<F>(&mut self, f: F) where
    F: FnMut(&mut T) -> bool, 

Retains only the elements specified by the predicate.

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

pub unsafe fn extend_from_slice_unchecked(&mut self, slice: &[T])

Shallow copies and appends all elements in a slice to the GenericVec.

Safety

You must not drop any of the elements in slice, and there must be at least slice.len() remaining capacity in the vector

pub fn extend_from_slice(&mut self, slice: &[T]) where
    T: Clone, 

Clones and appends all elements in a slice to the GenericVec.

Iterates over the slice other, clones each element, and then appends it to this GenericVec. The other vector is traversed in-order.

Note that this function is same as extend except that it is specialized to work with slices instead. If and when Rust gets specialization this function will likely be deprecated (but still available).

Trait Implementations

impl<T, S: ?Sized + Storage<T>> AsMut<[T]> for GenericVec<T, S>

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

Performs the conversion.

impl<T, S: ?Sized + Storage<T>> AsRef<[T]> for GenericVec<T, S>

pub fn as_ref(&self) -> &[T]

Performs the conversion.

impl<T, S: ?Sized + Storage<T>> Borrow<[T]> for GenericVec<T, S>

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

Immutably borrows from an owned value.

impl<T, S: ?Sized + Storage<T>> BorrowMut<[T]> for GenericVec<T, S>

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

Mutably borrows from an owned value.

impl<T, S: StorageWithCapacity<T>> Clone for GenericVec<T, S> where
    T: Clone, 

pub fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, S: ?Sized + Storage<T>> Debug for GenericVec<T, S> where
    T: Debug, 

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

Formats the value using the given formatter.

impl<T, S: StorageWithCapacity<T>> Default for GenericVec<T, S>

pub fn default() -> Self

Returns the "default value" for a type.

impl<T, S: ?Sized + Storage<T>> Deref for GenericVec<T, S>

type Target = [T]

The resulting type after dereferencing.

pub fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T, S: ?Sized + Storage<T>> DerefMut for GenericVec<T, S>

pub fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T, S: ?Sized + Storage<T>> Drop for GenericVec<T, S>

pub fn drop(&mut self)

Executes the destructor for this type.

impl<T, S: ?Sized + Storage<T>> Eq for GenericVec<T, S> where
    T: Eq, 

impl<T, S: ?Sized + Storage<T>> Extend<T> for GenericVec<T, S>

pub fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

pub fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

pub 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<GenericVec<T, Heap<T>>> for Vec<T>

pub fn from(vec: HeapVec<T>) -> Self

Performs the conversion.

impl<V, T, S: StorageWithCapacity<T>> FromIterator<V> for GenericVec<T, S> where
    Self: Extend<V>, 

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

Creates a value from an iterator.

impl<T, S: ?Sized + Storage<T>> Hash for GenericVec<T, S> where
    T: Hash, 

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<T, S: Storage<T> + ?Sized, I> Index<I> for GenericVec<T, S> where
    I: SliceIndex<[T]>, 

type Output = I::Output

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T, S: Storage<T> + ?Sized, I> IndexMut<I> for GenericVec<T, S> where
    I: SliceIndex<[T]>, 

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

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

impl<T, S: Storage<T>> IntoIterator for GenericVec<T, S>

type IntoIter = IntoIter<T, S>

Which kind of iterator are we turning this into?

type Item = T

The type of the elements being iterated over.

pub fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T, S: ?Sized + Storage<T>> IntoIterator for &'a mut GenericVec<T, S>

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

type Item = &'a mut T

The type of the elements being iterated over.

pub fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T, S: ?Sized + Storage<T>> IntoIterator for &'a GenericVec<T, S>

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

type Item = &'a T

The type of the elements being iterated over.

pub fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, S: ?Sized + Storage<T>> Ord for GenericVec<T, S> where
    T: Ord, 

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

This method returns an Ordering between self and other.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<T, O: ?Sized + AsRef<[T]>, S: ?Sized + Storage<T>> PartialEq<O> for GenericVec<T, S> where
    T: PartialEq, 

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

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

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T, O: ?Sized + AsRef<[T]>, S: ?Sized + Storage<T>> PartialOrd<O> for GenericVec<T, S> where
    T: PartialOrd, 

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

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

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

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

#[must_use]pub fn le(&self, other: &Rhs) -> bool

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

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

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

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

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