Struct display_error_chain::DisplayErrorChain

pub struct DisplayErrorChain<E>(_);

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

// or `.into_chain()` to make the `DisplayErrorChain` to consume the error.
let formatted = no_cause.into_chain().to_string();
assert_eq!("No cause", formatted);

// `from` or `into` will also work with both owned and referenced errors:
let chain: DisplayErrorChain<_> = CustomError::NoCause.into();
assert_eq!("No cause", chain.to_string());

let chain: DisplayErrorChain<_> = (&CustomError::NoCause).into();
assert_eq!("No cause", chain.to_string());

Implementations

impl<E> DisplayErrorChain<E>where E: Error,

pub fn new(error: E) -> Self

Initializes the formatter with the error provided.

pub fn into_inner(self) -> E

Deconstructs the DisplayErrorChain and returns the wrapped error.

Trait Implementations

impl<E> Display for DisplayErrorChain<E>where E: Error,

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

Formats the value using the given formatter.

impl<E: Error> From<E> for DisplayErrorChain<E>

fn from(value: E) -> Self

Converts to this type from the input type.