Enum stacked_errors::ErrorKind

#[non_exhaustive]
pub enum ErrorKind {
    UnitError,
    TimeoutError,
    ProbablyNotRootCauseError,
    StrError(&'static str),
    StringError(String),
    CowStrError(Cow<'static, str>),
    BoxedError(Box<dyn Error + Send + Sync>),
    TryFromIntError(TryFromIntError),
    StdIoError(Error),
    FromUtf8Error(FromUtf8Error),
    FromUtf16Error(FromUtf16Error),
    ParseIntError(ParseIntError),
    ParseFloatError(ParseFloatError),
}

This includes BoxedError for general errors, tag errors, and directly encoded standard library errors.

The intention with TimeoutError is that if it is in the error stack, a timeout occured. When other timeout structs are used, this should be added on.

ProbablyNotRootCauseError is used to signal that the error is probably not the “root cause”. This is used by the super_orchestrator crate to reduce noise when one error triggers a cascade of errors in a network.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

UnitError

TimeoutError

ProbablyNotRootCauseError

StrError(&'static str)

StringError(String)

CowStrError(Cow<'static, str>)

BoxedError(Box<dyn Error + Send + Sync>)

TryFromIntError(TryFromIntError)

StdIoError(Error)

FromUtf8Error(FromUtf8Error)

FromUtf16Error(FromUtf16Error)

ParseIntError(ParseIntError)

ParseFloatError(ParseFloatError)

Implementations

impl ErrorKind

pub fn from_err<E: Error + Send + Sync + 'static>(e: E) -> Self

pub fn from_box(e: Box<dyn Error + Send + Sync>) -> Self

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

Attempts to downcast from a ErrorKind::BoxedError to a concrete type. Returns the input in an Err if it was not an ErrorKind::BoxedError or the box would not downcast.

Trait Implementations

impl Debug for ErrorKind

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

Formats the value using the given formatter.

impl Default for ErrorKind

fn default() -> ErrorKind

Returns the “default value” for a type.

impl Display for ErrorKind

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

Formats the value using the given formatter.

impl Error for ErrorKind

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

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.

impl From<&'static str> for ErrorKind

fn from(e: &'static str) -> Self

Converts to this type from the input type.

impl From<()> for ErrorKind

fn from(_e: ()) -> Self

Converts to this type from the input type.

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

fn from(e: Box<dyn Error + Send + Sync>) -> Self

Converts to this type from the input type.

impl From<Cow<'static, str>> for ErrorKind

fn from(e: Cow<'static, str>) -> Self

Converts to this type from the input type.

impl From<Error> for ErrorKind

fn from(e: Error) -> Self

Converts to this type from the input type.

impl From<FromUtf16Error> for ErrorKind

fn from(e: FromUtf16Error) -> Self

Converts to this type from the input type.

impl From<FromUtf8Error> for ErrorKind

fn from(e: FromUtf8Error) -> Self

Converts to this type from the input type.

impl From<ParseFloatError> for ErrorKind

fn from(e: ParseFloatError) -> Self

Converts to this type from the input type.

impl From<ParseIntError> for ErrorKind

fn from(e: ParseIntError) -> Self

Converts to this type from the input type.

impl From<String> for ErrorKind

fn from(e: String) -> Self

Converts to this type from the input type.

impl From<TryFromIntError> for ErrorKind

fn from(e: TryFromIntError) -> Self

Converts to this type from the input type.