Enum LockMode 

pub enum LockMode {
    IntentionShared,
    IntentionExclusive,
    Shared,
    SharedIntentionExclusive,
    Exclusive,
}

The mode in which a transaction holds, or wants to hold, a lock.

The five modes form a lattice ordered by privilege: holding a stronger mode grants the capabilities of every weaker mode it covers. Acquiring a mode while already holding another upgrades to their join (least upper bound) — for example shared + intention exclusive becomes SharedIntentionExclusive.

Examples

use lock_db::LockMode;

// Two readers coexist; a writer excludes everyone.
assert!(LockMode::Shared.compatible_with(LockMode::Shared));
assert!(!LockMode::Shared.compatible_with(LockMode::Exclusive));

// Intention-shared coexists with everything except an exclusive lock.
assert!(LockMode::IntentionShared.compatible_with(LockMode::SharedIntentionExclusive));
assert!(!LockMode::IntentionShared.compatible_with(LockMode::Exclusive));

Variants

IntentionShared

Intention shared (IS). Announces intent to take shared locks on finer resources beneath this one. Compatible with everything except exclusive.

IntentionExclusive

Intention exclusive (IX). Announces intent to take exclusive (or shared) locks on finer resources. Compatible with the intention modes only.

Shared

Shared (S). A read lock. Any number of transactions may hold a resource Shared at once, alongside intention-shared holders.

SharedIntentionExclusive

Shared and intention exclusive (SIX). The transaction reads the whole subtree (S) and intends to write part of it (IX). Compatible only with intention-shared.

Exclusive

Exclusive (X). A write lock. Held by at most one transaction, and only when no other transaction holds the resource in any mode.

Implementations

impl LockMode

pub const fn compatible_with(self, other: LockMode) -> bool

Returns true if a lock in self mode and a lock in other mode may be held on the same resource by two different transactions at once.

This is the symmetric compatibility relation of the standard MGL matrix:

	IS	IX	S	SIX	X
IS	✓	✓	✓	✓	✗
IX	✓	✓	✗	✗	✗
S	✓	✗	✓	✗	✗
SIX	✓	✗	✗	✗	✗
X	✗	✗	✗	✗	✗

Examples

use lock_db::LockMode;

assert!(LockMode::IntentionShared.compatible_with(LockMode::IntentionExclusive));
assert!(!LockMode::IntentionExclusive.compatible_with(LockMode::Shared));
assert!(!LockMode::Exclusive.compatible_with(LockMode::IntentionShared));

pub const fn join(self, other: LockMode) -> LockMode

Returns the least mode that grants everything both self and other grant — their least upper bound in the privilege lattice.

This is what an upgrade resolves to: a transaction already holding self that requests other ends up holding self.join(other). For example a reader (Shared) that announces intent to write part of the subtree (IntentionExclusive) upgrades to SharedIntentionExclusive. join is commutative and associative.

Examples

use lock_db::LockMode;

assert_eq!(
    LockMode::Shared.join(LockMode::IntentionExclusive),
    LockMode::SharedIntentionExclusive,
);
assert_eq!(LockMode::IntentionShared.join(LockMode::Shared), LockMode::Shared);
assert_eq!(LockMode::Shared.join(LockMode::Exclusive), LockMode::Exclusive);
// join with itself is itself.
assert_eq!(LockMode::IntentionExclusive.join(LockMode::IntentionExclusive), LockMode::IntentionExclusive);

pub const fn covers(self, other: LockMode) -> bool

Returns true if holding self already grants everything other would.

Equivalent to self.join(other) == self: self sits at or above other in the lattice. This drives the idempotent path of acquisition — a request for a mode you already cover is a no-op.

Examples

use lock_db::LockMode;

assert!(LockMode::Exclusive.covers(LockMode::Shared));
assert!(LockMode::SharedIntentionExclusive.covers(LockMode::Shared));
assert!(LockMode::SharedIntentionExclusive.covers(LockMode::IntentionExclusive));
assert!(!LockMode::Shared.covers(LockMode::IntentionExclusive));

pub const fn is_exclusive(self) -> bool

Returns true for LockMode::Exclusive.

Examples

use lock_db::LockMode;

assert!(LockMode::Exclusive.is_exclusive());
assert!(!LockMode::Shared.is_exclusive());

pub const fn is_intention(self) -> bool

Returns true for the intention modes (IS, IX, SIX).

Intention modes are placeholders taken on a coarse resource to signal that a finer lock will be taken beneath it; they are not themselves read or write locks on the resource’s own data.

Examples

use lock_db::LockMode;

assert!(LockMode::IntentionShared.is_intention());
assert!(LockMode::SharedIntentionExclusive.is_intention());
assert!(!LockMode::Shared.is_intention());
assert!(!LockMode::Exclusive.is_intention());

Trait Implementations

impl Clone for LockMode

fn clone(&self) -> LockMode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for LockMode

impl Debug for LockMode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LockMode

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for LockMode

impl Hash for LockMode

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for LockMode

fn cmp(&self, other: &LockMode) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for LockMode

fn eq(&self, other: &LockMode) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for LockMode

fn partial_cmp(&self, other: &LockMode) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for LockMode

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for LockMode