Struct RootToLeavesValidator 

pub struct RootToLeavesValidator {
    introduced_directories: HashMap<B3Digest, u64>,
    pending_directories: HashSet<B3Digest>,
    poison: bool,
}

A struct holding state while consuming a sequence of Directories in Root-To-Leaves order.

It allows querying whether a certain digest could be acceptable (to be able to skip parsing entirely if present in serialized form)

Validates that newly received directories are already referenced from the root via existing directories. It also ensures the actual directory sizes are the same as the sizes communicated previously alongside the pointers. Commonly used when receiving a directory closure from a store.

Internally keeps a list of digests introduced (pointers in previously received directories), to recognize getting sent unrelated directories, as well as a list of introduced, but not yet received digest (to detect still-missing directories).

Fields

introduced_directories: HashMap<B3Digest, u64>

directory digest introduced so far, and the sizes they are expected to have.

pending_directories: HashSet<B3Digest>

the subset of introduced_directories that we still wait to receive.

poison: bool

tracks whether Self::finalize has been called, or an error has occured while trying to accept.

Implementations

impl RootToLeavesValidator

pub fn new_with_root(directory: &Directory) -> Self

Initialize with the passed root directory That directory is implicitly accepted and should not be sent again

pub fn would_accept(&self, digest: &B3Digest) -> bool

Checks a directory digest on whether it’s introduced. Particularly useful when receiving directories in canonical protobuf encoding, so that directories not connected to the root can be rejected without parsing.

After parsing, the directory can be passed to Self::try_accept to add its children to the list of expected digests.

pub fn try_accept(&mut self, directory: &Directory) -> Result<(), OrderingError>

Accepts a directory if previously introduced, or returns an error if it’s unknown.

pub fn finalize(self) -> Result<(), OrderingError>

Should be called after accepting the last Directory Ensures there’s no more pending directories.

fn introduce_children_of(&mut self, directory: &Directory)

pub fn validate_stream<'s, S>( directories: S, ) -> BoxStream<'s, Result<Directory, OrderingError>>

where S: Stream<Item = Directory> + Send + 's,

This receives a stream of Directories, validating them to be in Root-To-Leaves order. If the order is correct, they are yielded wrapped in an Ok(). If not, we yield an error.