Struct biodivine_sketchbook::app::AeonError

pub struct AeonError {
    description: String,
    source: Option<DynError>,
}

AeonError is an implementation of Error which is intended as a general “runtime error” in the AEON application.

Fields

description: String

source: Option<DynError>

Implementations

impl AeonError

pub fn new( description: impl Into<String>, source: Option<DynError>, ) -> AeonError

Create a new instance of AeonError with the provided description and an optional source DynError.

Refer to Error regarding recommended error description format.

let error = AeonError::new("something failed", None);
let other_error = AeonError::new("something else failed", Some(Box::new(error)));
assert_eq!("something else failed", format!("{}", other_error));
assert_eq!("something failed", format!("{}", other_error.source().unwrap()));

pub fn dyn_new(description: impl Into<String>) -> DynError

The same as Self::new, but returns DynError instead.

pub fn throw<R>(description: impl Into<String>) -> Result<R, DynError>

Create a new instance of AeonError, convert it to DynError and return it as the specified Result type.

This function is useful when you want to return an error from a function which returns some Result<R, DynError>, because you don’t need to convert the error into the expected result type.

See also AeonError::throw_with_source.

fn division(numerator: i32, denominator: i32) -> Result<i32, DynError> {
    if denominator == 0 {
        AeonError::throw("division by zero")
    } else {
        Ok(numerator / denominator)
    }
}

assert_eq!(5, division(10, 2).unwrap());
assert_eq!("division by zero", format!("{}", division(10, 0).unwrap_err()));

pub fn throw_with_source<R>( description: impl Into<String>, source: impl Into<DynError>, ) -> Result<R, DynError>

The same as AeonError::throw, but also includes a generic error source.

Note that compared to AeonError::new, source can be any Into<DynError> type, which means you can avoid conversions when they can be performed automatically (see the example below).

fn read_number(num: &str) -> Result<i32, DynError> {
    match num.parse::<i32>() {
        Ok(num) => Ok(num),
        Err(e) => AeonError::throw_with_source("invalid number", e),
    }
}

assert_eq!(5, read_number("5").unwrap());
assert_eq!("invalid number", format!("{}", read_number("abc").unwrap_err()));

Trait Implementations

impl Debug for AeonError

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

Formats the value using the given formatter.

impl Display for AeonError

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

Formats the value using the given formatter.

impl Error for AeonError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.