Struct DisplayErrorChain

pub struct DisplayErrorChain<E>(/* private fields */);

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

Other standard traits (like Debug, Clone and some others) are automatically derived for the convenience using the standard derive macros. If you need another trait, feel free to submit a PR and/or use the DisplayErrorChain::into_inner method to access the wrapped error.

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: Clone> Clone for DisplayErrorChain<E>

fn clone(&self) -> DisplayErrorChain<E>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<E: Debug> Debug for DisplayErrorChain<E>

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

Formats the value using the given formatter.

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.

impl<E: Hash> Hash for DisplayErrorChain<E>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<E: Ord> Ord for DisplayErrorChain<E>

fn cmp(&self, other: &DisplayErrorChain<E>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<E: PartialEq> PartialEq for DisplayErrorChain<E>

fn eq(&self, other: &DisplayErrorChain<E>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<E: PartialOrd> PartialOrd for DisplayErrorChain<E>

fn partial_cmp(&self, other: &DisplayErrorChain<E>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<E: Copy> Copy for DisplayErrorChain<E>

impl<E: Eq> Eq for DisplayErrorChain<E>

impl<E> StructuralPartialEq for DisplayErrorChain<E>