harald/chainerror
1
0
Fork 0
mirror of https://github.com/haraldh/chainerror.git synced 2024-10-05 12:15:10 +02:00
Code Issues Packages Projects Releases Wiki Activity

0.8 changes (#10)

Browse source 
* 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
parent b2a62b2f55 cf62d1a9f9
commit 005d46bf4d
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
12 changed files with 125 additions and 261 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
.github/workflows/rust.yml vendored
View file

@ -19,7 +19,7 @@ jobs:
strategy:
matrix:
version:
- 1.46.0
- 1.54.0
- stable
- beta
- nightly
@ -70,16 +70,3 @@ jobs:
with:
command: clippy
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

4
Cargo.toml
View file

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

10
README.md
View file

@ -1,9 +1,6 @@
[![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/)
[![Coverage Status](https://coveralls.io/repos/github/haraldh/chainerror/badge.svg?branch=master)](https://coveralls.io/github/haraldh/chainerror?branch=master)
[![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")
[![Coverage Status](https://codecov.io/gh/haraldh/chainerror/branch/master/graph/badge.svg?token=HGLJFGA11B)](https://codecov.io/gh/haraldh/chainerror)
![Maintenance](https://img.shields.io/badge/maintenance-activly--developed-brightgreen.svg)
# chainerror
@ -93,11 +90,6 @@ Along with the `ChainError<T>` struct, `chainerror` comes with some useful helpe
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)

4
examples/example.rs
View file

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

3
examples/tutorial1.rs
View file

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

3
examples/tutorial13.rs
View file

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

3
examples/tutorial14.rs
View file

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

3
examples/tutorial15.rs
View file

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

3
examples/tutorial6.rs
View file

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

3
examples/tutorial7.rs
View file

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

327
src/lib.rs
View file

@ -1,113 +1,11 @@
//! `chainerror` provides an error backtrace without doing a real backtrace, so even after you `strip` your
//! 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)
#![doc = include_str!("../README.md")]
#![deny(clippy::all)]
#![allow(clippy::needless_doctest_main)]
#![deny(missing_docs)]
use std::any::TypeId;
use std::error::Error;
use std::fmt::{Debug, Display, Formatter, Result};
use std::error::Error as StdError;
use std::fmt::{Debug, Display, Formatter};
use std::panic::Location;
pub mod prelude {
@ -115,28 +13,29 @@ pub mod prelude {
pub mod v1 {
//! convenience prelude
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::{ChainError, ChainResult};
pub use crate::{derive_err_kind, derive_str_context};
}
}
/// chains an inner error kind `T` with a causing error
pub struct ChainError<T> {
pub struct Error<T> {
occurrence: Option<String>,
kind: T,
error_cause: Option<Box<dyn Error + 'static + Send + Sync>>,
error_cause: Option<Box<dyn StdError + 'static + Send + Sync>>,
}
/// 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
#[inline]
pub fn new(
kind: T,
error_cause: Option<Box<dyn Error + 'static + Send + Sync>>,
error_cause: Option<Box<dyn StdError + 'static + Send + Sync>>,
occurrence: Option<String>,
) -> Self {
Self {
@ -147,7 +46,7 @@ impl<T: 'static + Display + Debug> ChainError<T> {
}
/// 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()
}
@ -195,9 +94,9 @@ impl<T: 'static + Display + Debug> ChainError<T> {
/// # }
/// ```
#[inline]
pub fn find_cause<U: Error + 'static>(&self) -> Option<&U> {
pub fn find_cause<U: StdError + 'static>(&self) -> Option<&U> {
self.iter()
.filter_map(<dyn Error>::downcast_ref::<U>)
.filter_map(<dyn StdError>::downcast_ref::<U>)
.next()
}
@ -218,9 +117,9 @@ impl<T: 'static + Display + Debug> ChainError<T> {
/// err.find_chain_cause::<FooError>();
/// ```
#[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()
.filter_map(<dyn Error>::downcast_ref::<ChainError<U>>)
.filter_map(<dyn StdError>::downcast_ref::<Error<U>>)
.next()
}
@ -245,10 +144,10 @@ impl<T: 'static + Display + Debug> ChainError<T> {
/// err.find_kind_or_cause::<FooErrorKind>();
/// ```
#[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()
.filter_map(|e| {
e.downcast_ref::<ChainError<U>>()
e.downcast_ref::<Error<U>>()
.map(|e| e.kind())
.or_else(|| e.downcast_ref::<U>())
})
@ -318,7 +217,7 @@ impl<T: 'static + Display + Debug> ChainError<T> {
///
/// # Example
#[inline]
pub fn iter(&self) -> impl Iterator<Item = &(dyn Error + 'static)> {
pub fn iter(&self) -> impl Iterator<Item = &(dyn StdError + 'static)> {
ErrorIter {
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
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`
fn context<T: 'static + Display + Debug>(
self,
kind: T,
) -> std::result::Result<O, ChainError<T>>;
fn context<T: 'static + Display + Debug>(self, kind: T) -> std::result::Result<O, Error<T>>;
/// 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>(
self,
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>
{
#[track_caller]
fn context<T: 'static + Display + Debug>(
self,
kind: T,
) -> std::result::Result<O, ChainError<T>> {
#[inline]
fn context<T: 'static + Display + Debug>(self, kind: T) -> std::result::Result<O, Error<T>> {
match self {
Ok(t) => Ok(t),
Err(error_cause) => Err(ChainError::new(
Err(error_cause) => Err(Error::new(
kind,
Some(error_cause.into()),
Some(Location::caller().to_string()),
@ -359,15 +253,16 @@ impl<O, E: Into<Box<dyn Error + 'static + Send + Sync>>> ResultTrait<O, E>
}
#[track_caller]
#[inline]
fn map_context<T: 'static + Display + Debug, F: FnOnce(&E) -> T>(
self,
op: F,
) -> std::result::Result<O, ChainError<T>> {
) -> std::result::Result<O, Error<T>> {
match self {
Ok(t) => Ok(t),
Err(error_cause) => {
let kind = op(&error_cause);
Err(ChainError::new(
Err(Error::new(
kind,
Some(error_cause.into()),
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
pub struct ErrorIter<'a> {
current: Option<&'a (dyn Error + 'static)>,
current: Option<&'a (dyn StdError + 'static)>,
}
impl<'a> Iterator for ErrorIter<'a> {
type Item = &'a (dyn Error + 'static);
type Item = &'a (dyn StdError + 'static);
#[inline]
fn next(&mut self) -> Option<Self::Item> {
let current = self.current;
self.current = self.current.and_then(Error::source);
self.current = self.current.and_then(StdError::source);
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;
#[inline]
@ -407,28 +302,28 @@ pub trait ChainErrorDown {
/// Test if of type `ChainError<T>`
fn is_chain<T: 'static + Display + Debug>(&self) -> bool;
/// 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>`
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>`
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>`
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]
fn is_chain<T: 'static + Display + Debug>(&self) -> bool {
TypeId::of::<T>() == TypeId::of::<U>()
}
#[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>() {
#[allow(clippy::cast_ptr_alignment)]
unsafe {
#[allow(trivial_casts)]
Some(*(self as *const dyn Error as *const &ChainError<T>))
Some(*(self as *const dyn StdError as *const &Error<T>))
}
} else {
None
@ -436,24 +331,24 @@ impl<U: 'static + Display + Debug> ChainErrorDown for ChainError<U> {
}
#[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>() {
#[allow(clippy::cast_ptr_alignment)]
unsafe {
#[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 {
None
}
}
#[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>() {
#[allow(clippy::cast_ptr_alignment)]
unsafe {
#[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 {
None
@ -461,12 +356,12 @@ impl<U: 'static + Display + Debug> ChainErrorDown for ChainError<U> {
}
#[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>() {
#[allow(clippy::cast_ptr_alignment)]
unsafe {
#[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 {
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]
fn is_chain<T: 'static + Display + Debug>(&self) -> bool {
self.is::<ChainError<T>>()
self.is::<Error<T>>()
}
#[inline]
fn downcast_chain_ref<T: 'static + Display + Debug>(&self) -> Option<&ChainError<T>> {
self.downcast_ref::<ChainError<T>>()
fn downcast_chain_ref<T: 'static + Display + Debug>(&self) -> Option<&Error<T>> {
self.downcast_ref::<Error<T>>()
}
#[inline]
fn downcast_chain_mut<T: 'static + Display + Debug>(&mut self) -> Option<&mut ChainError<T>> {
self.downcast_mut::<ChainError<T>>()
fn downcast_chain_mut<T: 'static + Display + Debug>(&mut self) -> Option<&mut Error<T>> {
self.downcast_mut::<Error<T>>()
}
#[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>()
.or_else(|| self.downcast_ref::<ChainError<T>>().map(|e| e.kind()))
.or_else(|| self.downcast_ref::<Error<T>>().map(|e| e.kind()))
}
#[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>() {
return self.downcast_mut::<T>();
}
self.downcast_mut::<ChainError<T>>()
self.downcast_mut::<Error<T>>()
.and_then(|e| e.downcast_inner_mut::<T>())
}
}
impl ChainErrorDown for dyn Error + 'static + Send {
impl ChainErrorDown for dyn StdError + 'static + Send {
#[inline]
fn is_chain<T: 'static + Display + Debug>(&self) -> bool {
self.is::<ChainError<T>>()
self.is::<Error<T>>()
}
#[inline]
fn downcast_chain_ref<T: 'static + Display + Debug>(&self) -> Option<&ChainError<T>> {
self.downcast_ref::<ChainError<T>>()
fn downcast_chain_ref<T: 'static + Display + Debug>(&self) -> Option<&Error<T>> {
self.downcast_ref::<Error<T>>()
}
#[inline]
fn downcast_chain_mut<T: 'static + Display + Debug>(&mut self) -> Option<&mut ChainError<T>> {
self.downcast_mut::<ChainError<T>>()
fn downcast_chain_mut<T: 'static + Display + Debug>(&mut self) -> Option<&mut Error<T>> {
self.downcast_mut::<Error<T>>()
}
#[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>()
.or_else(|| self.downcast_ref::<ChainError<T>>().map(|e| e.kind()))
.or_else(|| self.downcast_ref::<Error<T>>().map(|e| e.kind()))
}
#[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>() {
return self.downcast_mut::<T>();
}
self.downcast_mut::<ChainError<T>>()
self.downcast_mut::<Error<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]
fn is_chain<T: 'static + Display + Debug>(&self) -> bool {
self.is::<ChainError<T>>()
self.is::<Error<T>>()
}
#[inline]
fn downcast_chain_ref<T: 'static + Display + Debug>(&self) -> Option<&ChainError<T>> {
self.downcast_ref::<ChainError<T>>()
fn downcast_chain_ref<T: 'static + Display + Debug>(&self) -> Option<&Error<T>> {
self.downcast_ref::<Error<T>>()
}
#[inline]
fn downcast_chain_mut<T: 'static + Display + Debug>(&mut self) -> Option<&mut ChainError<T>> {
self.downcast_mut::<ChainError<T>>()
fn downcast_chain_mut<T: 'static + Display + Debug>(&mut self) -> Option<&mut Error<T>> {
self.downcast_mut::<Error<T>>()
}
#[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>()
.or_else(|| self.downcast_ref::<ChainError<T>>().map(|e| e.kind()))
.or_else(|| self.downcast_ref::<Error<T>>().map(|e| e.kind()))
}
#[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>() {
return self.downcast_mut::<T>();
}
self.downcast_mut::<ChainError<T>>()
self.downcast_mut::<Error<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]
fn source(&self) -> Option<&(dyn Error + 'static)> {
fn source(&self) -> Option<&(dyn StdError + 'static)> {
self.error_cause
.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]
fn source(&self) -> Option<&(dyn Error + 'static)> {
fn source(&self) -> Option<&(dyn StdError + 'static)> {
self.error_cause
.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]
fn fmt(&self, f: &mut Formatter<'_>) -> Result {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", self.kind)?;
#[cfg(feature = "display-cause")]
{
if f.alternate() {
if let Some(e) = self.source() {
writeln!(f, "\nCaused by:")?;
Display::fmt(&e, f)?;
write!(f, "\nCaused by:\n {:#}", &e)?;
}
}
Ok(())
}
}
impl<T: 'static + Display + Debug> Debug for ChainError<T> {
impl<T: 'static + Display + Debug> Debug for Error<T> {
#[inline]
fn fmt(&self, f: &mut Formatter<'_>) -> Result {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
if f.alternate() {
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() {
writeln!(f, "\nCaused by:")?;
Debug::fmt(&e, f)?;
write!(f, "\nCaused by:\n{:?}", &e)?;
}
Ok(())
}
}
}
/// `ChainErrorFrom<T>` is similar to `From<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
impl<T> From<T> for Error<T>
where
U: ChainErrorFrom<T>,
T: 'static + Display + Debug,
{
#[track_caller]
#[inline]
fn into_chain_error(self, line_filename: Option<String>) -> ChainError<U> {
U::chain_error_from(self, line_filename)
fn from(e: T) -> Error<T> {
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
///
/// # Examples
///
/// ```rust
/// # use crate::chainerror::*;
/// # use chainerror::prelude::v1::*;
/// # use std::error::Error;
/// # use std::io;
/// # use std::result::Result;
@ -799,7 +668,7 @@ macro_rules! derive_str_context {
#[macro_export]
macro_rules! derive_err_kind {
($e:ident, $k:ident) => {
pub struct $e($crate::ChainError<$k>);
pub struct $e($crate::Error<$k>);
impl $e {
pub fn kind(&self) -> &$k {
@ -809,12 +678,12 @@ macro_rules! derive_err_kind {
impl From<$k> for $e {
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 {
fn from(e: $crate::ChainError<$k>) -> Self {
fn from(e: $crate::Error<$k>) -> Self {
$e(e)
}
}

8
tests/test_iter.rs
View file

@ -2,7 +2,6 @@ use chainerror::prelude::v1::*;
use std::error::Error;
use std::io;
#[cfg(not(feature = "display-cause"))]
#[test]
fn test_iter() -> Result<(), Box<dyn Error + Send + Sync>> {
use std::fmt::Write;
@ -32,9 +31,8 @@ fn test_iter() -> Result<(), Box<dyn Error + Send + Sync>> {
Ok(())
}
#[cfg(feature = "display-cause")]
#[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 = err.context("1");
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.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
.iter()