Struct SparseIndexMap 

pub struct SparseIndexMap<'a, K: IndexedValue + 'a, V, P: PointerFamily<'a>> { /* private fields */ }

A mapping from indexed keys to values, implemented sparsely with a hash map.

This is more memory-efficient than the DenseIndexMap with a small number of keys.

Implementations

impl<'a, K, V, P> SparseIndexMap<'a, K, V, P>

where K: IndexedValue + 'a, P: PointerFamily<'a>,

pub fn new(domain: &P::Pointer<IndexedDomain<K>>) -> Self

Constructs an empty map within the given domain.

pub fn get<M>(&self, key: impl ToIndex<K, M>) -> Option<&V>

Returns an immutable reference to a value for a given key if it exists.

pub fn get_mut<M>(&mut self, key: impl ToIndex<K, M>) -> Option<&mut V>

Returns a mutable reference to a value for a given key if it exists.

pub unsafe fn get_unchecked<M>(&self, key: impl ToIndex<K, M>) -> &V

Returns a reference to a value for a given key.

Safety

This function has undefined behavior if key is not in self.

pub unsafe fn get_unchecked_mut<M>(&mut self, key: impl ToIndex<K, M>) -> &mut V

Returns a mutable reference to a value for a given key.

Safety

This function has undefined behavior if key is not in self.

pub fn insert<M>(&mut self, key: impl ToIndex<K, M>, value: V)

Inserts the key/value pair into self.

pub fn values(&self) -> impl ExactSizeIterator<Item = &V>

Returns an iterator over the values of the map.

pub fn entry<M>(&mut self, key: impl ToIndex<K, M>) -> Entry<'_, K::Index, V>

Returns a mutable entry into the map for the given key.

pub fn len(&self) -> usize

Returns the number of entries in the map.

pub fn is_empty(&self) -> bool

Returns true if the map has no elements.

Trait Implementations

impl<'a, K, V, P, M, U> FromIndexicalIterator<'a, K, P, M, (U, V)> for SparseIndexMap<'a, K, V, P>

where K: IndexedValue + 'a, P: PointerFamily<'a>, U: ToIndex<K, M>,

fn from_indexical_iter( iter: impl Iterator<Item = (U, V)>, domain: &P::Pointer<IndexedDomain<K>>, ) -> Self

Converts an iterator into a collection within the given domain.

impl<'a, K, V, P> Index<<K as IndexedValue>::Index> for SparseIndexMap<'a, K, V, P>

where K: IndexedValue + 'a, P: PointerFamily<'a>,

type Output = V

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<'a, K, V, P> IndexMut<<K as IndexedValue>::Index> for SparseIndexMap<'a, K, V, P>

where K: IndexedValue + 'a, P: PointerFamily<'a>,

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

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

impl<'a, 'b, K, V, P> IntoIterator for &'b SparseIndexMap<'a, K, V, P>

where K: IndexedValue + 'a + 'b, V: 'b, P: PointerFamily<'a>,

type Item = (&'b <K as IndexedValue>::Index, &'b V)

The type of the elements being iterated over.

type IntoIter = Iter<'b, <K as IndexedValue>::Index, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, K, V, P> PartialEq for SparseIndexMap<'a, K, V, P>

where K: IndexedValue + 'a, P: PointerFamily<'a>, V: PartialEq,

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, K, V, P> Eq for SparseIndexMap<'a, K, V, P>

where K: IndexedValue + 'a, P: PointerFamily<'a>, V: Eq,