Struct idmap::IdMap

pub struct IdMap<K: IntegerId, V, T: EntryTable<K, V> = DenseEntryTable<K, V>> { /* fields omitted */ }

A map of mostly-contiguous IntegerId keys to values, backed by a Vec.

This is parametric over the type of the underlying EntryTable, which controls its behavior By default it’s equivalent to an OrderedIdMap, though you can explicitly request a DirectIdMap instead.

From the user’s perspective, this is equivalent to a nice wrapper around a Vec<Option<(K, V)>>, that preserves insertion order and saves some space for missing keys. More details on the possible internal representations are documented in the OrderedIdMap and DirectIdMap aliases.

Implementations

impl<K: IntegerId, V> IdMap<K, V, DirectEntryTable<K, V>>

pub fn new_direct() -> Self

Create a new direct IdMap.

This stores its entries directly in a Vector

pub fn with_capacity_direct(capacity: usize) -> Self

Create new direct IdMap, initialized with the specified capacity

Because a direct id map stores its values directly, the capacity hints at the maximum id and not the length

impl<K: IntegerId, V> IdMap<K, V>

pub fn new() -> Self

Create an empty IdMap using a DenseEntryTable and OrderedIdTable

pub fn with_capacity(capacity: usize) -> Self

Create an IdMap with the specified capacity, using an OrderedIdTable

impl<K: IntegerId, V, T: EntryTable<K, V>> IdMap<K, V, T>

pub fn new_other() -> Self

Create an empty IdMap with a custom entry table type.

pub fn with_capacity_other(capacity: usize) -> Self

Create a new IdMap with the specified capacity but a custom entry table.

pub fn is_empty(&self) -> bool

If this map is empty

pub fn len(&self) -> usize

The length of this map

This doesn’t necessarily equal the maximum integer id

pub fn max_id(&self) -> Option<u64>

The maximum id of all the elements in this map

pub fn contains_key<Q: Borrow<K>>(&self, key: Q) -> bool

If this map contains the specified key

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

Retrieve the value associated with the specified key, or None if the value is not present

Keys that implement IntegerId are expected to be cheap, so we don’t borrow the key.

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

Retrieve a mutable reference to the value associated with the specified key, or None if the value is not present

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

Insert the specified value, associating it with a key

Returns the value previously associated with they key, or None if there wasn’t any

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

Remove the value associated with the specified key, or None if there isn’t any

pub fn entry(&mut self, key: K) -> Entry<'_, K, V, T>

Retrieve the entry associated with the specified key

Mimics the HashMap entry aPI

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

Iterate over all the keys and values in this map

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

Iterate over all the entries in this map, giving mutable references to the keys

pub fn keys(&self) -> Keys<'_, K, V, T>

Iterate over all the keys in the map

pub fn values(&self) -> Values<'_, K, V, T>

Iterate over all the values in the map

pub fn values_mut(&mut self) -> ValuesMut<'_, K, V, T>

Iterate over mutable references to all the values in the map

pub fn clear(&mut self)

Clear all the entries the map

Like Vec::clear this should retain the underlying memory for future use.

pub fn retain<F>(&mut self, func: F) where
    F: FnMut(&K, &mut V) -> bool, 

Retains only the elements specified by the predicate.

let mut map: IdMap<usize, usize> = (0..8).map(|x|(x, x*10)).collect();
map.retain(|k, _| k % 2 == 0);
assert_eq!(
    map.into_iter().collect::<Vec<_>>(),
    vec![(0, 0), (2, 20), (4, 40), (6, 60)]
);

pub fn reserve(&mut self, amount: usize)

Reserve space for the specified number of additional elements

pub fn raw_debug(&self) -> RawDebug<'_, K, V, T> where
    K: Debug,
    V: Debug, 

Give a wrapper that will debug the underlying representation of this IdMap

Trait Implementations

impl<K, V, T> Clone for IdMap<K, V, T> where
    K: IntegerId + Clone,
    V: Clone,
    T: EntryTable<K, V>, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K: IntegerId, V: Debug, T: EntryTable<K, V>> Debug for IdMap<K, V, T>

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

Formats the value using the given formatter.

impl<K: IntegerId, V, T: EntryTable<K, V>> Default for IdMap<K, V, T>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, K, V, T> Deserialize<'de> for IdMap<K, V, T> where
    K: Deserialize<'de>,
    T: EntryTable<K, V>,
    K: IntegerId,
    V: Deserialize<'de>, 

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<'a, K, V, T> Extend<(&'a K, &'a V)> for IdMap<K, V, T> where
    K: IntegerId + Clone + 'a,
    V: Clone + 'a,
    T: EntryTable<K, V>, 

fn extend<I: IntoIterator<Item = (&'a K, &'a V)>>(&mut self, iter: I)

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<K: IntegerId, V, T: EntryTable<K, V>> Extend<(K, V)> for IdMap<K, V, T>

fn extend<I: IntoIterator<Item = (K, V)>>(&mut self, iter: I)

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<'a, K, V, T> FromIterator<(&'a K, &'a V)> for IdMap<K, V, T> where
    K: IntegerId + Clone + 'a,
    V: Clone + 'a,
    T: EntryTable<K, V>, 

fn from_iter<I>(iterable: I) -> Self where
    I: IntoIterator<Item = (&'a K, &'a V)>, 

Creates a value from an iterator.

impl<K: IntegerId, V, T: EntryTable<K, V>> FromIterator<(K, V)> for IdMap<K, V, T>

fn from_iter<I>(iterable: I) -> Self where
    I: IntoIterator<Item = (K, V)>, 

Creates a value from an iterator.

impl<'a, K: IntegerId, V, T: EntryTable<K, V>> Index<&'a K> for IdMap<K, V, T>

type Output = V

The returned type after indexing.

fn index(&self, key: &'a K) -> &V

Performs the indexing (container[index]) operation.

impl<K: IntegerId, V, T: EntryTable<K, V>> Index<K> for IdMap<K, V, T>

type Output = V

The returned type after indexing.

fn index(&self, key: K) -> &V

Performs the indexing (container[index]) operation.

impl<'a, K: IntegerId, V, T: EntryTable<K, V>> IndexMut<&'a K> for IdMap<K, V, T>

fn index_mut(&mut self, key: &'a K) -> &mut V

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

impl<K: IntegerId, V, T: EntryTable<K, V>> IndexMut<K> for IdMap<K, V, T>

fn index_mut(&mut self, key: K) -> &mut V

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

impl<K: IntegerId, V, T: EntryTable<K, V>> IntoIterator for IdMap<K, V, T>

type Item = (K, V)

The type of the elements being iterated over.

type IntoIter = <T as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, K: IntegerId + 'a, V: 'a, T: 'a> IntoIterator for &'a IdMap<K, V, T> where
    T: EntryTable<K, V>, 

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

The type of the elements being iterated over.

type IntoIter = Iter<'a, K, V, T>

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, T> IntoIterator for &'a mut IdMap<K, V, T> where
    T: EntryTable<K, V>,
    K: IntegerId + 'a,
    V: 'a,
    T: 'a, 

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

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K, V1, T1, V2, T2> PartialEq<IdMap<K, V2, T2>> for IdMap<K, V1, T1> where
    K: IntegerId,
    V1: PartialEq<V2>,
    T1: EntryTable<K, V1>,
    T2: EntryTable<K, V2>, 

Checks if two have the same contents, ignoring the order.

fn eq(&self, other: &IdMap<K, V2, T2>) -> bool

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<K, V, T> Serialize for IdMap<K, V, T> where
    K: IntegerId,
    K: Serialize,
    V: Serialize,
    T: EntryTable<K, V>, 

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.