Struct IndexPage 

pub struct IndexPage {
    pub blocks: Vec<BlockInfo>,
}

Serialized array of block metadata records.

An index page contains up to ENTRIES_PER_PAGE (4096) block metadata entries for a contiguous range of logical blocks. Pages are serialized with bincode and stored in the snapshot file before the master index.

Size

• In-memory: Vec<BlockInfo> (~20 bytes per entry)
• Serialized: ~64KB for full page (4096 * 16 bytes)

Coverage

With 4KB logical blocks, each page covers:

• Logical data: ~16MB (4096 blocks * 4KB)
• Physical data: Depends on compression ratio

Access Pattern

Pages are loaded on-demand when a read operation requires block metadata:

1. Master index binary search identifies page
2. Page is read from disk and deserialized
3. Page is cached in memory (LRU)
4. Block metadata is extracted from page

Examples

use hexz_core::format::index::{IndexPage, BlockInfo};

let mut page = IndexPage {
    blocks: vec![
        BlockInfo {
            offset: 4096,
            length: 2048,
            logical_len: 4096,
            checksum: 0x12345678,
        },
        BlockInfo {
            offset: 6144,
            length: 1024,
            logical_len: 4096,
            checksum: 0x9ABCDEF0,
        },
    ],
};

// Serialize for storage
let bytes = bincode::serialize(&page).unwrap();
println!("Page size: {} bytes", bytes.len());

// Deserialize on read
let loaded: IndexPage = bincode::deserialize(&bytes).unwrap();
assert_eq!(loaded.blocks.len(), 2);

Fields

blocks: Vec<BlockInfo>

Block metadata entries for this page’s range.

Trait Implementations

impl Clone for IndexPage

fn clone(&self) -> IndexPage

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IndexPage

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

Formats the value using the given formatter.

impl Default for IndexPage

fn default() -> IndexPage

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for IndexPage

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for IndexPage

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

where __S: Serializer,

Serialize this value into the given Serde serializer.