Enum bincode::error::DecodeError

#[non_exhaustive]
pub enum DecodeError {
    UnexpectedEnd {
        additional: usize,
    },
    LimitExceeded,
    InvalidIntegerType {
        expected: IntegerType,
        found: IntegerType,
    },
    NonZeroTypeIsZero {
        non_zero_type: IntegerType,
    },
    UnexpectedVariant {
        type_name: &'static str,
        allowed: &'static AllowedEnumVariants,
        found: u32,
    },
    Utf8 {
        inner: Utf8Error,
    },
    InvalidCharEncoding([u8; 4]),
    InvalidBooleanValue(u8),
    ArrayLengthMismatch {
        required: usize,
        found: usize,
    },
    OutsideUsizeRange(u64),
    EmptyEnum {
        type_name: &'static str,
    },
    InvalidDuration {
        secs: u64,
        nanos: u32,
    },
    InvalidSystemTime {
        duration: Duration,
    },
    CStringNulError {
        position: usize,
    },
    Io {
        inner: Error,
        additional: usize,
    },
    OtherString(String),
    Serde(DecodeError),
}

Errors that can be encountered 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

Fields

additional: usize

Gives an estimate of how many extra bytes are needed.

Note: this is only an estimate and not indicative of the actual bytes needed.

Note: Bincode has no look-ahead mechanism. This means that this will only return the amount of bytes to be read for the current action, and not take into account the entire data structure being read.

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: &'static 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

Fields

inner: Utf8Error

The inner error

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

InvalidCharEncoding([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)

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.

OutsideUsizeRange(u64)

The encoded value is outside of the range of the target usize type.

This can happen if an usize was encoded on an architecture with a larger usize type and then decoded on an architecture with a smaller one. For example going from a 64 bit architecture to a 32 or 16 bit one may cause this error.

EmptyEnum

Fields

type_name: &'static str

The type that was being decoded

Tried to decode an enum with no variants

InvalidDuration

Fields

secs: u64

The number of seconds in the duration.

nanos: u32

The number of nanoseconds in the duration, which when converted to seconds and added to secs, overflows a u64.

The decoder tried to decode a Duration and overflowed the number of seconds.

InvalidSystemTime

Fields

duration: Duration

The duration which could not have been added to UNIX_EPOCH

The decoder tried to decode a SystemTime and overflowed

CStringNulError

Fields

position: usize

Nul byte position

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

Io

Fields

inner: Error

The IO error expected

additional: usize

Gives an estimate of how many extra bytes are needed.

Note: this is only an estimate and not indicative of the actual bytes needed.

Note: Bincode has no look-ahead mechanism. This means that this will only return the amount of bytes to be read for the current action, and not take into account the entire data structure being read.

The reader encountered an IO error but more bytes were expected.

OtherString(String)

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

Serde(DecodeError)

A serde-specific error that occurred while decoding.

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 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 self, demand: &mut Demand<'a>)

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

Provides type based access to context intended for error reports.

impl Error for DecodeError

Available on crate feature serde only.

fn custom<T>(msg: T) -> Selfwhere
    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 Into<DecodeError> for DecodeError

Available on crate feature serde only.

fn into(self) -> DecodeError

Converts this type into the (usually inferred) input type.