[−][src]Struct anyhow::Error
The Error
type, a wrapper around a dynamic error type.
Error
works a lot like Box<dyn std::error::Error>
, but with these
differences:
Error
requires that the error isSend
,Sync
, and'static
.Error
guarantees that a backtrace is available, even if the underlying error type does not provide one.Error
is represented as a narrow pointer — exactly one word in size instead of two.
Display representations
When you print an error object using "{}" or to_string(), only the outermost underlying error or context is printed, not any of the lower level causes. This is exactly as if you had called the Display impl of the error from which you constructed your anyhow::Error.
Failed to read instrs from ./path/to/instrs.json
To print causes as well using anyhow's default formatting of causes, use the alternate selector "{:#}".
Failed to read instrs from ./path/to/instrs.json: No such file or directory (os error 2)
The Debug format "{:?}" includes your backtrace if one was captured. Note
that this is the representation you get by default if you return an error
from fn main
instead of printing it explicitly yourself.
Error: Failed to read instrs from ./path/to/instrs.json
Caused by:
No such file or directory (os error 2)
Stack backtrace:
0: <E as anyhow::context::ext::StdError>::ext_context
at /git/anyhow/src/backtrace.rs:26
1: core::result::Result<T,E>::map_err
at /git/rustc/src/libcore/result.rs:596
2: anyhow::context::<impl anyhow::Context<T,E> for core::result::Result<T,E>>::with_context
at /git/anyhow/src/context.rs:58
3: testing::main
at src/main.rs:5
4: std::rt::lang_start
at /git/rustc/src/libstd/rt.rs:61
5: main
6: __libc_start_main
7: _start
To see a conventional struct-style Debug representation, use "{:#?}".
Error {
context: "Failed to read instrs from ./path/to/instrs.json",
source: Os {
code: 2,
kind: NotFound,
message: "No such file or directory",
},
}
If none of the built-in representations are appropriate and you would prefer to render the error and its cause chain yourself, it can be done something like this:
use anyhow::{Context, Result}; fn main() { if let Err(err) = try_main() { eprintln!("ERROR: {}", err); err.chain().skip(1).for_each(|cause| eprintln!("because: {}", cause)); std::process::exit(1); } } fn try_main() -> Result<()> { ... }
Methods
impl Error
[src]
pub fn new<E>(error: E) -> Self where
E: StdError + Send + Sync + 'static,
[src]
E: StdError + Send + Sync + 'static,
Create a new error object from any error type.
The error type must be threadsafe and 'static
, so that the Error
will be as well.
If the error type does not provide a backtrace, a backtrace will be created here to ensure that a backtrace exists.
pub fn msg<M>(message: M) -> Self where
M: Display + Debug + Send + Sync + 'static,
[src]
M: Display + Debug + Send + Sync + 'static,
Create a new error object from a printable error message.
If the argument implements std::error::Error, prefer Error::new
instead which preserves the underlying error's cause chain and
backtrace. If the argument may or may not implement std::error::Error
now or in the future, use anyhow!(err)
which handles either way
correctly.
Error::msg("...")
is equivalent to anyhow!("...")
but occasionally
convenient in places where a function is preferable over a macro, such
as iterator or stream combinators:
use anyhow::{Error, Result}; use futures::stream::{Stream, StreamExt, TryStreamExt}; async fn demo<S>(stream: S) -> Result<Vec<Output>> where S: Stream<Item = Input>, { stream .then(ffi::do_some_work) // returns Result<Output, &str> .map_err(Error::msg) .try_collect() .await }
pub fn context<C>(self, context: C) -> Self where
C: Display + Send + Sync + 'static,
[src]
C: Display + Send + Sync + 'static,
Wrap the error value with additional context.
For attaching context to a Result
as it is propagated, the
Context
extension trait may be more convenient than
this function.
The primary reason to use error.context(...)
instead of
result.context(...)
via the Context
trait would be if the context
needs to depend on some data held by the underlying error:
use anyhow::Result; use std::fs::File; use std::path::Path; struct ParseError { line: usize, column: usize, } fn parse_impl(file: File) -> Result<T, ParseError> { ... } pub fn parse(path: impl AsRef<Path>) -> Result<T> { let file = File::open(&path)?; parse_impl(file).map_err(|error| { let context = format!( "only the first {} lines of {} are valid", error.line, path.as_ref().display(), ); anyhow::Error::new(error).context(context) }) }
pub fn backtrace(&self) -> &Backtrace
[src]
Get the backtrace for this Error.
Backtraces are only available on the nightly channel. Tracking issue: rust-lang/rust#53487.
In order for the backtrace to be meaningful, the environment variable
RUST_LIB_BACKTRACE=1
must be defined. Backtraces are somewhat
expensive to capture in Rust, so we don't necessarily want to be
capturing them all over the place all the time.
ⓘImportant traits for Chain<'a>pub fn chain(&self) -> Chain
[src]
An iterator of the chain of source errors contained by this Error.
This iterator will visit every error in the cause chain of this error object, beginning with the error that this error object was created from.
Example
use anyhow::Error; use std::io; pub fn underlying_io_error_kind(error: &Error) -> Option<io::ErrorKind> { for cause in error.chain() { if let Some(io_error) = cause.downcast_ref::<io::Error>() { return Some(io_error.kind()); } } None }
pub fn root_cause(&self) -> &(dyn StdError + 'static)
[src]
The lowest level cause of this error — this error's cause's cause's cause etc.
The root cause is the last error in the iterator produced by
chain()
.
pub fn is<E>(&self) -> bool where
E: Display + Debug + Send + Sync + 'static,
[src]
E: Display + Debug + Send + Sync + 'static,
Returns true if E
is the type held by this error object.
For errors with context, this method returns true if E
matches the
type of the context C
or the type of the error on which the
context has been attached. For details about the interaction between
context and downcasting, see here.
pub fn downcast<E>(self) -> Result<E, Self> where
E: Display + Debug + Send + Sync + 'static,
[src]
E: Display + Debug + Send + Sync + 'static,
Attempt to downcast the error object to a concrete type.
pub fn downcast_ref<E>(&self) -> Option<&E> where
E: Display + Debug + Send + Sync + 'static,
[src]
E: Display + Debug + Send + Sync + 'static,
Downcast this error object by reference.
Example
// If the error was caused by redaction, then return a tombstone instead // of the content. match root_cause.downcast_ref::<DataStoreError>() { Some(DataStoreError::Censored(_)) => Ok(Poll::Ready(REDACTED_CONTENT)), None => Err(error), }
pub fn downcast_mut<E>(&mut self) -> Option<&mut E> where
E: Display + Debug + Send + Sync + 'static,
[src]
E: Display + Debug + Send + Sync + 'static,
Downcast this error object by mutable reference.
Methods from Deref<Target = dyn StdError + Send + Sync + 'static>
pub fn is<T>(&self) -> bool where
T: 'static + Error,
1.3.0[src]
T: 'static + Error,
Returns true
if the boxed type is the same as T
pub fn downcast_ref<T>(&self) -> Option<&T> where
T: 'static + Error,
1.3.0[src]
T: 'static + Error,
Returns some reference to the boxed value if it is of type T
, or
None
if it isn't.
pub fn downcast_mut<T>(&mut self) -> Option<&mut T> where
T: 'static + Error,
1.3.0[src]
T: 'static + Error,
Returns some mutable reference to the boxed value if it is of type T
, or
None
if it isn't.
pub fn is<T>(&self) -> bool where
T: 'static + Error,
1.3.0[src]
T: 'static + Error,
Forwards to the method defined on the type dyn Error
.
pub fn downcast_ref<T>(&self) -> Option<&T> where
T: 'static + Error,
1.3.0[src]
T: 'static + Error,
Forwards to the method defined on the type dyn Error
.
pub fn downcast_mut<T>(&mut self) -> Option<&mut T> where
T: 'static + Error,
1.3.0[src]
T: 'static + Error,
Forwards to the method defined on the type dyn Error
.
pub fn is<T>(&self) -> bool where
T: 'static + Error,
1.3.0[src]
T: 'static + Error,
Forwards to the method defined on the type dyn Error
.
pub fn downcast_ref<T>(&self) -> Option<&T> where
T: 'static + Error,
1.3.0[src]
T: 'static + Error,
Forwards to the method defined on the type dyn Error
.
pub fn downcast_mut<T>(&mut self) -> Option<&mut T> where
T: 'static + Error,
1.3.0[src]
T: 'static + Error,
Forwards to the method defined on the type dyn Error
.
pub fn chain(&self) -> Chain
[src]
error_iter
)Returns an iterator starting with the current error and continuing with
recursively calling source
.
If you want to omit the current error and only use its sources,
use skip(1)
.
Examples
#![feature(error_iter)] use std::error::Error; use std::fmt; #[derive(Debug)] struct A; #[derive(Debug)] struct B(Option<Box<dyn Error + 'static>>); impl fmt::Display for A { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "A") } } impl fmt::Display for B { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "B") } } impl Error for A {} impl Error for B { fn source(&self) -> Option<&(dyn Error + 'static)> { self.0.as_ref().map(|e| e.as_ref()) } } let b = B(Some(Box::new(A))); // let err : Box<Error> = b.into(); // or let err = &b as &(dyn Error); let mut iter = err.chain(); assert_eq!("B".to_string(), iter.next().unwrap().to_string()); assert_eq!("A".to_string(), iter.next().unwrap().to_string()); assert!(iter.next().is_none()); assert!(iter.next().is_none());
Trait Implementations
impl AsRef<dyn Error + 'static + Send + Sync> for Error
[src]
impl AsRef<dyn Error + 'static> for Error
[src]
impl Debug for Error
[src]
impl Deref for Error
[src]
type Target = dyn StdError + Send + Sync + 'static
The resulting type after dereferencing.
fn deref(&self) -> &Self::Target
[src]
impl DerefMut for Error
[src]
impl Display for Error
[src]
impl Drop for Error
[src]
impl<E> From<E> for Error where
E: StdError + Send + Sync + 'static,
[src]
E: StdError + Send + Sync + 'static,
impl From<Error> for Box<dyn StdError + Send + Sync + 'static>
[src]
impl From<Error> for Box<dyn StdError + 'static>
[src]
Auto Trait Implementations
impl RefUnwindSafe for Error
impl Send for Error
impl Sync for Error
impl Unpin for Error
impl UnwindSafe for Error
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<!> for T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToString for T where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,