Enum DecodeError 

#[non_exhaustive]
pub enum DecodeError {
    UnexpectedEof {
        needed: usize,
        remaining: usize,
    },
    UnknownTag(u8),
    InvalidBool(u8),
    InvalidUtf8,
    InvalidChar(u32),
    LengthTooLarge {
        count: u64,
        remaining: usize,
    },
    DepthExceeded,
    DuplicateKey,
    DuplicateElement,
    UnexpectedTag {
        expected: &'static str,
        got: u8,
    },
    UnknownVariant(String),
    WriterOnlyVariant(u32),
    BadVariantIndex(u32),
    Malformed(&'static str),
    TrailingBytes(usize),
}

Why decoding failed. A crafted message must never crash the decoder; every malformed input becomes one of these (r[validate.*]).

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.

UnexpectedEof

Fewer bytes remain than the next read needs.

Fields

needed: usize

remaining: usize

UnknownTag(u8)

A self-describing tag byte outside the defined table (r[validate.tags]).

InvalidBool(u8)

A bool byte other than 0 or 1.

InvalidUtf8

A string whose bytes are not valid UTF-8 (r[validate.text]).

InvalidChar(u32)

A char value that is not a Unicode scalar (r[validate.text]).

LengthTooLarge

A length or count larger than the remaining buffer could hold (r[validate.lengths]).

Fields

count: u64

remaining: usize

DepthExceeded

Nesting deeper than the decoder’s bound (r[validate.depth]).

DuplicateKey

A duplicate key in a map (r[validate.uniqueness]).

DuplicateElement

A duplicate element in a set (r[validate.uniqueness]).

UnexpectedTag

A typed decode found a tag it did not expect for the type being read.

Fields

expected: &'static str

got: u8

UnknownVariant(String)

A typed decode found an enum variant name it does not recognize.

WriterOnlyVariant(u32)

A compat decode received an enum variant the writer has but the reader removed (r[compat.enum]); carries the wire variant index. The DecodeError-channel counterpart of CompactError::WriterOnlyVariant.

BadVariantIndex(u32)

A compat decode received an enum variant index in neither the reader’s variants nor the writer’s known set — hostile/garbage. Carries the wire index. The DecodeError-channel counterpart of CompactError::BadVariantIndex.

Malformed(&'static str)

A typed decode found a structurally wrong value (e.g. an unexpected struct field count).

TrailingBytes(usize)

Bytes remained after a value that should have consumed the whole input.

Trait Implementations

impl Clone for DecodeError

fn clone(&self) -> DecodeError

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DecodeError

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

Formats the value using the given formatter.

impl Display for DecodeError

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

Formats the value using the given formatter.

impl Eq for DecodeError

impl Error for DecodeError

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.

impl PartialEq for DecodeError

fn eq(&self, other: &DecodeError) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for DecodeError