Struct DictMap 

pub struct DictMap<K: Eq + Hash, V> { /* private fields */ }

Generic typed map keyed by K with an ahash hasher.

The wrapper exposes the small set of operations used by the rest of the engine and intentionally hides the underlying hasher and table layout. Use DictMap::iter for read-only traversal and DictMap::drain when you need to consume the entire map.

Examples

use dynomite::util::dict::DictMap;

let mut m: DictMap<&'static str, u32> = DictMap::new();
m.insert("k", 7);
assert_eq!(m.get(&"k"), Some(&7));
assert_eq!(m.len(), 1);
assert!(m.remove(&"k").is_some());
assert!(m.is_empty());

Implementations

impl<K: Eq + Hash, V> DictMap<K, V>

pub fn new() -> Self

Construct an empty map.

Examples

use dynomite::util::dict::DictMap;
let m: DictMap<u32, u32> = DictMap::new();
assert!(m.is_empty());

pub fn with_capacity(capacity: usize) -> Self

Construct an empty map with at least capacity slots.

Examples

use dynomite::util::dict::DictMap;
let m: DictMap<u32, u32> = DictMap::with_capacity(8);
assert!(m.is_empty());

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

Insert value at key, returning the previous value (if any).

Examples

use dynomite::util::dict::DictMap;
let mut m: DictMap<u32, u32> = DictMap::new();
assert_eq!(m.insert(1, 10), None);
assert_eq!(m.insert(1, 20), Some(10));

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

Remove and return the value at key.

Examples

use dynomite::util::dict::DictMap;
let mut m: DictMap<u32, u32> = DictMap::new();
m.insert(1, 10);
assert_eq!(m.remove(&1), Some(10));
assert_eq!(m.remove(&1), None);

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

Look up an immutable reference to the value at key.

Examples

use dynomite::util::dict::DictMap;
let mut m: DictMap<u32, u32> = DictMap::new();
m.insert(1, 10);
assert_eq!(m.get(&1), Some(&10));

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

Look up a mutable reference to the value at key.

Examples

use dynomite::util::dict::DictMap;
let mut m: DictMap<u32, u32> = DictMap::new();
m.insert(1, 10);
*m.get_mut(&1).unwrap() = 20;
assert_eq!(m.get(&1), Some(&20));

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

Whether key is in the map.

Examples

use dynomite::util::dict::DictMap;
let mut m: DictMap<u32, u32> = DictMap::new();
m.insert(1, 10);
assert!(m.contains_key(&1));
assert!(!m.contains_key(&2));

pub fn len(&self) -> usize

Number of entries.

Examples

use dynomite::util::dict::DictMap;
let mut m: DictMap<u32, u32> = DictMap::new();
m.insert(1, 10);
assert_eq!(m.len(), 1);

pub fn is_empty(&self) -> bool

Whether the map is empty.

Examples

use dynomite::util::dict::DictMap;
let m: DictMap<u32, u32> = DictMap::new();
assert!(m.is_empty());

pub fn clear(&mut self)

Drop every entry.

Examples

use dynomite::util::dict::DictMap;
let mut m: DictMap<u32, u32> = DictMap::new();
m.insert(1, 10);
m.clear();
assert!(m.is_empty());

pub fn iter(&self) -> impl Iterator<Item = (&K, &V)>

Borrowed iterator over (key, value) pairs.

Examples

use dynomite::util::dict::DictMap;
let mut m: DictMap<u32, u32> = DictMap::new();
m.insert(1, 10);
m.insert(2, 20);
let mut sum = 0u32;
for (_k, v) in m.iter() { sum += v; }
assert_eq!(sum, 30);

pub fn iter_mut(&mut self) -> impl Iterator<Item = (&K, &mut V)>

Mutable iterator over (key, value) pairs.

Examples

use dynomite::util::dict::DictMap;
let mut m: DictMap<u32, u32> = DictMap::new();
m.insert(1, 10);
for (_k, v) in m.iter_mut() { *v += 1; }
assert_eq!(m.get(&1), Some(&11));

pub fn drain(&mut self) -> impl Iterator<Item = (K, V)> + '_

Consume the map and yield (key, value) pairs.

Examples

use dynomite::util::dict::DictMap;
let mut m: DictMap<u32, u32> = DictMap::new();
m.insert(1, 10);
let drained: Vec<_> = m.drain().collect();
assert_eq!(drained, vec![(1, 10)]);
assert!(m.is_empty());

Trait Implementations

impl<K: Clone + Eq + Hash, V: Clone> Clone for DictMap<K, V>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Debug + Eq + Hash, V: Debug> Debug for DictMap<K, V>

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

Formats the value using the given formatter.

impl<K: Default + Eq + Hash, V: Default> Default for DictMap<K, V>

fn default() -> DictMap<K, V>

Returns the “default value” for a type.

impl<K: Eq + Hash, V> IntoIterator for DictMap<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::IntoIter

Creates an iterator from a value.