Enum GeometryError 

#[non_exhaustive]
pub enum GeometryError {
    #[non_exhaustive]
    SectorSizeUnsupported {
        bytes_per_sector: u32,
    },
    #[non_exhaustive]
    ClusterSizeUnsupported {
        bytes_per_cluster: u32,
        bytes_per_sector: u32,
    },
    #[non_exhaustive]
    ClusterTooLarge {
        bytes_per_cluster: u32,
        limit: u32,
    },
    #[non_exhaustive]
    BoundaryAlignUnsupported {
        bytes: u32,
        bytes_per_sector: u32,
    },
    #[non_exhaustive]
    VolumeTooSmall {
        sectors: u64,
        minimum: u64,
    },
    #[non_exhaustive]
    NoClusterHeap {
        heap_at: u64,
        volume_bytes: u64,
    },
    #[non_exhaustive]
    TooManyClusters {
        clusters: u64,
        limit: u32,
    },
    #[non_exhaustive]
    HeapTooSmall {
        clusters: u32,
        needed: u32,
    },
}

A geometry that cannot be realized.

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.

#[non_exhaustive]

SectorSizeUnsupported

The sector size is not one the format defines.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

bytes_per_sector: u32

The size requested, in bytes.

#[non_exhaustive]

ClusterSizeUnsupported

The allocation unit is not a power of two, or is smaller than a sector.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

bytes_per_cluster: u32

The size requested, in bytes.

bytes_per_sector: u32

The sector size it was requested against.

#[non_exhaustive]

ClusterTooLarge

The allocation unit exceeds what the format’s two shifts can express.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

bytes_per_cluster: u32

The size requested, in bytes.

limit: u32

MAX_BYTES_PER_CLUSTER.

#[non_exhaustive]

BoundaryAlignUnsupported

The alignment boundary is not a power of two, or is smaller than a sector.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

bytes: u32

The alignment requested, in bytes.

bytes_per_sector: u32

The sector size it was requested against.

#[non_exhaustive]

VolumeTooSmall

The volume is too small to hold a filesystem at all.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

sectors: u64

Sectors the volume spans.

minimum: u64

MIN_VOLUME_SECTORS.

#[non_exhaustive]

NoClusterHeap

The regions ahead of the cluster heap leave no room for the heap.

Reached by an alignment large enough to push the heap past the end of the volume, and by a cluster small enough that its allocation table is most of the volume.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

heap_at: u64

Where the heap would have begun, in bytes from the volume’s start.

volume_bytes: u64

Bytes the volume spans.

#[non_exhaustive]

TooManyClusters

The cluster is small enough that the volume holds more clusters than a 32-bit number addresses.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

clusters: u64

Clusters the heap would have held.

limit: u32

MAX_CLUSTER_COUNT.

#[non_exhaustive]

HeapTooSmall

The heap is too small to hold the three residents a format writes: the allocation bitmap, the up-case table, and the root directory.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

clusters: u32

Clusters the heap holds.

needed: u32

Clusters the three residents need.

Trait Implementations

impl Clone for GeometryError

fn clone(&self) -> GeometryError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GeometryError

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

Formats the value using the given formatter.

impl Display for GeometryError

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

Formats the value using the given formatter.

impl Error for GeometryError

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<GeometryError> for FormatError

fn from(source: GeometryError) -> Self

Converts to this type from the input type.

impl PartialEq for GeometryError

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

impl Eq for GeometryError

impl StructuralPartialEq for GeometryError