Enum ErrorCause 

pub enum ErrorCause {
    ParseError,
    NonBlocksizeMultipleLengthError {
        actual: usize,
        block_size: usize,
    },
    UsbTransferError {
        direction: UsbTransferDirection,
    },
    FlagError {
        flags: u32,
    },
    BufferTooSmallError {
        expected: usize,
        actual: usize,
    },
    UnsupportedOperationError,
    InvalidDeviceError,
}

The cause of a returned error. This is implemented as an enum with a large number of variants to reduce allocations.

Variants

ParseError

The error was caused because the library failed to parse a byte buffer into a struct correctly.

NonBlocksizeMultipleLengthError

The error was caused because a passed-in byte length was not a multiple of the previously provided block size.

Fields

actual: usize

The transfer length that was passed in, but was rejected because actual % block_size != 0.

block_size: usize

The expected block size.

UsbTransferError

The error was caused because we failed to read/write enough bytes to/from the communication device.

Fields

direction: UsbTransferDirection

The direction the failed transfer was in.

FlagError

The error was thrown because a struct’s flags were invalid.

Fields

flags: u32

The value of whatever flag that was rejected.

BufferTooSmallError

The error was thrown becaused we attempted to read/write too many bytes from/to a buffer.

Fields

expected: usize

The size of the buffer the read/write expected.

actual: usize

The actual size of the buffer.

UnsupportedOperationError

The error was thrown because we called a method for a trait that isn’t valid in this particular struct’s implementation.

InvalidDeviceError

The error was thrown because we tried connecting to a device we don’t support.

Trait Implementations

impl Clone for ErrorCause

fn clone(&self) -> ErrorCause

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ErrorCause

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

Formats the value using the given formatter.

impl Hash for ErrorCause

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ErrorCause

fn eq(&self, other: &ErrorCause) -> 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 Copy for ErrorCause

impl Eq for ErrorCause

impl StructuralPartialEq for ErrorCause