Struct ConcurrentElasticMap 

pub struct ConcurrentElasticMap<K, V> { /* private fields */ }

A thread-safe hash table with adaptive probing strategy.

This implementation uses atomic operations to ensure thread safety without traditional locks, allowing for high concurrency with minimal contention. The adaptive probing strategy dynamically adjusts step sizes based on occupancy patterns.

Implementations

impl<K, V> ConcurrentElasticMap<K, V>

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

pub fn new() -> Self

Creates a new ConcurrentElasticMap with the default initial capacity and parameters

pub fn with_capacity(capacity: usize) -> Self

Creates a new ConcurrentElasticMap with the specified initial capacity

pub fn get_index<Q: ?Sized + Hash>(&self, key: &Q) -> usize

Computes the index in the buckets array for a given key

Panics

This function will panic if unable to acquire the read lock on the buckets.

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

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

Retrieve a value for a given key

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

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

Removes a key-value pair from the hash table

pub fn len(&self) -> usize

Returns the number of elements in the hash table

pub fn is_empty(&self) -> bool

Returns true if the hash table is empty

pub fn set_occupancy_threshold(&self, threshold: usize)

Provide a way to configure the occupancy threshold

pub fn set_load_factor_threshold(&self, threshold: f64)

Provide a way to configure the load factor threshold

pub fn iter(&self) -> Iter<'_, K, V>

Returns an iterator over the key-value pairs

Panics

This function will panic if unable to acquire the read lock on buckets.

pub fn capacity(&self) -> usize

Returns the capacity (number of buckets) in the map

Panics

This function will panic if unable to acquire the read lock on buckets.

pub fn load_factor(&self) -> f64

Returns the current load factor of the map

Panics

This function will panic if unable to acquire the read lock on buckets.

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

Inserts a key-value pair into the map

Returns the old value if the key was already present

Panics

This function may panic if unable to acquire locks on the buckets.

Trait Implementations

impl<K: Debug, V: Debug> Debug for ConcurrentElasticMap<K, V>

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

Formats the value using the given formatter.

impl<K, V> Default for ConcurrentElasticMap<K, V>

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

fn default() -> Self

Returns the “default value” for a type.

impl<K, V> HashMapExtensions<K, V> for ConcurrentElasticMap<K, V>

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

fn keys(&self) -> Vec<K>

Returns the keys of the hash map as a Vec

fn values(&self) -> Vec<V>

Returns the values of the hash map as a Vec

fn contains_key<Q>(&self, key: &Q) -> bool

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

Returns true if the hash map contains the given key

impl<'a, K, V> IntoIterator for &'a ConcurrentElasticMap<K, V>

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

type Item = (K, V)

The type of the elements being iterated over.

type IntoIter = Iter<'a, K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.