Struct chainerror::ChainError

pub struct ChainError<T> { /* fields omitted */ }

chains an inner error kind T with a causing error

Methods

impl<T: 'static + Display + Debug> ChainError<T>

pub fn new(
    kind: T,
    error_cause: Option<Box<dyn Error + 'static>>,
    occurrence: Option<(u32, &'static str)>
) -> Self

Use the cherr!() or mstrerr!() macro instead of calling this directly

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

return the root cause of the error chain, if any exists

pub fn find_cause<U: Error + 'static>(&self) -> Option<&U>

Find the first error cause of type U, if any exists

Examples

fn do_some_io() -> Result<(), Box<Error>> {
    Err(io::Error::from(io::ErrorKind::NotFound))?;
    Ok(())
}

derive_str_cherr!(Func2Error);

fn func2() -> Result<(), Box<Error>> {
    let filename = "foo.txt";
    do_some_io().map_err(mstrerr!(Func2Error, "Error reading '{}'", filename))?;
    Ok(())
}

derive_str_cherr!(Func1Error);

fn func1() -> Result<(), Box<Error>> {
    func2().map_err(mstrerr!(Func1Error, "func1 error"))?;
    Ok(())
}

fn main() {
    if let Err(e) = func1() {
        if let Some(f1err) = e.downcast_chain_ref::<Func1Error>() {

            assert!(f1err.find_cause::<io::Error>().is_some());

            assert!(f1err.find_chain_cause::<Func2Error>().is_some());
        }
    }
}

pub fn find_chain_cause<U: Error + 'static>(&self) -> Option<&ChainError<U>>

Find the first error cause of type ChainError<U>, if any exists

Same as find_cause, but hides the ChainError<U> implementation internals

Examples

// Instead of writing
err.find_cause::<ChainError<FooError>>();

// leave out the ChainError<FooError> implementation detail
err.find_chain_cause::<FooError>();

pub fn find_kind_or_cause<U: Error + 'static>(&self) -> Option<&U>

Find the first error cause of type ChainError<U> or U, if any exists and return U

Same as find_cause and find_chain_cause, but hides the ChainError<U> implementation internals

Examples

// Instead of writing
err.find_cause::<ChainError<FooErrorKind>>();
// and/or
err.find_chain_cause::<FooErrorKind>();
// and/or
err.find_cause::<FooErrorKind>();

// leave out the ChainError<FooErrorKind> implementation detail
err.find_chain_or_kind::<FooErrorKind>();

pub fn kind(&self) -> &T

Return a reference to T of ChainError<T>

Examples

fn do_some_io() -> Result<(), Box<Error>> {
    Err(io::Error::from(io::ErrorKind::NotFound))?;
    Ok(())
}

derive_str_cherr!(Func2Error);

fn func2() -> Result<(), Box<Error>> {
    let filename = "foo.txt";
    do_some_io().map_err(mstrerr!(Func2Error, "Error reading '{}'", filename))?;
    Ok(())
}

#[derive(Debug)]
enum Func1ErrorKind {
    Func2,
    IO(String),
}

/// impl ::std::fmt::Display for Func1ErrorKind {…}

fn func1() -> ChainResult<(), Func1ErrorKind> {
    func2().map_err(|e| cherr!(e, Func1ErrorKind::Func2))?;
    do_some_io().map_err(|e| cherr!(e, Func1ErrorKind::IO("bar.txt".into())))?;
    Ok(())
}

fn main() {
    if let Err(e) = func1() {
        match e.kind() {
            Func1ErrorKind::Func2 => {},
            Func1ErrorKind::IO(filename) => panic!(),
        }
    }
}

pub fn iter(
    &self
) -> impl Iterator<Item = &(dyn Error + 'static)>

Returns an Iterator over all error causes/sources

Example

Trait Implementations

impl<U: 'static + Display + Debug> ChainErrorDown for ChainError<U>

fn is_chain<T: 'static + Display + Debug>(&self) -> bool

Test if of type ChainError<T>

fn downcast_chain_ref<T: 'static + Display + Debug>(
    &self
) -> Option<&ChainError<T>>

Downcast to a reference of ChainError<T>

fn downcast_chain_mut<T: 'static + Display + Debug>(
    &mut self
) -> Option<&mut ChainError<T>>

Downcast to a mutable reference of ChainError<T>

impl<T: 'static + Display + Debug> Deref for ChainError<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: 'static + Display + Debug> Debug for ChainError<T>

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

Formats the value using the given formatter.

impl<T: 'static + Display + Debug> Display for ChainError<T>

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

Formats the value using the given formatter.

impl<T: 'static + Display + Debug> Error for ChainError<T>

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

The lower-level source of this error, if any.

fn description(&self) -> &str

This method is soft-deprecated.

fn cause(&self) -> Option<&dyn Error>

Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

The lower-level cause of this error, if any.

impl<T: 'static + Display + Debug, '_> Error for &'_ ChainError<T>

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

The lower-level source of this error, if any.

fn description(&self) -> &str

This method is soft-deprecated.

fn cause(&self) -> Option<&dyn Error>

Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

The lower-level cause of this error, if any.

impl<T: 'static + Display + Debug, '_> Error for &'_ mut ChainError<T>

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

The lower-level source of this error, if any.

fn description(&self) -> &str

This method is soft-deprecated.

fn cause(&self) -> Option<&dyn Error>

Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

The lower-level cause of this error, if any.