Struct SparseChunk

pub struct SparseChunk<A, const N: usize>
where
    BitsImpl<N>: Bits,
{ /* private fields */ }

A fixed capacity sparse array.

An inline sparse array of up to N items of type A. You can think of it as an array of Option<A>, where the discriminant (whether the value is Some<A> or None) is kept in a bitmap instead of adjacent to the value.

Examples

// Construct a chunk with a 20 item capacity
let mut chunk = SparseChunk::<i32, 20>::new();
// Set the 18th index to the value 5.
chunk.insert(18, 5);
// Set the 5th index to the value 23.
chunk.insert(5, 23);

assert_eq!(chunk.len(), 2);
assert_eq!(chunk.get(5), Some(&23));
assert_eq!(chunk.get(6), None);
assert_eq!(chunk.get(18), Some(&5));

Implementations

impl<A, const N: usize> SparseChunk<A, N>

where BitsImpl<N>: Bits,

pub const CAPACITY: usize = N

The maximum number of elements a SparseChunk can contain.

pub fn new() -> Self

Construct a new empty chunk.

pub fn unit(index: usize, value: A) -> Self

Construct a new chunk with one item.

pub fn pair(index1: usize, value1: A, index2: usize, value2: A) -> Self

Construct a new chunk with two items.

pub fn len(&self) -> usize

Get the length of the chunk.

pub fn is_empty(&self) -> bool

Test if the chunk is empty.

pub fn is_full(&self) -> bool

Test if the chunk is at capacity.

pub fn insert(&mut self, index: usize, value: A) -> Option<A>

Insert a new value at a given index.

Returns the previous value at that index, if any.

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

Remove the value at a given index.

Returns the value, or None if the index had no value.

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

Remove the first value present in the array.

Returns the value that was removed, or None if the array was empty.

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

Get the value at a given index.

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

Get a mutable reference to the value at a given index.

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

Get an unchecked reference to the value at a given index.

Safety

Uninhabited indices contain uninitialised data, so make sure you validate the index before using this method.

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

Get an unchecked mutable reference to the value at a given index.

Safety

Uninhabited indices contain uninitialised data, so make sure you validate the index before using this method.

pub fn indices(&self) -> BitmapIter<'_, N>

Make an iterator over the indices which contain values.

pub fn first_index(&self) -> Option<usize>

Find the first index which contains a value.

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

Make an iterator of references to the values contained in the array.

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

Make an iterator of mutable references to the values contained in the array.

pub fn drain(self) -> Drain<A, N>

Turn the chunk into an iterator over the values contained within it.

pub fn entries(&self) -> impl Iterator<Item = (usize, &A)>

Make an iterator of pairs of indices and references to the values contained in the array.

pub fn option_iter(&self) -> OptionIter<'_, A, N>

Make an iterator of Options of references to the values contained in the array.

Iterates over every index in the SparseChunk, from zero to its full capacity, returning an Option<&A> for each index.

pub fn option_iter_mut(&mut self) -> OptionIterMut<'_, A, N>

Make an iterator of Options of mutable references to the values contained in the array.

Iterates over every index in the SparseChunk, from zero to its full capacity, returning an Option<&mut A> for each index.

pub fn option_drain(self) -> OptionDrain<A, N>

Make a draining iterator of `Option’s of the values contained in the array.

Iterates over every index in the SparseChunk, from zero to its full capacity, returning an Option<A> for each index.

Trait Implementations

impl<A: Clone, const N: usize> Clone for SparseChunk<A, N>

where BitsImpl<N>: Bits,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A, const N: usize> Debug for SparseChunk<A, N>

where A: Debug, BitsImpl<N>: Bits,

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

Formats the value using the given formatter.

impl<A, const N: usize> Default for SparseChunk<A, N>

where BitsImpl<N>: Bits,

fn default() -> Self

Returns the “default value” for a type.

impl<A, const N: usize> Drop for SparseChunk<A, N>

where BitsImpl<N>: Bits,

fn drop(&mut self)

Executes the destructor for this type.

impl<A, const N: usize> FromIterator<Option<A>> for SparseChunk<A, N>

where BitsImpl<N>: Bits,

fn from_iter<I>(iter: I) -> Self

where I: IntoIterator<Item = Option<A>>,

Creates a value from an iterator.

impl<A, const N: usize> Index<usize> for SparseChunk<A, N>

where BitsImpl<N>: Bits,

type Output = A

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<A, const N: usize> IndexMut<usize> for SparseChunk<A, N>

where BitsImpl<N>: Bits,

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

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

impl<A, const N: usize> IntoIterator for SparseChunk<A, N>

where BitsImpl<N>: Bits,

type Item = A

The type of the elements being iterated over.

type IntoIter = Drain<A, N>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<A, const N: usize> PartialEq<BTreeMap<usize, A>> for SparseChunk<A, N>

where A: PartialEq, BitsImpl<N>: Bits,

fn eq(&self, other: &BTreeMap<usize, A>) -> 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<A, const N: usize> PartialEq<HashMap<usize, A>> for SparseChunk<A, N>

where A: PartialEq, BitsImpl<N>: Bits,

fn eq(&self, other: &HashMap<usize, A>) -> 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<A, const N: usize> PartialEq for SparseChunk<A, N>

where A: PartialEq, BitsImpl<N>: Bits,

fn eq(&self, other: &Self) -> 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<A, const N: usize> Eq for SparseChunk<A, N>

where A: Eq, BitsImpl<N>: Bits,