Enum DecodeError

pub enum DecodeError {
    RequiredHandleAbsent,
    RequiredValueAbsent,
    InvalidBool(u8),
    InvalidHandlePresence(u32),
    InvalidPointerPresence(u64),
    InvalidEnvelopeSize(u32),
    InvalidEnumOrdinal(i128),
    InvalidUnionOrdinal(usize),
    InvalidBits {
        expected: usize,
        actual: usize,
    },
    OutOfLineValueTooSmall(u32),
    InlineValueTooBig(usize),
    ExpectedInline(usize),
    IncorrectNumberOfHandlesConsumed {
        expected: usize,
        actual: usize,
    },
    InvalidOptionalSize(u64),
    VectorTooLong {
        size: u64,
        limit: u64,
    },
    InvalidUtf8(Utf8Error),
    InvalidUnionEnvelope,
    InvalidFrameworkError(i32),
    InsufficientData,
    InsufficientHandles,
    ExtraBytes {
        num_extra: usize,
    },
    ExtraHandles {
        num_extra: usize,
    },
}

Errors that can be produced when decoding FIDL messages.

Variants

RequiredHandleAbsent

A required handle was absent

RequiredValueAbsent

A required value was absent

InvalidBool(u8)

A boolean was set to a value other than 0 or 1

InvalidHandlePresence(u32)

A handle was set to a value other than 0 or u32::MAX

InvalidPointerPresence(u64)

A pointer was set to a value other than 0 or u64::MAX

InvalidEnvelopeSize(u32)

An envelope had an invalid size

InvalidEnumOrdinal(i128)

An enum had an invalid ordinal

InvalidUnionOrdinal(usize)

A union had an invalid ordinal

InvalidBits

A bit set had an invalid set of bits

Fields

expected: usize

The expected set of bits

actual: usize

The actual set of bits

OutOfLineValueTooSmall(u32)

An envelope was out-of-line, but the out-of-line data was too small

InlineValueTooBig(usize)

An envelope had inline data that was too big

ExpectedInline(usize)

An envelope should always be inline, but it contained out-of-line data

IncorrectNumberOfHandlesConsumed

An envelope consumed a different number of handles than it indicated in its metadata

Fields

expected: usize

The number of handles the envelope was expected to consume

actual: usize

The number of handles actually consumed by the envelope

InvalidOptionalSize(u64)

An optional value was marked absent but its size was non-zero

VectorTooLong

A vector had a length greater than its allowed limit

Fields

size: u64

The actual size of the vector

limit: u64

The maximum allowed size of the vector

InvalidUtf8(Utf8Error)

A string contained non-UTF8 data

InvalidUnionEnvelope

A union was marked absent, but its envelope was not set to zero

InvalidFrameworkError(i32)

A framework error contained an unrecognized error code.

InsufficientData

The decoder ran out of data before decoding finished

InsufficientHandles

The decoder ran out of handles before decoding finished

ExtraBytes

Decoding finished without consuming all of the bytes

Fields

num_extra: usize

The number of bytes left over after decoding finished

ExtraHandles

Decoding finished without consuming all of the handles

Fields

num_extra: usize

The number of handles left over after decoding finished

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

fn from(source: Utf8Error) -> Self

Converts to this type from the input type.