Enum AccessPlan 

#[non_exhaustive]
pub enum AccessPlan {
    Direct,
    Wrapper {
        codec: Codec,
        access: Access,
    },
    Member {
        format: Format,
        index: usize,
        name: String,
        access: Access,
    },
    SegmentSet {
        format: Format,
        members: Vec<Segment>,
        kind: SegmentKind,
    },
    Collection {
        format: Format,
    },
}

The classified, most-direct route from packed bytes to the evidence.

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.

Direct

Uncompressed, non-archive stream — open as-is.

Wrapper

A bare gzip/bzip2 wrapper over a single stream.

Fields

codec: Codec

The outer compression codec.

access: Access

Access strategy for the single wrapped stream.

Member

Exactly one forensic file member inside an archive.

Fields

format: Format

The archive format the member lives in.

index: usize

The member’s index in the archive table.

name: String

The member’s recorded name.

access: Access

The member’s most-seekable access strategy.

SegmentSet

A segmented image (E01/E02…, split raw, split VMDK) — one logical stream.

Fields

format: Format

The archive format the segments live in.

members: Vec<Segment>

The segments, ordered by segment number.

kind: SegmentKind

How the segments reassemble.

Collection

Several independent members — a tree, each re-resolved on its own.

Fields

format: Format

The archive format.

Trait Implementations

impl Clone for AccessPlan

fn clone(&self) -> AccessPlan

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AccessPlan

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

Formats the value using the given formatter.

impl Eq for AccessPlan

impl PartialEq for AccessPlan

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for AccessPlan