Enum ApplicationErrorCode 

pub enum ApplicationErrorCode {
    InvalidRequest,
    InputInvalid,
    AuthorizationDenied,
    ContractMismatch,
    QueryInvalid,
    QueryUnavailable,
    ModuleUnavailable,
    CursorInvalid,
    ResponseTooLarge,
    StorageUnavailable,
    OutcomeUnknown,
    OperationCancelled,
    DeadlineExceeded,
    InternalDefect,
    IdempotencyKeyReuse,
    CommandExecutionFailed,
    CapabilityRevoked,
    ProtocolInvalid,
    HistoryIncarnationMismatch,
    HistoryPruned,
    Overloaded,
    ProjectionDiverged,
    SnapshotRetired,
    FreshnessUnsatisfied,
    ProjectedSourceRequired,
    FollowerMode,
    PrimaryFenced,
}

Closed stable code registry for application-semantic failures.

Variants

InvalidRequest

Public message bytes failed structural validation.

InputInvalid

A typed application input failed validation.

AuthorizationDenied

Current policy denied the operation.

ContractMismatch

Contract identity is absent, stale, or does not match.

QueryInvalid

RiffQL could not be parsed, resolved, typed, or planned.

QueryUnavailable

A checked query cannot currently be loaded or executed.

ModuleUnavailable

The requested named-query module is absent or stale.

CursorInvalid

A continuation cursor is invalid or stale.

ResponseTooLarge

One complete authorized result exceeds a public bound.

StorageUnavailable

Authoritative storage is temporarily unavailable.

OutcomeUnknown

A durable mutation may have completed.

OperationCancelled

The request was cancelled at a safe point.

DeadlineExceeded

The request deadline elapsed.

InternalDefect

A redacted internal defect occurred.

IdempotencyKeyReuse

An idempotency identity was reused with different input.

CommandExecutionFailed

Deterministic command execution failed.

CapabilityRevoked

A formerly valid capability is revoked.

ProtocolInvalid

A public peer violated the application protocol.

HistoryIncarnationMismatch

Observed history predates a database restore.

HistoryPruned

Requested history was retired by retention prune.

Overloaded

The service is over capacity and rejected admission.

ProjectionDiverged

Exact result-set providers cannot prove one common epoch.

SnapshotRetired

The exact snapshot bound to the request is no longer retained.

FreshnessUnsatisfied

No servable exact snapshot satisfies the requested freshness floor.

ProjectedSourceRequired

A retained nearest plan predates the required compiler-owned source declaration.

FollowerMode

This node is a follower and cannot execute a write operation.

PrimaryFenced

Durable source fencing permanently refuses new command admission.

Implementations

impl ApplicationErrorCode

pub const fn from_public_kind(kind: PublicErrorKind) -> Self

Maps the compatible kernel classification into the application registry.

pub const fn as_str(self) -> &'static str

Returns the stable externally documented code.

Examples found in repository

examples/generate_error_registry.rs (line 20)

fn main() -> io::Result<()> {
    let mut output = io::BufWriter::new(io::stdout().lock());
    writeln!(output, "code\tcategory\trecovery_action\tfixes\tmessage")?;
    for code in riffdb_errors::APPLICATION_ERROR_CODES {
        let fixes = code
            .fixes()
            .iter()
            .map(|fix| fix.as_str())
            .collect::<Vec<_>>()
            .join(",");
        writeln!(
            output,
            "{}\t{}\t{}\t{}\t{}",
            code.as_str(),
            code.category().as_str(),
            code.recovery_action().as_str(),
            fixes,
            code.safe_message()
        )?;
    }
    output.flush()
}

pub const fn safe_message(self) -> &'static str

Returns the one registry-owned public message for this code.

Examples found in repository

examples/generate_error_registry.rs (line 24)

fn main() -> io::Result<()> {
    let mut output = io::BufWriter::new(io::stdout().lock());
    writeln!(output, "code\tcategory\trecovery_action\tfixes\tmessage")?;
    for code in riffdb_errors::APPLICATION_ERROR_CODES {
        let fixes = code
            .fixes()
            .iter()
            .map(|fix| fix.as_str())
            .collect::<Vec<_>>()
            .join(",");
        writeln!(
            output,
            "{}\t{}\t{}\t{}\t{}",
            code.as_str(),
            code.category().as_str(),
            code.recovery_action().as_str(),
            fixes,
            code.safe_message()
        )?;
    }
    output.flush()
}

pub const fn category(self) -> ApplicationErrorCategory

Returns the closed category.

Examples found in repository

examples/generate_error_registry.rs (line 21)

fn main() -> io::Result<()> {
    let mut output = io::BufWriter::new(io::stdout().lock());
    writeln!(output, "code\tcategory\trecovery_action\tfixes\tmessage")?;
    for code in riffdb_errors::APPLICATION_ERROR_CODES {
        let fixes = code
            .fixes()
            .iter()
            .map(|fix| fix.as_str())
            .collect::<Vec<_>>()
            .join(",");
        writeln!(
            output,
            "{}\t{}\t{}\t{}\t{}",
            code.as_str(),
            code.category().as_str(),
            code.recovery_action().as_str(),
            fixes,
            code.safe_message()
        )?;
    }
    output.flush()
}

pub const fn recovery_action(self) -> ApplicationRecoveryAction

Returns deterministic recovery guidance.

Examples found in repository

examples/generate_error_registry.rs (line 22)

fn main() -> io::Result<()> {
    let mut output = io::BufWriter::new(io::stdout().lock());
    writeln!(output, "code\tcategory\trecovery_action\tfixes\tmessage")?;
    for code in riffdb_errors::APPLICATION_ERROR_CODES {
        let fixes = code
            .fixes()
            .iter()
            .map(|fix| fix.as_str())
            .collect::<Vec<_>>()
            .join(",");
        writeln!(
            output,
            "{}\t{}\t{}\t{}\t{}",
            code.as_str(),
            code.category().as_str(),
            code.recovery_action().as_str(),
            fixes,
            code.safe_message()
        )?;
    }
    output.flush()
}

pub const fn fixes(self) -> &'static [ApplicationFixCode]

Returns the exact deterministic remediation set.

Examples found in repository

examples/generate_error_registry.rs (line 12)

fn main() -> io::Result<()> {
    let mut output = io::BufWriter::new(io::stdout().lock());
    writeln!(output, "code\tcategory\trecovery_action\tfixes\tmessage")?;
    for code in riffdb_errors::APPLICATION_ERROR_CODES {
        let fixes = code
            .fixes()
            .iter()
            .map(|fix| fix.as_str())
            .collect::<Vec<_>>()
            .join(",");
        writeln!(
            output,
            "{}\t{}\t{}\t{}\t{}",
            code.as_str(),
            code.category().as_str(),
            code.recovery_action().as_str(),
            fixes,
            code.safe_message()
        )?;
    }
    output.flush()
}

Trait Implementations

impl Clone for ApplicationErrorCode

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ApplicationErrorCode

impl Debug for ApplicationErrorCode

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

Formats the value using the given formatter.

impl Eq for ApplicationErrorCode

impl Hash for ApplicationErrorCode

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 PartialEq for ApplicationErrorCode

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ApplicationErrorCode