Struct parallel_vec::ParallelVec

pub struct ParallelVec<Param: ParallelVecParam> { /* private fields */ }

A contiguously growable heterogenous array type.

This type stores the values [structure of arrays] layout. This layout may improve cache utilizatoin in specific use cases, which may have.

Unlike a struct of Vecs, this type allocates memory for the all individual fields simultaneously. This may minimize memory fragmentation and decrease allocation pressure. It also only stores one length and capacity instead of duplicating the values across multiple Vec fields.

Implementations

impl<Param: ParallelVecParam> ParallelVec<Param>

pub fn new() -> Self

Constructs a new, empty ParallelVec.

The vector will not allocate until elements are pushed onto it.

pub fn with_capacity(capacity: usize) -> Self

Constructs a new, empty ParallelVec with the specified capacity.

The vector will be able to hold exactly capacity elements without reallocating. If capacity is 0, the vector will not allocate.

It is important to note that although the returned vector has the capacity specified, the vector will have a zero length.

pub fn len(&self) -> usize

Returns the number of elements in the vector, also referred to as its ‘length’.

pub fn is_empty(&self) -> bool

Returns true if the vector contains no elements.

pub fn capacity(&self) -> usize

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

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 get(&self, index: usize) -> Option<Param::Ref>

Returns a immutable reference to the element at index, if available, or None if it is out of bounds.

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

Returns a mutable reference to the element at index, if available, or None if it is out of bounds.

pub fn first(&self) -> Option<Param::Ref>

Returns the first element of the ParallelVec, or None if it is empty.

pub fn first_mut(&mut self) -> Option<Param::RefMut>

Returns the mutable pointer first element of the ParallelVec, or None if it is empty.

pub fn last(&self) -> Option<Param::Ref>

Returns the last element of the ParallelVec, or None if it is empty.

pub fn last_mut(&mut self) -> Option<Param::RefMut>

Returns the mutable pointer last element of the ParallelVec, or None if it is empty.

pub fn index(&self, index: usize) -> Param::Ref

Gets a immutable reference to the elements at index.

Panics

This function will panic if index is >= self.len.

pub fn index_mut(&mut self, index: usize) -> Param::RefMut

Gets a mutable reference to the elements at index.

Panics

This function will panic if index is >= self.len.

pub unsafe fn get_unchecked(&self, index: usize) -> Param::Ref

Returns references to elements, without doing bounds checking.

For a safe alternative see get.

Safety

Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.

pub unsafe fn get_unchecked_mut(&mut self, index: usize) -> Param::RefMut

Returns mutable references to elements, without doing bounds checking.

For a safe alternative see get_mut.

Safety

Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.

pub fn as_mut_ptrs(&mut self) -> Param::Ptr

Returns a raw pointer to the slice’s buffer.

The caller must ensure that the slice outlives the pointer this function returns, or else it will end up pointing to garbage.

Modifying the container referenced by this slice may cause its buffer to be reallocated, which would also make any pointers to it invalid.

pub fn as_slices(&self) -> Param::Slices

Gets the individual slices for very sub-Vec.

pub fn as_slices_mut(&mut self) -> Param::SlicesMut

Gets mutable individual slices for very sub-Vec.

pub fn swap(&mut self, a: usize, b: usize)

Swaps two elements.

Arguments

• a - The index of the first element
• b - The index of the second element

Panics

Panics if a or b are out of bounds.

pub unsafe fn swap_unchecked(&mut self, a: usize, b: usize)

Swaps two elements in the slice, without doing bounds checking.

For a safe alternative see swap.

Arguments

• a - The index of the first element
• b - The index of the second element

Safety

Calling this method with an out-of-bounds index is undefined behavior. The caller has to ensure that a < self.len() and b < self.len().

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 reverse(&mut self)

Reverses the order of elements in the ParallelVec, in place.

This is a O(n) operation.

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

Shrinks the capacity of the vector with a lower bound.

The capacity will remain at least as large as both the length and the supplied value.

If the current capacity is less than the lower limit, this is a no-op.

pub fn swap_with(&mut self, other: &mut Self)

Swaps all elements in self with those in other.

The length of other must be the same as self.

Panics

This function will panic if the two slices have different lengths.

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the vector as much as possible.

It will drop down as close as possible to the length but the allocator may still inform the vector that there is space for a few more elements.

pub fn append(&mut self, other: &mut ParallelVec<Param>)

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

pub fn push(&mut self, value: Param)

Appends an element to the back of a collection.

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

Removes the last element from the vector and returns it, or None if it is empty.

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

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). If you need to preserve the element order, use remove instead.

pub fn insert(&mut self, index: usize, value: Param)

Inserts a value at index. Moves all of the elements above index up one index. This is a O(N) operation.

Panics

This function will panic if index is greater than or equal to len().

pub fn remove(&mut self, index: usize) -> Option<Param>

Removes a value at index. Moves all of the elements above index down one index. This is a O(N) operation.

Returns None if index is is greater than or equal to len().

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

Reserves capacity for at least additional more elements to be inserted in the given ParallelVec. The collection may reserve more space to avoid frequent reallocations. After calling reserve, capacity will be greater than or equal to self.len() + additional. Does nothing if capacity is already sufficient.

pub fn iter(&self) -> Iter<'_, Param>

Returns an iterator over the ParallelVec.

pub fn iter_mut(&mut self) -> IterMut<'_, Param>

Returns an iterator that allows modifying each value.

pub fn iters(&self) -> Param::Iters

Returns an iterator over the ParallelVec.

pub fn iters_mut(&mut self) -> Param::ItersMut

Gets individual iterators.

impl<Param: ParallelVecParam + Copy> ParallelVec<Param>

pub fn repeat(&self, n: usize) -> ParallelVec<Param>

Creates a ParallelVec by repeating self n times.

impl<Param: ParallelVecParam + Clone> ParallelVec<Param>

pub fn fill(&mut self, value: Param)

Fills self with elements by cloning value.

impl<Param: ParallelVecParam> ParallelVec<Param>

pub fn fill_with<F: FnMut() -> Param>(&mut self, f: F)

Fills self with elements returned by calling a closure repeatedly.

This method uses a closure to create new values. If you’d rather Clone a given value, use fill. If you want to use the Default trait to generate values, you can pass Default::default as the argument.

Trait Implementations

impl<Param: ParallelVecParam + Clone> Clone for ParallelVec<Param>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Param: ParallelVecParam> Default for ParallelVec<Param>

fn default() -> Self

Returns the “default value” for a type.

impl<Param: ParallelVecParam> Drop for ParallelVec<Param>

fn drop(&mut self)

Executes the destructor for this type.

impl<Param: ParallelVecParam> Extend<Param> for ParallelVec<Param>

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

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<Param: ParallelVecParam> IntoIterator for ParallelVec<Param>

type Item = Param

The type of the elements being iterated over.

type IntoIter = IntoIter<Param>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static> TryFrom<(Vec<T1, Global>, Vec<T2, Global>, Vec<T3, Global>, Vec<T4, Global>, Vec<T5, Global>, Vec<T6, Global>, Vec<T7, Global>, Vec<T8, Global>)> for ParallelVec<(T1, T2, T3, T4, T5, T6, T7, T8)>

type Error = ParallelVecConversionError

The type returned in the event of a conversion error.

fn try_from(
    vecs: (Vec<T1>, Vec<T2>, Vec<T3>, Vec<T4>, Vec<T5>, Vec<T6>, Vec<T7>, Vec<T8>)
) -> Result<Self, Self::Error>

Performs the conversion.

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static, T7: 'static> TryFrom<(Vec<T1, Global>, Vec<T2, Global>, Vec<T3, Global>, Vec<T4, Global>, Vec<T5, Global>, Vec<T6, Global>, Vec<T7, Global>)> for ParallelVec<(T1, T2, T3, T4, T5, T6, T7)>

type Error = ParallelVecConversionError

The type returned in the event of a conversion error.

fn try_from(
    vecs: (Vec<T1>, Vec<T2>, Vec<T3>, Vec<T4>, Vec<T5>, Vec<T6>, Vec<T7>)
) -> Result<Self, Self::Error>

Performs the conversion.

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static, T6: 'static> TryFrom<(Vec<T1, Global>, Vec<T2, Global>, Vec<T3, Global>, Vec<T4, Global>, Vec<T5, Global>, Vec<T6, Global>)> for ParallelVec<(T1, T2, T3, T4, T5, T6)>

type Error = ParallelVecConversionError

The type returned in the event of a conversion error.

fn try_from(
    vecs: (Vec<T1>, Vec<T2>, Vec<T3>, Vec<T4>, Vec<T5>, Vec<T6>)
) -> Result<Self, Self::Error>

Performs the conversion.

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static, T5: 'static> TryFrom<(Vec<T1, Global>, Vec<T2, Global>, Vec<T3, Global>, Vec<T4, Global>, Vec<T5, Global>)> for ParallelVec<(T1, T2, T3, T4, T5)>

type Error = ParallelVecConversionError

The type returned in the event of a conversion error.

fn try_from(
    vecs: (Vec<T1>, Vec<T2>, Vec<T3>, Vec<T4>, Vec<T5>)
) -> Result<Self, Self::Error>

Performs the conversion.

impl<T1: 'static, T2: 'static, T3: 'static, T4: 'static> TryFrom<(Vec<T1, Global>, Vec<T2, Global>, Vec<T3, Global>, Vec<T4, Global>)> for ParallelVec<(T1, T2, T3, T4)>

type Error = ParallelVecConversionError

The type returned in the event of a conversion error.

fn try_from(
    vecs: (Vec<T1>, Vec<T2>, Vec<T3>, Vec<T4>)
) -> Result<Self, Self::Error>

Performs the conversion.

impl<T1: 'static, T2: 'static, T3: 'static, V3: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static, T12: 'static> TryFrom<(Vec<T1, Global>, Vec<T2, Global>, Vec<T3, Global>, Vec<V3, Global>, Vec<T5, Global>, Vec<T6, Global>, Vec<T7, Global>, Vec<T8, Global>, Vec<T9, Global>, Vec<T10, Global>, Vec<T11, Global>, Vec<T12, Global>)> for ParallelVec<(T1, T2, T3, V3, T5, T6, T7, T8, T9, T10, T11, T12)>

type Error = ParallelVecConversionError

The type returned in the event of a conversion error.

fn try_from(
    vecs: (Vec<T1>, Vec<T2>, Vec<T3>, Vec<V3>, Vec<T5>, Vec<T6>, Vec<T7>, Vec<T8>, Vec<T9>, Vec<T10>, Vec<T11>, Vec<T12>)
) -> Result<Self, Self::Error>

Performs the conversion.

impl<T1: 'static, T2: 'static, T3: 'static, V3: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static, T11: 'static> TryFrom<(Vec<T1, Global>, Vec<T2, Global>, Vec<T3, Global>, Vec<V3, Global>, Vec<T5, Global>, Vec<T6, Global>, Vec<T7, Global>, Vec<T8, Global>, Vec<T9, Global>, Vec<T10, Global>, Vec<T11, Global>)> for ParallelVec<(T1, T2, T3, V3, T5, T6, T7, T8, T9, T10, T11)>

type Error = ParallelVecConversionError

The type returned in the event of a conversion error.

fn try_from(
    vecs: (Vec<T1>, Vec<T2>, Vec<T3>, Vec<V3>, Vec<T5>, Vec<T6>, Vec<T7>, Vec<T8>, Vec<T9>, Vec<T10>, Vec<T11>)
) -> Result<Self, Self::Error>

Performs the conversion.

impl<T1: 'static, T2: 'static, T3: 'static, V3: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static, T10: 'static> TryFrom<(Vec<T1, Global>, Vec<T2, Global>, Vec<T3, Global>, Vec<V3, Global>, Vec<T5, Global>, Vec<T6, Global>, Vec<T7, Global>, Vec<T8, Global>, Vec<T9, Global>, Vec<T10, Global>)> for ParallelVec<(T1, T2, T3, V3, T5, T6, T7, T8, T9, T10)>

type Error = ParallelVecConversionError

The type returned in the event of a conversion error.

fn try_from(
    vecs: (Vec<T1>, Vec<T2>, Vec<T3>, Vec<V3>, Vec<T5>, Vec<T6>, Vec<T7>, Vec<T8>, Vec<T9>, Vec<T10>)
) -> Result<Self, Self::Error>

Performs the conversion.

impl<T1: 'static, T2: 'static, T3: 'static, V3: 'static, T5: 'static, T6: 'static, T7: 'static, T8: 'static, T9: 'static> TryFrom<(Vec<T1, Global>, Vec<T2, Global>, Vec<T3, Global>, Vec<V3, Global>, Vec<T5, Global>, Vec<T6, Global>, Vec<T7, Global>, Vec<T8, Global>, Vec<T9, Global>)> for ParallelVec<(T1, T2, T3, V3, T5, T6, T7, T8, T9)>

type Error = ParallelVecConversionError

The type returned in the event of a conversion error.

fn try_from(
    vecs: (Vec<T1>, Vec<T2>, Vec<T3>, Vec<V3>, Vec<T5>, Vec<T6>, Vec<T7>, Vec<T8>, Vec<T9>)
) -> Result<Self, Self::Error>

Performs the conversion.

impl<T1: 'static, T2: 'static, T3: 'static> TryFrom<(Vec<T1, Global>, Vec<T2, Global>, Vec<T3, Global>)> for ParallelVec<(T1, T2, T3)>

type Error = ParallelVecConversionError

The type returned in the event of a conversion error.

fn try_from(vecs: (Vec<T1>, Vec<T2>, Vec<T3>)) -> Result<Self, Self::Error>

Performs the conversion.

impl<T1: 'static, T2: 'static> TryFrom<(Vec<T1, Global>, Vec<T2, Global>)> for ParallelVec<(T1, T2)>

type Error = ParallelVecConversionError

The type returned in the event of a conversion error.

fn try_from(vecs: (Vec<T1>, Vec<T2>)) -> Result<Self, Self::Error>

Performs the conversion.