Struct SharedError 

pub struct SharedError { /* private fields */ }

SharedError is a simple, cloneable anyhow::Error wrapper. It holds the inner error in an Arc<anyhow::Error> to support Clone.

Propagation of errors via ? converts automatically to SharedError.

use shared_error::anyhow::*;
use ::anyhow::Error;
use thiserror::Error;

#[derive(Debug, Error)]
enum SomeErrorType {
    #[error("Some error variant: {0}")]
    SomeErrorVariant(String),
}

fn some_fallible_func() -> Result<(), SharedError> {
    let result: Result<(), SomeErrorType> =
        Err(SomeErrorType::SomeErrorVariant("some context".to_owned()));
    Ok(result.shared_error()?)
}

fn some_fallible_func_anyhow() -> Result<(), SharedError> {
    let result: Result<(), Error> =
        Err(SomeErrorType::SomeErrorVariant("some context".to_owned()).into());
    Ok(result.shared_error()?)
}

fn some_caller() {
    let result = some_fallible_func();
    match result {
        Ok(_) => { /* do something */ },
        Err(shared_error) => {
            // some_func_1_that_consumes_error(shared_error.clone());
            // ...
            // some_func_N_that_consumes_error(shared_error.clone());
        }
    }
    let _result = some_fallible_func_anyhow();
}

Implementations

impl SharedError

pub fn inner(&self) -> &Error

Return reference to the inner Error.

pub fn new_arcederror(error: Arc<Error>) -> SharedError

Creates a new arced error

Trait Implementations

impl Clone for SharedError

fn clone(&self) -> SharedError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SharedError

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

Formats the value using the given formatter.

impl Display for SharedError

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

Formats the value using the given formatter.

impl Error for SharedError

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 From<Arc<Error>> for SharedError

fn from(source: Arc<Error>) -> SharedError

Converts to this type from the input type.

impl KV for SharedError

fn serialize( &self, _record: &Record<'_>, serializer: &mut dyn Serializer, ) -> Result<(), Error>

Serialize self into Serializer