Struct SyncIndexMap 

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

A concurrent IndexMap 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> SyncIndexMap<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,

Insert or replace the value for k, returning the previous value if the key already existed.

This requires V: Clone because the previous value must stay alive for concurrent readers. Use set when the value is not Clone and the previous value is not needed.

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

where K: Clone, V: Clone,

pub fn set(&self, k: K, v: V)

Insert or overwrite the value for k without returning the previous one. Unlike insert this does not require V: Clone, so it works with non-Clone values. Updating an existing key swaps the value in place (O(1)); readers observe the new value immediately.

pub fn set_mut(&mut self, k: K, v: V)

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

where K: Clone, V: Clone,

Remove k and return its value.

This requires V: Clone because the removed value must stay alive for concurrent readers. Use delete when the value is not Clone and the removed value is not needed.

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

where K: Clone, V: Clone,

pub fn delete(&self, k: &K)

where K: Clone,

Remove k without returning its value. Unlike remove this does not require V: Clone, so it works with non-Clone values.

pub fn delete_mut(&mut self, k: &K)

where K: 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::{SyncIndexMap};

let mut map = SyncIndexMap::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 SyncIndexMap<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 SyncIndexMap<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 SyncIndexMap<K, V>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, K, V> Deserialize<'de> for SyncIndexMap<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 SyncIndexMap<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<IndexMap<K, V>> for SyncIndexMap<K, V>

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

Converts to this type from the input type.

impl<K, V> Index<&K> for SyncIndexMap<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 SyncIndexMap<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 SyncIndexMap<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 SyncIndexMap<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 SyncIndexMap<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 SyncIndexMap<K, V>