Struct FrozenTrace 

pub struct FrozenTrace {
    pub message: String,
    pub source: Option<Box<Self>>,
}

A helper type that can be used to “freeze” a trace and then pass it on to a further error.

This is useful in case you’re dealing with errors where you don’t want to propagate the type (e.g., due to lifetimes) but do want to propagate the trace.

Example

use std::error::Error;
use std::fmt::{Display, Formatter, Result as FResult};

use error_trace::{ErrorTrace as _, FrozenTrace};

#[derive(Debug)]
struct SomeError {
    msg: String,
}
impl Display for SomeError {
    fn fmt(&self, f: &mut Formatter<'_>) -> FResult { write!(f, "{}", self.msg) }
}
impl Error for SomeError {}

#[derive(Debug)]
struct HigherError {
    msg:   String,
    child: SomeError,
}
impl Display for HigherError {
    fn fmt(&self, f: &mut Formatter<'_>) -> FResult { write!(f, "{}", self.msg) }
}
impl Error for HigherError {
    fn source(&self) -> Option<&(dyn 'static + Error)> { Some(&self.child) }
}



let err = HigherError {
    msg:   "Oh no, something went wrong!".into(),
    child: SomeError { msg: "A specific reason".into() },
};
assert_eq!(
    FrozenTrace::new(err).trace().to_string(),
    r#"Oh no, something went wrong!

Caused by:
 o A specific reason

"#
);

Fields

message: String

The error on this level.

source: Option<Box<Self>>

The error on the next level, if any.

Implementations

impl FrozenTrace

pub fn new(err: impl Error) -> Self

Builds a new FrozenTrace from the given Error.

Arguments

• err: The error to walk and to freeze the errors of by serializing the messages.

Returns

A new FrozenTrace that itself implements Error again.

Example

See FrozenTrace itself for an example of how to use it, or see ErrorTrace::freeze().

pub fn from_msg(msg: impl Into<String>) -> Self

Builds a new Trace from a single String.

Arguments

• msg: The (already serialized) message to wrap this trace around.

Returns

A new Trace that wraps the msg implementing Error.

Example

use std::error::Error as _;

use error_trace::{ErrorTrace as _, FrozenTrace};

let trace = FrozenTrace::from_msg("Hello there!");
assert_eq!(trace.trace().to_string(), "Hello there!");

pub fn from_source(msg: impl Into<String>, err: impl Error) -> Self

Builds a new Trace from a message and a source Error.

Arguments

• msg: Some toplevel to show as root cause.
• err: The first error of the trace that causes msg.

Returns

A new Trace that wraps the msg as error, with err as trace, and that implements Error.

pub fn as_error(&self) -> &(dyn Error + 'static)

Returns this Trace as an Error trait object.

Returns

A &'static dyn Error which is even static!

Trait Implementations

impl Clone for FrozenTrace

fn clone(&self) -> FrozenTrace

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FrozenTrace

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FrozenTrace

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for FrozenTrace

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

Formats the value using the given formatter.

impl Error for FrozenTrace

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

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

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

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

Provides type-based access to context intended for error reports.

impl Serialize for FrozenTrace

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.