Struct RcuHashMap 

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

A concurrent hash map that uses RCU for read synchronization and a mutex with a statically typed LockDep level for write synchronization.

By default, this map uses rapidhash::RapidBuildHasher, which provides high performance. However, if this map holds keys which may be attacker-controlled, consider using std::collections::hash_map::RandomState instead.

Implementations

impl<K, V, L> RcuHashMap<K, V, L, RapidBuildHasher>

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

pub fn new() -> Self

Creates a new hash map.

impl<K, V, S> RcuHashMap<K, V, RcuHashMapLock, S>

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

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

Creates a new hash map with the given capacity and hasher.

pub fn with_hasher(hash_builder: S) -> Self

Creates a new hash map with the given hasher.

Methods from Deref<Target = DynamicRcuHashMap<K, V, S>>

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, L, S> Debug for RcuHashMap<K, V, L, S>

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

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

Formats the value using the given formatter.

impl<K, V> Default for RcuHashMap<K, V, RcuHashMapLock, 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, L, S> Deref for RcuHashMap<K, V, L, S>

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

type Target = DynamicRcuHashMap<K, V, S>

The resulting type after dereferencing.

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

Dereferences the value.

impl<K, V, L, S> MutexLike for RcuHashMap<K, V, L, S>

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

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

type Context = <DynamicRcuHashMap<K, V, S> 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, L, S> RcuDroppable for RcuHashMap<K, V, L, S>

where K: Eq + Hash + Clone + RcuDroppable + Sync, V: Clone + RcuDroppable + Sync, L: LockLevel + RcuDroppable, S: BuildHasher + Send + Sync + 'static + RcuDroppable, DynamicRcuHashMap<K, V, S>: RcuDroppable, PhantomData<L>: RcuDroppable,

impl<K, V, L, S> ResetDependencies for RcuHashMap<K, V, L, S>

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

unsafe fn reset_dependencies(&self)

Resets the lock dependency graph for this lock.