Struct MutexMap 

pub struct MutexMap<Key, Val> {
    map: Arc<Mutex<HashMap<Key, Arc<Mutex<Val>>>>>,
}

Provides independent asynchronous mutexes keyed by owned values.

Lock acquisition creates entries on demand, and callers contending for the same key serialize. An entry lives exactly as long as some caller holds or contends for it.

Fields

map: Arc<Mutex<HashMap<Key, Arc<Mutex<Val>>>>>

Implementations

impl<Key, Val> MutexMap<Key, Val>

where Key: Clone + Eq + Hash + Send, Val: Default + Send,

pub fn new() -> Self

Creates an empty keyed mutex map.

No per-key mutex is allocated until a lock method first sees its key. The result is equivalent to Default::default.

pub async fn lock<K>(&self, k: &K) -> Guard<Key, Val>

where K: Debug + Send + ?Sized + Sync + ToOwned<Owned = Key>,

Acquires the asynchronous mutex associated with a key.

The method creates an entry if absent and waits for the current holder to release it. Cancellation while waiting releases the claim on the entry, and a poisoned internal map mutex causes a panic.

pub fn try_lock<K>(&self, k: &K) -> Result<Guard<Key, Val>>

where K: Debug + Send + ?Sized + Sync + ToOwned<Owned = Key>,

Attempts to acquire a key without waiting for its asynchronous mutex.

The key entry is created if absent, and contention returns an error instead of yielding. Acquiring the internal map mutex can still block and panics if that mutex is poisoned.

pub fn try_try_lock<K>(&self, k: &K) -> Result<Guard<Key, Val>>

where K: Debug + Send + ?Sized + Sync + ToOwned<Owned = Key>,

Attempts to acquire a key without yielding, blocking only to release a failed attempt.

Contention on either the internal map or keyed mutex returns an error. The entry is created only after the map mutex is acquired, and releasing a failed attempt blocks on that mutex again. A poisoned map mutex causes a panic.

pub fn contains(&self, k: &Key) -> bool

Reports whether the map currently contains an entry for a key.

An entry represents a held mutex or contenders that still reference it. The check locks the internal map and panics if that mutex is poisoned.

pub fn is_empty(&self) -> bool

Reports whether no keyed mutex entries are currently tracked.

A false result implies at least one active holder or contender. The check locks the internal map and panics if that mutex is poisoned.

pub fn len(&self) -> usize

Returns the number of keyed mutex entries currently tracked.

The count includes held mutexes and entries retained by contenders. The check locks the internal map and panics if that mutex is poisoned.

fn entry<K>(&self, k: &K) -> Guard<Key, Val>

where K: ?Sized + ToOwned<Owned = Key>,

fn try_entry<K>(&self, k: &K) -> Result<Guard<Key, Val>>

where K: ?Sized + ToOwned<Owned = Key>,

fn pending(&self, val: Arc<Mutex<Val>>) -> Guard<Key, Val>

Trait Implementations

impl<Key: Debug, Val: Debug> Debug for MutexMap<Key, Val>

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

Formats the value using the given formatter.

impl<Key, Val> Default for MutexMap<Key, Val>

where Key: Clone + Eq + Hash + Send, Val: Default + Send,

fn default() -> Self

Returns the “default value” for a type.