Struct VerificationSession 

pub struct VerificationSession { /* private fields */ }

Streaming verification session that tracks PAR2 verification state as data arrives during download.

Usage:

1. Call Self::add_par2_data when PAR2 metadata packets arrive.
2. Call Self::feed_data as decoded file data arrives (slice-aligned).
3. Query Self::file_status, Self::repairability, or Self::is_complete at any time.
4. Call Self::verification_result once all data has been fed.

Implementations

impl VerificationSession

pub fn new() -> Self

Create a new empty verification session.

pub fn with_options(options: VerificationSessionOptions) -> Self

Create a session using the supplied buffering policy.

pub fn with_memory_budget(memory_budget: VerificationMemoryBudget) -> Self

Create a session using a caller-shareable boundary-buffer budget.

pub fn memory_budget(&self) -> &VerificationMemoryBudget

The budget used for incomplete slice data in this session.

pub fn add_par2_data(&mut self, packets: &[Packet])

Called when PAR2 metadata arrives. May be called multiple times as packets from different .par2 volumes arrive.

Once a valid Par2FileSet can be built from the accumulated packets, per-file verification state is initialized.

pub fn feed_data(&mut self, file_id: &FileId, offset: u64, data: &[u8])

Feed decoded file data for a specific file.

This compatibility wrapper accepts the historical aligned input and intentionally discards the detailed outcome. New callers should use feed_range to receive evidence and settle reads.

If PAR2 metadata has not yet arrived, the data is silently ignored. (The assembly layer should re-feed data after PAR2 metadata arrives if needed, or the caller can handle this at a higher level.)

pub fn feed_range( &mut self, file_id: &FileId, offset: u64, data: &[u8], ) -> FeedOutcome

Feed an arbitrary logical byte range for a PAR2 file.

Aligned complete slices are checksummed immediately without retaining the slice payload. Only incomplete boundary slices are buffered. The returned FeedOutcome reports newly settled SliceEvidence and precise SettleRead ranges needed to complete or disambiguate a slice.

pub fn feed_data_range( &mut self, file_id: &FileId, offset: u64, data: &[u8], ) -> FeedOutcome

Alias for callers that use feed_data terminology for arbitrary ranges.

pub fn file_status(&self, file_id: &FileId) -> Option<FileStatus>

Query the current status of a specific file.

pub fn repairability(&self) -> Repairability

Estimate repairability given the current state.

This accounts for both verified-damaged slices and pending (unverified) slices, treating pending slices optimistically (assuming they will pass).

pub fn is_complete(&self) -> bool

Check if all files have been verified successfully.

pub fn verification_result(&self) -> Option<VerificationResult>

Produce a full VerificationResult from the current session state.

This can be passed to plan_repair if repair is needed. Returns None if PAR2 metadata has not been loaded.

pub fn verify_from_slice_crcs( &mut self, file_id: &FileId, slice_crcs: &[u32], ) -> Option<Vec<bool>>

Verify a file’s slices using pre-computed CRC32 values from download.

Each entry in slice_crcs must be the CRC32 of the (possibly zero-padded) slice data. This is a CRC-only check (no MD5); it avoids re-reading files from disk when the download layer already computed per-slice CRCs.

Returns per-slice validity, or None if PAR2 metadata isn’t loaded or the file is unknown.

pub fn slice_evidence(&self) -> Vec<SliceEvidence>

Return every settled slice verdict held by this session.

The result is deterministic by file ID and slice index, and contains only PAR2 coordinates plus validity so it can be handed to a later repair stage without coupling it to filesystem paths.

pub fn par2_set(&self) -> Option<&Arc<Par2FileSet>>

Get a reference to the underlying PAR2 file set, if loaded.

Trait Implementations

impl Default for VerificationSession

fn default() -> Self

Returns the “default value” for a type.

impl Drop for VerificationSession

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.