Struct BlockPostingList 

pub struct BlockPostingList { /* private fields */ }

Implementations

impl BlockPostingList

pub fn from_posting_list(list: &PostingList) -> Result<Self>

Build from a posting list.

Block format (8-byte header + packed arrays):

[count: u16][first_doc: u32][doc_id_bits: u8][tf_bits: u8]
[packed doc_id deltas: (count-1) × bytes_per_value(doc_id_bits)]
[packed tfs: count × bytes_per_value(tf_bits)]

pub fn serialize<W: Write>(&self, writer: &mut W) -> Result<()>

Serialize the block posting list (footer-based: stream first).

Format:

[stream: block data]
[L0 entries: l0_count × 16 bytes (first_doc, last_doc, offset, max_weight)]
[L1 entries: l1_count × 4 bytes (last_doc)]
[footer: stream_len(8) + l0_count(4) + l1_count(4) + doc_count(4) + max_tf(4) = 24 bytes]

pub fn deserialize(raw: &[u8]) -> Result<Self>

Deserialize from a byte slice (footer-based format).

pub fn deserialize_zero_copy(raw: OwnedBytes) -> Result<Self>

Zero-copy deserialization from OwnedBytes. Stream and L0 are sliced from the source without copying. L1 is extracted into a Vec<u32> for SIMD-friendly access (tiny: ≤ N/8 entries).

pub fn doc_count(&self) -> u32

pub fn max_tf(&self) -> u32

Get maximum term frequency (for MaxScore upper bound computation)

pub fn num_blocks(&self) -> usize

Get number of blocks

pub fn block_max_tf(&self, block_idx: usize) -> Option<u32>

Get block’s max term frequency for block-max pruning

pub fn concatenate_blocks(sources: &[(BlockPostingList, u32)]) -> Result<Self>

Concatenate blocks from multiple posting lists with doc_id remapping. This is O(num_blocks) instead of O(num_postings).

pub fn concatenate_streaming<W: Write>( sources: &[(&[u8], u32)], writer: &mut W, ) -> Result<(u32, usize)>

Streaming merge: write blocks directly to output writer (bounded memory).

Zero-materializing: reads L0 entries directly from source bytes (mmap or &u8) without parsing into Vecs. Block sizes computed from the 8-byte header (deterministic with packed encoding).

Output L0 + L1 are buffered (bounded O(total_blocks × 16 + total_blocks/8 × 4)). Block data flows source → output writer without intermediate buffering.

Returns (doc_count, bytes_written).

pub fn decode_block_into( &self, block_idx: usize, doc_ids: &mut Vec<u32>, tfs: &mut Vec<u32>, ) -> bool

Decode a specific block into caller-provided buffers.

Returns true if the block was decoded, false if block_idx is out of range. Reuses doc_ids and tfs buffers (cleared before filling).

Uses SIMD-accelerated unpack for 8/16/32-bit packed arrays.

pub fn block_first_doc(&self, block_idx: usize) -> Option<DocId>

First doc_id of a block (from L0 skip entry). Returns None if out of range.

pub fn block_last_doc(&self, block_idx: usize) -> Option<DocId>

Last doc_id of a block (from L0 skip entry). Returns None if out of range.

pub fn seek_block(&self, target: DocId, from_block: usize) -> Option<usize>

Find the first block whose last_doc >= target, starting from from_block.

Uses SIMD-accelerated linear scan:

1. find_first_ge_u32 on the contiguous L1 last_doc array
2. Extract ≤L1_INTERVAL L0 last_doc values into a stack buffer → find_first_ge_u32

Returns None if no block contains target.

pub fn iterator(&self) -> BlockPostingIterator<'_>

Create an iterator with skip support

pub fn into_iterator(self) -> BlockPostingIterator<'static>

Create an owned iterator that doesn’t borrow self

Trait Implementations

impl Clone for BlockPostingList

fn clone(&self) -> BlockPostingList

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BlockPostingList

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

Formats the value using the given formatter.