Struct dashmap::DashMap [−][src]
pub struct DashMap<K, V, S = RandomState> { /* fields omitted */ }
Expand description
DashMap is an implementation of a concurrent associative array/hashmap in Rust.
DashMap tries to implement an easy to use API similar to std::collections::HashMap
with some slight changes to handle concurrency.
DashMap tries to be very simple to use and to be a direct replacement for RwLock<HashMap<K, V, S>>
.
To accomplish these all methods take &self
instead modifying methods taking &mut self
.
This allows you to put a DashMap in an Arc<T>
and share it between threads while being able to modify it.
Documentation mentioning locking behaviour acts in the reference frame of the calling thread. This means that it is safe to ignore it across multiple threads.
Implementations
Creates a new DashMap with a capacity of 0.
Examples
use dashmap::DashMap;
let reviews = DashMap::new();
reviews.insert("Veloren", "What a fantastic game!");
Creates a new DashMap with a specified starting capacity.
Examples
use dashmap::DashMap;
let mappings = DashMap::with_capacity(2);
mappings.insert(2, 4);
mappings.insert(8, 16);
Wraps this DashMap
into a read-only view. This view allows to obtain raw references to the stored values.
Creates a new DashMap with a capacity of 0 and the provided hasher.
Examples
use dashmap::DashMap;
use std::collections::hash_map::RandomState;
let s = RandomState::new();
let reviews = DashMap::with_hasher(s);
reviews.insert("Veloren", "What a fantastic game!");
Creates a new DashMap with a specified starting capacity and hasher.
Examples
use dashmap::DashMap;
use std::collections::hash_map::RandomState;
let s = RandomState::new();
let mappings = DashMap::with_capacity_and_hasher(2, s);
mappings.insert(2, 4);
mappings.insert(8, 16);
Hash a given item to produce a usize. Uses the provided or default HashBuilder.
Returns a reference to the map’s BuildHasher
.
Examples
use dashmap::DashMap;
use std::collections::hash_map::RandomState;
let hasher = RandomState::new();
let map: DashMap<i32, i32> = DashMap::new();
let hasher: &RandomState = map.hasher();
Inserts a key and a value into the map. Returns the old value associated with the key if there was one.
Locking behaviour: May deadlock if called when holding any sort of reference into the map.
Examples
use dashmap::DashMap;
let map = DashMap::new();
map.insert("I am the key!", "And I am the value!");
Removes an entry from the map, returning the key and value if they existed in the map.
Locking behaviour: May deadlock if called when holding any sort of reference into the map.
Examples
use dashmap::DashMap;
let soccer_team = DashMap::new();
soccer_team.insert("Jack", "Goalie");
assert_eq!(soccer_team.remove("Jack").unwrap().1, "Goalie");
Removes an entry from the map, returning the key and value if the entry existed and the provided conditional function returned true.
Locking behaviour: May deadlock if called when holding any sort of reference into the map.
use dashmap::DashMap;
let soccer_team = DashMap::new();
soccer_team.insert("Sam", "Forward");
soccer_team.remove_if("Sam", |_, position| position == &"Goalie");
assert!(soccer_team.contains_key("Sam"));
use dashmap::DashMap;
let soccer_team = DashMap::new();
soccer_team.insert("Sam", "Forward");
soccer_team.remove_if("Sam", |_, position| position == &"Forward");
assert!(!soccer_team.contains_key("Sam"));
pub fn remove_if_mut<Q>(
&self,
key: &Q,
f: impl FnOnce(&K, &mut V) -> bool
) -> Option<(K, V)> where
K: Borrow<Q>,
Q: Hash + Eq + ?Sized,
Creates an iterator over a DashMap yielding immutable references.
Locking behaviour: May deadlock if called when holding a mutable reference into the map.
Examples
use dashmap::DashMap;
let words = DashMap::new();
words.insert("hello", "world");
assert_eq!(words.iter().count(), 1);
Iterator over a DashMap yielding mutable references.
Locking behaviour: May deadlock if called when holding any sort of reference into the map.
Examples
use dashmap::DashMap;
let map = DashMap::new();
map.insert("Johnny", 21);
map.iter_mut().for_each(|mut r| *r += 1);
assert_eq!(*map.get("Johnny").unwrap(), 22);
Get a immutable reference to an entry in the map
Locking behaviour: May deadlock if called when holding a mutable reference into the map.
Examples
use dashmap::DashMap;
let youtubers = DashMap::new();
youtubers.insert("Bosnian Bill", 457000);
assert_eq!(*youtubers.get("Bosnian Bill").unwrap(), 457000);
Get a mutable reference to an entry in the map
Locking behaviour: May deadlock if called when holding any sort of reference into the map.
Examples
use dashmap::DashMap;
let class = DashMap::new();
class.insert("Albin", 15);
*class.get_mut("Albin").unwrap() -= 1;
assert_eq!(*class.get("Albin").unwrap(), 14);
Remove excess capacity to reduce memory usage.
Locking behaviour: May deadlock if called when holding any sort of reference into the map.
Retain elements that whose predicates return true and discard elements whose predicates return false.
Locking behaviour: May deadlock if called when holding any sort of reference into the map.
Examples
use dashmap::DashMap;
let people = DashMap::new();
people.insert("Albin", 15);
people.insert("Jones", 22);
people.insert("Charlie", 27);
people.retain(|_, v| *v > 20);
assert_eq!(people.len(), 2);
Fetches the total number of key-value pairs stored in the map.
Locking behaviour: May deadlock if called when holding a mutable reference into the map.
Examples
use dashmap::DashMap;
let people = DashMap::new();
people.insert("Albin", 15);
people.insert("Jones", 22);
people.insert("Charlie", 27);
assert_eq!(people.len(), 3);
Checks if the map is empty or not.
Locking behaviour: May deadlock if called when holding a mutable reference into the map.
Examples
use dashmap::DashMap;
let map = DashMap::<(), ()>::new();
assert!(map.is_empty());
Removes all key-value pairs in the map.
Locking behaviour: May deadlock if called when holding any sort of reference into the map.
Examples
use dashmap::DashMap;
let stats = DashMap::new();
stats.insert("Goals", 4);
assert!(!stats.is_empty());
stats.clear();
assert!(stats.is_empty());
Returns how many key-value pairs the map can store without reallocating.
Locking behaviour: May deadlock if called when holding a mutable reference into the map.
Modify a specific value according to a function.
Locking behaviour: May deadlock if called when holding any sort of reference into the map.
Examples
use dashmap::DashMap;
let stats = DashMap::new();
stats.insert("Goals", 4);
stats.alter("Goals", |_, v| v * 2);
assert_eq!(*stats.get("Goals").unwrap(), 8);
Panics
If the given closure panics, then alter
will abort the process
Modify every value in the map according to a function.
Locking behaviour: May deadlock if called when holding any sort of reference into the map.
Examples
use dashmap::DashMap;
let stats = DashMap::new();
stats.insert("Wins", 4);
stats.insert("Losses", 2);
stats.alter_all(|_, v| v + 1);
assert_eq!(*stats.get("Wins").unwrap(), 5);
assert_eq!(*stats.get("Losses").unwrap(), 3);
Panics
If the given closure panics, then alter_all
will abort the process
Scoped access into an item of the map according to a function.
Locking behaviour: May deadlock if called when holding any sort of reference into the map.
Examples
use dashmap::DashMap;
let warehouse = DashMap::new();
warehouse.insert(4267, ("Banana", 100));
warehouse.insert(2359, ("Pear", 120));
let fruit = warehouse.view(&4267, |_k, v| *v);
assert_eq!(fruit, Some(("Banana", 100)));
Panics
If the given closure panics, then view
will abort the process
Checks if the map contains a specific key.
Locking behaviour: May deadlock if called when holding a mutable reference into the map.
Examples
use dashmap::DashMap;
let team_sizes = DashMap::new();
team_sizes.insert("Dakota Cherries", 23);
assert!(team_sizes.contains_key("Dakota Cherries"));
Trait Implementations
Extends a collection with the contents of an iterator. Read more
extend_one
)Extends a collection with exactly one element.
extend_one
)Reserves capacity in a collection for the given number of additional elements. Read more
impl<K: Eq + Hash, V, S: BuildHasher + Clone + Default> FromIterator<(K, V)> for DashMap<K, V, S>
impl<K: Eq + Hash, V, S: BuildHasher + Clone + Default> FromIterator<(K, V)> for DashMap<K, V, S>
Safety Read more
unsafe fn _yield_read_shard(
&'a self,
i: usize
) -> RwLockReadGuard<'a, HashMap<K, SharedValue<V>, S>>
unsafe fn _yield_read_shard(
&'a self,
i: usize
) -> RwLockReadGuard<'a, HashMap<K, SharedValue<V>, S>>
Safety Read more
unsafe fn _yield_write_shard(
&'a self,
i: usize
) -> RwLockWriteGuard<'a, HashMap<K, SharedValue<V>, S>>
unsafe fn _yield_write_shard(
&'a self,
i: usize
) -> RwLockWriteGuard<'a, HashMap<K, SharedValue<V>, S>>
Safety Read more
fn _remove_if<Q>(
&self,
key: &Q,
f: impl FnOnce(&K, &V) -> bool
) -> Option<(K, V)> where
K: Borrow<Q>,
Q: Hash + Eq + ?Sized,
fn _remove_if_mut<Q>(
&self,
key: &Q,
f: impl FnOnce(&K, &mut V) -> bool
) -> Option<(K, V)> where
K: Borrow<Q>,
Q: Hash + Eq + ?Sized,
fn _iter_mut(&'a self) -> IterMut<'a, K, V, S, DashMap<K, V, S>>ⓘNotable traits for IterMut<'a, K, V, S, M>impl<'a, K: Eq + Hash, V, S: 'a + BuildHasher + Clone, M: Map<'a, K, V, S>> Iterator for IterMut<'a, K, V, S, M> type Item = RefMutMulti<'a, K, V, S>;
impl<'a, K: Eq + Hash, V, S: 'a + BuildHasher + Clone, M: Map<'a, K, V, S>> Iterator for IterMut<'a, K, V, S, M> type Item = RefMutMulti<'a, K, V, S>;
fn _get<Q>(&'a self, key: &Q) -> Option<Ref<'a, K, V, S>> where
K: Borrow<Q>,
Q: Hash + Eq + ?Sized,
fn _get_mut<Q>(&'a self, key: &Q) -> Option<RefMut<'a, K, V, S>> where
K: Borrow<Q>,
Q: Hash + Eq + ?Sized,
Auto Trait Implementations
impl<K, V, S = RandomState> !RefUnwindSafe for DashMap<K, V, S>
impl<K, V, S> UnwindSafe for DashMap<K, V, S> where
K: UnwindSafe,
S: UnwindSafe,
V: UnwindSafe,
Blanket Implementations
Mutably borrows from an owned value. Read more