Struct chainerror::ChainError

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

chains an inner error kind T with a causing error

Implementations

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

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

Use the context() or map_context() Result methods 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

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

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_kind_or_cause::<FooErrorKind>();

pub fn kind(&self) -> &T

Return a reference to T of ChainError<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!(),
    }
}

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>

fn downcast_inner_ref<T: 'static + Error>(&self) -> Option<&T>

Downcast to T of ChainError<T>

fn downcast_inner_mut<T: 'static + Error>(&mut self) -> Option<&mut T>

Downcast to T mutable reference of ChainError<T>

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> 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> 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.

pub fn backtrace(&self) -> Option<&Backtrace>

🔬 This is a nightly-only experimental API. (backtrace)

Returns a stack backtrace, if available, of where this error occurred.

pub fn description(&self) -> &str

👎 Deprecated since 1.42.0:

use the Display impl or to_string()

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

👎 Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

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.

pub fn backtrace(&self) -> Option<&Backtrace>

🔬 This is a nightly-only experimental API. (backtrace)

Returns a stack backtrace, if available, of where this error occurred.

pub fn description(&self) -> &str

👎 Deprecated since 1.42.0:

use the Display impl or to_string()

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

👎 Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting