Struct HashMap 

pub struct HashMap<K: 'static, V: 'static, S = FixedState> { /* private fields */ }

High-Performance Lock-Free Map with automatic grow/shrink.

Implementations

impl<K, V> HashMap<K, V, FixedState>

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

pub fn new() -> Self

Creates a new empty hash map with FoldHash (FixedState).

pub fn with_capacity(capacity: usize) -> Self

Creates a new empty hash map with at least capacity buckets.

impl<K, V, S> HashMap<K, V, S>

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

pub fn with_hasher(hasher: S) -> Self

Creates a new hash map with custom hasher.

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

Creates a new hash map with at least capacity buckets and a custom hasher.

The map grows when its load factor exceeds 0.75 and shrinks when it falls below 0.25 — but never below capacity.

pub fn capacity(&self) -> usize

Returns the current number of buckets.

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

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

Optimized get operation. Never blocks — reads the current table snapshot under a guard, even while a resize is in flight.

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

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

Checks if the key exists.

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

Insert a key-value pair.

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

Insert a key-value pair only if the key does not exist. Returns None if inserted, Some(existing_value) if the key already exists.

pub fn get_or_insert(&self, key: K, value: V) -> V

Returns the value corresponding to the key, or inserts the given value if the key is not present.

This is linearizable: concurrent callers for the same key are guaranteed to agree on which value was inserted (exactly one thread’s CAS succeeds at the list tail, and all others see that node on retry).

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

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

Remove a key-value pair.

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

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

Remove all nodes matching key, returning the most recent value if the key was present.

remove unlinks only the first matching entry. Insert/remove races can transiently leave more than one entry for the same key (“versions”); after a plain remove() an older version would become visible again. This method keeps removing until a full scan finds no match, so the key is guaranteed absent at the linearization point of the final scan.

Use remove() for single-version removal semantics and force_remove() when the key must be fully evicted.

Note: a concurrent insert of the same key can land after the final scan, as with any removal under contention.

pub fn clear(&self)

Clear the map.

pub fn is_empty(&self) -> bool

Returns true if the map is empty.

pub fn len(&self) -> usize

Returns the number of elements in the map.

O(1): maintained by insert/remove. Approximate while concurrent updates are in flight (exact in quiescence), like HopscotchMap.

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

Returns an iterator over the map entries. Yields (K, V) clones from a table snapshot taken at creation.

pub fn keys(&self) -> Keys<'_, K, V, S>

Returns an iterator over the map keys. Yields K clones.

pub fn values(&self) -> Values<'_, K, V, S>

Returns an iterator over the map values (clones V).

pub fn extend<I: IntoIterator<Item = (K, V)>>(&self, iter: I)

Insert all (K, V) pairs from iter. Takes &self (concurrent map).

pub fn hasher(&self) -> &S

Get the underlying hasher itself.

Trait Implementations

impl<K, V> Default for HashMap<K, V, FixedState>

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

Available on crate feature std only.

fn default() -> Self

Returns the “default value” for a type.

impl<K: 'static, V: 'static, S> Drop for HashMap<K, V, S>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<K, V, S> FromIterator<(K, V)> for HashMap<K, V, S>

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

fn from_iter<I: IntoIterator<Item = (K, V)>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a, K, V, S> IntoIterator for &'a HashMap<K, V, S>

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

type Item = (K, V)

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K, V, S> IntoIterator for HashMap<K, V, S>

where K: 'static, V: 'static,

type Item = (K, V)

The type of the elements being iterated over.

type IntoIter = IntoIter<K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IntoIter<K, V>

Creates an iterator from a value.

impl<K: Send, V: Send, S: Send> Send for HashMap<K, V, S>

impl<K: Send + Sync, V: Send + Sync, S: Send + Sync> Sync for HashMap<K, V, S>