Struct DynamicRcuHashMap 

pub struct DynamicRcuHashMap<K, V, S = RapidBuildHasher>
where
    K: Eq + Hash + Clone + RcuDroppable + Sync,
    V: Clone + RcuDroppable + Sync,
    S: BuildHasher + Send + Sync + 'static,
{ /* private fields */ }

A concurrent hash map that uses RCU for read synchronization and a mutex with a dynamically specified lock level for write synchronization.

Implementations

impl<K, V> DynamicRcuHashMap<K, V, RapidBuildHasher>

where K: Eq + Hash + Clone + RcuDroppable + Sync, V: Clone + RcuDroppable + Sync,

pub fn new<L: LockLevel>() -> Self

Creates a new hash map with the given LockDep lock level.

impl<K, V, S> DynamicRcuHashMap<K, V, S>

where K: Eq + Hash + Clone + RcuDroppable + Sync, V: Clone + RcuDroppable + Sync, S: BuildHasher + Send + Sync + 'static,

pub fn with_capacity_and_hasher<L: LockLevel>( capacity: usize, hash_builder: S, ) -> Self

Creates a new hash map with the given capacity, hasher, and LockDep lock level.

pub fn with_hasher<L: LockLevel>(hash_builder: S) -> Self

Creates a new hash map with the given hasher and LockDep lock level.

pub fn get<'a, Q>(&self, scope: &'a RcuReadScope, key: &Q) -> Option<&'a V>

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

Returns a reference to the value associated with the given key, if it exists.

The returned reference is bound to the lifetime of the RcuReadScope.

pub fn lock(&self) -> RcuHashMapGuard<'_, K, V, S>

Locks the map for exclusive access, returning a guard that allows mutation.

pub fn insert(&self, key: K, value: V) -> Option<V>

Inserts a key-value pair into the map, returning the old value if the key was already present.

pub fn remove<Q>(&self, key: &Q) -> Option<V>

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

Removes a key from the map, returning the value if the key was present.

pub fn iter<'a>( &'a self, scope: &'a RcuReadScope, ) -> impl Iterator<Item = (&'a K, &'a V)>

Returns an iterator over the map’s entries.

pub fn keys<'a>( &'a self, scope: &'a RcuReadScope, ) -> impl Iterator<Item = &'a K>

Returns an iterator over the map’s keys.

pub fn values<'a>( &'a self, scope: &'a RcuReadScope, ) -> impl Iterator<Item = &'a V>

Returns an iterator over the map’s values.

pub fn len(&self) -> usize

Returns the number of entries in the map.

pub fn is_empty(&self) -> bool

Returns true if the map contains no entries.

pub fn clear(&self)

Removes all entries from the map while preserving active RCU reader snapshots.

Trait Implementations

impl<K, V, S> Debug for DynamicRcuHashMap<K, V, S>

where K: Eq + Hash + Debug + Clone + RcuDroppable + Sync, V: Debug + Clone + RcuDroppable + Sync, S: BuildHasher + Send + Sync + 'static,

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

Formats the value using the given formatter.

impl<K, V> Default for DynamicRcuHashMap<K, V, RapidBuildHasher>

where K: Eq + Hash + Clone + RcuDroppable + Sync, V: Clone + RcuDroppable + Sync,

fn default() -> Self

Returns the “default value” for a type.

impl<K, V, S> MutexLike for DynamicRcuHashMap<K, V, S>

where K: Eq + Hash + Clone + RcuDroppable + Sync, V: Clone + RcuDroppable + Sync, S: BuildHasher + Send + Sync + 'static,

type Guard<'a> = RcuHashMapGuard<'a, K, V, S> where Self: 'a

type Context = <DynamicLockDepMutex<()> as MutexLike>::Context

fn context() -> Self::Context

fn lock(&self, context: &mut Self::Context) -> Self::Guard<'_>

Lock the mutex. level is the index of the locked mutex in the lock ordering.

fn key(&self) -> *const ()

where Self: Sized,

impl<K, V, S> RcuDroppable for DynamicRcuHashMap<K, V, S>

where K: Eq + Hash + Clone + RcuDroppable + Sync, V: Clone + RcuDroppable + Sync, S: BuildHasher + Send + Sync + 'static + RcuDroppable, RcuRawHashMap<K, V, S>: RcuDroppable, DynamicLockDepMutex<()>: RcuDroppable,

impl<K, V, S> ResetDependencies for DynamicRcuHashMap<K, V, S>

where K: Eq + Hash + Clone + RcuDroppable + Sync, V: Clone + RcuDroppable + Sync, S: BuildHasher + Send + Sync + 'static,

unsafe fn reset_dependencies(&self)

Resets the lock dependency graph for this lock.