Enum ResponseError 

pub enum ResponseError<E> {
    UsedLength {
        used: u32,
    },
    ResponseLimit,
    HeaderAccess(E),
    PayloadAccess(E),
    RequestId {
        expected: u64,
        actual: u64,
    },
    Flags(u16),
    PayloadLength {
        expected: u64,
        actual: u32,
    },
    PayloadEncoding,
    ObjectId,
    DeviceInfo(DeviceInfoError),
    EventState(u16),
    EventStatus {
        state: u16,
        error: StatusCode,
    },
}

Malformed or inaccessible device response.

Variants

UsedLength

Used length cannot contain the required response header or exact payload.

Fields

used: u32

Published used length.

ResponseLimit

The response exceeds the negotiated frame limit.

HeaderAccess(E)

The response header cannot be read.

PayloadAccess(E)

The response payload cannot be read.

RequestId

Response request ID does not match the chain’s request.

Fields

expected: u64

Expected request ID.

actual: u64

Device-provided request ID.

Flags(u16)

Protocol 1.0 response flags are nonzero.

PayloadLength

Payload shape does not match the operation and status.

Fields

expected: u64

Required payload bytes.

actual: u32

Device-provided payload bytes.

PayloadEncoding

A fixed payload cannot be decoded from its exact bytes.

ObjectId

A successful object-creation response returned object ID zero.

DeviceInfo(DeviceInfoError)

Device discovery returned invalid limits or reserved values.

EventState(u16)

Event state uses an unknown numeric value.

EventStatus

Event state and error status contradict each other.

Fields

state: u16

Raw event state.

error: StatusCode

Raw event error status.

Trait Implementations

impl<E: Debug> Debug for ResponseError<E>

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

Formats the value using the given formatter.

impl<E: Eq> Eq for ResponseError<E>

impl<E: PartialEq> PartialEq for ResponseError<E>

fn eq(&self, other: &ResponseError<E>) -> 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<E: PartialEq> StructuralPartialEq for ResponseError<E>