Struct FileWriteLocks 

pub struct FileWriteLocks { /* private fields */ }

One async mutex per file, for code that reads a file, patches it and writes it back.

Without it two writes to the same note — a task toggle and a flashcard review a moment apart, two windows, or a move rewriting a link in a note being toggled — both read the old text and the second rename silently drops the first one’s change.

Entries are Weak: a file’s mutex lives exactly as long as someone holds or awaits it, and dead entries are swept on every acquisition, so the map only ever holds the files being written right now.

Keys are compared as given, so callers must pass canonical paths (two spellings of one file would otherwise get two locks). Not reentrant: never lock a path the current task already holds.

Implementations

impl FileWriteLocks

pub async fn lock(&self, path: &Path) -> OwnedMutexGuard<()>

Waits for exclusive write access to path.

pub fn lock_blocking(&self, path: &Path) -> OwnedMutexGuard<()>

Self::lock for blocking code (spawn_blocking, plain threads).

Panics

When called from within an async execution context, like tokio’s own blocking_lock.

pub fn lock_all_blocking(&self, paths: &[&Path]) -> Vec<OwnedMutexGuard<()>>

Locks every path in paths, in sorted order and once each, so two callers locking overlapping sets can never deadlock. Blocking.

Trait Implementations

impl Default for FileWriteLocks

fn default() -> Self

Returns the “default value” for a type.