Struct Q42RangeVolumeSet 

pub struct Q42RangeVolumeSet<S: Q42RangeSource> { /* private fields */ }

Transport-neutral logical Q42 snapshot. Root and child volumes can be opened from HTTP/IPFS range sources just as from a local file.

Implementations

impl<S: Q42RangeSource> Q42RangeVolumeSet<S>

pub fn open_root_with_lexicon_factory<R, DF, LF>( root: &Q42RangeVolume<R>, data_factory: &DF, lexicon_factory: &LF, ) -> Result<Self>

where R: Q42RangeSource, DF: Q42SegmentRangeFactory<Source = S>, LF: Q42LexiconRangeFactory<Source = S>,

Open a root’s graph and lexicon shards as one transport-neutral range snapshot. This is the service-facing constructor for HTTP/IPFS callers.

pub fn open_root<R, F>(root: &Q42RangeVolume<R>, factory: &F) -> Result<Self>

where R: Q42RangeSource, F: Q42SegmentRangeFactory<Source = S>,

pub fn manifest(&self) -> &Q42VolumeManifest

pub fn segments(&self) -> &[Q42RangeVolume<S>]

pub fn lexicon_segments(&self) -> &[Q42RangeVolume<S>]

pub fn attach_lexicon_segments<F>(&mut self, factory: &F) -> Result<()>

where F: Fn(&Q42LexiconSegment) -> Result<S>,

Attach the root-manifested Q42LEX shards through the same exact-range transport used for graph segments. The separate closure keeps legacy data-only factories source-compatible while allowing IPFS locators for lexicon shards.

pub fn lookup_lexicon_hash_into( &self, hash: u64, page: &mut [u8], out: &mut [u8], ) -> Result<Option<usize>>

Resolve a term through the hash-routed lexicon shard. Callers supply page and text buffers, preserving the zero-heap range contract.

pub fn execute_query_page_into( &self, plan: Q42RangeQueryPlan, cursor: Q42VolumeSetQueryCursor, compressed: &mut [u8], decoded: &mut [u8], out: &mut [NQuin], ) -> Result<Q42VolumeSetQueryPage>

Scan one bounded result page across child segments. Bound-object patterns prune the segment list through the root manifest before the per-segment BIDX reader runs; other patterns stream segments in their stable manifest order.

pub fn segment_index_for_object(&self, object_hash: u64) -> Option<usize>

Find the first segment whose object interval can contain object_hash. Segment boundary overlap is legal for high-frequency values, so callers must advance through adjoining intervals when a value spans segments.

pub fn segment_indices_for_object_into( &self, object_hash: u64, cursor: usize, out: &mut [usize], ) -> Result<Option<Q42SegmentMatchPage>>

pub fn verify_segment_hashes(&self, scratch: &mut [u8]) -> Result<()>

Verify every immutable child digest using a caller-owned scratch buffer.

pub fn verify_segment_quin_counts( &self, compressed: &mut [u8], decoded: &mut [u8], ) -> Result<()>

Verify the committed Quin count in every segment. The supplied buffers are reused for every block and cap the verifier’s memory use.