Enum RefRejection 

pub enum RefRejection {
    Cas {
        name: String,
        expected: Observed,
        actual: Observed,
    },
    Locked {
        name: String,
    },
}

The typed ref rejection, re-exported so a consumer of this crate reaches it without also naming the contract crate. RefRejection::of(&err) is the only sanctioned way to ask whether a ref write lost a race — never a message. Why a ref write was refused, typed.

Why this exists at all

Error::is_cas_failure() / is_lock_contention() died with RefStore, and receive-pack has to tell a client which ref lost the race and what was there instead — never by sniffing an error string. gunnar-store’s error.rs records the loss verbatim: this type “used to carry RefCas { name, expected, actual } and the Observed three-state beside it”. This is that, restored, in the one crate both backends already share.

How it travels, and why the crate is still anyhow-only

The trait methods keep returning anyhow::Result, so no signature in the frozen contract changes and no caller is forced to match on a storage error it does not care about. This type implements std::error::Error by hand — no thiserror, no new dependency — so a backend raises it with anyhow::Error::new(rejection) and a caller that does care recovers it with RefRejection::of. The tiny-crate property is about not forcing one backend’s dependencies onto the other; it was never about refusing to name this crate’s own errors.

The two variants, and why Locked is one of them

From the gix arm’s classifier, whose comment is the argument: a lock this writer could not take is “TYPED, not a Backend: it is transient and the one control-document writer retries it. Left as an opaque backend error it read to a caller as a broken disk.”

Variants

Cas

A compare-and-swap lost: name did not hold what the caller expected, and nothing was written.

expected is the caller’s claim (Observed::Nothing for a must-not-exist create); actual is what the backend found.

Fields

name: String

expected: Observed

actual: Observed

Locked

A lock on name this writer could not take. Transient — the caller retries. Not a fault, and specifically not a broken disk.

Fields

name: String

Implementations

impl RefRejection

pub fn name(&self) -> &str

The ref this is about.

pub fn is_cas_failure(&self) -> bool

“Another push beat you to it” — a lost race, not a fault.

pub fn is_lock_contention(&self) -> bool

“Try again” — transient contention on the one writer.

pub fn of(err: &Error) -> Option<&RefRejection>

Recover a rejection from an anyhow::Error a backend raised.

This is the only sanctioned way to ask, and it is a named function so that no caller ever spells downcast_ref — or, worse, matches on the message text. It walks the context chain, so a backend is free to add .context(..) above the rejection without hiding it.

Trait Implementations

impl Clone for RefRejection

fn clone(&self) -> RefRejection

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RefRejection

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

Formats the value using the given formatter.

impl Display for RefRejection

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

Formats the value using the given formatter.

impl Eq for RefRejection

impl Error for RefRejection

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl PartialEq for RefRejection

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for RefRejection