Struct ProofNode 

#[non_exhaustive]
pub struct ProofNode {
    pub key: PathBuf,
    pub partial_len: usize,
    pub value_digest: Option<ValueDigest<Value>>,
    pub child_hashes: Children<Option<HashType>>,
}

A node in a proof.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

key: PathBuf

The key this node is at. Each byte is a nibble.

partial_len: usize

The length of the key prefix that is shared with the previous node.

value_digest: Option<ValueDigest<Value>>

None if the node does not have a value. Otherwise, the node’s value or the hash of its value.

child_hashes: Children<Option<HashType>>

The hash of each child, or None if the child does not exist.

Trait Implementations

impl Clone for ProofNode

fn clone(&self) -> ProofNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProofNode

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

Formats the value using the given formatter.

impl From<PathIterItem> for ProofNode

fn from(item: PathIterItem) -> Self

Converts to this type from the input type.

impl Hashable for ProofNode

type LeadingPath<'a> = &'a [PathComponent] where Self: 'a

The type of the leading path.

type PartialPath<'a> = &'a [PathComponent] where Self: 'a

The type of the partial path.

type FullPath<'a> = &'a [PathComponent] where Self: 'a

The type of the full path.

fn parent_prefix_path(&self) -> Self::LeadingPath<'_>

The full path of this node’s parent where each byte is a nibble.

fn partial_path(&self) -> Self::PartialPath<'_>

The partial path of this node where each byte is a nibble.

fn full_path(&self) -> Self::FullPath<'_>

The full path of this node including the parent’s prefix where each byte is a nibble.

fn value_digest(&self) -> Option<ValueDigest<&[u8]>>

The node’s value or hash.

fn children(&self) -> Children<Option<HashType>>

Each element is a child’s index and hash. Yields 0 elements if the node is a leaf.

impl PartialEq for ProofNode

fn eq(&self, other: &ProofNode) -> 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 Version0 for ProofNode

fn read_v0_item(reader: &mut V0Reader<'_>) -> Result<Self, ReadError>

impl WriteItem for ProofNode

fn write_item(&self, out: &mut Vec<u8>)

impl Eq for ProofNode

impl StructuralPartialEq for ProofNode