1.0.0[−][src]Trait loa::Error

pub trait Error: Debug + Display {
    fn source(&self) -> Option<&(dyn Error + 'static)> { ... }
    fn backtrace(&self) -> Option<&Backtrace> { ... }
    fn description(&self) -> &str { ... }
    fn cause(&self) -> Option<&dyn Error> { ... }
}

Error is a trait representing the basic expectations for error values, i.e., values of type E in Result<T, E>. Errors must describe themselves through the Display and Debug traits, and may provide cause chain information:

The source method is generally used when errors cross "abstraction boundaries". If one module must report an error that is caused by an error from a lower-level module, it can allow access to that error via the source method. This makes it possible for the high-level module to provide its own errors while also revealing some of the implementation for debugging via source chains.

Provided methods

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

The lower-level source of this error, if any.

Examples

use std::error::Error;
use std::fmt;

#[derive(Debug)]
struct SuperError {
    side: SuperErrorSideKick,
}

impl fmt::Display for SuperError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "SuperError is here!")
    }
}

impl Error for SuperError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        Some(&self.side)
    }
}

#[derive(Debug)]
struct SuperErrorSideKick;

impl fmt::Display for SuperErrorSideKick {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "SuperErrorSideKick is here!")
    }
}

impl Error for SuperErrorSideKick {}

fn get_super_error() -> Result<(), SuperError> {
    Err(SuperError { side: SuperErrorSideKick })
}

fn main() {
    match get_super_error() {
        Err(e) => {
            println!("Error: {}", e.description());
            println!("Caused by: {}", e.source().unwrap());
        }
        _ => println!("No error"),
    }
}

`fn backtrace(&self) -> Option<&Backtrace>`

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

Returns a stack backtrace, if available, of where this error occurred.

This function allows inspecting the location, in code, of where an error happened. The returned Backtrace contains information about the stack trace of the OS thread of execution of where the error originated from.

Note that not all errors contain a Backtrace. Also note that a Backtrace may actually be empty. For more information consult the Backtrace type itself.

`fn description(&self) -> &str`

Deprecated since 1.42.0:

use the Display impl or to_string()

if let Err(e) = "xc".parse::<u32>() {
    // Print `e` itself, no need for description().
    eprintln!("Error: {}", e);
}

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

Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

Loading content...

Methods

`impl dyn Error + 'static`[src]

`pub fn is<T>(&self) -> bool where T: 'static + Error,` 1.3.0[src]

Returns true if the boxed type is the same as T

`pub fn downcast_ref<T>(&self) -> Option<&T> where T: 'static + Error,` 1.3.0[src]

Returns some reference to the boxed value if it is of type T, or None if it isn't.