Struct PageSlab 

pub struct PageSlab {
    pub size: u64,
    pub pages: Vec<PageSlot>,
}

The dense immutable backing of a DataCap: a custom runtime-sized SSZ vector of pages.

pages[i] is absolute page i; trailing PageSlot::Empty pages may be omitted (so pages.len() <= page_count), and an out-of-range index reads as Empty (zero) — the merkle pads them back via the zero-hash table. The hash_tree_root is merkleize(page_roots, page_count) at runtime depth.

Fields

size: u64

Logical byte length; always a PAGE_SIZE multiple. page_count = size / PAGE_SIZE.

pages: Vec<PageSlot>

Dense page storage indexed by absolute page (trailing Empty trimmed).

Implementations

impl PageSlab

pub fn empty() -> Self

An empty slab (size 0, no pages).

pub fn page_count(&self) -> usize

Number of logical pages (size / PAGE_SIZE).

pub fn page(&self, i: usize) -> &PageSlot

Borrow page i (absolute). Out-of-range / trimmed-tail reads as PageSlot::Empty.

pub fn from_sparse_pages<'a>( size: u64, pages: impl IntoIterator<Item = (u32, &'a [u8])>, ) -> Self

Build a slab of logical size (a PAGE_SIZE multiple) from sparse named pages: pages yields (page_index, content) for the non-zero pages (content ≤ PAGE_SIZE); every unnamed page is the canonical zero page. Reuses put_page_idx so the result is the same canonical form (all-zero → Empty, trailing Empty trimmed) a contiguous from_bytes_sized build would produce — i.e. byte- and hash-identical for equivalent logical content. The decode target for crate::image::DataDesc.

Trait Implementations

impl Archive for PageSlab

where u64: Archive, Vec<PageSlot>: Archive,

const COPY_OPTIMIZATION: CopyOptimization<Self>

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

type Archived = ArchivedPageSlab

The archived representation of this type.

type Resolver = PageSlabResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

impl Clone for PageSlab

fn clone(&self) -> PageSlab

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PageSlab

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

Formats the value using the given formatter.

impl Default for PageSlab

fn default() -> PageSlab

Returns the “default value” for a type.

impl<__D: Fallible + ?Sized> Deserialize<PageSlab, __D> for Archived<PageSlab>

where u64: Archive, <u64 as Archive>::Archived: Deserialize<u64, __D>, Vec<PageSlot>: Archive, <Vec<PageSlot> as Archive>::Archived: Deserialize<Vec<PageSlot>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<PageSlab, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl HashTreeRoot for PageSlab

fn hash_tree_root<D: Digest<OutputSize = U32>>(&self) -> [u8; 32]

The pages field root: the flat size-scaled page merkle at exact depth ceil_log2(page_count). Empty/absent pages contribute [0;32], folded by the merkle zero-hash table.

impl<__S: Fallible + ?Sized> Serialize<__S> for PageSlab

where u64: Serialize<__S>, Vec<PageSlot>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.