Enum ErrorKind 

#[non_exhaustive]
pub enum ErrorKind {
    ObjectGone,
    Refused,
    ServerGone,
    Timeout,
    Unreachable,
    UnsupportedVersion,
    InvalidInput,
    Transport,
    Decode,
}

What a failure means for the caller.

Error carries the detail; this carries the decision. Each variant is a different thing to do about it, which is why there are fewer of these than there are error variants.

New kinds may be added, so match with a _ arm.

Examples

use libtmux::ErrorKind;

fn retryable(kind: ErrorKind) -> bool {
    matches!(kind, ErrorKind::Timeout | ErrorKind::Transport)
}

assert!(retryable(ErrorKind::Transport));
assert!(!retryable(ErrorKind::ObjectGone));

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.

ObjectGone

The object is not on the server. Look it up again, or create it.

Refused

tmux ran the command and refused it. The arguments were wrong.

ServerGone

No tmux server answered. Start one, or name the socket that has it.

Timeout

The command did not finish in time. Retry, or allow longer.

Unreachable

tmux could not be run at all: not installed, or not where the server was told to look. Nothing about the request will change this.

UnsupportedVersion

The tmux that answered is older than this crate supports.

InvalidInput

The caller passed something that cannot be sent to tmux.

Transport

The process or connection carrying the command failed. Usually the environment rather than the request, so retrying may work.

Decode

tmux answered in a shape the crate could not read. Worth reporting.

Trait Implementations

impl Clone for ErrorKind

fn clone(&self) -> ErrorKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ErrorKind

impl Debug for ErrorKind

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

Formats the value using the given formatter.

impl Eq for ErrorKind

impl Hash for ErrorKind

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 ErrorKind

fn eq(&self, other: &ErrorKind) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for ErrorKind