Trait core2::error::Error

pub trait Error: Debug + Display {
    // Provided method
    fn source(&self) -> Option<&(dyn Error + 'static)> { ... }
}

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:

Error::source() 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 accessing that error via Error::source(). 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)>

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);
            println!("Caused by: {}", e.source().unwrap());
        }
        _ => println!("No error"),
    }
}

Implementations

impl dyn Error + 'static

pub fn is<T: Error + 'static>(&self) -> bool

Returns true if the boxed type is the same as T

pub fn downcast_ref<T: Error + 'static>(&self) -> Option<&T>

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

pub fn downcast_mut<T: Error + 'static>(&mut self) -> Option<&mut T>

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

impl dyn Error + Send + 'static

pub fn is<T: Error + 'static>(&self) -> bool

Forwards to the method defined on the type dyn Error.

pub fn downcast_ref<T: Error + 'static>(&self) -> Option<&T>

Forwards to the method defined on the type dyn Error.

pub fn downcast_mut<T: Error + 'static>(&mut self) -> Option<&mut T>

Forwards to the method defined on the type dyn Error.

impl dyn Error + Send + Sync + 'static

pub fn is<T: Error + 'static>(&self) -> bool

Forwards to the method defined on the type dyn Error.

pub fn downcast_ref<T: Error + 'static>(&self) -> Option<&T>

Forwards to the method defined on the type dyn Error.

pub fn downcast_mut<T: Error + 'static>(&mut self) -> Option<&mut T>

Forwards to the method defined on the type dyn Error.

impl dyn Error

pub fn downcast<T: Error + 'static>( self: Box<Self> ) -> Result<Box<T>, Box<dyn Error>>

Attempts to downcast the box to a concrete type.

impl dyn Error + Send

pub fn downcast<T: Error + 'static>( self: Box<Self> ) -> Result<Box<T>, Box<dyn Error + Send>>

Attempts to downcast the box to a concrete type.

impl dyn Error + Send + Sync

pub fn downcast<T: Error + 'static>( self: Box<Self> ) -> Result<Box<T>, Box<Self>>

Attempts to downcast the box to a concrete type.

Trait Implementations

impl From<&str> for Box<dyn Error>

fn from(err: &str) -> Box<dyn Error>

Converts a str into a box of dyn Error.

Examples

use std::error::Error;
use std::mem;

let a_str_error = "a str error";
let a_boxed_error = Box::<dyn Error>::from(a_str_error);
assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))

impl<'a> From<&str> for Box<dyn Error + Send + Sync + 'a>

fn from(err: &str) -> Box<dyn Error + Send + Sync + 'a>

Converts a str into a box of dyn Error + Send + Sync.

Examples

use std::error::Error;
use std::mem;

let a_str_error = "a str error";
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_str_error);
assert!(
    mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))

impl<'a> From<Cow<'a, str>> for Box<dyn Error>

fn from(err: Cow<'a, str>) -> Box<dyn Error>

Converts a Cow into a box of dyn Error.

Examples

use std::error::Error;
use std::mem;
use std::borrow::Cow;

let a_cow_str_error = Cow::from("a str error");
let a_boxed_error = Box::<dyn Error>::from(a_cow_str_error);
assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))

impl<'a, 'b> From<Cow<'b, str>> for Box<dyn Error + Send + Sync + 'a>

fn from(err: Cow<'b, str>) -> Box<dyn Error + Send + Sync + 'a>

Converts a Cow into a box of dyn Error + Send + Sync.

Examples

use std::error::Error;
use std::mem;
use std::borrow::Cow;

let a_cow_str_error = Cow::from("a str error");
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_cow_str_error);
assert!(
    mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))

impl<'a, E: Error + 'a> From<E> for Box<dyn Error + 'a>

fn from(err: E) -> Box<dyn Error + 'a>

Converts a type of Error into a box of dyn Error.

Examples

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

#[derive(Debug)]
struct AnError;

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

impl Error for AnError {}

let an_error = AnError;
assert!(0 == mem::size_of_val(&an_error));
let a_boxed_error = Box::<dyn Error>::from(an_error);
assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))

impl<'a, E: Error + Send + Sync + 'a> From<E> for Box<dyn Error + Send + Sync + 'a>

fn from(err: E) -> Box<dyn Error + Send + Sync + 'a>

Converts a type of Error + Send + Sync into a box of dyn Error + Send + Sync.

Examples

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

#[derive(Debug)]
struct AnError;

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

impl Error for AnError {}

unsafe impl Send for AnError {}

unsafe impl Sync for AnError {}

let an_error = AnError;
assert!(0 == mem::size_of_val(&an_error));
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(an_error);
assert!(
    mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))

impl From<String> for Box<dyn Error>

fn from(str_err: String) -> Box<dyn Error>

Converts a String into a box of dyn Error.

Examples

use std::error::Error;
use std::mem;

let a_string_error = "a string error".to_string();
let a_boxed_error = Box::<dyn Error>::from(a_string_error);
assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))

impl From<String> for Box<dyn Error + Send + Sync>

fn from(err: String) -> Box<dyn Error + Send + Sync>

Converts a String into a box of dyn Error + Send + Sync.

Examples

use std::error::Error;
use std::mem;

let a_string_error = "a string error".to_string();
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_string_error);
assert!(
    mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))

Implementations on Foreign Types

impl Error for ParseBoolError

impl Error for TryFromIntError

impl Error for LayoutErr

impl Error for TryFromSliceError

impl Error for ParseIntError

impl<T: Error> Error for Box<T>

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

impl Error for Utf8Error

impl Error for FromUtf8Error

impl Error for FromUtf16Error

impl Error for ParseFloatError

Implementors

impl Error for Error