Struct Reader 

pub struct Reader {
    pub header: Header,
    pub sections: Vec<SectionEntry>,
    pub manifest: Manifest,
    pub index: ChunkIndex,
    /* private fields */
}

Fields

header: Header

sections: Vec<SectionEntry>

manifest: Manifest

index: ChunkIndex

Implementations

impl Reader

pub fn open(path: &Path, password: Option<&str>) -> Result<Reader>

Open an archive file (memory-mapped; nothing is decoded before the framing and every section hash have been verified).

pub fn open_with_refs( path: &Path, password: Option<&str>, references: &[PathBuf], ) -> Result<Reader>

Open an archive together with the reference archives that hold its external chunks.

pub fn open_with( path: &Path, creds: &Credentials, references: &[PathBuf], ) -> Result<Reader>

Open with full credentials (passphrase and/or hybrid identities) and reference archives.

pub fn unresolved_external(&self) -> usize

Number of external chunks that cannot be resolved with the references given so far.

pub fn from_bytes(data: Vec<u8>, password: Option<&str>) -> Result<Reader>

pub fn is_encrypted(&self) -> bool

pub fn signature(&self) -> Option<&SignatureBlock>

pub fn verify_signature(&self, pubkey: &[u8; 32]) -> Result<bool>

Verify the embedded signature against a public key (hex or raw 32 bytes).

pub fn stream_entry(&mut self, ei: usize, sink: &mut dyn Write) -> Result<u64>

Stream the bytes of an entry to sink (raw entries chunk by chunk; container entries rebuilt) and verify the entry hash; returns the number of bytes written.

pub fn chunk(&mut self, ci: u32) -> Result<Vec<u8>>

Plaintext of one chunk (verified); external chunks are fetched from the reference archives.

pub fn entry_bytes(&mut self, ei: usize) -> Result<Vec<u8>>

Full bytes of an entry, verified against its BLAKE3 hash.

pub fn read_range( &mut self, ei: usize, start: u64, len: usize, ) -> Result<Vec<u8>>

Byte range of a raw entry without materialising the whole file (zip entries are rebuilt).

pub fn find_entry(&self, path: &str) -> Option<usize>

pub fn entries(&self) -> &[Entry]

pub fn extract( &mut self, dir: &Path, selected: Option<&[usize]>, overwrite: bool, ) -> Result<Vec<PathBuf>>

Extract everything (or the selected entry indices) under dir, with sanitised paths. Raw entries stream chunk by chunk to a temporary file that is renamed into place only after the hash verified; container entries are rebuilt in memory. Existing files are replaced only with overwrite; every destination is checked before the first byte is written, so a refusal leaves the directory as it was.

pub fn verify(&mut self, pubkey: Option<&[u8; 32]>) -> Result<VerifyReport>

Decompress and hash-check every entry; verify the signature if a public key is given.