Struct chainerror::Error

source ·

pub struct Error<T> { /* private fields */ }

Expand description

chains an inner error kind T with a causing error

Implementations§

source §

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

source

pub fn new( kind: T, error_cause: Option<Box<dyn StdError + Send + Sync + 'static>>, occurrence: Option<String> ) -> Self

Use the context() or map_context() Result methods instead of calling this directly

source

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

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

source

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

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

Examples

use chainerror::prelude::v1::*;
use std::error::Error;
use std::io;

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

derive_str_context!(Func2Error);

fn func2() -> Result<(), Box<dyn Error + Send + Sync>> {
    let filename = "foo.txt";
    do_some_io().context(Func2Error(format!("Error reading '{}'", filename)))?;
    Ok(())
}

derive_str_context!(Func1Error);

fn func1() -> Result<(), Box<dyn Error + Send + Sync>> {
    func2().context(Func1Error("func1 error".into()))?;
    Ok(())
}

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());
    }
}

source

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

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

Same as find_cause, but hides the Error implementation internals

Examples

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

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

source

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

Find the first error cause of type Error or U, if any exists and return U

Same as find_cause and find_chain_cause, but hides the Error 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_kind_or_cause::<FooErrorKind>();

source

pub fn kind(&self) -> &T

Return a reference to T of Error<T>

Examples

use chainerror::prelude::v1::*;
use std::error::Error;
use std::io;

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

derive_str_context!(Func2Error);

fn func2() -> Result<(), Box<dyn Error + Send + Sync>> {
    let filename = "foo.txt";
    do_some_io().context(Func2Error(format!("Error reading '{}'", filename)))?;
    Ok(())
}

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

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

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

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