Enum bincode::error::DecodeError

#[non_exhaustive]
pub enum DecodeError {
    UnexpectedEnd,
    LimitExceeded,
    InvalidIntegerType {
        expected: IntegerType,
        found: IntegerType,
    },
    NonZeroTypeIsZero {
        non_zero_type: IntegerType,
    },
    UnexpectedVariant {
        type_name: &'static str,
        allowed: AllowedEnumVariants,
        found: u32,
    },
    Utf8(Utf8Error),
    InvalidCharEncoding([u8; 4]),
    InvalidBooleanValue(u8),
    ArrayLengthMismatch {
        required: usize,
        found: usize,
    },
    CStrNulError {
        inner: FromBytesWithNulError,
    },
    OtherString(String),
    SerdeAnyNotSupported,
    SerdeIdentifierNotSupported,
    SerdeIgnoredAnyNotSupported,
    CannotBorrowOwnedData,
}

Errors that can be encounted by decoding a type

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.

UnexpectedEnd

The reader reached its end but more bytes were expected.

LimitExceeded

The given configuration limit was exceeded

InvalidIntegerType

Fields

expected: IntegerType

The type that was being read from the reader

found: IntegerType

The type that was encoded in the data

Invalid type was found. The decoder tried to read type expected, but found type found instead.

NonZeroTypeIsZero

Fields

non_zero_type: IntegerType

The type that was being read from the reader

The decoder tried to decode any of the NonZero* types but the value is zero

UnexpectedVariant

Fields

type_name: &'static str

The type name that was being decoded.

allowed: AllowedEnumVariants

The variants that are allowed

found: u32

The index of the enum that the decoder encountered

Invalid enum variant was found. The decoder tried to decode variant index found, but the variant index should be between min and max.

Utf8(Utf8Error)

Tuple Fields

0: Utf8Error

The decoder tried to decode a str, but an utf8 error was encountered.

InvalidCharEncoding([u8; 4])

Tuple Fields

0: [u8; 4]

The decoder tried to decode a char and failed. The given buffer contains the bytes that are read at the moment of failure.

InvalidBooleanValue(u8)

Tuple Fields

0: u8

The decoder tried to decode a bool and failed. The given value is what is actually read.

ArrayLengthMismatch

Fields

required: usize

The length of the array required by the rust type.

found: usize

The length of the array found in the binary format.

The decoder tried to decode an array of length required, but the binary data contained an array of length found.

CStrNulError

Fields

inner: FromBytesWithNulError

The inner exception

The decoder tried to decode a CStr or CString, but the incoming data contained a 0 byte

OtherString(String)

Tuple Fields

0: String

An uncommon error occured, see the inner text for more information

SerdeAnyNotSupported

Bincode does not support serde’s any decoding feature

SerdeIdentifierNotSupported

Bincode does not support serde identifiers

SerdeIgnoredAnyNotSupported

Bincode does not support serde’s ignored_any

CannotBorrowOwnedData

Serde tried decoding a borrowed value from an owned reader. Use serde_decode_borrowed_from_* instead

Trait Implementations

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

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

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

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

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

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

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

impl Error for DecodeError

This is supported on crate feature serde only.

fn custom<T>(msg: T) -> Self where
    T: Display, 

Raised when there is general error when deserializing a type.

fn invalid_type(unexp: Unexpected<'_>, exp: &dyn Expected) -> Self

Raised when a Deserialize receives a type different from what it was expecting.

fn invalid_value(unexp: Unexpected<'_>, exp: &dyn Expected) -> Self

Raised when a Deserialize receives a value of the right type but that is wrong for some other reason.

fn invalid_length(len: usize, exp: &dyn Expected) -> Self

Raised when deserializing a sequence or map and the input data contains too many or too few elements.

fn unknown_variant(variant: &str, expected: &'static [&'static str]) -> Self

Raised when a Deserialize enum type received a variant with an unrecognized name.

fn unknown_field(field: &str, expected: &'static [&'static str]) -> Self

Raised when a Deserialize struct type received a field with an unrecognized name.

fn missing_field(field: &'static str) -> Self

Raised when a Deserialize struct type expected to receive a required field with a particular name but that field was not present in the input.

fn duplicate_field(field: &'static str) -> Self

Raised when a Deserialize struct type received more than one of the same field.

impl PartialEq<DecodeError> for DecodeError

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl StructuralPartialEq for DecodeError