Struct Error 

pub struct Error { /* private fields */ }

An error from a cache operation.

Wraps any underlying error from a cache implementation while preserving the ability to extract the original typed error.

For CacheTier implementers

Wrap your storage-specific errors using from_source:

impl CacheTier<K, V> for RedisCache {
    async fn get(&self, key: &K) -> Result<Option<CacheEntry<V>>, Error> {
        self.client.get(key).await.map_err(Error::from_source)
    }
}

For Consumers

Extract the underlying error using source_as or find_source:

match cache.get(&key).await {
    Err(e) if e.is_source::<redis::RedisError>() => {
        let redis_err = e.source_as::<redis::RedisError>().unwrap();
        // Handle Redis-specific error
    }
    Err(e) => // Handle generic error
    Ok(v) => // Success
}

Implementations

impl Error

pub fn from_source(cause: impl Into<Box<dyn Error + Send + Sync>>) -> Error

Creates a new error wrapping a source error.

This preserves the original error type for later extraction via source_as.

Examples

use cachet_tier::Error;

let io_err = std::io::Error::new(std::io::ErrorKind::NotFound, "file missing");
let error = Error::from_source(io_err);

// Later, extract the original error
assert!(error.source_as::<std::io::Error>().is_some());

pub fn from_message(message: impl Into<String>) -> Error

Creates a new error from a message string.

Use from_source instead when wrapping an existing error.

Examples

use cachet_tier::Error;

let error = Error::from_message("operation failed");

pub fn with_recovery(self, recovery_info: RecoveryInfo) -> Error

Attaches recovery information to this error.

This is for informational purposes and does not affect error handling logic. It can be used by monitoring or debugging tools to provide hints on how to recover from the error.

Examples

use cachet_tier::Error;
use recoverable::RecoveryInfo;

let error = Error::from_message("temporary failure").with_recovery(RecoveryInfo::retry());

pub fn is_source<T>(&self) -> bool

where T: Error + 'static,

Returns true if the source error is of type T.

Examples

use cachet_tier::Error;

let io_err = std::io::Error::new(std::io::ErrorKind::NotFound, "not found");
let error = Error::from_source(io_err);

assert!(error.is_source::<std::io::Error>());
assert!(!error.is_source::<std::fmt::Error>());

pub fn source_as<T>(&self) -> Option<&T>

where T: Error + 'static,

Returns the source error as type T if it matches.

This checks the immediate source. For nested errors, use find_source from the ErrorExt trait.

Examples

use cachet_tier::Error;

let io_err = std::io::Error::new(std::io::ErrorKind::NotFound, "not found");
let error = Error::from_source(io_err);

if let Some(io_err) = error.source_as::<std::io::Error>() {
    assert_eq!(io_err.kind(), std::io::ErrorKind::NotFound);
}

Trait Implementations

impl Clone for Error

fn clone(&self) -> Error

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl Enrichable for Error

fn add_enrichment(&mut self, entry: EnrichmentEntry)

Adds enrichment information to the error.

impl Error for Error

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 ErrorExt for Error

fn message(&self) -> String

Returns the formatted error message without backtrace.

fn backtrace(&self) -> &Backtrace

Returns a reference to the captured backtrace.

fn has_backtrace(&self) -> bool

Returns true if the error has a captured backtrace.

fn find_source<T>(&self) -> Option<&T>

where T: Error + 'static,

Finds the first source error of the specified type in the error chain.

fn find_source_with<T>(&self, search: impl Fn(&T) -> bool) -> Option<&T>

where T: Error + 'static,

Finds the first source error of the specified type that matches the given predicate.

impl From<Error> for SizeError

fn from(error: Error) -> SizeError

Converts to this type from the input type.

impl From<Infallible> for Error

fn from(_: Infallible) -> Error

Converts to this type from the input type.

impl From<SizeError> for Error

fn from(err: SizeError) -> Error

Converts to this type from the input type.

impl Recovery for Error

fn recovery(&self) -> RecoveryInfo

Returns recovery information for this instance.