Struct PageEntry 

pub struct PageEntry {
    pub offset: u64,
    pub length: u32,
    pub start_block: u64,
    pub start_logical: u64,
}

Master index entry pointing to a serialized index page.

Each PageEntry describes the location of an index page containing up to ENTRIES_PER_PAGE block metadata records. The master index is an array of these entries, stored at the end of the snapshot file.

Fields

• offset: Physical byte offset of the serialized index page
• length: Size of the serialized page in bytes
• start_block: Global block index of the first block in this page
• start_logical: Logical byte offset where this page’s coverage begins

Usage

To find the page covering logical offset O:

binary_search(master.disk_pages, |p| p.start_logical.cmp(&O))

Serialization

Pages are serialized using bincode and stored contiguously before the master index. The page entry provides the offset and length for deserialization.

Examples

use hexz_core::format::index::PageEntry;

let entry = PageEntry {
    offset: 1048576,      // Page starts at 1MB
    length: 65536,        // Page is 64KB serialized
    start_block: 0,       // First block is block #0
    start_logical: 0,     // Covers logical bytes 0..N
};

Fields

offset: u64

Physical offset of the index page in the snapshot file.

length: u32

Serialized size of the index page in bytes.

start_block: u64

Global block index of the first block in this page.

start_logical: u64

Logical byte offset where this page’s coverage begins.

Trait Implementations

impl Clone for PageEntry

fn clone(&self) -> PageEntry

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PageEntry

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PageEntry

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for PageEntry

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

where __S: Serializer,

Serialize this value into the given Serde serializer.