Enum ErrorKind

#[non_exhaustive]
pub enum ErrorKind {
    NotFound,
    PermissionDenied,
    AlreadyExists,
    WouldBlock,
    InvalidInput,
    InvalidData,
    TimedOut,
    WriteZero,
    Interrupted,
    Unsupported,
    UnexpectedEof,
    OutOfMemory,
    Other,
}

An enum providing a rough classification of errors.

The variants of this type partly resemble those of std::io::Error, because these are the most common sources of error that the crate concerns itself with.

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.

NotFound

An entity was not found, often a file.

PermissionDenied

The operation lacked the necessary privileges to complete.

AlreadyExists

An entity already exists, often a file.

WouldBlock

The operation needs to block to complete, but the blocking operation was requested to not occur.

InvalidInput

A parameter was incorrect.

InvalidData

Data not valid for the operation were encountered.

TimedOut

The I/O operation’s timeout expired, causing it to be canceled.

WriteZero

An error returned when an operation could not be completed because a call to write returned [Ok(0)].

Interrupted

This operation was interrupted.

Interrupted operations can typically be retried.

Unsupported

This operation is unsupported on this platform.

UnexpectedEof

An error returned when an operation could not be completed because an “end of file” was reached prematurely.

OutOfMemory

An operation could not be completed, because it failed to allocate enough memory.

Other

A custom error that does not fall under any other I/O error kind.

Trait Implementations

impl Clone for ErrorKind

fn clone(&self) -> ErrorKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ErrorKind

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

Formats the value using the given formatter.

impl PartialEq for ErrorKind

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

impl StructuralPartialEq for ErrorKind