0.8 changes (#10)

* use `#[track_caller]`
* removed feature `display-cause`
* remove ChainErrorFrom and IntoChainError, add From
* cleanup
This commit is contained in:
Harald Hoyer 2023-07-27 15:00:07 +02:00 committed by GitHub
commit 005d46bf4d
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
12 changed files with 125 additions and 261 deletions

View file

@ -19,7 +19,7 @@ jobs:
strategy: strategy:
matrix: matrix:
version: version:
- 1.46.0 - 1.54.0
- stable - stable
- beta - beta
- nightly - nightly
@ -70,16 +70,3 @@ jobs:
with: with:
command: clippy command: clippy
args: -- -D warnings args: -- -D warnings
readme:
name: cargo readme
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- uses: dtolnay/rust-toolchain@master
with:
toolchain: stable
profile: minimal
override: true
- run: cargo install cargo-readme
- run: cargo readme > README.md && git diff --exit-code

View file

@ -21,7 +21,3 @@ github = { repository = "haraldh/chainerror", workflow = "Rust" }
maintenance = { status = "actively-developed" } maintenance = { status = "actively-developed" }
is-it-maintained-issue-resolution = { repository = "haraldh/chainerror" } is-it-maintained-issue-resolution = { repository = "haraldh/chainerror" }
is-it-maintained-open-issues = { repository = "haraldh/chainerror" } is-it-maintained-open-issues = { repository = "haraldh/chainerror" }
[features]
default = []
display-cause = []

View file

@ -1,9 +1,6 @@
[![Crate](https://img.shields.io/crates/v/chainerror.svg)](https://crates.io/crates/chainerror) [![Crate](https://img.shields.io/crates/v/chainerror.svg)](https://crates.io/crates/chainerror)
[![Rust Documentation](https://img.shields.io/badge/api-rustdoc-blue.svg)](https://docs.rs/chainerror/) [![Rust Documentation](https://img.shields.io/badge/api-rustdoc-blue.svg)](https://docs.rs/chainerror/)
[![Coverage Status](https://coveralls.io/repos/github/haraldh/chainerror/badge.svg?branch=master)](https://coveralls.io/github/haraldh/chainerror?branch=master) [![Coverage Status](https://codecov.io/gh/haraldh/chainerror/branch/master/graph/badge.svg?token=HGLJFGA11B)](https://codecov.io/gh/haraldh/chainerror)
[![Workflow Status](https://github.com/haraldh/chainerror/workflows/Rust/badge.svg)](https://github.com/haraldh/chainerror/actions?query=workflow%3A%22Rust%22)
[![Average time to resolve an issue](https://isitmaintained.com/badge/resolution/haraldh/chainerror.svg)](https://isitmaintained.com/project/haraldh/chainerror "Average time to resolve an issue")
[![Percentage of issues still open](https://isitmaintained.com/badge/open/haraldh/chainerror.svg)](https://isitmaintained.com/project/haraldh/chainerror "Percentage of issues still open")
![Maintenance](https://img.shields.io/badge/maintenance-activly--developed-brightgreen.svg) ![Maintenance](https://img.shields.io/badge/maintenance-activly--developed-brightgreen.svg)
# chainerror # chainerror
@ -93,11 +90,6 @@ Along with the `ChainError<T>` struct, `chainerror` comes with some useful helpe
Debug information is worth it! Debug information is worth it!
### Features
`display-cause`
: turn on printing a backtrace of the errors in `Display`
## Tutorial ## Tutorial
Read the [Tutorial](https://haraldh.github.io/chainerror/tutorial1.html) Read the [Tutorial](https://haraldh.github.io/chainerror/tutorial1.html)

View file

@ -51,6 +51,10 @@ fn func1() -> ChainResult<(), Func1Error> {
fn main() { fn main() {
if let Err(e) = func1() { if let Err(e) = func1() {
eprintln!("\nDisplay Error {{}}:\n{}", e);
eprintln!("\nAlternative Display Error {{:#}}:\n{:#}", e);
eprintln!("\nDebug Error {{:?}}:\n{:?}", e); eprintln!("\nDebug Error {{:?}}:\n{:?}", e);
eprintln!("\nAlternative Debug Error {{:#?}}:\n{:#?}\n", e); eprintln!("\nAlternative Debug Error {{:#?}}:\n{:#?}\n", e);

View file

@ -1,3 +1,6 @@
#![allow(clippy::single_match)]
#![allow(clippy::redundant_pattern_matching)]
use std::error::Error; use std::error::Error;
use std::io; use std::io;
use std::result::Result; use std::result::Result;

View file

@ -1,3 +1,6 @@
#![allow(clippy::single_match)]
#![allow(clippy::redundant_pattern_matching)]
pub mod mycrate { pub mod mycrate {
use chainerror::prelude::v1::*; use chainerror::prelude::v1::*;
use std::io; use std::io;

View file

@ -1,3 +1,6 @@
#![allow(clippy::single_match)]
#![allow(clippy::redundant_pattern_matching)]
pub mod mycrate { pub mod mycrate {
use std::error::Error as StdError; use std::error::Error as StdError;

View file

@ -1,3 +1,6 @@
#![allow(clippy::single_match)]
#![allow(clippy::redundant_pattern_matching)]
pub mod mycrate { pub mod mycrate {
use chainerror::prelude::v1::*; use chainerror::prelude::v1::*;
use std::io; use std::io;

View file

@ -1,3 +1,6 @@
#![allow(clippy::single_match)]
#![allow(clippy::redundant_pattern_matching)]
use chainerror::prelude::v1::*; use chainerror::prelude::v1::*;
use std::error::Error; use std::error::Error;
use std::io; use std::io;

View file

@ -1,3 +1,6 @@
#![allow(clippy::single_match)]
#![allow(clippy::redundant_pattern_matching)]
use chainerror::prelude::v1::*; use chainerror::prelude::v1::*;
use std::error::Error; use std::error::Error;
use std::io; use std::io;

View file

@ -1,113 +1,11 @@
//! `chainerror` provides an error backtrace without doing a real backtrace, so even after you `strip` your #![doc = include_str!("../README.md")]
//! binaries, you still have the error backtrace.
//!
//! Having nested function returning errors, the output doesn't tell where the error originates from.
//!
//! ```rust
//! use std::path::PathBuf;
//!
//! type BoxedError = Box<dyn std::error::Error + Send + Sync>;
//! fn read_config_file(path: PathBuf) -> Result<(), BoxedError> {
//! // do stuff, return other errors
//! let _buf = std::fs::read_to_string(&path)?;
//! // do stuff, return other errors
//! Ok(())
//! }
//!
//! fn process_config_file() -> Result<(), BoxedError> {
//! // do stuff, return other errors
//! let _buf = read_config_file("foo.txt".into())?;
//! // do stuff, return other errors
//! Ok(())
//! }
//!
//! fn main() {
//! if let Err(e) = process_config_file() {
//! eprintln!("Error:\n{:?}", e);
//! }
//! }
//! ```
//!
//! This gives the output:
//! ```console
//! Error:
//! Os { code: 2, kind: NotFound, message: "No such file or directory" }
//! ```
//! and you have no idea where it comes from.
//!
//!
//! With `chainerror`, you can supply a context and get a nice error backtrace:
//!
//! ```rust
//! use chainerror::prelude::v1::*;
//! use std::path::PathBuf;
//!
//! type BoxedError = Box<dyn std::error::Error + Send + Sync>;
//! fn read_config_file(path: PathBuf) -> Result<(), BoxedError> {
//! // do stuff, return other errors
//! let _buf = std::fs::read_to_string(&path).context(format!("Reading file: {:?}", &path))?;
//! // do stuff, return other errors
//! Ok(())
//! }
//!
//! fn process_config_file() -> Result<(), BoxedError> {
//! // do stuff, return other errors
//! let _buf = read_config_file("foo.txt".into()).context("read the config file")?;
//! // do stuff, return other errors
//! Ok(())
//! }
//!
//! fn main() {
//! if let Err(e) = process_config_file() {
//! eprintln!("Error:\n{:?}", e);
//! # let s = format!("{:?}", e);
//! # let lines = s.lines().collect::<Vec<_>>();
//! # assert_eq!(lines.len(), 5);
//! # assert!(lines[0].starts_with("src/lib.rs:"));
//! # assert_eq!(lines[1], "Caused by:");
//! # assert!(lines[2].starts_with("src/lib.rs:"));
//! # assert_eq!(lines[3], "Caused by:");
//! # assert_eq!(lines[4], "Os { code: 2, kind: NotFound, message: \"No such file or directory\" }");
//! }
//! # else { panic!(); }
//! }
//! ```
//!
//! with the output:
//! ```console
//! Error:
//! examples/simple.rs:14:51: read the config file
//! Caused by:
//! examples/simple.rs:7:47: Reading file: "foo.txt"
//! Caused by:
//! Os { code: 2, kind: NotFound, message: "No such file or directory" }
//! ```
//!
//! `chainerror` uses `.source()` of `std::error::Error` along with `#[track_caller]` and `Location` to provide a nice debug error backtrace.
//! It encapsulates all types, which have `Display + Debug` and can store the error cause internally.
//!
//! Along with the `ChainError<T>` struct, `chainerror` comes with some useful helper macros to save a lot of typing.
//!
//! `chainerror` has no dependencies!
//!
//! Debug information is worth it!
//!
//! ## Features
//!
//! `display-cause`
//! : turn on printing a backtrace of the errors in `Display`
//!
//! # Tutorial
//!
//! Read the [Tutorial](https://haraldh.github.io/chainerror/tutorial1.html)
#![deny(clippy::all)] #![deny(clippy::all)]
#![allow(clippy::needless_doctest_main)] #![allow(clippy::needless_doctest_main)]
#![deny(missing_docs)] #![deny(missing_docs)]
use std::any::TypeId; use std::any::TypeId;
use std::error::Error; use std::error::Error as StdError;
use std::fmt::{Debug, Display, Formatter, Result}; use std::fmt::{Debug, Display, Formatter};
use std::panic::Location; use std::panic::Location;
pub mod prelude { pub mod prelude {
@ -115,28 +13,29 @@ pub mod prelude {
pub mod v1 { pub mod v1 {
//! convenience prelude //! convenience prelude
pub use super::super::ChainErrorDown as _; pub use super::super::ChainErrorDown as _;
pub use super::super::Error as ChainError;
pub use super::super::Result as ChainResult;
pub use super::super::ResultTrait as _; pub use super::super::ResultTrait as _;
pub use super::super::{ChainError, ChainResult};
pub use crate::{derive_err_kind, derive_str_context}; pub use crate::{derive_err_kind, derive_str_context};
} }
} }
/// chains an inner error kind `T` with a causing error /// chains an inner error kind `T` with a causing error
pub struct ChainError<T> { pub struct Error<T> {
occurrence: Option<String>, occurrence: Option<String>,
kind: T, kind: T,
error_cause: Option<Box<dyn Error + 'static + Send + Sync>>, error_cause: Option<Box<dyn StdError + 'static + Send + Sync>>,
} }
/// convenience type alias /// convenience type alias
pub type ChainResult<O, E> = std::result::Result<O, ChainError<E>>; pub type Result<O, E> = std::result::Result<O, Error<E>>;
impl<T: 'static + Display + Debug> ChainError<T> { impl<T: 'static + Display + Debug> Error<T> {
/// Use the `context()` or `map_context()` Result methods instead of calling this directly /// Use the `context()` or `map_context()` Result methods instead of calling this directly
#[inline] #[inline]
pub fn new( pub fn new(
kind: T, kind: T,
error_cause: Option<Box<dyn Error + 'static + Send + Sync>>, error_cause: Option<Box<dyn StdError + 'static + Send + Sync>>,
occurrence: Option<String>, occurrence: Option<String>,
) -> Self { ) -> Self {
Self { Self {
@ -147,7 +46,7 @@ impl<T: 'static + Display + Debug> ChainError<T> {
} }
/// return the root cause of the error chain, if any exists /// return the root cause of the error chain, if any exists
pub fn root_cause(&self) -> Option<&(dyn Error + 'static)> { pub fn root_cause(&self) -> Option<&(dyn StdError + 'static)> {
self.iter().last() self.iter().last()
} }
@ -195,9 +94,9 @@ impl<T: 'static + Display + Debug> ChainError<T> {
/// # } /// # }
/// ``` /// ```
#[inline] #[inline]
pub fn find_cause<U: Error + 'static>(&self) -> Option<&U> { pub fn find_cause<U: StdError + 'static>(&self) -> Option<&U> {
self.iter() self.iter()
.filter_map(<dyn Error>::downcast_ref::<U>) .filter_map(<dyn StdError>::downcast_ref::<U>)
.next() .next()
} }
@ -218,9 +117,9 @@ impl<T: 'static + Display + Debug> ChainError<T> {
/// err.find_chain_cause::<FooError>(); /// err.find_chain_cause::<FooError>();
/// ``` /// ```
#[inline] #[inline]
pub fn find_chain_cause<U: Error + 'static>(&self) -> Option<&ChainError<U>> { pub fn find_chain_cause<U: StdError + 'static>(&self) -> Option<&Error<U>> {
self.iter() self.iter()
.filter_map(<dyn Error>::downcast_ref::<ChainError<U>>) .filter_map(<dyn StdError>::downcast_ref::<Error<U>>)
.next() .next()
} }
@ -245,10 +144,10 @@ impl<T: 'static + Display + Debug> ChainError<T> {
/// err.find_kind_or_cause::<FooErrorKind>(); /// err.find_kind_or_cause::<FooErrorKind>();
/// ``` /// ```
#[inline] #[inline]
pub fn find_kind_or_cause<U: Error + 'static>(&self) -> Option<&U> { pub fn find_kind_or_cause<U: StdError + 'static>(&self) -> Option<&U> {
self.iter() self.iter()
.filter_map(|e| { .filter_map(|e| {
e.downcast_ref::<ChainError<U>>() e.downcast_ref::<Error<U>>()
.map(|e| e.kind()) .map(|e| e.kind())
.or_else(|| e.downcast_ref::<U>()) .or_else(|| e.downcast_ref::<U>())
}) })
@ -318,7 +217,7 @@ impl<T: 'static + Display + Debug> ChainError<T> {
/// ///
/// # Example /// # Example
#[inline] #[inline]
pub fn iter(&self) -> impl Iterator<Item = &(dyn Error + 'static)> { pub fn iter(&self) -> impl Iterator<Item = &(dyn StdError + 'static)> {
ErrorIter { ErrorIter {
current: Some(self), current: Some(self),
} }
@ -326,31 +225,26 @@ impl<T: 'static + Display + Debug> ChainError<T> {
} }
/// Convenience methods for `Result<>` to turn the error into a decorated ChainError /// Convenience methods for `Result<>` to turn the error into a decorated ChainError
pub trait ResultTrait<O, E: Into<Box<dyn Error + 'static + Send + Sync>>> { pub trait ResultTrait<O, E: Into<Box<dyn StdError + 'static + Send + Sync>>> {
/// Decorate the error with a `kind` of type `T` and the source `Location` /// Decorate the error with a `kind` of type `T` and the source `Location`
fn context<T: 'static + Display + Debug>( fn context<T: 'static + Display + Debug>(self, kind: T) -> std::result::Result<O, Error<T>>;
self,
kind: T,
) -> std::result::Result<O, ChainError<T>>;
/// Decorate the `error` with a `kind` of type `T` produced with a `FnOnce(&error)` and the source `Location` /// Decorate the `error` with a `kind` of type `T` produced with a `FnOnce(&error)` and the source `Location`
fn map_context<T: 'static + Display + Debug, F: FnOnce(&E) -> T>( fn map_context<T: 'static + Display + Debug, F: FnOnce(&E) -> T>(
self, self,
op: F, op: F,
) -> std::result::Result<O, ChainError<T>>; ) -> std::result::Result<O, Error<T>>;
} }
impl<O, E: Into<Box<dyn Error + 'static + Send + Sync>>> ResultTrait<O, E> impl<O, E: Into<Box<dyn StdError + 'static + Send + Sync>>> ResultTrait<O, E>
for std::result::Result<O, E> for std::result::Result<O, E>
{ {
#[track_caller] #[track_caller]
fn context<T: 'static + Display + Debug>( #[inline]
self, fn context<T: 'static + Display + Debug>(self, kind: T) -> std::result::Result<O, Error<T>> {
kind: T,
) -> std::result::Result<O, ChainError<T>> {
match self { match self {
Ok(t) => Ok(t), Ok(t) => Ok(t),
Err(error_cause) => Err(ChainError::new( Err(error_cause) => Err(Error::new(
kind, kind,
Some(error_cause.into()), Some(error_cause.into()),
Some(Location::caller().to_string()), Some(Location::caller().to_string()),
@ -359,15 +253,16 @@ impl<O, E: Into<Box<dyn Error + 'static + Send + Sync>>> ResultTrait<O, E>
} }
#[track_caller] #[track_caller]
#[inline]
fn map_context<T: 'static + Display + Debug, F: FnOnce(&E) -> T>( fn map_context<T: 'static + Display + Debug, F: FnOnce(&E) -> T>(
self, self,
op: F, op: F,
) -> std::result::Result<O, ChainError<T>> { ) -> std::result::Result<O, Error<T>> {
match self { match self {
Ok(t) => Ok(t), Ok(t) => Ok(t),
Err(error_cause) => { Err(error_cause) => {
let kind = op(&error_cause); let kind = op(&error_cause);
Err(ChainError::new( Err(Error::new(
kind, kind,
Some(error_cause.into()), Some(error_cause.into()),
Some(Location::caller().to_string()), Some(Location::caller().to_string()),
@ -379,21 +274,21 @@ impl<O, E: Into<Box<dyn Error + 'static + Send + Sync>>> ResultTrait<O, E>
/// An iterator over all error causes/sources /// An iterator over all error causes/sources
pub struct ErrorIter<'a> { pub struct ErrorIter<'a> {
current: Option<&'a (dyn Error + 'static)>, current: Option<&'a (dyn StdError + 'static)>,
} }
impl<'a> Iterator for ErrorIter<'a> { impl<'a> Iterator for ErrorIter<'a> {
type Item = &'a (dyn Error + 'static); type Item = &'a (dyn StdError + 'static);
#[inline] #[inline]
fn next(&mut self) -> Option<Self::Item> { fn next(&mut self) -> Option<Self::Item> {
let current = self.current; let current = self.current;
self.current = self.current.and_then(Error::source); self.current = self.current.and_then(StdError::source);
current current
} }
} }
impl<T: 'static + Display + Debug> std::ops::Deref for ChainError<T> { impl<T: 'static + Display + Debug> std::ops::Deref for Error<T> {
type Target = T; type Target = T;
#[inline] #[inline]
@ -407,28 +302,28 @@ pub trait ChainErrorDown {
/// Test if of type `ChainError<T>` /// Test if of type `ChainError<T>`
fn is_chain<T: 'static + Display + Debug>(&self) -> bool; fn is_chain<T: 'static + Display + Debug>(&self) -> bool;
/// Downcast to a reference of `ChainError<T>` /// Downcast to a reference of `ChainError<T>`
fn downcast_chain_ref<T: 'static + Display + Debug>(&self) -> Option<&ChainError<T>>; fn downcast_chain_ref<T: 'static + Display + Debug>(&self) -> Option<&Error<T>>;
/// Downcast to a mutable reference of `ChainError<T>` /// Downcast to a mutable reference of `ChainError<T>`
fn downcast_chain_mut<T: 'static + Display + Debug>(&mut self) -> Option<&mut ChainError<T>>; fn downcast_chain_mut<T: 'static + Display + Debug>(&mut self) -> Option<&mut Error<T>>;
/// Downcast to T of `ChainError<T>` /// Downcast to T of `ChainError<T>`
fn downcast_inner_ref<T: 'static + Error>(&self) -> Option<&T>; fn downcast_inner_ref<T: 'static + StdError>(&self) -> Option<&T>;
/// Downcast to T mutable reference of `ChainError<T>` /// Downcast to T mutable reference of `ChainError<T>`
fn downcast_inner_mut<T: 'static + Error>(&mut self) -> Option<&mut T>; fn downcast_inner_mut<T: 'static + StdError>(&mut self) -> Option<&mut T>;
} }
impl<U: 'static + Display + Debug> ChainErrorDown for ChainError<U> { impl<U: 'static + Display + Debug> ChainErrorDown for Error<U> {
#[inline] #[inline]
fn is_chain<T: 'static + Display + Debug>(&self) -> bool { fn is_chain<T: 'static + Display + Debug>(&self) -> bool {
TypeId::of::<T>() == TypeId::of::<U>() TypeId::of::<T>() == TypeId::of::<U>()
} }
#[inline] #[inline]
fn downcast_chain_ref<T: 'static + Display + Debug>(&self) -> Option<&ChainError<T>> { fn downcast_chain_ref<T: 'static + Display + Debug>(&self) -> Option<&Error<T>> {
if self.is_chain::<T>() { if self.is_chain::<T>() {
#[allow(clippy::cast_ptr_alignment)] #[allow(clippy::cast_ptr_alignment)]
unsafe { unsafe {
#[allow(trivial_casts)] #[allow(trivial_casts)]
Some(*(self as *const dyn Error as *const &ChainError<T>)) Some(*(self as *const dyn StdError as *const &Error<T>))
} }
} else { } else {
None None
@ -436,24 +331,24 @@ impl<U: 'static + Display + Debug> ChainErrorDown for ChainError<U> {
} }
#[inline] #[inline]
fn downcast_chain_mut<T: 'static + Display + Debug>(&mut self) -> Option<&mut ChainError<T>> { fn downcast_chain_mut<T: 'static + Display + Debug>(&mut self) -> Option<&mut Error<T>> {
if self.is_chain::<T>() { if self.is_chain::<T>() {
#[allow(clippy::cast_ptr_alignment)] #[allow(clippy::cast_ptr_alignment)]
unsafe { unsafe {
#[allow(trivial_casts)] #[allow(trivial_casts)]
Some(&mut *(self as *mut dyn Error as *mut &mut ChainError<T>)) Some(&mut *(self as *mut dyn StdError as *mut &mut Error<T>))
} }
} else { } else {
None None
} }
} }
#[inline] #[inline]
fn downcast_inner_ref<T: 'static + Error>(&self) -> Option<&T> { fn downcast_inner_ref<T: 'static + StdError>(&self) -> Option<&T> {
if self.is_chain::<T>() { if self.is_chain::<T>() {
#[allow(clippy::cast_ptr_alignment)] #[allow(clippy::cast_ptr_alignment)]
unsafe { unsafe {
#[allow(trivial_casts)] #[allow(trivial_casts)]
Some(&(*(self as *const dyn Error as *const &ChainError<T>)).kind) Some(&(*(self as *const dyn StdError as *const &Error<T>)).kind)
} }
} else { } else {
None None
@ -461,12 +356,12 @@ impl<U: 'static + Display + Debug> ChainErrorDown for ChainError<U> {
} }
#[inline] #[inline]
fn downcast_inner_mut<T: 'static + Error>(&mut self) -> Option<&mut T> { fn downcast_inner_mut<T: 'static + StdError>(&mut self) -> Option<&mut T> {
if self.is_chain::<T>() { if self.is_chain::<T>() {
#[allow(clippy::cast_ptr_alignment)] #[allow(clippy::cast_ptr_alignment)]
unsafe { unsafe {
#[allow(trivial_casts)] #[allow(trivial_casts)]
Some(&mut (*(self as *mut dyn Error as *mut &mut ChainError<T>)).kind) Some(&mut (*(self as *mut dyn StdError as *mut &mut Error<T>)).kind)
} }
} else { } else {
None None
@ -474,142 +369,141 @@ impl<U: 'static + Display + Debug> ChainErrorDown for ChainError<U> {
} }
} }
impl ChainErrorDown for dyn Error + 'static { impl ChainErrorDown for dyn StdError + 'static {
#[inline] #[inline]
fn is_chain<T: 'static + Display + Debug>(&self) -> bool { fn is_chain<T: 'static + Display + Debug>(&self) -> bool {
self.is::<ChainError<T>>() self.is::<Error<T>>()
} }
#[inline] #[inline]
fn downcast_chain_ref<T: 'static + Display + Debug>(&self) -> Option<&ChainError<T>> { fn downcast_chain_ref<T: 'static + Display + Debug>(&self) -> Option<&Error<T>> {
self.downcast_ref::<ChainError<T>>() self.downcast_ref::<Error<T>>()
} }
#[inline] #[inline]
fn downcast_chain_mut<T: 'static + Display + Debug>(&mut self) -> Option<&mut ChainError<T>> { fn downcast_chain_mut<T: 'static + Display + Debug>(&mut self) -> Option<&mut Error<T>> {
self.downcast_mut::<ChainError<T>>() self.downcast_mut::<Error<T>>()
} }
#[inline] #[inline]
fn downcast_inner_ref<T: 'static + Error>(&self) -> Option<&T> { fn downcast_inner_ref<T: 'static + StdError>(&self) -> Option<&T> {
self.downcast_ref::<T>() self.downcast_ref::<T>()
.or_else(|| self.downcast_ref::<ChainError<T>>().map(|e| e.kind())) .or_else(|| self.downcast_ref::<Error<T>>().map(|e| e.kind()))
} }
#[inline] #[inline]
fn downcast_inner_mut<T: 'static + Error>(&mut self) -> Option<&mut T> { fn downcast_inner_mut<T: 'static + StdError>(&mut self) -> Option<&mut T> {
if self.is::<T>() { if self.is::<T>() {
return self.downcast_mut::<T>(); return self.downcast_mut::<T>();
} }
self.downcast_mut::<ChainError<T>>() self.downcast_mut::<Error<T>>()
.and_then(|e| e.downcast_inner_mut::<T>()) .and_then(|e| e.downcast_inner_mut::<T>())
} }
} }
impl ChainErrorDown for dyn Error + 'static + Send { impl ChainErrorDown for dyn StdError + 'static + Send {
#[inline] #[inline]
fn is_chain<T: 'static + Display + Debug>(&self) -> bool { fn is_chain<T: 'static + Display + Debug>(&self) -> bool {
self.is::<ChainError<T>>() self.is::<Error<T>>()
} }
#[inline] #[inline]
fn downcast_chain_ref<T: 'static + Display + Debug>(&self) -> Option<&ChainError<T>> { fn downcast_chain_ref<T: 'static + Display + Debug>(&self) -> Option<&Error<T>> {
self.downcast_ref::<ChainError<T>>() self.downcast_ref::<Error<T>>()
} }
#[inline] #[inline]
fn downcast_chain_mut<T: 'static + Display + Debug>(&mut self) -> Option<&mut ChainError<T>> { fn downcast_chain_mut<T: 'static + Display + Debug>(&mut self) -> Option<&mut Error<T>> {
self.downcast_mut::<ChainError<T>>() self.downcast_mut::<Error<T>>()
} }
#[inline] #[inline]
fn downcast_inner_ref<T: 'static + Error>(&self) -> Option<&T> { fn downcast_inner_ref<T: 'static + StdError>(&self) -> Option<&T> {
self.downcast_ref::<T>() self.downcast_ref::<T>()
.or_else(|| self.downcast_ref::<ChainError<T>>().map(|e| e.kind())) .or_else(|| self.downcast_ref::<Error<T>>().map(|e| e.kind()))
} }
#[inline] #[inline]
fn downcast_inner_mut<T: 'static + Error>(&mut self) -> Option<&mut T> { fn downcast_inner_mut<T: 'static + StdError>(&mut self) -> Option<&mut T> {
if self.is::<T>() { if self.is::<T>() {
return self.downcast_mut::<T>(); return self.downcast_mut::<T>();
} }
self.downcast_mut::<ChainError<T>>() self.downcast_mut::<Error<T>>()
.and_then(|e| e.downcast_inner_mut::<T>()) .and_then(|e| e.downcast_inner_mut::<T>())
} }
} }
impl ChainErrorDown for dyn Error + 'static + Send + Sync { impl ChainErrorDown for dyn StdError + 'static + Send + Sync {
#[inline] #[inline]
fn is_chain<T: 'static + Display + Debug>(&self) -> bool { fn is_chain<T: 'static + Display + Debug>(&self) -> bool {
self.is::<ChainError<T>>() self.is::<Error<T>>()
} }
#[inline] #[inline]
fn downcast_chain_ref<T: 'static + Display + Debug>(&self) -> Option<&ChainError<T>> { fn downcast_chain_ref<T: 'static + Display + Debug>(&self) -> Option<&Error<T>> {
self.downcast_ref::<ChainError<T>>() self.downcast_ref::<Error<T>>()
} }
#[inline] #[inline]
fn downcast_chain_mut<T: 'static + Display + Debug>(&mut self) -> Option<&mut ChainError<T>> { fn downcast_chain_mut<T: 'static + Display + Debug>(&mut self) -> Option<&mut Error<T>> {
self.downcast_mut::<ChainError<T>>() self.downcast_mut::<Error<T>>()
} }
#[inline] #[inline]
fn downcast_inner_ref<T: 'static + Error>(&self) -> Option<&T> { fn downcast_inner_ref<T: 'static + StdError>(&self) -> Option<&T> {
self.downcast_ref::<T>() self.downcast_ref::<T>()
.or_else(|| self.downcast_ref::<ChainError<T>>().map(|e| e.kind())) .or_else(|| self.downcast_ref::<Error<T>>().map(|e| e.kind()))
} }
#[inline] #[inline]
fn downcast_inner_mut<T: 'static + Error>(&mut self) -> Option<&mut T> { fn downcast_inner_mut<T: 'static + StdError>(&mut self) -> Option<&mut T> {
if self.is::<T>() { if self.is::<T>() {
return self.downcast_mut::<T>(); return self.downcast_mut::<T>();
} }
self.downcast_mut::<ChainError<T>>() self.downcast_mut::<Error<T>>()
.and_then(|e| e.downcast_inner_mut::<T>()) .and_then(|e| e.downcast_inner_mut::<T>())
} }
} }
impl<T: 'static + Display + Debug> Error for ChainError<T> { impl<T: 'static + Display + Debug> StdError for Error<T> {
#[inline] #[inline]
fn source(&self) -> Option<&(dyn Error + 'static)> { fn source(&self) -> Option<&(dyn StdError + 'static)> {
self.error_cause self.error_cause
.as_ref() .as_ref()
.map(|e| e.as_ref() as &(dyn Error + 'static)) .map(|e| e.as_ref() as &(dyn StdError + 'static))
} }
} }
impl<T: 'static + Display + Debug> Error for &mut ChainError<T> { impl<T: 'static + Display + Debug> StdError for &mut Error<T> {
#[inline] #[inline]
fn source(&self) -> Option<&(dyn Error + 'static)> { fn source(&self) -> Option<&(dyn StdError + 'static)> {
self.error_cause self.error_cause
.as_ref() .as_ref()
.map(|e| e.as_ref() as &(dyn Error + 'static)) .map(|e| e.as_ref() as &(dyn StdError + 'static))
} }
} }
impl<T: 'static + Display + Debug> Display for ChainError<T> { impl<T: 'static + Display + Debug> Display for Error<T> {
#[inline] #[inline]
fn fmt(&self, f: &mut Formatter<'_>) -> Result { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", self.kind)?; write!(f, "{}", self.kind)?;
#[cfg(feature = "display-cause")] if f.alternate() {
{
if let Some(e) = self.source() { if let Some(e) = self.source() {
writeln!(f, "\nCaused by:")?; write!(f, "\nCaused by:\n {:#}", &e)?;
Display::fmt(&e, f)?;
} }
} }
Ok(()) Ok(())
} }
} }
impl<T: 'static + Display + Debug> Debug for ChainError<T> { impl<T: 'static + Display + Debug> Debug for Error<T> {
#[inline] #[inline]
fn fmt(&self, f: &mut Formatter<'_>) -> Result { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
if f.alternate() { if f.alternate() {
let mut f = f.debug_struct(&format!("ChainError<{}>", std::any::type_name::<T>())); let mut f = f.debug_struct(&format!("ChainError<{}>", std::any::type_name::<T>()));
@ -633,54 +527,29 @@ impl<T: 'static + Display + Debug> Debug for ChainError<T> {
} }
if let Some(e) = self.source() { if let Some(e) = self.source() {
writeln!(f, "\nCaused by:")?; write!(f, "\nCaused by:\n{:?}", &e)?;
Debug::fmt(&e, f)?;
} }
Ok(()) Ok(())
} }
} }
} }
/// `ChainErrorFrom<T>` is similar to `From<T>` impl<T> From<T> for Error<T>
pub trait ChainErrorFrom<T>: Sized {
/// similar to From<T>::from()
fn chain_error_from(from: T, line_filename: Option<String>) -> ChainError<Self>;
}
/// `IntoChainError<T>` is similar to `Into<T>`
pub trait IntoChainError<T>: Sized {
/// similar to Into<T>::into()
fn into_chain_error(self, line_filename: Option<String>) -> ChainError<T>;
}
impl<T, U> IntoChainError<U> for T
where where
U: ChainErrorFrom<T>, T: 'static + Display + Debug,
{ {
#[track_caller]
#[inline] #[inline]
fn into_chain_error(self, line_filename: Option<String>) -> ChainError<U> { fn from(e: T) -> Error<T> {
U::chain_error_from(self, line_filename) Error::new(e, None, Some(Location::caller().to_string()))
} }
} }
impl<T, U> ChainErrorFrom<T> for U
where
T: Into<U>,
U: 'static + Display + Debug,
{
#[inline]
fn chain_error_from(t: T, line_filename: Option<String>) -> ChainError<Self> {
let e: U = t.into();
ChainError::new(e, None, line_filename)
}
}
/// Convenience macro to create a "new type" T(String) and implement Display + Debug for T /// Convenience macro to create a "new type" T(String) and implement Display + Debug for T
/// ///
/// # Examples /// # Examples
/// ///
/// ```rust /// ```rust
/// # use crate::chainerror::*; /// # use chainerror::prelude::v1::*;
/// # use std::error::Error; /// # use std::error::Error;
/// # use std::io; /// # use std::io;
/// # use std::result::Result; /// # use std::result::Result;
@ -799,7 +668,7 @@ macro_rules! derive_str_context {
#[macro_export] #[macro_export]
macro_rules! derive_err_kind { macro_rules! derive_err_kind {
($e:ident, $k:ident) => { ($e:ident, $k:ident) => {
pub struct $e($crate::ChainError<$k>); pub struct $e($crate::Error<$k>);
impl $e { impl $e {
pub fn kind(&self) -> &$k { pub fn kind(&self) -> &$k {
@ -809,12 +678,12 @@ macro_rules! derive_err_kind {
impl From<$k> for $e { impl From<$k> for $e {
fn from(e: $k) -> Self { fn from(e: $k) -> Self {
$e($crate::ChainError::new(e, None, None)) $e($crate::Error::new(e, None, None))
} }
} }
impl From<ChainError<$k>> for $e { impl From<ChainError<$k>> for $e {
fn from(e: $crate::ChainError<$k>) -> Self { fn from(e: $crate::Error<$k>) -> Self {
$e(e) $e(e)
} }
} }

View file

@ -2,7 +2,6 @@ use chainerror::prelude::v1::*;
use std::error::Error; use std::error::Error;
use std::io; use std::io;
#[cfg(not(feature = "display-cause"))]
#[test] #[test]
fn test_iter() -> Result<(), Box<dyn Error + Send + Sync>> { fn test_iter() -> Result<(), Box<dyn Error + Send + Sync>> {
use std::fmt::Write; use std::fmt::Write;
@ -32,9 +31,8 @@ fn test_iter() -> Result<(), Box<dyn Error + Send + Sync>> {
Ok(()) Ok(())
} }
#[cfg(feature = "display-cause")]
#[test] #[test]
fn test_iter() -> Result<(), Box<dyn Error + Send + Sync>> { fn test_iter_alternate() -> Result<(), Box<dyn Error + Send + Sync>> {
let err: Result<(), _> = Err(io::Error::from(io::ErrorKind::NotFound)); let err: Result<(), _> = Err(io::Error::from(io::ErrorKind::NotFound));
let err = err.context("1"); let err = err.context("1");
let err = err.context("2"); let err = err.context("2");
@ -44,9 +42,9 @@ fn test_iter() -> Result<(), Box<dyn Error + Send + Sync>> {
let err = err.context("6"); let err = err.context("6");
let err = err.err().unwrap(); let err = err.err().unwrap();
let res = err.to_string(); let res = format!("{:#}", err);
assert_eq!(res, "6\nCaused by:\n5\nCaused by:\n4\nCaused by:\n3\nCaused by:\n2\nCaused by:\n1\nCaused by:\nentity not found"); assert_eq!(res, format!("6\nCaused by:\n 5\nCaused by:\n 4\nCaused by:\n 3\nCaused by:\n 2\nCaused by:\n 1\nCaused by:\n {:#}", io::Error::from(io::ErrorKind::NotFound)));
let io_error: Option<&io::Error> = err let io_error: Option<&io::Error> = err
.iter() .iter()