Struct ChainedError

pub struct ChainedError<T: ErrorKind> { /* private fields */ }

Chainable error type.

See module level documentation for usage.

Implementations

impl<T: ErrorKind> ChainedError<T>

pub fn new(kind: T, context: Vec<Box<dyn ErrorContext>>) -> Self

Create new ChainedError.

pub fn kind(&self) -> &T

Returns a reference of Error Kind

Usage

#[derive(Debug, ErrorKind, Eq, PartialEq)]
enum ErrorType {
    A,
    B,
    C
}
let chained = ErrorType::B.into_err();
assert_eq!(*chained.kind(), ErrorType::B);

pub fn contexts(&self) -> impl Iterator<Item = &str>

Returns a reference of Error Contexts Returns a reference of Error Kind

Usage

#[derive(Debug, ErrorKind, Eq, PartialEq)]
enum ErrorType {
    A,
    B,
    C
}
let chained = ErrorType::B.into_with(|| "Error is Caused!");
let chained = chained.chain(|| "Error is Chained!");
let mut cxts = chained.contexts();
assert_eq!(cxts.next().unwrap(), "Error is Caused!");
assert_eq!(cxts.next().unwrap(), "Error is Chained!");

pub fn chain<C, F>(self, op: F) -> Self

where C: ErrorContext, F: FnOnce() -> C,

Add context to ChainedError by closure.

It’s more useful to use chain_err.

pub fn convert<U>(self) -> ChainedError<U>

where U: ErrorKind + From<T>,

Convert ChainedError<T> into ChainedError<U> using std::convert::from.

Usage

mod external {
    #[derive(ErrorKind, Eq, PartialEq, Debug)]
    #[msg(short = "error in external")]
    pub struct ExtErrorKind;
    pub type Error = ChainedError<ExtErrorKind>;
    pub fn func() -> Result<(), Error> {
        Err(ExtErrorKind{}.into_with(|| "In external::func()"))
    }
}
use external::{self, ExtErrorKind};
#[derive(ErrorKind, Eq, PartialEq, Debug)]
enum MyErrorKind {
    Internal,
    #[msg(short = "from mod 'external'", detailed = "{:?}", _0)]
    External(ExtErrorKind),
};
impl From<ExtErrorKind> for MyErrorKind {
    fn from(e: ExtErrorKind) -> MyErrorKind {
        MyErrorKind::External(e)
    }
}
type Error = ChainedError<MyErrorKind>;
let chained: Result<(), Error>
    = external::func().map_err(|e| e.convert().chain(|| "In my_func()"));
if let Err(chained) = chained {
    assert_eq!(*chained.kind(), MyErrorKind::External(ExtErrorKind {}));
    assert_eq!(chained.contexts().nth(1).unwrap(), "In my_func()");
}

pub fn convert_with<U, F>(self, converter: F) -> ChainedError<U>

where U: ErrorKind, F: FnOnce(T) -> U,

Convert ChainedError<T> into ChainedError<U> using closure.

Usage

mod external {
    #[derive(ErrorKind, Eq, PartialEq, Debug)]
    #[msg(short = "error in external")]
    pub struct ExtErrorKind;
    pub type Error = ChainedError<ExtErrorKind>;
    pub fn func() -> Result<(), Error> {
        Err(ExtErrorKind{}.into_with(|| "In external::func()"))
    }
}
use external::{self, ExtErrorKind};
#[derive(ErrorKind, Eq, PartialEq, Debug)]
enum MyErrorKind {
    Internal,
    #[msg(short = "from mod 'external'", detailed = "{:?}", _0)]
    External(ExtErrorKind),
};
type Error = ChainedError<MyErrorKind>;
let chained: Result<(), Error> = external::func().map_err(|e| {
        e.convert_with(|e| MyErrorKind::External(e))
         .chain(|| "In my_func()")
   });
if let Err(chained) = chained {
    assert_eq!(*chained.kind(), MyErrorKind::External(ExtErrorKind {}));
    assert_eq!(chained.contexts().nth(1).unwrap(), "In my_func()");
}

Trait Implementations

impl<T: ErrorKind> Debug for ChainedError<T>

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

Formats the value using the given formatter.

impl<T: ErrorKind> Display for ChainedError<T>

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

Formats the value using the given formatter.

impl<T: ErrorKind> Error for ChainedError<T>

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

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.