Enum ssh_packet::Error

#[non_exhaustive]
pub enum Error {
    BadMagic {
        pos: u64,
        found: Box<dyn Debug + Send + Sync>,
    },
    AssertFail {
        pos: u64,
        message: String,
    },
    Io(Error),
    Custom {
        pos: u64,
        err: Box<dyn CustomError>,
    },
    NoVariantMatch {
        pos: u64,
    },
    EnumErrors {
        pos: u64,
        variant_errors: Vec<(&'static str, Error)>,
    },
    Backtrace(Backtrace),
}

The error type used by BinRead.

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.

BadMagic

Fields

pos: u64

The byte position of the unexpected magic in the reader.

found: Box<dyn Debug + Send + Sync>

The value which was actually read.

An expected magic number was not found.

AssertFail

Fields

pos: u64

The byte position of the start of the field or object that raised an error.

message: String

The failure message.

An assertion failed.

This variant is used for assert directives which use a string literal instead of an error object. Assertions that use error objects are represented by the Custom variant.

Io(Error)

An error occurred in the underlying reader while reading or seeking to data.

Custom

Fields

pos: u64

The byte position of the start of the field or object that raised an error.

err: Box<dyn CustomError>

The original error.

A user-generated error.

This variant is used for assert directives which use an error object instead of a string literal. Assertions that use string literals are represented by the AssertFail variant.

NoVariantMatch

Fields

pos: u64

The byte position of the unparsable data in the reader.

None of the variants of an enum could successfully be parsed from the data in the reader.

This variant is used when the return_unexpected_error directive is set on an enum.

EnumErrors

Fields

pos: u64

The byte position of the unparsable data in the reader.

variant_errors: Vec<(&'static str, Error)>

The original errors which occurred when trying to parse each variant.

The first field of the tuple is the name of the variant, and the second field is the error that occurred when parsing that variant.

None of the variants of an enum could successfully be parsed from the data in the reader.

This variant is used when the return_all_errors directive is set on an enum (which is the default).

Backtrace(Backtrace)

An error with additional frames of context used to construct a backtrace

Implementations

impl Error

pub fn root_cause(&self) -> &Error

Returns the source error. For a Backtrace this is the error that caused it, for every other error this returns self

pub fn is_eof(&self) -> bool

Check if the root cause of this error is an Error::Io and an io::ErrorKind::UnexpectedEof.

pub fn custom_err<T>(&self) -> Option<&T>where T: CustomError + 'static,

Returns a reference to the boxed error object if this Error is a custom error of type T, or None if it isn’t.

Trait Implementations

impl ContextExt for Error

fn with_context<Frame>(self, frame: Frame) -> Errorwhere Frame: Into<BacktraceFrame>,

Adds a new context frame to the error, consuming the original error.

fn with_message(self, message: impl Into<Cow<'static, str>>) -> Error

Adds a new frame of context to the error with the given message, consuming the original error.

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl Error for Error

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<Error> for Error

fn from(err: Error) -> Error

Converts to this type from the input type.