Struct Container 

pub struct Container<'a> { /* private fields */ }

A parsed container, borrowing the bytes it was parsed from.

Parsing does not copy the payload and does not read it. A container of a hundred gigabytes parses in the time it takes to hash a footer, and the sections are read when somebody asks for them.

Implementations

impl<'a> Container<'a>

pub fn parse(bytes: &'a [u8]) -> Result<Self>

Parses a container and checks that the footer is the footer that was written.

The root digest covers the header and the footer, so a container that parses has metadata nobody has edited since it was written. Section contents are not read here. Call Container::verify for that, which is the expensive one and is a separate decision.

Errors

Returns Error describing the first thing that was wrong. It never panics, whatever the input is, and there is a fuzz target that exists to keep that true.

pub fn parse_without_root_digest(bytes: &'a [u8]) -> Result<Self>

Parses a container without checking the root digest.

This exists for the fuzzer. Checking the digest first would mean essentially every generated input is rejected in the trailer, and the parser behind it would never be reached, which is the part that needs the fuzzing. It is public because the fuzz target lives outside this crate, and it is named at length so that nobody reaches for it by accident.

Errors

The same as Container::parse, minus the digest mismatch.

pub const fn directory(&self) -> &Directory<'a>

The metadata, without the payload.

This is what a host hands on to anything that does not need the bytes, which is most of what sits above this crate.

pub const fn header(&self) -> FileHeader

The format version this container was written at.

pub const fn root_digest(&self) -> Digest

The digest that covers the header and the footer.

pub const fn dataset(&self) -> &Dataset

What the dataset is.

pub const fn schema(&self) -> Option<&Schema<'a>>

The schema, if there is one.

pub const fn decoder(&self) -> Option<&DecoderRef<'a>>

The decoder reference, if there is one.

pub fn sections(&self) -> &[Section]

Every section, in the order the footer listed them.

pub fn section(&self, id: u32) -> Option<&Section>

The section with this id.

pub fn section_bytes(&self, section: &Section) -> &'a [u8]

The bytes of a section.

The bounds were checked during parsing, so this cannot be out of range for a section that came from this container. It takes a &Section rather than an id so that the only way to call it is with one that did.

pub fn decoder_bytes(&self) -> Option<&'a [u8]>

The bytes of the embedded decoder module, if the decoder is embedded and the section it names exists.

pub fn verify(&self) -> Result<()>

Hashes every section and checks it against the footer.

This reads the whole file, so it is a decision rather than something that happens on every open. The honest place for it is once when a dataset arrives and then never again.

Errors

Returns Error::DigestMismatch naming the first section whose bytes do not hash to what the footer says they should.

Trait Implementations

impl<'a> Clone for Container<'a>

fn clone(&self) -> Container<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Container<'a>

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

Formats the value using the given formatter.