Enum FsErrorKind 

#[non_exhaustive]
pub enum FsErrorKind {
    NotFound,
    AlreadyExists,
    NotDirectory,
    IsDirectory,
    InvalidPath,
    InvalidUri,
    InvalidOptions,
    ProviderContractViolation,
    PermissionDenied,
    AuthenticationFailed,
    ProviderUnavailable,
    UnsupportedOperation,
    UnsupportedCapability,
    RequirementNotMet,
    InvalidState,
    Indeterminate,
    Cancelled,
    Conflict,
    PreconditionFailed,
    Timeout,
    Interrupted,
    QuotaExceeded,
    ResourceLimitExceeded,
    DataCorruption,
    Io,
    Other,
}

Provider-neutral filesystem error category.

Examples

use qubit_fs::error::FsError;
use qubit_fs::error::FsErrorKind;
use qubit_fs::error::FsOperation;

let error = FsError::new(FsErrorKind::NotFound, FsOperation::Stat, "missing object");
assert_eq!(FsErrorKind::NotFound, error.kind());

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

The requested resource does not exist.

AlreadyExists

The target resource already exists.

NotDirectory

A path component expected to be a directory is not a directory.

IsDirectory

The requested operation expected a file but found a directory.

InvalidPath

A provider-local path is invalid for the selected filesystem.

InvalidUri

A filesystem URI is malformed or violates the credential boundary.

InvalidOptions

Operation options or provider construction input are inconsistent.

ProviderContractViolation

A provider returned a value that violates the SPI contract.

PermissionDenied

The current credentials do not grant the requested operation.

AuthenticationFailed

Authentication failed before authorization could be evaluated.

ProviderUnavailable

The selected provider is unavailable in the current environment.

UnsupportedOperation

The filesystem model does not support the requested operation.

UnsupportedCapability

A specific stable filesystem capability is not supported.

RequirementNotMet

The operation exists but cannot satisfy a required semantic guarantee.

InvalidState

The handle or resource is not in a state that permits the operation.

Indeterminate

Side effects may have occurred, but their final state is unknown.

Cancelled

The operation was cancelled before a definitive result was produced.

Conflict

The operation conflicts with current filesystem state.

PreconditionFailed

A conditional operation failed its precondition.

Timeout

The operation timed out.

Interrupted

The operation was interrupted.

QuotaExceeded

A quota, capacity, or storage limit was exceeded.

ResourceLimitExceeded

A deterministic caller or provider resource bound was exceeded.

DataCorruption

Stored or transferred data failed integrity validation.

Io

A lower-level local or remote I/O error occurred.

Other

An error occurred that does not fit a more specific category.

Trait Implementations

impl Clone for FsErrorKind

fn clone(&self) -> FsErrorKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for FsErrorKind

impl Debug for FsErrorKind

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

Formats the value using the given formatter.

impl Eq for FsErrorKind

impl PartialEq for FsErrorKind

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for FsErrorKind