Struct SyncHashMap 

pub struct SyncHashMap<K: Eq + Hash, V> { /* private fields */ }

A concurrent HashMap with a Go sync.Map-style read/dirty architecture:

• read: an immutable snapshot, atomically published. get / iter / Index read it lock-free.
• dirty: the canonical, mutable map, guarded by lock.

Every slot is an Arc<Entry<V>> shared between the snapshot and dirty. The entry holds an atomic pointer to the value, so updating an existing key swaps the pointer in place (O(1)) — no snapshot rebuild — and readers always see the latest value. New keys and removals are published lazily (tracked by the amended flag). Snapshots and retired values are kept alive until the map is dropped, so references returned by get stay valid.

Implementations

impl<K, V> SyncHashMap<K, V>

where K: Eq + Hash,

pub fn new_arc() -> Arc<Self>

pub fn new() -> Self

pub fn with_capacity(capacity: usize) -> Self

pub fn with_map(map: Map<K, V>) -> Self

pub fn insert(&self, k: K, v: V) -> Option<V>

where K: Clone, V: Clone,

pub fn insert_mut(&mut self, k: K, v: V) -> Option<V>

where K: Clone, V: Clone,

pub fn remove(&self, k: &K) -> Option<V>

where K: Clone, V: Clone,

pub fn remove_mut(&mut self, k: &K) -> Option<V>

where K: Clone, V: Clone,

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn clear(&self)

where K: Clone,

pub fn clear_mut(&mut self)

where K: Clone,

pub fn shrink_to_fit(&self)

pub fn shrink_to_fit_mut(&mut self)

pub fn from(map: Map<K, V>) -> Self

where K: Eq + Hash,

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

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

Returns a reference to the value corresponding to the key.

The key may be any borrowed form of the map’s key type, but Hash and Eq on the borrowed form must match those for the key type.

Reads are lock-free: the value is served from the immutable read snapshot through a shared entry, so updates are visible immediately. If the key was added to dirty since the last snapshot was published, a fresh snapshot is published first.

Examples

use dark_std::sync::{SyncHashMap};

let mut map = SyncHashMap::new();
map.insert_mut(1, "a");
assert_eq!(*map.get(&1).unwrap(), "a");
assert_eq!(map.get(&2).is_none(), true);

pub fn get_mut(&self, k: &K) -> Option<HashMapRefMut<'_, K, V>>

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

Returns a mutable handle to the value for k, implemented with copy-on-write: the value is cloned, the handle mutates the clone, and the result is swapped back into the shared entry (O(1)) when the handle is dropped. Concurrent readers may observe the pre-mutation value until the handle is dropped.

pub fn contains_key(&self, x: &K) -> bool

where K: PartialEq,

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

where K: Clone,

Iterate over the current contents. A fresh snapshot is published first, so all entries written so far are visible.

pub fn iter_mut(&self) -> IterMut<'_, K, V>

where K: Clone, V: Clone,

pub fn into_iter(self) -> MapIntoIter<K, V>

pub fn into_inner(self) -> Map<K, V>

Trait Implementations

impl<K: Clone + Eq + Hash, V: Clone> Clone for SyncHashMap<K, V>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<K, V> Debug for SyncHashMap<K, V>

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

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

Formats the value using the given formatter.

impl<K: Eq + Hash, V> Default for SyncHashMap<K, V>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, K, V> Deserialize<'de> for SyncHashMap<K, V>

where K: Eq + Hash + Deserialize<'de>, V: Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<K, V> Display for SyncHashMap<K, V>

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

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

Formats the value using the given formatter.

impl<K: Eq + Hash, V> From<HashMap<K, V>> for SyncHashMap<K, V>

fn from(arg: Map<K, V>) -> Self

Converts to this type from the input type.

impl<K, V> Index<&K> for SyncHashMap<K, V>

where K: Eq + Hash + Clone,

type Output = V

The returned type after indexing.

fn index(&self, index: &K) -> &Self::Output

Performs the indexing (container[index]) operation.

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

where K: Eq + Hash + Clone,

type Item = (&'a K, &'a 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.

impl<K, V> IntoIterator for SyncHashMap<K, V>

where K: Eq + Hash,

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) -> Self::IntoIter

Creates an iterator from a value.

impl<K: Eq + Hash, V> Send for SyncHashMap<K, V>

Safety: dirty is only ever accessed under lock; the read snapshot is immutable once published; values behind entries are immutable once published and swapped out atomically; retired values and retired snapshots are kept alive until the map is dropped, so references derived from get remain valid for the lifetime of &self.

impl<K, V> Serialize for SyncHashMap<K, V>

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

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<K: Eq + Hash, V> Sync for SyncHashMap<K, V>