Struct RcuRawHashMap 

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

A hash map that uses read-copy-update (RCU) to manage concurrent accesses.

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> RcuRawHashMap<K, V, RapidBuildHasher>

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

pub fn with_capacity(capacity: usize) -> Self

Creates a new hash map with the given capacity.

impl<K, V, S> RcuRawHashMap<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(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.

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 corresponding to the key.

Another thread running concurrently might see a different value for the object.

pub fn len(&self) -> usize

Returns the number of entries in the map.

The length can change concurrently with this call.

pub unsafe fn insert( &self, scope: &RcuReadScope, key: K, value: V, ) -> InsertionResult<V>

Inserts a key-value pair into the map.

If the map did not have this key present, None is returned.

If the map did have this key present, the value is updated, and the old value is returned.

Concurrent readers might not see the inserted value until the RCU state machine has made sufficient progress to ensure that no concurrent readers are holding read guards.

Safety

Requires external synchronization to exclude concurrent writers.

pub unsafe 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 at the key if the key was previously in the map.

Concurrent readers might see the removed value until the RCU state machine has made sufficient progress to ensure that no concurrent readers are holding read guards.

Safety

Requires external synchronization to exclude concurrent writers.

pub fn is_empty(&self) -> bool

Returns true if the map contains no entries.

pub unsafe fn clear(&self)

Removes all entries from the map.

Concurrent readers holding an active RcuReadScope continue to observe a consistent snapshot of the previous bucket table until the RCU grace period completes and rcu_drop reclaims the retired bucket array and entry nodes.

Safety

Requires external synchronization to exclude concurrent writers.

pub fn cursor<'a>( &'a self, scope: &'a RcuReadScope, ) -> RcuRawHashMapCursor<'a, K, V, S>

Returns a cursor that can be used to traverse and modify the map.

The cursor iterates through the map in insertion order.

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

Returns an iterator over the key-value pairs in the map in insertion order.

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

Returns an iterator over the keys in the map.

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

Returns an iterator over the values in the map.

Trait Implementations

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

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

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

Formats the value using the given formatter.

impl<K, V> Default for RcuRawHashMap<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> RcuDroppable for RcuRawHashMap<K, V, S>

where K: Eq + Hash + Clone + RcuDroppable + Sync, V: Clone + RcuDroppable + Sync, S: BuildHasher + Send + Sync + 'static + RcuDroppable, RcuArray<RcuList<Entry<K, V>, CollisionAdapter>>: RcuDroppable, AtomicUsize: RcuDroppable, RcuIntrusiveList<Entry<K, V>, InsertionAdapter>: RcuDroppable,