Struct contiguous_map::ContiguousMap

pub struct ContiguousMap<K: Key, V> { /* fields omitted */ }

An ordered, associative container like std::collections::BTreeMap. Additionally stores values with adjacent keys contiguously so they may be accessed as a slice.

Implementations

impl<K: Key, V> ContiguousMap<K, V>

pub fn new() -> Self

Makes a new, empty ContiguousMap.

pub fn len(&self) -> usize

Gets the number of entries in this map.

This is the total number of values in the map, not the number of contiguous regions. For the number of contiguous regions use ContiguousMap::num_contiguous_regions()

pub fn is_empty(&self) -> bool

Gets if this map is empty.

pub fn num_contiguous_regions(&self) -> usize

Gets the number of contiguous regions in this map.

This is the number of (key, slice) tuples that will be iterated over by iterators returned by ContiguousMap::iter_slice() and ContiguousMap::iter_slice_mut().

This is also th number of (key, vector) tuples that will be iterated over by iterators returned by ContiguousMap::iter_vec().

pub fn insert(&mut self, key: K, value: V) -> Option<V>

Inserts a value into a map with a given key. Returns the old value for this key if one existed.

pub fn insert_slice(&mut self, start_key: K, values: &[V]) where
    V: Clone, 

Inserts values into the map from a slice starting at a given key.

pub fn remove<KB: Borrow<K>>(&mut self, key: KB) -> Option<V>

Removes a key’s value in this map, returning it if it existed.

pub fn clear(&mut self)

Removes all entries from this map.

pub fn clear_range<R: RangeBounds<K>>(&mut self, range: R)

Removes all entries within a range of keys.

pub fn clear_with_len<KB: Borrow<K>>(&mut self, start_key: KB, len: usize)

Removes all entries starting at the provided key for the next len adjacent keys.

pub fn get<KB: Borrow<K>>(&self, key: KB) -> Option<&V>

Returns a reference to a key’s value, if it exists.

pub fn get_mut<KB: Borrow<K>>(&mut self, key: KB) -> Option<&mut V>

Returns a mutable reference to a key’s value, if it exists.

pub fn get_slice<R: InclusiveStartRangeBounds<K>>(
    &self,
    range: R
) -> Option<&[V]>

Gets a slice from this map using a range of keys.

pub fn get_slice_with_len<KB: Borrow<K>>(
    &self,
    key: KB,
    len: usize
) -> Option<&[V]>

Gets a slice from this map using a key and a length.

pub fn get_slice_mut<R: InclusiveStartRangeBounds<K>>(
    &mut self,
    range: R
) -> Option<&mut [V]>

Gets a mutable slice from this map using a range of keys.

pub fn get_slice_with_len_mut<KB: Borrow<K>>(
    &mut self,
    key: KB,
    len: usize
) -> Option<&mut [V]>

Gets a mutable slice from this map using a key and a length.

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

Iteration over all keys and values in this map in ascending key order.

Unlike std::collections::BTreeMap the tuples yielded by the iterator contains a key directly instead of a reference to a key. This is due to how contiguous regions are stored internally.

pub fn iter_mut(&mut self) -> IterMut<'_, K, V>

Mutable iteration over all keys and values in this map in ascending key order.

Unlike std::collections::BTreeMap the tuples yielded by the iterator contains a key directly instead of a reference to a key. This is due to how contiguous regions are stored internally.

pub fn range<R: RangeBounds<K>>(&self, range: R) -> Range<'_, K, V>

Iteration over a range of keys and values in this map in ascending key order.

Unlike std::collections::BTreeMap the tuples yielded by the iterator contains a key directly instead of a reference to a key. This is due to how contiguous regions are stored internally.

pub fn range_mut<R: RangeBounds<K>>(&mut self, range: R) -> RangeMut<'_, K, V>

Mutable iteration over a range of keys and values in this map in ascending key order.

Unlike std::collections::BTreeMap the tuples yielded by the iterator contains a key directly instead of a reference to a key. This is due to how contiguous regions are stored internally.

pub fn iter_vec(self) -> IterVec<K, V>

Owning iteration over all keys and values in this map grouped up in contiguous regions in ascending key order.

The iterator yields tuples containing a key and vector of values. The key of each value is its index in the vector plus the key in the tuple.

The iterator will never yield a tuple with an empty vector.

pub fn iter_slice(&self) -> IterSlice<'_, K, V>

Iteration over all keys and values in this map grouped up in contiguous regions in ascending key order.

The iterator yields tuples containing a key and slice of values. The key of each value is its index in the slice plus the key in the tuple.

The iterator will never yield a tuple with an empty slice.

pub fn iter_slice_mut(&mut self) -> IterSliceMut<'_, K, V>

Mutable iteration over all keys and values in this map grouped up in contiguous regions in ascending key order.

The iterator yields tuples containing a key and slice of values. The key of each value is its index in the slice plus the key in the tuple.

The iterator will never yield a tuple with an empty slice.

Trait Implementations

impl<K: Clone + Key, V: Clone> Clone for ContiguousMap<K, V>

fn clone(&self) -> ContiguousMap<K, V>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K: Debug + Key, V: Debug> Debug for ContiguousMap<K, V>

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

Formats the value using the given formatter.

impl<K: Key, V> Default for ContiguousMap<K, V>

fn default() -> Self

Returns the “default value” for a type.

impl<K: Key, V> IntoIterator for ContiguousMap<K, V>

type Item = (K, V)

The type of the elements being iterated over.

type IntoIter = IntoIter<K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Self as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, K: Key, V> IntoIterator for &'a ContiguousMap<K, V>

type Item = (K, &'a V)

The type of the elements being iterated over.

type IntoIter = Iter<'a, K, 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: Key, V> IntoIterator for &'a mut ContiguousMap<K, V>

type Item = (K, &'a mut V)

The type of the elements being iterated over.

type IntoIter = IterMut<'a, K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K: PartialEq + Key, V: PartialEq> PartialEq<ContiguousMap<K, V>> for ContiguousMap<K, V>

fn eq(&self, other: &ContiguousMap<K, V>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &ContiguousMap<K, V>) -> bool

This method tests for !=.

impl<K: Eq + Key, V: Eq> Eq for ContiguousMap<K, V>

impl<K: Key, V> StructuralEq for ContiguousMap<K, V>

impl<K: Key, V> StructuralPartialEq for ContiguousMap<K, V>