Struct deduped_dashmap::DedupedMap

pub struct DedupedMap<K, M, V> where
    K: Eq + Hash,
    M: Debug,
    V: Debug,  {
    pub(crate) pointers: DashMap<K, MapPointer<M>>,
    pub(crate) storage: DashMap<u64, MapValue<V>>,
}

A hashmap that assumes a large number of keys will map to a relatively smaller number of values.

If a value is stored in the map that is already stored by another key, the refcount of the value will be incremented instead of duplicating it.

Uses DashMap internally

Fields

pointers: DashMap<K, MapPointer<M>>

First layer of the map. A mapping from incoming requests to a u64 pointer into the cache storage.

storage: DashMap<u64, MapValue<V>>

Second layer of the map. The items stored in the cache, keyed by their hash.

Implementations

impl<K, M, V> DedupedMap<K, M, V> where
    K: Eq + Hash + Debug,
    M: Debug + Clone,
    V: Hash + Debug + Clone, 

pub fn new() -> Self

Create an empty map.

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

Insert value into the map at key with metadata meta.

If value is already in the map under a different key, its refcount will be incremented instead of storing another copy of value. The metadata data meta will be attached to this specific key, and not refcounted.

pub fn remove(&self, key: K)

Remove the item associated with a key from the map.

The metadata associated with key will always be removed. The reference count of the storage item it points to will be decremented. If no more keys refer to the storage item, it will also be removed.

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

Get cloned copies of the metadata and value associated with key.

pub fn len_storage(&self) -> usize

Fetches the total number of storage items in the map.

This will be at most self.len_pointers().

pub fn len_pointers(&self) -> usize

Fetches the total number of pointers stored in the map.

This will be at least self.len_storage().

pub fn retain<F>(&self, pred: F) where
    F: FnMut(&K, &M, &V) -> ControlFlow<bool>, 

Retain elements based on the result of a predicate.

If the predicate function returns:

• ControlFlow::Continue(true): The item will be retained and the iteration will continue.
• ControlFlow::Continue(false): The item will be removed and the iteration will continue.
• ControlFlow::Break(()): This item, and all further items in the map, will be retained, and the predicate won’t be called again.

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

Checks if the map contains a specific key.

pub fn clear(&self)

Clears the map, both the pointer and the storage maps.

It behaves as Self::retain(|_, _, _| ControlFlow::Continue(false)) except being faster as the predicate checking step is skipped.

Note that the two underlying maps are cleared sequentially without locking, calling this function while other map mutations are done concurrently could result in dangling pointers. As a mitigation, it clears the pointer map first, followed by the storage map to reduce the chance of dangling pointers.

Trait Implementations

impl<K: Debug, M: Debug, V: Debug> Debug for DedupedMap<K, M, V> where
    K: Eq + Hash,
    M: Debug,
    V: Debug, 

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

Formats the value using the given formatter.

impl<K, M, V> Default for DedupedMap<K, M, V> where
    K: Eq + Hash,
    M: Debug,
    V: Debug, 

fn default() -> Self

Returns the “default value” for a type.

impl<K, M, V> FromIterator<(K, M, V)> for DedupedMap<K, M, V> where
    K: Debug + Eq + Hash,
    M: Clone + Debug,
    V: Clone + Debug + Eq + Hash, 

fn from_iter<T: IntoIterator<Item = (K, M, V)>>(iter: T) -> Self

Creates a value from an iterator.

impl<K, V> FromIterator<(K, V)> for DedupedMap<K, (), V> where
    K: Debug + Eq + Hash,
    V: Clone + Debug + Eq + Hash, 

fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> Self

Creates a value from an iterator.