Enum Code

pub enum Code {
    Ok = 0,
    Cancelled = 1,
    Unknown = 2,
    InvalidArgument = 3,
    DeadlineExceeded = 4,
    NotFound = 5,
    AlreadyExists = 6,
    PermissionDenied = 7,
    ResourceExhausted = 8,
    FailedPrecondition = 9,
    Aborted = 10,
    OutOfRange = 11,
    Unimplemented = 12,
    Internal = 13,
    Unavailable = 14,
    DataLoss = 15,
    Unauthenticated = 16,
}

Status codes for CEL errors.

These codes are based on the Google RPC status codes and provide standardized error categorization for different types of failures that can occur during CEL operations.

Examples

use cel_cxx::Code;

let code = Code::InvalidArgument;
println!("Description: {}", code.description());
println!("Display: {}", code);

Variants

Ok = 0

The operation completed successfully.

This is not typically used for errors, but may appear in some contexts.

Cancelled = 1

The operation was cancelled.

This typically indicates that the operation was cancelled by the caller or due to a timeout.

Unknown = 2

Unknown error.

This is used when the specific error category cannot be determined, often when converting from other error types.

InvalidArgument = 3

Client specified an invalid argument.

This indicates that the input provided to the operation was invalid. For CEL, this often means syntax errors or invalid expression structure.

DeadlineExceeded = 4

Deadline expired before operation could complete.

This indicates that the operation took too long to complete.

NotFound = 5

Some requested entity was not found.

This indicates that a referenced entity (like a variable or function) was not found in the current context.

AlreadyExists = 6

Some entity that we attempted to create already exists.

This indicates that an operation tried to create something that already exists.

PermissionDenied = 7

The caller does not have permission to execute the specified operation.

This indicates insufficient permissions to perform the operation.

ResourceExhausted = 8

Some resource has been exhausted.

This indicates that a resource limit has been exceeded, such as memory or computation limits.

FailedPrecondition = 9

The system is not in a state required for the operation’s execution.

This indicates that the operation cannot be performed in the current state.

Aborted = 10

The operation was aborted.

This indicates that the operation was aborted, typically due to a concurrency issue.

OutOfRange = 11

Operation was attempted past the valid range.

This indicates that the operation exceeded valid bounds, such as accessing an array out of bounds.

Unimplemented = 12

Operation is not implemented or not supported.

This indicates that the requested operation is not implemented or not supported in the current context.

Internal = 13

Internal error.

This indicates an internal error that should not normally occur. It often indicates a bug in the implementation.

Unavailable = 14

The service is currently unavailable.

This indicates that the service is temporarily unavailable and the operation should be retried later.

DataLoss = 15

Unrecoverable data loss or corruption.

This indicates that data has been lost or corrupted in an unrecoverable way.

Unauthenticated = 16

The request does not have valid authentication credentials.

This indicates that the operation requires authentication credentials that are missing or invalid.

Implementations

impl Code

pub fn description(&self) -> &'static str

Returns a human-readable description of this error code.

This method provides a detailed description of what the error code means.

Examples

use cel_cxx::Code;

let code = Code::InvalidArgument;
println!("Description: {}", code.description());
// Output: Description: Client specified an invalid argument

Note

If you only need the description for display purposes (such as in println!, format!, or logging), you can use the Display trait implementation instead, which is more concise.

Trait Implementations

impl Clone for Code

fn clone(&self) -> Code

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Code

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

Formats the value using the given formatter.

impl Display for Code

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

Formats the value using the given formatter.

impl Hash for Code

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 Code

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

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

const 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 Copy for Code

impl Eq for Code

impl StructuralPartialEq for Code