Struct XorbBlock 

pub struct XorbBlock {
    pub xorb_hash: MerkleHash,
    pub chunk_ranges: Vec<ChunkRange>,
    pub xorb_block_index: usize,
    pub references: Vec<XorbReference>,
    pub uncompressed_size_if_known: Option<usize>,
    pub data: OnceCell<Arc<XorbBlockData>>,
}

A downloadable xorb block identified by hash and chunk ranges, with cached data.

A block may contain multiple disjoint chunk ranges from the same xorb (V2 multi-range). Multiple file terms may reference the same block. Downloaded data is cached in data so that the first term to request it triggers the download, and subsequent terms reuse the cached result.

Fields

xorb_hash: MerkleHash

chunk_ranges: Vec<ChunkRange>

The chunk ranges fetched for this block. For V1 this is a single range; for V2 multi-range fetches this may contain multiple disjoint ranges.

xorb_block_index: usize

Index into the parent TermBlockRetrievalURLs for URL lookup.

references: Vec<XorbReference>

All file-term references covered by this block, sorted by chunk range start. Populated during retrieve_file_term_block and used to compute uncompressed_size_if_known.

uncompressed_size_if_known: Option<usize>

Expected total decompressed size across all chunk ranges, if it can be determined from the references. Passed to clients as a debug assertion hint.

data: OnceCell<Arc<XorbBlockData>>

Implementations

impl XorbBlock

pub async fn retrieve_data( self: Arc<Self>, client: Arc<dyn Client>, url_info: Arc<TermBlockRetrievalURLs>, progress_updater: Option<Arc<ItemProgressUpdater>>, chunk_cache: Option<Arc<dyn ChunkCache>>, ) -> Result<Arc<XorbBlockData>>

Retrieve the xorb block data from the client, caching it for subsequent calls.

Uses single-flight: the first caller acquires a CAS download permit and downloads the data; concurrent callers wait on the same result without acquiring permits or duplicating work. If the download fails, the cell remains empty and a later caller can retry.

pub fn determine_size_if_possible( xorb_ranges: &[ChunkRange], terms: &[XorbReference], ) -> Option<usize>

Determines the total uncompressed size of the xorb block from the reference terms, if possible.

Uses a forward-chaining DP: starting from the first chunk range’s start, we track which chunk positions are “reachable” (i.e., fully covered by a contiguous chain of terms) along with the accumulated uncompressed size.

For multi-range blocks with disjoint chunk ranges (e.g. [0,3) and [5,8)), the gaps between ranges are inserted as zero-cost bridges. This lets the DP traverse the full set of ranges in a single pass — a gap [3,5) contributes no data but connects the end of one range to the start of the next.

Returns Some(total_size) if every range is fully covered, None otherwise.

The terms slice must be sorted by term_chunks.start.

Trait Implementations

impl PartialEq for XorbBlock

fn eq(&self, other: &Self) -> 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 Eq for XorbBlock