Type Alias freya_native_core::FxDashMap
source · pub type FxDashMap<K, V> = DashMap<K, V, BuildHasherDefault<FxHasher>>;
Expand description
A map that can be sent between threads
Aliased Type§
struct FxDashMap<K, V> { /* private fields */ }
Implementations
§impl<'a, K, V, S> DashMap<K, V, S>
impl<'a, K, V, S> DashMap<K, V, S>
pub fn into_read_only(self) -> ReadOnlyView<K, V, S>
pub fn into_read_only(self) -> ReadOnlyView<K, V, S>
Wraps this DashMap
into a read-only view. This view allows to obtain raw references to the stored values.
pub fn with_hasher(hasher: S) -> DashMap<K, V, S>
pub fn with_hasher(hasher: S) -> DashMap<K, V, S>
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!");
pub fn with_capacity_and_hasher(capacity: usize, hasher: S) -> DashMap<K, V, S>
pub fn with_capacity_and_hasher(capacity: usize, hasher: S) -> DashMap<K, V, S>
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);
pub fn with_hasher_and_shard_amount(
hasher: S,
shard_amount: usize,
) -> DashMap<K, V, S>
pub fn with_hasher_and_shard_amount( hasher: S, shard_amount: usize, ) -> DashMap<K, V, S>
Creates a new DashMap with a specified hasher and shard amount
shard_amount should be greater than 0 and a power of two. If a shard_amount which is not a power of two is provided, the function will panic.
§Examples
use dashmap::DashMap;
use std::collections::hash_map::RandomState;
let s = RandomState::new();
let mappings = DashMap::with_hasher_and_shard_amount(s, 32);
mappings.insert(2, 4);
mappings.insert(8, 16);
pub fn with_capacity_and_hasher_and_shard_amount(
capacity: usize,
hasher: S,
shard_amount: usize,
) -> DashMap<K, V, S>
pub fn with_capacity_and_hasher_and_shard_amount( capacity: usize, hasher: S, shard_amount: usize, ) -> DashMap<K, V, S>
Creates a new DashMap with a specified starting capacity, hasher and shard_amount.
shard_amount should greater than 0 and be a power of two. If a shard_amount which is not a power of two is provided, the function will panic.
§Examples
use dashmap::DashMap;
use std::collections::hash_map::RandomState;
let s = RandomState::new();
let mappings = DashMap::with_capacity_and_hasher_and_shard_amount(2, s, 32);
mappings.insert(2, 4);
mappings.insert(8, 16);
pub fn hash_usize<T>(&self, item: &T) -> usizewhere
T: Hash,
pub fn hash_usize<T>(&self, item: &T) -> usizewhere
T: Hash,
Hash a given item to produce a usize. Uses the provided or default HashBuilder.
pub fn hasher(&self) -> &S
pub fn hasher(&self) -> &S
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();
pub fn insert(&self, key: K, value: V) -> Option<V>
pub fn insert(&self, key: K, value: V) -> Option<V>
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!");
pub fn remove<Q>(&self, key: &Q) -> Option<(K, V)>
pub fn remove<Q>(&self, key: &Q) -> Option<(K, V)>
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");
pub fn remove_if<Q>(
&self,
key: &Q,
f: impl FnOnce(&K, &V) -> bool,
) -> Option<(K, V)>
pub fn remove_if<Q>( &self, key: &Q, f: impl FnOnce(&K, &V) -> bool, ) -> Option<(K, V)>
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)>
pub fn iter(&'a self) -> Iter<'a, K, V, S>
pub fn iter(&'a self) -> Iter<'a, K, V, S>
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);
pub fn iter_mut(&'a self) -> IterMut<'a, K, V, S>
pub fn iter_mut(&'a self) -> IterMut<'a, K, V, S>
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);
pub fn get<Q>(&'a self, key: &Q) -> Option<Ref<'a, K, V>>
pub fn get<Q>(&'a self, key: &Q) -> Option<Ref<'a, K, V>>
Get an 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);
pub fn get_mut<Q>(&'a self, key: &Q) -> Option<RefMut<'a, K, V>>
pub fn get_mut<Q>(&'a self, key: &Q) -> Option<RefMut<'a, K, V>>
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);
pub fn try_get<Q>(&'a self, key: &Q) -> TryResult<Ref<'a, K, V>>
pub fn try_get<Q>(&'a self, key: &Q) -> TryResult<Ref<'a, K, V>>
Get an immutable reference to an entry in the map, if the shard is not locked. If the shard is locked, the function will return [TryResult::Locked].
§Examples
use dashmap::DashMap;
use dashmap::try_result::TryResult;
let map = DashMap::new();
map.insert("Johnny", 21);
assert_eq!(*map.try_get("Johnny").unwrap(), 21);
let _result1_locking = map.get_mut("Johnny");
let result2 = map.try_get("Johnny");
assert!(result2.is_locked());
pub fn try_get_mut<Q>(&'a self, key: &Q) -> TryResult<RefMut<'a, K, V>>
pub fn try_get_mut<Q>(&'a self, key: &Q) -> TryResult<RefMut<'a, K, V>>
Get a mutable reference to an entry in the map, if the shard is not locked. If the shard is locked, the function will return [TryResult::Locked].
§Examples
use dashmap::DashMap;
use dashmap::try_result::TryResult;
let map = DashMap::new();
map.insert("Johnny", 21);
*map.try_get_mut("Johnny").unwrap() += 1;
assert_eq!(*map.get("Johnny").unwrap(), 22);
let _result1_locking = map.get("Johnny");
let result2 = map.try_get_mut("Johnny");
assert!(result2.is_locked());
pub fn shrink_to_fit(&self)
pub fn shrink_to_fit(&self)
Remove excess capacity to reduce memory usage.
Locking behaviour: May deadlock if called when holding any sort of reference into the map.
§Examples
use dashmap::DashMap;
use dashmap::try_result::TryResult;
let map = DashMap::new();
map.insert("Johnny", 21);
assert!(map.capacity() > 0);
map.remove("Johnny");
map.shrink_to_fit();
assert_eq!(map.capacity(), 0);
pub fn retain(&self, f: impl FnMut(&K, &mut V) -> bool)
pub fn retain(&self, f: impl FnMut(&K, &mut V) -> bool)
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);
pub fn len(&self) -> usize
pub fn len(&self) -> usize
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);
pub fn is_empty(&self) -> bool
pub fn is_empty(&self) -> bool
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());
pub fn clear(&self)
pub fn clear(&self)
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());
pub fn capacity(&self) -> usize
pub fn capacity(&self) -> usize
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.
pub fn alter<Q>(&self, key: &Q, f: impl FnOnce(&K, V) -> V)
pub fn alter<Q>(&self, key: &Q, f: impl FnOnce(&K, V) -> V)
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
pub fn alter_all(&self, f: impl FnMut(&K, V) -> V)
pub fn alter_all(&self, f: impl FnMut(&K, V) -> V)
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
pub fn view<Q, R>(&self, key: &Q, f: impl FnOnce(&K, &V) -> R) -> Option<R>
pub fn view<Q, R>(&self, key: &Q, f: impl FnOnce(&K, &V) -> R) -> Option<R>
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
pub fn contains_key<Q>(&self, key: &Q) -> bool
pub fn contains_key<Q>(&self, key: &Q) -> bool
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"));
pub fn entry(&'a self, key: K) -> Entry<'a, K, V>
pub fn entry(&'a self, key: K) -> Entry<'a, K, V>
Advanced entry API that tries to mimic std::collections::HashMap
.
See the documentation on dashmap::mapref::entry
for more details.
Locking behaviour: May deadlock if called when holding any sort of reference into the map.
pub fn try_entry(&'a self, key: K) -> Option<Entry<'a, K, V>>
pub fn try_entry(&'a self, key: K) -> Option<Entry<'a, K, V>>
Advanced entry API that tries to mimic std::collections::HashMap
.
See the documentation on dashmap::mapref::entry
for more details.
Returns None if the shard is currently locked.
pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>
pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>
Advanced entry API that tries to mimic std::collections::HashMap::try_reserve
.
Tries to reserve capacity for at least shard * additional
and may reserve more space to avoid frequent reallocations.
§Errors
If the capacity overflows, or the allocator reports a failure, then an error is returned.
Trait Implementations
§impl<K, V, S> Extend<(K, V)> for DashMap<K, V, S>
impl<K, V, S> Extend<(K, V)> for DashMap<K, V, S>
§fn extend<I>(&mut self, intoiter: I)where
I: IntoIterator<Item = (K, V)>,
fn extend<I>(&mut self, intoiter: I)where
I: IntoIterator<Item = (K, V)>,
source§fn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)source§fn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)