Trait ErrorExt 

pub trait ErrorExt: SealedErrorExt {
    // Required methods
    fn into_box_error(self) -> Box<dyn Error + Sync + Send>;
    fn into_opaque_error(self) -> OpaqueError;
    fn context<M>(self, value: M) -> Box<dyn Error + Sync + Send>
       where M: Debug + Display + Send + Sync + 'static;
    fn context_hex<M>(self, value: M) -> Box<dyn Error + Sync + Send>
       where M: Debug + Send + Sync + 'static;
    fn context_debug<M>(self, value: M) -> Box<dyn Error + Sync + Send>
       where M: Debug + Send + Sync + 'static;
    fn context_field<M>(
        self,
        key: &'static str,
        value: M,
    ) -> Box<dyn Error + Sync + Send>
       where M: Debug + Display + Send + Sync + 'static;
    fn context_str_field<M>(
        self,
        key: &'static str,
        value: M,
    ) -> Box<dyn Error + Sync + Send>
       where M: Into<String>;
    fn context_hex_field<M>(
        self,
        key: &'static str,
        value: M,
    ) -> Box<dyn Error + Sync + Send>
       where M: Debug + Send + Sync + 'static;
    fn context_debug_field<M>(
        self,
        key: &'static str,
        value: M,
    ) -> Box<dyn Error + Sync + Send>
       where M: Debug + Send + Sync + 'static;
    fn with_context<C, F>(self, cb: F) -> Box<dyn Error + Sync + Send>
       where C: Debug + Display + Send + Sync + 'static,
             F: FnOnce() -> C;
    fn with_context_hex<C, F>(self, cb: F) -> Box<dyn Error + Sync + Send>
       where C: Debug + Send + Sync + 'static,
             F: FnOnce() -> C;
    fn with_context_debug<C, F>(self, cb: F) -> Box<dyn Error + Sync + Send>
       where C: Debug + Send + Sync + 'static,
             F: FnOnce() -> C;
    fn with_context_field<C, F>(
        self,
        key: &'static str,
        cb: F,
    ) -> Box<dyn Error + Sync + Send>
       where C: Debug + Display + Send + Sync + 'static,
             F: FnOnce() -> C;
    fn with_context_str_field<C, F>(
        self,
        key: &'static str,
        cb: F,
    ) -> Box<dyn Error + Sync + Send>
       where C: Into<String>,
             F: FnOnce() -> C;
    fn with_context_hex_field<C, F>(
        self,
        key: &'static str,
        cb: F,
    ) -> Box<dyn Error + Sync + Send>
       where C: Debug + Send + Sync + 'static,
             F: FnOnce() -> C;
    fn with_context_debug_field<C, F>(
        self,
        key: &'static str,
        cb: F,
    ) -> Box<dyn Error + Sync + Send>
       where C: Debug + Send + Sync + 'static,
             F: FnOnce() -> C;
}

Extends the Error type with methods for working with errors.

See the module level documentation for more information.

Required Methods

fn into_box_error(self) -> Box<dyn Error + Sync + Send>

Return self as BoxError without additional context.

fn into_opaque_error(self) -> OpaqueError

Return self as OpaqueError without additional context.

Pretty much always you’ll want Self::into_box_error instead, but OpaqueError can be useful as a last-resort, should you run into higher-rank lifetime issues while spawning (tokio) tasks…

fn context<M>(self, value: M) -> Box<dyn Error + Sync + Send>

where M: Debug + Display + Send + Sync + 'static,

Wrap the error in a context.

fn context_hex<M>(self, value: M) -> Box<dyn Error + Sync + Send>

where M: Debug + Send + Sync + 'static,

Wrap the error in a context, using fmt::LowerHex as fmt::Debug and [fmt::Display].

fn context_debug<M>(self, value: M) -> Box<dyn Error + Sync + Send>

where M: Debug + Send + Sync + 'static,

Wrap the error in a context, using fmt::Debug as [fmt::Display].

fn context_field<M>( self, key: &'static str, value: M, ) -> Box<dyn Error + Sync + Send>

where M: Debug + Display + Send + Sync + 'static,

Wrap the error in a keyed context.

fn context_str_field<M>( self, key: &'static str, value: M, ) -> Box<dyn Error + Sync + Send>

where M: Into<String>,

Same as Self::context_field but using a string-like value, this is useful in case you need to pass a string slice which is borrowed and thus cannot be passed as part of ’static error.

fn context_hex_field<M>( self, key: &'static str, value: M, ) -> Box<dyn Error + Sync + Send>

where M: Debug + Send + Sync + 'static,

Wrap the error in a keyed context, using fmt::LowerHex as fmt::Debug and [fmt::Display].

fn context_debug_field<M>( self, key: &'static str, value: M, ) -> Box<dyn Error + Sync + Send>

where M: Debug + Send + Sync + 'static,

Wrap the error in a keyed context, using fmt::Debug as [fmt::Display].

fn with_context<C, F>(self, cb: F) -> Box<dyn Error + Sync + Send>

where C: Debug + Display + Send + Sync + 'static, F: FnOnce() -> C,

Lazily wrap the error with a context.

fn with_context_hex<C, F>(self, cb: F) -> Box<dyn Error + Sync + Send>

where C: Debug + Send + Sync + 'static, F: FnOnce() -> C,

Lazily wrap the error with a context, using fmt::LowerHex as fmt::Debug and [fmt::Display].

fn with_context_debug<C, F>(self, cb: F) -> Box<dyn Error + Sync + Send>

where C: Debug + Send + Sync + 'static, F: FnOnce() -> C,

Lazily wrap the error with a context, using fmt::Debug as [fmt::Display].

fn with_context_field<C, F>( self, key: &'static str, cb: F, ) -> Box<dyn Error + Sync + Send>

where C: Debug + Display + Send + Sync + 'static, F: FnOnce() -> C,

Lazily wrap the error with keyed context.

fn with_context_str_field<C, F>( self, key: &'static str, cb: F, ) -> Box<dyn Error + Sync + Send>

where C: Into<String>, F: FnOnce() -> C,

Same as Self::with_context_field but using a string-like value, this is useful in case you need to pass a string slice which is borrowed and thus cannot be passed as part of ’static error.

fn with_context_hex_field<C, F>( self, key: &'static str, cb: F, ) -> Box<dyn Error + Sync + Send>

where C: Debug + Send + Sync + 'static, F: FnOnce() -> C,

Lazily wrap the error with keyed context using fmt::LowerHex as fmt::Debug and [fmt::Display].

fn with_context_debug_field<C, F>( self, key: &'static str, cb: F, ) -> Box<dyn Error + Sync + Send>

where C: Debug + Send + Sync + 'static, F: FnOnce() -> C,

Lazily wrap the error with keyed context using fmt::Debug as [fmt::Display].

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<Error> ErrorExt for Error

where Error: Into<Box<dyn Error + Sync + Send>>,