Struct qsu::AppErr

pub struct AppErr(/* private fields */);

An error type used to pass an application-specific error through a library runtime.

Application callbacks can return this type for the Err() case in order to allow application-defined errors to be passed back to the application through a library runtime.

Implementations

impl AppErr

pub fn new<E>(e: E) -> AppErr

where E: Blessed + Send + 'static,

Create a new application callback error object that can be converted back into to its original type (as long as it is Any compatible).

use std::fmt;
use apperr::{AppErr, Blessed};

#[derive(Debug)]
enum MyErr {
  Something(String)
}
impl fmt::Display for MyErr {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    match self {
      MyErr::Something(s) => {
        write!(f, "Some error; {}", s)
      }
    }
  }
}
impl std::error::Error for MyErr { }
impl Blessed for MyErr { }

let apperr = AppErr::new(MyErr::Something("hello".into()));

pub fn is<T>(&self) -> bool

where T: Any,

Inspect error type wrapped by the AppErr.

use std::fmt;
use apperr::{AppErr, Blessed};

#[derive(Debug)]
enum MyErr {
  Something(String)
}
impl fmt::Display for MyErr {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    match self {
      MyErr::Something(s) => {
        write!(f, "Some error; {}", s)
      }
    }
  }
}
impl std::error::Error for MyErr { }
impl Blessed for MyErr { }

let apperr = AppErr::new(MyErr::Something("hello".into()));

assert!(apperr.is::<MyErr>());
assert_eq!(apperr.is::<String>(), false);

pub fn try_into_inner<E>(self) -> Result<E, AppErr>

where E: 'static,

Attempt to unpack and cast the inner error type.

If it can’t be downcast to E, the AppErr will be returned back to the caller in the Err() case.

use std::fmt;
use apperr::{AppErr, Blessed};

#[derive(Debug)]
enum MyErr {
  Something(String)
}
impl fmt::Display for MyErr {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    match self {
      MyErr::Something(s) => {
        write!(f, "Some error; {}", s)
      }
    }
  }
}
impl std::error::Error for MyErr { }
impl Blessed for MyErr { }

let apperr = AppErr::new(MyErr::Something("hello".into()));

let Ok(e) = apperr.try_into_inner::<MyErr>() else {
  panic!("Unexpectedly not MyErr");
};

pub fn unwrap_inner<E>(self) -> E

where E: 'static,

Unwrap application-specific error.

use std::fmt;
use apperr::{AppErr, Blessed};

#[derive(Debug)]
enum MyErr {
  Something(String)
}
impl fmt::Display for MyErr {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    match self {
      MyErr::Something(s) => {
        write!(f, "Some error; {}", s)
      }
    }
  }
}
impl std::error::Error for MyErr { }
impl Blessed for MyErr { }

let apperr = AppErr::new(MyErr::Something("hello".into()));

let MyErr::Something(e) = apperr.unwrap_inner::<MyErr>() else {
  panic!("Unexpectedly not MyErr::Something");
};
assert_eq!(e, "hello");

Panic

Panics if the inner type is not castable to E.

Trait Implementations

impl Debug for AppErr

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl From<AppErr> for Error

fn from(err: AppErr) -> Self

Wrap an AppErr in an Error.