Enum DecodeError 

pub enum DecodeError {
    Io(Error),
    UnexpectedEof,
    InvalidCbor {
        reason: String,
    },
    NonCanonicalEncoding {
        major_type: u8,
        additional_info: u8,
        value: u64,
    },
    UnsupportedTag {
        tag: u64,
    },
    MapKeyNotString,
    InvalidCid {
        reason: String,
    },
    InvalidCidContent,
    InvalidFloat,
    UnsupportedSimpleValue {
        value: u8,
    },
    IndefiniteLengthNotSupported,
    TypeMismatch {
        expected: &'static str,
        found: String,
    },
    MaxDepthExceeded {
        depth: usize,
        max: usize,
    },
    AllocationExceeded {
        size: usize,
        max: usize,
    },
    InvalidUtf8(FromUtf8Error),
    MapKeysNotSorted,
    ReservedAdditionalInfo {
        value: u8,
    },
    Deserialization(String),
    TrailingData,
    NonCanonicalFloat,
    DuplicateMapKey,
    FloatsNotAllowed,
    IntegerOutOfRange {
        value: String,
    },
    ArrayTooLarge {
        count: usize,
        max: usize,
    },
    MapTooLarge {
        count: usize,
        max: usize,
    },
}

Errors that can occur during DAG-CBOR decoding

Variants

Io(Error)

I/O error during reading

UnexpectedEof

Unexpected end of input

InvalidCbor

Invalid CBOR major type

Fields

reason: String

The reason the CBOR is invalid

NonCanonicalEncoding

Non-canonical encoding in strict mode

Fields

major_type: u8

The major type of the non-canonical encoding

additional_info: u8

The additional info byte

value: u64

The decoded value

UnsupportedTag

Unsupported CBOR tag (only tag 42 allowed)

Fields

tag: u64

The unsupported tag number

MapKeyNotString

Map key is not a string (DAG-CBOR requirement)

InvalidCid

Invalid CID encoding

Fields

reason: String

The reason the CID is invalid

InvalidCidContent

CID tag not followed by byte string

InvalidFloat

Invalid float value (NaN or Infinity)

UnsupportedSimpleValue

Invalid simple value (only false, true, null allowed)

Fields

value: u8

The unsupported simple value

IndefiniteLengthNotSupported

Indefinite length not supported

TypeMismatch

Type mismatch during deserialization

Fields

expected: &'static str

The expected type

found: String

The found type

MaxDepthExceeded

Maximum nesting depth exceeded

Fields

depth: usize

The current depth

max: usize

The maximum allowed depth

AllocationExceeded

Allocation limit exceeded

Fields

size: usize

The requested allocation size

max: usize

The maximum allowed size

InvalidUtf8(FromUtf8Error)

Invalid UTF-8 in text string

MapKeysNotSorted

Non-canonical map key ordering in strict mode

ReservedAdditionalInfo

Reserved additional info value (28-30)

Fields

value: u8

The reserved value

Deserialization(String)

Deserialization error from serde

TrailingData

Trailing data after top-level object

NonCanonicalFloat

Non-canonical float encoding (not 64-bit)

DuplicateMapKey

Duplicate map key detected

FloatsNotAllowed

Float values not allowed (no_floats config)

IntegerOutOfRange

Integer out of i64 range (int64_range_only config)

Fields

value: String

The value that was out of range

ArrayTooLarge

Array exceeds maximum element count

Fields

count: usize

Actual array length

max: usize

Maximum allowed length

MapTooLarge

Map exceeds maximum entry count

Fields

count: usize

Actual map size

max: usize

Maximum allowed size

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, __formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

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

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

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 From<DecodeError> for CarError

fn from(err: DecodeError) -> Self

Converts to this type from the input type.

impl From<Error> for DecodeError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<FromUtf8Error> for DecodeError

fn from(source: FromUtf8Error) -> Self

Converts to this type from the input type.