Struct Vec2d

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

Compact representation of a Vec<Vec<T>>

Implementations

impl<T> Vec2d<T>

pub fn new() -> Self

Create a new empty Vec2d.

This is equivalent to Self::with_capacity(0, 0).

pub fn with_capacity(vectors: usize, elements_sum: usize) -> Self

Create a new empty Vec2d with at least the specified capacities.

A Vec2d internally contains two Vecs, one for the elements of all the inner vectors and one for the indices where these inner vectors begin. vectors is the capacity for the latter and elements_sum is the capacity for the former Vec.

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

Reserve space for at least additional more inner vectors. Note that this will not reserve space for elements of the inner vectors. To that end, use Self::reserve_elements().

This is essentially a wrapper around Vec::reserve(), so the documentation there provides more details.

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

Reserve space for at least additional more elements in the inner vectors. The space is shared between the inner vectors: After reserving space for n additional elements, pushing, e.g., two vectors with k1 + k2 <= n elements will not lead to a reallocation.

This is essentially a wrapper around Vec::reserve(), so the documentation there provides more details.

pub fn len(&self) -> usize

Get the number of inner vectors

pub fn is_empty(&self) -> bool

true iff there are no inner vectors

Equivalent to self.len() == 0

pub fn get(&self, index: usize) -> Option<&[T]>

Get the vector at index if there is one

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

Get the vector at index if there is one

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

Get the first vector if there is one

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

Get the first vector if there is one

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

Get the last vector if there is one

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

Get the last vector if there is one

pub fn iter(&self) -> Vec2dIter<'_, T>

Iterate over the inner vector

pub fn push_vec(&mut self)

Add an empty inner vector

Elements can be added to that vector using Self::push_element()

pub fn pop_vec(&mut self) -> bool

Remove the last vector (if there is one)

Returns true iff the outer vector was non-empty before removal.

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

Truncate the outer vector to len inner vectors

If len is greater or equal to self.len(), this is a no-op.

pub fn push_element(&mut self, element: T)

Push an element to the last vector

The vector list must be non-empty.

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

Extend the last vector by the elements from iter

There must be at least one inner vector (i.e., !self.is_empty()).

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

Get a slice containing all elements, ignoring the boundaries of the inner vectors

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

Get a slice containing all elements, ignoring the boundaries of the inner vectors

Trait Implementations

impl<T: Clone> Clone for Vec2d<T>

fn clone(&self) -> Vec2d<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Vec2d<T>

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

Formats the value using the given formatter.

impl<T> Default for Vec2d<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'a, T: Copy> Extend<&'a [T]> for Vec2d<T>

fn extend<I: IntoIterator<Item = &'a [T]>>(&mut self, iter: I)

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<'a, T: Copy> FromIterator<&'a [T]> for Vec2d<T>

fn from_iter<I: IntoIterator<Item = &'a [T]>>(iter: I) -> Self

Creates a value from an iterator.

impl<T> Index<usize> for Vec2d<T>

type Output = [T]

The returned type after indexing.

fn index(&self, index: usize) -> &[T]

Performs the indexing (container[index]) operation.

impl<T> IndexMut<usize> for Vec2d<T>

fn index_mut(&mut self, index: usize) -> &mut [T]

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

impl<T: PartialEq> PartialEq for Vec2d<T>

fn eq(&self, other: &Vec2d<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Eq> Eq for Vec2d<T>

impl<T> StructuralPartialEq for Vec2d<T>