Struct SlotCacheInner

pub struct SlotCacheInner { /* private fields */ }

Implementations

impl SlotCacheInner

pub fn report_slot_store_metrics(&self)

pub fn get_all_pubkeys(&self) -> Vec<Pubkey>

pub fn insert( &self, pubkey: &Pubkey, account: AccountSharedData, ) -> CachedAccount

pub fn get_cloned(&self, pubkey: &Pubkey) -> Option<CachedAccount>

pub fn mark_slot_frozen(&self)

pub fn is_frozen(&self) -> bool

pub fn total_bytes(&self) -> u64

Methods from Deref<Target = DashMap<Pubkey, CachedAccount>>

pub fn par_iter_mut(&self) -> IterMut<'_, K, V, S>

pub fn hash_usize<T>(&self, item: &T) -> usize

where T: Hash,

Hash a given item to produce a usize. Uses the provided or default HashBuilder.

pub fn shards(&self) -> &[RwLock<RawRwLock, HashMap<K, SharedValue<V>, S>>]

Allows you to peek at the inner shards that store your data. You should probably not use this unless you know what you are doing.

Requires the raw-api feature to be enabled.

Examples

use dashmap::DashMap;

let map = DashMap::<(), ()>::new();
println!("Amount of shards: {}", map.shards().len());

pub fn determine_map<Q>(&self, key: &Q) -> usize

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Finds which shard a certain key is stored in. You should probably not use this unless you know what you are doing. Note that shard selection is dependent on the default or provided HashBuilder.

Requires the raw-api feature to be enabled.

Examples

use dashmap::DashMap;

let map = DashMap::new();
map.insert("coca-cola", 1.4);
println!("coca-cola is stored in shard: {}", map.determine_map("coca-cola"));

pub fn determine_shard(&self, hash: usize) -> usize

Finds which shard a certain hash is stored in.

Requires the raw-api feature to be enabled.

Examples

use dashmap::DashMap;

let map: DashMap<i32, i32> = DashMap::new();
let key = "key";
let hash = map.hash_usize(&key);
println!("hash is stored in shard: {}", map.determine_shard(hash));

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>

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)>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

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)>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

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,

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>

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, S>>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

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, S>>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

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, S>>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

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, S>>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

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)

Remove excess capacity to reduce memory usage.

Locking behaviour: May deadlock if called when holding any sort of reference into the map.

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

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

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)

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

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)

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

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)

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>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

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

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

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, S>

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, S>>

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.

Trait Implementations

impl Debug for SlotCacheInner

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

Formats the value using the given formatter.

impl Drop for SlotCacheInner

fn drop(&mut self)

Executes the destructor for this type.

impl Deref for SlotCacheInner

type Target = DashMap<Pubkey, Arc<CachedAccountInner>>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.