Enum ResultCode 

#[non_exhaustive]
pub enum ResultCode {
    Ok,
    Unsupported,
    NotFound,
    InvalidArgument,
    TooLarge,
    Conflict,
    Stale,
    VersionSkew,
    Unauthenticated,
    Backend,
    Forbidden,
    StepUpRequired,
    Unavailable,
    ResourceLimit,
    Cancelled,
    DeadlineExceeded,
    ExpiredSnapshot,
    StaleGeneration,
    TargetUnavailable,
    Pending,
    BackendUnavailable,
    Unrecognized(u16),
}

One logical outcome code spanning query, key-value, fork, and browse. Built from a surface’s typed error via the From impls below. The typed error keeps the detail, this is the shared classification.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Ok

The operation succeeded (no error to classify).

Unsupported

The operation, or the managed surface, is not available here.

NotFound

A named entity (index, fork, key) does not exist.

InvalidArgument

The request was malformed or a field was out of range.

TooLarge

A result or value exceeded a size cap.

Conflict

A precondition lost a race (a compare-and-swap version mismatch, a fork promote/squash conflict).

Stale

A consistency level could not be met within the deadline (the read model is still catching up).

VersionSkew

The wire op version is not accepted by this peer.

Unauthenticated

No credential, or an invalid one: the caller is not authenticated.

Backend

The managed backend failed or was unreachable.

Forbidden

Authenticated, but the grant needed for the operation is missing.

StepUpRequired

Authenticated, but the operation needs a stronger authentication (a step-up) than the caller currently holds.

Unavailable

The request could not be served right now, and the same request may succeed on a later attempt: the store was momentarily out of reach, a connection was refused or dropped, a concurrency conflict was aborted, or a resource limit was hit. Distinct from Backend, which is a fault the caller cannot retry away. This is the one code a generic client may safely retry with backoff, so it never has to parse a message to decide (see is_retryable).

ResourceLimit

The query exceeded a server-enforced resource budget.

Cancelled

The query was cancelled through its execution identity.

DeadlineExceeded

The query did not finish before its absolute deadline.

ExpiredSnapshot

The requested historical snapshot is no longer retained.

StaleGeneration

The requested destination or backend generation is no longer current.

TargetUnavailable

The resolved target is not ready to serve queries.

Pending

The mutation was accepted into the log, but its outcome is not known yet. Only a retry with the same operation identity may follow: it returns the recorded outcome once the mutation has applied. A new identity could apply the change a second time.

BackendUnavailable

The node could not reach its managed backend, or the backend did not answer in time. The request may still apply, so a mutation repeats only under the same operation identity, on this node or another one.

Unrecognized(u16)

A code from a newer peer this build does not name. Decodes and re-encodes byte-for-byte so an old build relays it rather than failing. Only a value outside the named range (21 and up) should ever appear here: from_code never produces Unrecognized for 0..=20, which map to the named variants.

Implementations

impl ResultCode

pub const fn code(self) -> u16

The pinned numeric code, stable across repos and language ports.

pub const fn from_code(code: u16) -> Self

The code for a pinned numeric value, where an unknown value becomes Unrecognized rather than an error.

pub const fn http_status(self) -> u16

The HTTP status this code maps to, the one mapping every surface shares, so a status need not be decided per surface or per route.

pub const fn is_retryable(self) -> bool

Whether a caller may retry the identical request and reasonably expect a different outcome. True only for the two transient classes: the store was momentarily unreachable, or the read model had not caught up yet. Every other code needs the request, the credential, or the data to change first, so retrying it unchanged only wastes the attempt. Pending is not in this set: only the original operation identity may be retried, see is_pending.

pub const fn is_pending(self) -> bool

Whether the mutation was accepted and its outcome is still unknown. The caller repeats the exact request with the same operation identity.

pub const fn is_backend_unavailable(self) -> bool

Whether the node could not reach its managed backend, or the backend did not answer in time. The request may still apply. A client repeats a mutation under the same operation identity, and may send it to another node. Unlike Unavailable, which a busy node or an unreachable destination answers, this one names the node itself as the problem.

Trait Implementations

impl Clone for ResultCode

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 ResultCode

impl Debug for ResultCode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ResultCode

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ResultCode

impl From<&AuthzError> for ResultCode

fn from(error: &AuthzError) -> Self

Converts to this type from the input type.

impl From<&CheckpointError> for ResultCode

fn from(error: &CheckpointError) -> Self

Converts to this type from the input type.

impl From<&ForkError> for ResultCode

fn from(error: &ForkError) -> Self

Converts to this type from the input type.

impl From<&GraphError> for ResultCode

fn from(error: &GraphError) -> Self

Converts to this type from the input type.

impl From<&KvError> for ResultCode

fn from(error: &KvError) -> Self

Converts to this type from the input type.

impl From<&QueryError> for ResultCode

fn from(error: &QueryError) -> Self

Converts to this type from the input type.

impl From<&SessionError> for ResultCode

fn from(error: &SessionError) -> Self

Converts to this type from the input type.

impl PartialEq for ResultCode

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for ResultCode

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 ResultCode