Struct failure_without_backtrace::SyncFailure

pub struct SyncFailure<T> { /* fields omitted */ }

Wrapper for std errors to make them Sync.

This exists to coerce existing types that are only Error + Send + 'static into a Fail-compatible representation, most notably for types generated by error-chain.

Unfortunately, this requires wrapping the error in a Mutex, which must be locked for every Debug/Display. Therefore, this should be something of a last resort in making the error work with failure.

Methods

impl<E: Error + Send + 'static> SyncFailure<E>

pub fn new(err: E) -> Self

Wraps a non-Sync Error in order to make it implement Fail.

Example

extern crate failure;

use failure::{Error, SyncFailure};
use std::cell::RefCell;

#[derive(Debug)]
struct NonSyncError {
    // RefCells are non-Sync, so structs containing them will be
    // non-Sync as well.
    count: RefCell<usize>,
}

// implement Display/Error for NonSyncError...

fn returns_error() -> Result<(), NonSyncError> {
    // Do stuff
}

fn my_function() -> Result<(), Error> {
    // without the map_err here, we end up with a compile error
    // complaining that NonSyncError doesn't implement Sync.
    returns_error().map_err(SyncFailure::new)?;
    // Do more stuff
}

Trait Implementations

impl<T> Display for SyncFailure<T> where     T: Display,

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

Formats the value using the given formatter.

impl<T> Debug for SyncFailure<T> where     T: Debug,

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

Formats the value using the given formatter.

impl<E: Error + Send + 'static> Fail for SyncFailure<E>

fn cause(&self) -> Option<&Fail>

Returns a reference to the underlying cause of this failure, if it is an error that wraps other errors.

fn backtrace(&self) -> Option<&Backtrace>

Returns a reference to the Backtrace carried by this failure, if it carries one.

fn context<D>(self, context: D) -> Context<D> where     D: Display + Send + Sync + 'static,     Self: Sized,

Provides context for this failure.

fn compat(self) -> Compat<Self> where     Self: Sized,

Wraps this failure in a compatibility wrapper that implements std::error::Error.