Struct ccl::dhashmap::DHashMap

pub struct DHashMap<K, V> where
    K: Hash + Eq,  { /* fields omitted */ }

DHashMap is a threadsafe, versatile and concurrent hashmap with good performance and is balanced for both reads and writes.

The API mostly matches that of the standard library hashmap but there are some differences to due to the design.

One of those limits is iteration, you cannot iterate over the elements directly. Instead you have to iterate over chunks which can iterate over KV pairs. This is needed in order to use the calling thread stack as scratch space to avoid heap allocations.

Unsafe is used to avoid bounds checking when accessing chunks. This is guaranteed to be safe since we cannot possibly get a value higher than the amount of chunks. The amount of chunks cannot be altered after creation in any way.

This map is not lockfree but uses some clever locking internally. It has good average case performance but you should not rely on being able to hold any combination of references involving a mutable one as it may cause a deadlock.

Methods

impl<'a, K: 'a, V: 'a> DHashMap<K, V> where
    K: Hash + Eq, 

pub fn new(submaps_exp_of_two_pow: usize) -> Self

Create a new DHashMap. The amount of chunks used is based on the formula 2^n where n is the value passed. The default method will automagically determine the optimal amount.

Will panic if the first parameter plugged into the formula 2^n produces a result higher than isize::MAX.

pub fn with_capacity(submaps_exp_of_two_pow: usize, capacity: usize) -> Self

Create a new DHashMap with a specified capacity.

Will panic if the first parameter plugged into the formula 2^n produces a result higher than isize::MAX.

pub fn insert(&self, key: K, value: V)

Insert an element into the map.

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

Check if the map contains the specified key.

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

Get a shared reference to an element contained within the map.

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

Shortcut for a get followed by an unwrap.

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

Get a unique reference to an element contained within the map.

pub fn index_mut(&'a self, key: &'a K) -> DHashMapRefMut<'a, K, V>

Shortcut for a get_mut followed by an unwrap.

pub fn len(&self) -> usize

Get the amount of elements stored within the map.

pub fn is_empty(&self) -> bool

Check if the map is empty.

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

Remove an element from the map if it exists. Will return the K, V pair.

pub fn retain<F: Clone + FnMut(&K, &mut V) -> bool>(&self, f: F)

Retain all elements that the specified function returns true for.

pub fn clear(&self)

Clear all elements from the map.

pub fn alter<F: FnMut((&K, &mut V)) + Clone>(&self, f: F)

Apply a function to every item in the map.

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

Iterate over chunks in a read only fashion.

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

Iterate over chunks in a read-write fashion.

Trait Implementations

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

fn default() -> Self

Creates a new DHashMap and automagically determines the optimal amount of chunks.