Struct display_error_chain::DisplayErrorChain

pub struct DisplayErrorChain<'a, E: ?Sized>(_);

Provides an fmt::Display implementation for an error as a chain.

use display_error_chain::{DisplayErrorChain, ErrorChainExt as _};

// Let's set up a custom error. Normally one would use `snafu` or
// something similar to avoid the boilerplate.
#[derive(Debug)]
enum CustomError {
    NoCause,
    IO { source: std::io::Error },
}

// Custom display implementation (which doesn't take error
// sources into consideration).
impl std::fmt::Display for CustomError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            CustomError::NoCause => {
                write!(f, "No cause")
            }
            CustomError::IO { .. } => {
                write!(f, "Some I/O")
            }
        }
    }
}

impl std::error::Error for CustomError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            CustomError::NoCause => None,
            CustomError::IO { source } => Some(source),
        }
    }
}

// And finally let's see how `DisplayErrorChain` helps!
let io = CustomError::IO {
    source: std::io::Error::new(std::io::ErrorKind::AlreadyExists, "wow"),
};
let formatted = DisplayErrorChain::new(&io).to_string();
assert_eq!("Some I/O\nCaused by:\n  -> wow", formatted);

let no_cause = CustomError::NoCause;
// You can also use a `.chain()` shortcut from the `ErrorChainExt` trait.
let formatted = no_cause.chain().to_string();
assert_eq!("No cause", formatted);

Implementations

impl<'a, E> DisplayErrorChain<'a, E> where
    E: Error + ?Sized, 

pub fn new(error: &'a E) -> Self

Initializes the formatter with the error provided.

Trait Implementations

impl<'a, E> Display for DisplayErrorChain<'a, E> where
    E: Error + ?Sized, 

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

Formats the value using the given formatter.