Enum Error 

#[non_exhaustive]
pub enum Error {
    Transport(Error),
    Server {
        code: u16,
        kind: ServerErrorKind,
    },
    Crypto(CryptoError),
    Decode(Error),
    Encode(Error),
    NotLoggedIn,
    PayloadTooLarge {
        len: usize,
    },
    NotHdm {
        protocol_version: (u8, u8),
    },
}

All errors the HDM client can produce.

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.

Transport(Error)

Underlying transport (TCP, mock, etc.) failure.

Includes timeouts, connection resets, DNS failures. Recovery: reconnect + retry, possibly with backoff.

Server

HDM returned a non-success response code. See ServerErrorKind for the categorisation.

Fields

code: u16

Raw numeric code as returned in the response header (e.g. 141, 185).

kind: ServerErrorKind

Categorised kind. ServerErrorKind::Unknown(code) for codes outside the documented set.

Crypto(CryptoError)

3DES decryption or padding validation failed.

In practice this almost always means the session key is stale (server-side session timed out, or sequence numbers drifted). Recovery: re-login.

Decode(Error)

Response payload could not be parsed as JSON, or required fields were missing.

Usually indicates spec drift between the crate and the device, or a corrupted payload that survived decryption. Not recoverable without intervention.

Encode(Error)

Request payload could not be serialised to JSON. Indicates a programming bug — the crate’s request structs are always serialisable by construction.

NotLoggedIn

Operation requires an active session but crate::Client::login has not been called successfully.

PayloadTooLarge

A request payload exceeded the protocol’s 2-byte length field (65 535 bytes).

Fields

len: usize

The actual size that overflowed.

NotHdm

crate::identify reached a responsive endpoint, but its reply did not begin with the HDM protocol version — some other TCP service is listening on that address. Distinct from Self::Transport (nothing answered) so a discovery sweep can tell “wrong service” from “unreachable”.

Fields

protocol_version: (u8, u8)

The first two response bytes the endpoint sent, interpreted as a protocol version.

Implementations

impl Error

pub fn is_retryable(&self) -> bool

Whether retrying the same operation with no state change might succeed.

True for transient transport failures (timeout, broken pipe) and a small set of server-side conditions that resolve themselves (e.g. printer-out-of-paper after operator intervention). False for logical errors that need data fixes.

pub const fn requires_relogin(&self) -> bool

Whether the client should drop the current session and call crate::Client::login again before the next operation.

pub const fn requires_reconnect(&self) -> bool

Whether the underlying TCP connection is in an unrecoverable state and must be re-established.

Trait Implementations

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl Error for Error

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

fn from(source: CryptoError) -> Self

Converts to this type from the input type.

impl From<Error> for Error

fn from(source: Error) -> Self

Converts to this type from the input type.