Struct shared_vector::UniqueVector

pub struct UniqueVector<T> { /* private fields */ }

A heap allocated, mutable contiguous buffer containing elements of type T.

Similar in principle to a Vec<T>. It can be converted for free into an immutable SharedVector<T> or AtomicSharedVector<T>.

Unique and shared vectors expose similar functionality. UniqueVector takes advantage of the guaranteed uniqueness at the type level to provide overall faster operations than its shared counterparts, while its memory layout makes it very cheap to convert to a shared vector (involving not allocation or copy).

Internal representation

UniqueVector stores its length and capacity inline and points to the first element of the allocated buffer. Room for a 16 bytes header is left before the first element so that the vector can be converted into a SharedVector or AtomicSharedVector without reallocating the storage.

Implementations

impl<T> UniqueVector<T>

pub fn new() -> Self

Creates an empty vector.

This does not allocate memory.

pub fn with_capacity(cap: usize) -> Self

Creates an empty pre-allocated vector with a given storage capacity.

Does not allocate memory if cap is zero.

pub fn try_with_capacity(cap: usize) -> Result<Self, AllocError>

Creates an empty pre-allocated vector with a given storage capacity.

Does not allocate memory if cap is zero.

pub fn from_slice(data: &[T]) -> Selfwhere T: Clone,

pub fn from_elem(elem: T, n: usize) -> Selfwhere T: Clone,

Creates a vector with n copies of elem.

pub fn is_empty(&self) -> bool

Returns true if the vector contains no elements.

pub fn len(&self) -> usize

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

pub fn capacity(&self) -> usize

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

pub fn remaining_capacity(&self) -> usize

Returns number of elements that can be added without reallocating.

pub fn into_shared(self) -> SharedVector<T>

Make this vector immutable.

This operation is cheap, the underlying storage does not not need to be reallocated.

pub fn into_shared_atomic(self) -> AtomicSharedVector<T>

Make this vector immutable.

This operation is cheap, the underlying storage does not not need to be reallocated.

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

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

pub fn iter(&self) -> impl Iterator<Item = &T>

pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T>

pub fn first(&self) -> Option<&T>

pub fn last(&self) -> Option<&T>

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

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

pub fn push(&mut self, val: T)

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

pub fn push_slice(&mut self, data: &[T])where T: Clone,

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

pub fn clear(&mut self)

pub fn clone_buffer(&self) -> Selfwhere T: Clone,

Allocate a clone of this buffer.

pub fn clone_buffer_with_capacity(&self, cap: usize) -> Selfwhere T: Clone,

Allocate a clone of this buffer with a different capacity

The capacity must be at least as large as the buffer’s length.

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

Trait Implementations

impl<T> AsMut<[T]> for UniqueVector<T>

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

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T> AsRef<[T]> for UniqueVector<T>

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

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Clone> Clone for UniqueVector<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Default for UniqueVector<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> Drop for UniqueVector<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T, I> Index<I> for UniqueVector<T>where I: SliceIndex<[T]>,

type Output = <I as SliceIndex<[T]>>::Output

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T, I> IndexMut<I> for UniqueVector<T>where I: SliceIndex<[T]>,

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

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

impl<'a, T> IntoIterator for &'a UniqueVector<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) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut UniqueVector<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) -> IterMut<'a, T>

Creates an iterator from a value.

impl<T: PartialEq<T>> PartialEq<&[T]> for UniqueVector<T>

fn eq(&self, other: &&[T]) -> 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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: PartialEq<T>> PartialEq<UniqueVector<T>> for UniqueVector<T>

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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.