Enum BaoChunk

pub enum BaoChunk<R = ()> {
    Parent {
        node: TreeNode,
        is_root: bool,
        left: bool,
        right: bool,
        ranges: R,
    },
    Leaf {
        start_chunk: ChunkNum,
        size: usize,
        is_root: bool,
        ranges: R,
    },
}

A chunk describeds what to read or write next

In some cases you want additional information about what part of the chunk matches the query. That is what the R type parameter is for. By default it is ().

Variants

Parent

expect a 64 byte parent node.

To validate, use parent_cv using the is_root value

Fields

node: TreeNode

The tree node, useful for error reporting

is_root: bool

This is the root, to be passed to parent_cv

left: bool

Push the left hash to the stack, since it will be needed later

right: bool

Push the right hash to the stack, since it will be needed later

ranges: R

Additional information about what part of the chunk matches the query

Leaf

expect data of size size

To validate, use hash_block using the is_root and start_chunk values

Fields

start_chunk: ChunkNum

Start chunk, to be passed to hash_block

size: usize

Size of the data to expect. Will be chunk_group_bytes for all but the last block.

is_root: bool

This is the root, to be passed to hash_block

ranges: R

Additional information about what part of the chunk matches the query

Implementations

impl<T> BaoChunk<T>

pub fn without_ranges(&self) -> BaoChunk

Set the ranges to the unit value

impl BaoChunk

pub fn size(&self) -> usize

Return the size of the chunk in bytes.

Trait Implementations

impl<R: Clone> Clone for BaoChunk<R>

fn clone(&self) -> BaoChunk<R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R: Debug> Debug for BaoChunk<R>

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

Formats the value using the given formatter.

impl<T: Default> Default for BaoChunk<T>

fn default() -> Self

Returns the “default value” for a type.

impl<R: PartialEq> PartialEq for BaoChunk<R>

fn eq(&self, other: &BaoChunk<R>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<R: Copy> Copy for BaoChunk<R>

impl<R: Eq> Eq for BaoChunk<R>

impl<R> StructuralPartialEq for BaoChunk<R>