Enum LockableContainer 

pub enum LockableContainer {
    RefPointerIndex,
    RefLog,
    ReceivedIndex,
    TrustPolicy,
}

One of the four containers RFC 102 Stage 6 Step 2 locks against concurrent writer/compactor races (design-v1.md §15.8, ruled wide by the project owner over the developer’s own narrower lean): the three genuine compaction targets, plus the ref log, whose own tearing exposure predates RFC 102 and is not caused by compaction, but is fixed here because the exclusion machinery being built for compaction closes it for free. trust_key_container is deliberately absent – it never compacts, and stays protected by the unchanged, repository-wide ActiveLock alone, the same as before this stage.

derive(Ord) on a fieldless enum compares by declaration order, which is the one fixed total lock order every multi-container acquisition sorts into (lock::acquire_container_locks, design-v1.md §15.7’s deadlock ruling) – no call site can express an inverted order even by accident, because sorting is structural, not a discipline to remember.

Variants

RefPointerIndex

refs/containers/pointer-index-{a,b}.container – Stage 6 Step 1’s own generation-aware target.

RefLog

refs/containers/log-{a,b}.container – never compacted (DC-38/DC-69), but shares the ref pointer index’s write path (publication.rs) and the same unserialized-appender exposure.

ReceivedIndex

refs/containers/received-index-{a,b}.container – Stage 6 Step 1’s own generation-aware target, and the container whose investigation (bundle.rs:270’s import_bundle, no lock at all) is what surfaced this whole ruling.

TrustPolicy

trust/policy-{a,b}.container – Stage 6 Step 1’s own generation-aware target. Already incidentally protected today by ActiveLock (trust.rs:88,144); gains its own dedicated lock here anyway, per the owner’s decision that the lock is container-scoped, not repository-wide (design-v1.md §15.7 decision 2) – so a prikk compact run on this container never contends with unrelated ActiveLock holders (a commit, a seal) that never touch it.

Implementations

impl LockableContainer

pub const ALL: [Self; 4]

Every variant, in the declared total order – the one enumeration prikk unlock (and anything else that needs to sweep every container lock) should use, rather than hand-rolling the list and risking it drift from the enum’s own declaration.

Trait Implementations

impl Clone for LockableContainer

fn clone(&self) -> LockableContainer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for LockableContainer

impl Debug for LockableContainer

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

Formats the value using the given formatter.

impl Eq for LockableContainer

impl Hash for LockableContainer

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 LockableContainer

fn cmp(&self, other: &LockableContainer) -> 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 LockableContainer

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for LockableContainer

fn partial_cmp(&self, other: &LockableContainer) -> 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 StructuralPartialEq for LockableContainer