1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141
#![deny(warnings)]
#![deny(missing_docs)]
#![deny(unsafe_code)]
#![allow(clippy::collapsible_else_if)]
//! OneErr to rule them all.
//!
//! There are some great error helper crates out there.
//! My favorites are [thiserror](https://crates.io/crates/thiserror) and
//! [anyhow](https://crates.io/crates/anyhow).
//!
//! But sometimes you just need something different. The `thiserror` crate can
//! over time lead to giant trees of nested error enums, while `anyhow` is
//! difficult to match on.
//!
//! Sometimes you need to interoperate with std::io::Error, but that type is
//! awkward to construct, not `Clone`, and cannot be serialized.
//!
//! `OneErr` is a newtype over std::io::Error, but makes it clonable,
//! serializable, and hopefully more ergonomic.
//!
//! ### std::io::ErrorKind Matching
//!
//! ```rust
//! use one_err::*;
//!
//! for res in [
//! Ok("not-error"),
//! Err(OneErr::from(std::io::ErrorKind::InvalidInput)),
//! Err(OneErr::from(std::io::ErrorKind::ConnectionRefused)),
//! ] {
//! match res.map_err(|e| e.kind()) {
//! Ok(ok) => assert_eq!("not-error", ok),
//! Err(std::io::ErrorKind::InvalidInput) => (),
//! Err(std::io::ErrorKind::ConnectionRefused) => (),
//! oth => panic!("unexpected: {:?}", oth),
//! }
//! }
//! ```
//!
//! ### ErrNo Matching
//!
//! ```rust
//! use one_err::*;
//!
//! for res in [
//! Ok("not-error"),
//! Err(OneErr::from(ErrNo::NoData)),
//! Err(OneErr::from(ErrNo::Proto)),
//! ] {
//! match res.map_err(|e| e.errno()) {
//! Ok(ok) => assert_eq!("not-error", ok),
//! Err(ErrNo::NoData) => (),
//! Err(ErrNo::Proto) => (),
//! oth => panic!("unexpected: {:?}", oth),
//! }
//! }
//! ```
//!
//! ### Custom Matching
//!
//! ```rust
//! use one_err::*;
//!
//! const ERR_FOO: &str = "FOO";
//! const ERR_BAR: &str = "BAR";
//!
//! for res in [
//! Ok("not-error"),
//! Err(OneErr::with_message(ERR_FOO, "foo test")),
//! Err(OneErr::with_message(ERR_BAR, "bar test")),
//! ] {
//! match res.as_ref().map_err(|e| (e.str_kind(), e)) {
//! Ok(ok) => assert_eq!("not-error", *ok),
//! Err((ERR_FOO, e)) => assert_eq!("foo test", e.get_message().unwrap()),
//! Err((ERR_BAR, e)) => assert_eq!("bar test", e.get_message().unwrap()),
//! oth => panic!("unexpected: {:?}", oth),
//! }
//! }
//! ```
//!
//! ### std::io Interoperability
//!
//! ```rust
//! use one_err::*;
//! use std::io::Read;
//!
//! const CUSTOM_ERR: &str = "CustomError";
//!
//! /// My custom Read that always errors.
//! pub struct ErrReader;
//!
//! impl Read for ErrReader {
//! fn read(&mut self, _buf: &mut [u8]) -> std::io::Result<usize> {
//! Err(OneErr::new(CUSTOM_ERR).into())
//! }
//! }
//!
//! assert_eq!(
//! r#"{"error":"CustomError"}"#,
//! &ErrReader.read(&mut []).unwrap_err().to_string(),
//! );
//! ```
//!
//! ### Serialization and Parsing
//!
//! ```rust
//! use one_err::*;
//!
//! const CUSTOM_ERR: &str = "CustomError";
//!
//! let err = OneErr::new(CUSTOM_ERR);
//! let enc = err.to_string();
//!
//! assert_eq!(
//! r#"{"error":"CustomError"}"#,
//! &enc,
//! );
//!
//! let dec: OneErr = enc.parse().unwrap();
//! assert_eq!(err, dec);
//! ```
mod errno_;
pub use errno_::*;
pub mod io_error;
mod value;
pub use value::*;
mod inner;
use inner::*;
mod util;
use util::*;
mod one_err;
pub use crate::one_err::*;
#[cfg(test)]
mod test;