DashMap

DashMap is a high-performance concurrent associative array (hashmap) implementation for Rust. It is designed to be a direct, easy-to-use replacement for RwLock<HashMap<K, V>>.

Key characteristics:

• Concurrency Model: Unlike std::collections::HashMap, DashMap methods take &self instead of &mut self. This allows you to wrap a DashMap in an Arc<T> and share it across multiple threads while still performing mutations.
• API Design: The API is modeled to be similar to std::collections::HashMap with minor adjustments to accommodate concurrency.
• MSRV: The Minimum Supported Rust Version is 1.70. Note that DashMap typically stays at least one year behind the current stable Rust release.

You can enable additional functionality in dashmap by toggling the following Cargo features in your Cargo.toml:

• serde: Enables serde support for serialization and deserialization.
• raw-api: Enables the unstable raw-shard API.
• rayon: Enables rayon support for parallel processing.
• inline-more: Enables the inline-more feature from the hashbrown crate (may result in larger binaries due to excessive inlining).
• arbitrary: Enables support for the arbitrary crate.

Use the following methods to manage elements in a DashSet:

• insert(key): Inserts a key into the set. Returns true if the key was not already present.
• remove(key): Removes an entry from the set. Returns Option<K> containing the key if it existed.
• remove_if(key, f): Removes an entry if the key exists and the provided predicate function f returns true. Returns Option<K>.
• clear(): Removes all keys from the set.

use dashmap::DashSet;

let mut soccer_team = DashSet::new();
soccer_team.insert("Jack");

// Remove by key
assert_eq!(soccer_team.remove("Jack").unwrap(), "Jack");

// Conditional removal
soccer_team.insert("Sam");
soccer_team.remove_if("Sam", |player| player.starts_with("Ja"));

The DashMap type implements serde::Serialize and serde::Deserialize. This allows you to convert a DashMap to and from supported formats like JSON, Bincode, or YAML.

When deserializing, DashMap is reconstructed using its default hasher. When serializing, it is treated as a standard map structure.

Use .insert(key, value) to add entries to the map. To retrieve a value, use .get(key), which returns a reference to the value. For mutable access, use .get_mut(key). Note that these methods will lock the shard containing the key.

dm.insert(0, 0);
assert_eq!(dm.get(&0).unwrap().value(), &0);

Use these methods to manage the overall state of the map:

• len(): Returns the total number of key-value pairs.
• is_empty(): Returns true if the map contains no elements.
• clear(): Removes all key-value pairs.
• capacity(): Returns the total number of key-value pairs the map can store without reallocating.
• shrink_to_fit(): Removes excess capacity to reduce memory usage.
• retain(f): Keeps only the elements that satisfy the predicate f.

DashMap provides several ways to access and modify values:

• get(key): Returns an immutable reference (Ref) to the value.
• get_mut(key): Returns a mutable reference (RefMut) to the value.
• try_get(key): Returns a TryResult<Ref>. If the shard is currently locked, it returns TryResult::Locked instead of blocking.
• try_get_mut(key): Returns a TryResult<RefMut>. If the shard is currently locked, it returns TryResult::Locked instead of blocking.
• alter(key, f): Modifies a specific value in place using the function f.
• alter_all(f): Modifies every value in the map using the function f.
• view(key, f): Performs a scoped operation on a value using function f and returns the result of f.

Warning: These methods may deadlock if called while holding a reference into the map.