pub struct Error<Kind> { /* private fields */ }
Expand description
The generic error type for the Astral engine.
Error
can be created with crafted error messages and a particular value of
Kind
and optionally with a arbitrary error payload.
It is useful but not necessary, that Kind
implements Debug
and
Display
so std::error::Error
is implemented.
Example
use std::fmt::{self, Debug, Display, Formatter};
use std::error::Error as StdError;
use astral::error::Error;
#[derive(Debug, PartialEq)]
enum MyErrorKind {
Variant,
}
impl Display for MyErrorKind {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
Debug::fmt(self, f)
}
}
let my_error = Error::new(MyErrorKind::Variant, "oh no!");
let my_error2 = Error::new(MyErrorKind::Variant, my_error);
assert_eq!(*my_error2.kind(), MyErrorKind::Variant);
assert!(my_error2.source().is_none());
Implementations
sourceimpl<Kind> Error<Kind>
impl<Kind> Error<Kind>
sourcepub fn new<E>(kind: Kind, error: E) -> Error<Kind>where
E: Into<Box<dyn Error + Send + Sync + 'static, Global>>,
pub fn new<E>(kind: Kind, error: E) -> Error<Kind>where
E: Into<Box<dyn Error + Send + Sync + 'static, Global>>,
Creates a new error from a known kind of error as well as an arbitrary
error payload. The error
argument is an arbitrary payload which will
be contained in this Error
. The resulting error don’t have a source
error returned by Error::source
.
Example
use std::error::Error as StdError;
use astral::error::Error;
let my_error = Error::new(MyErrorKind::Variant, "oh no!");
let my_error2 = Error::new(MyErrorKind::Variant, my_error);
assert!(my_error2.source().is_none());
sourcepub fn chained<E, S>(kind: Kind, error: E, source: S) -> Error<Kind>where
E: Into<Box<dyn Error + Send + Sync + 'static, Global>>,
S: Into<Box<dyn Error + Send + Sync + 'static, Global>>,
pub fn chained<E, S>(kind: Kind, error: E, source: S) -> Error<Kind>where
E: Into<Box<dyn Error + Send + Sync + 'static, Global>>,
S: Into<Box<dyn Error + Send + Sync + 'static, Global>>,
Creates a new error from a known kind of error as well as an arbitrary error payload and keeps another payload as source error.
The error
argument is an arbitrary payload which will be contained in
this Error
. The source
argument is an error, which will be returned
by Error::source
Example
use std::error::Error as StdError;
use astral::error::Error;
let my_error = Error::new(MyErrorKind::Variant, "oh no!");
let my_error2 = Error::chained(MyErrorKind::Variant, "failed!", my_error);
assert_eq!(my_error2.source()?.to_string(), "oh no!");
sourcepub fn get_ref(&self) -> Option<&(dyn Error + Send + Sync + 'static)>
pub fn get_ref(&self) -> Option<&(dyn Error + Send + Sync + 'static)>
Returns a reference to the inner error wrapped by this error (if any).
If this Error
was constructed via new
or chained
then this
function will return Some
, otherwise it will return None
.
Examples
use astral::error::Error;
#[derive(Debug)]
enum MyErrorKind {
Variant,
}
fn print_error<Kind>(err: &Error<Kind>) {
if let Some(inner_err) = err.get_ref() {
println!("Inner error: {:?}", inner_err);
} else {
println!("No inner error");
}
}
fn main() {
// Will print "Inner error: Variant".
print_error(&Error::new(MyErrorKind::Variant, "oh no!"));
}
sourcepub fn get_mut(&mut self) -> Option<&mut (dyn Error + Send + Sync + 'static)>
pub fn get_mut(&mut self) -> Option<&mut (dyn Error + Send + Sync + 'static)>
Returns a mutable reference to the inner error wrapped by this error (if any).
If this Error
was constructed via new
or chained
then this
function will return Some
, otherwise it will return None
.
Examples
use std::{error, fmt};
use std::fmt::Display;
use astral::error::Error;
#[derive(Debug)]
struct MyError {
v: String,
}
impl MyError {
fn new() -> MyError {
MyError {
v: "oh no!".to_string()
}
}
fn change_message(&mut self, new_message: &str) {
self.v = new_message.to_string();
}
}
impl error::Error for MyError {}
impl Display for MyError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "MyError: {}", &self.v)
}
}
fn change_error<Kind>(mut err: Error<Kind>) -> Error<Kind> {
if let Some(inner_err) = err.get_mut() {
inner_err.downcast_mut::<MyError>().unwrap().change_message("I've been changed!");
}
err
}
#[derive(Debug)]
enum MyErrorKind {
Variant,
}
fn print_error<Kind>(err: &Error<Kind>) {
if let Some(inner_err) = err.get_ref() {
println!("Inner error: {}", inner_err);
} else {
println!("No inner error");
}
}
fn main() {
// Will print "Inner error: ...".
print_error(&change_error(Error::new(MyErrorKind::Variant, MyError::new())));
}
sourcepub fn into_inner(
self
) -> Option<Box<dyn Error + Send + Sync + 'static, Global>>
pub fn into_inner(
self
) -> Option<Box<dyn Error + Send + Sync + 'static, Global>>
Consumes the Error
, returning its inner error (if any).
If this Error
was constructed via new
or chained
then this
function will return Some
, otherwise it will return None
.
Example
use astral::error::Error;
let my_error = Error::new(MyErrorKind::Variant, "oh no!");
let my_error2 = Error::new(MyErrorKind::Variant, my_error);
assert_eq!(my_error2.into_inner()?.to_string(), "oh no!");