Struct Nested

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

A two dimensional collection with minimal allocation

T is the owning underlying container.

For instance, it behaves similarly to Vec<Vec<T>> or Vec<String> but only has 2 internal buffers.

It can be used:

• on your own collection as long as it implements the Collection trait.
• like a sparse vector
• when you need to collect (move ownership) many Strings or Vec<T>s

Implementations

impl<T: Collection> Nested<T>

pub fn new() -> Self

Create a new Nested.

pub fn with_capacity(len: usize, size: usize) -> Self

Creates a new Nested with given capacity.

len: the expected item count size: the expected total size taken by all items

pub fn push<I: AsRef<Item<T>>>(&mut self, el: I)

Pushes a new item

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

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

pub fn extend_empty(&mut self, count: usize)

Extend with count empty elements

pub fn len(&self) -> usize

Returns the number of elements in the Nested.

pub fn data_len(&self) -> usize

Get the total length taken by the data

pub fn is_empty(&self) -> bool

Returns true if self has a length of zero.

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

Shortens the Nested, 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 clear(&mut self)

Truncates this Nested, removing all contents.

While this means the Nested will have a length of zero, it does not touch its capacity.

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

Returns a shared reference to the output at this location, if in bounds.

pub fn into_parts(self) -> (Vec<usize>, T)

Converts this Nested into its constituent parts.

pub fn indices(&self) -> &[usize]

Returns a reference to the underlying indices.

Each index represents the start of each logical vector beyond the first one.

pub fn data(&self) -> &T

Returns a reference to the underlying data.

The data is stored contiguously.

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

Returns an iterator over Nested elements.

pub fn split_off(&mut self, at: usize) -> Nested<T>

Splits the collection into two at the given index.

Returns a newly allocated Self. self contains elements [0, at), and the returned Self contains elements [at, len).

Note that the capacity of self does not change.

Trait Implementations

impl<T: Clone> Clone for Nested<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Nested<T>

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

Formats the value using the given formatter.

impl<T: Collection, A: AsRef<Item<T>>> Extend<A> for Nested<T>

fn extend<I>(&mut self, iter: I)

where I: IntoIterator, I::Item: AsRef<Item<T>>,

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<T: Collection, A: AsRef<Item<T>>> FromIterator<A> for Nested<T>

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

Creates a value from an iterator.

impl<T: Hash> Hash for Nested<T>

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: Collection> Index<usize> for Nested<T>

type Output = <T as Index<Range<usize>>>::Output

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T: PartialEq> PartialEq for Nested<T>

fn eq(&self, other: &Nested<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 Nested<T>

impl<T> StructuralPartialEq for Nested<T>