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 equivelant to an OrderedIdMap, though you can explicitly request a DirectIdMap instead.

From the user's presepctive, this is equivelant 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.

Methods

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

pub fn new_direct() -> Self

pub fn with_capacity_direct(capacity: usize) -> Self

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

pub fn len(&self) -> usize

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

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

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

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

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

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

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

Important traits for Iter<'a, K, V, I>

impl<'a, K, V, I> Iterator for Iter<'a, K, V, I> where
    K: IntegerId + 'a,
    V: 'a,
    I: 'a + EntryIterable<K, V>,  type Item = (&'a K, &'a V);

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

Important traits for IterMut<'a, K, V, I>

impl<'a, K, V, I> Iterator for IterMut<'a, K, V, I> where
    K: IntegerId + 'a,
    V: 'a,
    I: 'a + EntryIterable<K, V>,  type Item = (&'a K, &'a mut V);

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

Important traits for Keys<'a, K, V, I>

impl<'a, K, V, I> Iterator for Keys<'a, K, V, I> where
    K: IntegerId + 'a,
    V: 'a,
    I: 'a + EntryIterable<K, V>,  type Item = &'a K;

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

Important traits for Values<'a, K, V, I>

impl<'a, K, V, I> Iterator for Values<'a, K, V, I> where
    K: IntegerId + 'a,
    V: 'a,
    I: 'a + EntryIterable<K, V>,  type Item = &'a V;

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

Important traits for ValuesMut<'a, K, V, I>

impl<'a, K, V, I> Iterator for ValuesMut<'a, K, V, I> where
    K: IntegerId + 'a,
    V: 'a,
    I: 'a + EntryIterable<K, V>,  type Item = &'a mut V;

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

pub fn clear(&mut self)

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<'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<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.

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

fn default() -> Self

Returns the "default value" for a type.

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<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<'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<'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: 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>> 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: 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.

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, 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<'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.