Crate bolt 

Hierarchical read-write lock.

Given a hierarchical path defined as a sequence of progressively nested segments separated by slashes—as in a/b/c where c is nested in b and a, and b is nested in a—the locking mechanism ensures that

• a writer is given access to the path only when the rightmost segment is not currently being read from or written into and is not nested in any segment that is currently being written into, and that

• a reader is given access to the path only when the rightmost segment is not currently being written into and is not nested in any segment that is currently being written into.

For instance, one can concurrently write into a/b/c and a/b/d and read from a and a/b. However, reading from or writing into a/b/c or a/b/d would have to wait for a/b if the rightmost was acquired for writing, but one would be able to read from a.

Usage

const N: usize = 10;

let lock = std::sync::Arc::new(bolt::Lock::<N>::default());

{
    let lock = lock.clone();
    tokio::task::spawn(async move {
        let _guards = lock.write_backward("a/b/c").await;
    });
}

{
    let lock = lock.clone();
    tokio::task::spawn(async move {
        let _guards = lock.write_backward("a/b/d").await;
    });
}

Structs

Lock

A lock.

Enums

Guard

A guard.

Type Aliases

ReadGuard

A read guard.

WriteGuard

A write guard.