[][src]Struct sized_chunks::sparse_chunk::SparseChunk

pub struct SparseChunk<A, N: Bits + ChunkLength<A> = U64> { /* fields omitted */ }

A fixed capacity sparse array.

An inline sparse array of up to N items of type A, where N is an Unsigned type level numeral. 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.

Because the bitmap is kept in a primitive type, the maximum value of N is currently 128, corresponding to a type of u128. The type of the bitmap will be the minimum unsigned integer type required to fit the number of bits required. Thus, disregarding memory alignment rules, the allocated size of a SparseChunk will be uX + A * N where uX is the type of the discriminant bitmap, either u8, u16, u32, u64 or u128.

Examples

// Construct a chunk with a 20 item capacity
let mut chunk = SparseChunk::<i32, U20>::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));

Methods

impl<A, N> SparseChunk<A, N> where
    N: Bits + ChunkLength<A>, 
[src]

pub const CAPACITY: usize[src]

pub fn new() -> Self[src]

Construct a new empty chunk.

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

Construct a new chunk with one item.

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

Construct a new chunk with two items.

pub fn len(&self) -> usize[src]

Get the length of the chunk.

pub fn is_empty(&self) -> bool[src]

Test if the chunk is empty.

pub fn is_full(&self) -> bool[src]

Test if the chunk is at capacity.

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

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>[src]

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>[src]

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>[src]

Get the value at a given index.

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

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

pub fn indices(&self) -> BitmapIter<N>[src]

Make an iterator over the indices which contain values.

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

Find the first index which contains a value.

Important traits for Iter<'a, A, N>
pub fn iter(&self) -> Iter<A, N>[src]

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

Important traits for IterMut<'a, A, N>
pub fn iter_mut(&mut self) -> IterMut<A, N>[src]

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

Important traits for Drain<A, N>
pub fn drain(self) -> Drain<A, N>[src]

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

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

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

Trait Implementations

impl<A, N> Eq for SparseChunk<A, N> where
    A: Eq,
    N: Bits + ChunkLength<A>, 
[src]

impl<A, N: Bits + ChunkLength<A>> Drop for SparseChunk<A, N>[src]

impl<A: Clone, N: Bits + ChunkLength<A>> Clone for SparseChunk<A, N>[src]

impl<A, N> PartialEq<SparseChunk<A, N>> for SparseChunk<A, N> where
    A: PartialEq,
    N: Bits + ChunkLength<A>, 
[src]

impl<A, N> PartialEq<BTreeMap<usize, A>> for SparseChunk<A, N> where
    A: PartialEq,
    N: Bits + ChunkLength<A>, 
[src]

impl<A, N> PartialEq<HashMap<usize, A, RandomState>> for SparseChunk<A, N> where
    A: PartialEq,
    N: Bits + ChunkLength<A>, 
[src]

impl<A, N: Bits + ChunkLength<A>> IntoIterator for SparseChunk<A, N>[src]

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?

impl<A, N: Bits + ChunkLength<A>> Index<usize> for SparseChunk<A, N>[src]

type Output = A

The returned type after indexing.

impl<A, N: Bits + ChunkLength<A>> IndexMut<usize> for SparseChunk<A, N>[src]

impl<A, N> Debug for SparseChunk<A, N> where
    A: Debug,
    N: Bits + ChunkLength<A>, 
[src]

Auto Trait Implementations

impl<A, N> Unpin for SparseChunk<A, N> where
    <N as ChunkLength<A>>::SizedType: Unpin,
    <N as Bits>::Store: Unpin

impl<A, N> Sync for SparseChunk<A, N> where
    <N as ChunkLength<A>>::SizedType: Sync,
    <N as Bits>::Store: Sync

impl<A, N> Send for SparseChunk<A, N> where
    <N as ChunkLength<A>>::SizedType: Send,
    <N as Bits>::Store: Send

impl<A, N> UnwindSafe for SparseChunk<A, N> where
    <N as ChunkLength<A>>::SizedType: UnwindSafe,
    <N as Bits>::Store: UnwindSafe

impl<A, N> RefUnwindSafe for SparseChunk<A, N> where
    <N as ChunkLength<A>>::SizedType: RefUnwindSafe,
    <N as Bits>::Store: RefUnwindSafe

Blanket Implementations

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<I> IntoIterator for I where
    I: Iterator
[src]

type Item = <I as Iterator>::Item

The type of the elements being iterated over.

type IntoIter = I

Which kind of iterator are we turning this into?

impl<T> From<T> for T[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Same<T> for T[src]

type Output = T

Should always be Self