Struct Header 

pub struct Header {

    pub magic: [u8; 4],
    pub version: u32,
    pub block_size: u32,
    pub index_offset: u64,
    pub parent_path: Option<String>,
    pub dictionary_offset: Option<u64>,
    pub dictionary_length: Option<u32>,
    pub metadata_offset: Option<u64>,
    pub metadata_length: Option<u32>,
    pub signature_offset: Option<u64>,
    pub signature_length: Option<u32>,
    pub encryption: Option<KeyDerivationParams>,
    pub compression: CompressionType,
    pub features: FeatureFlags,
}

On-disk snapshot file header containing format metadata.

This structure is serialized at the beginning of every .hxz file and describes the format version, compression settings, encryption parameters, and locations of key data structures within the file.

Binary Layout

The header occupies exactly 4096 bytes (HEADER_SIZE) at file offset 0 with the following logical structure:

• Magic bytes (4): File signature “HEXZ”
• Version (4): Format version number
• Block size (4): Logical block size in bytes
• Index offset (8): File offset to the master index structure
• Parent path (variable): Optional path for thin snapshots
• Dictionary offset/length: Optional compression dictionary location
• Metadata offset/length: Optional user metadata location
• Signature offset/length: Optional cryptographic signature location
• Encryption parameters: Optional key derivation settings
• Compression type: Algorithm used (LZ4 or Zstd)
• Feature flags: Capabilities enabled in this snapshot

Versioning

The version field enables forward compatibility. Readers check this field and reject files with incompatible versions. The current format version is defined in the magic module.

Thin Provisioning

When parent_path is set, this snapshot is a thin snapshot that references blocks from the parent. Blocks marked with BLOCK_OFFSET_PARENT are read from the parent snapshot instead of the current file.

Fields

magic: [u8; 4]

version: u32

block_size: u32

index_offset: u64

parent_path: Option<String>

Path to the parent snapshot for thin provisioning. If None, this is a standalone (thick) snapshot.

dictionary_offset: Option<u64>

dictionary_length: Option<u32>

metadata_offset: Option<u64>

metadata_length: Option<u32>

signature_offset: Option<u64>

signature_length: Option<u32>

encryption: Option<KeyDerivationParams>

compression: CompressionType

features: FeatureFlags

Implementations

impl Header

pub fn read_from<R: Read>(reader: &mut R) -> Result<Self>

Read and deserialize a header from a std::io::Read source.

pub fn read_from_backend(backend: &dyn StorageBackend) -> Result<Self>

Read a header from a StorageBackend at offset 0.

pub fn load_dictionary( &self, backend: &dyn StorageBackend, ) -> Result<Option<Vec<u8>>>

Load the compression dictionary from the backend, if present.

Trait Implementations

impl Clone for Header

fn clone(&self) -> Header

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Header

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

Formats the value using the given formatter.

impl Default for Header

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Header

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Header

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Header

impl StructuralPartialEq for Header