use core::fmt::{self, Display, Debug};
use core::mem;
use core::ptr;
use Fail;
use backtrace::Backtrace;
use context::Context;
use compat::Compat;
pub struct Error {
pub(crate) inner: Box<Inner<Fail>>,
}
pub(crate) struct Inner<F: ?Sized + Fail> {
backtrace: Backtrace,
pub(crate) failure: F,
}
impl<F: Fail> From<F> for Error {
fn from(failure: F) -> Error {
let inner: Inner<F> = {
let backtrace = if failure.backtrace().is_none() {
Backtrace::new()
} else { Backtrace::none() };
Inner { failure, backtrace }
};
Error { inner: Box::new(inner) }
}
}
impl Error {
pub fn cause(&self) -> &Fail {
&self.inner.failure
}
pub fn backtrace(&self) -> &Backtrace {
self.inner.failure.backtrace().unwrap_or(&self.inner.backtrace)
}
pub fn context<D: Display + Send + Sync + 'static>(self, context: D) -> Context<D> {
Context::with_err(context, self)
}
pub fn compat(self) -> Compat<Error> {
Compat { error: self }
}
pub fn downcast<T: Fail>(self) -> Result<T, Error> {
let ret: Option<T> = self.downcast_ref().map(|fail| {
unsafe {
let _ = ptr::read(&self.inner.backtrace as *const Backtrace);
ptr::read(fail as *const T)
}
});
match ret {
Some(ret) => {
mem::forget(self);
Ok(ret)
}
_ => Err(self)
}
}
pub fn root_cause(&self) -> &Fail {
::find_root_cause(self.cause())
}
pub fn downcast_ref<T: Fail>(&self) -> Option<&T> {
self.inner.failure.downcast_ref()
}
pub fn downcast_mut<T: Fail>(&mut self) -> Option<&mut T> {
self.inner.failure.downcast_mut()
}
}
impl Display for Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
Display::fmt(&self.inner.failure, f)
}
}
impl Debug for Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
if self.inner.backtrace.is_none() {
Debug::fmt(&self.inner.failure, f)
} else {
write!(f, "{:?}\n\n{:?}", &self.inner.failure, self.inner.backtrace)
}
}
}
#[cfg(test)]
mod test {
fn assert_just_data<T: Send + Sync + 'static>() { }
#[test]
fn assert_error_is_just_data() {
assert_just_data::<super::Error>();
}
}