Enum LookupResult

pub enum LookupResult<F, P, N> {
    Ok(F, P),
    NotInMemory,
    NotFound(N),
}

The result of querying at an index in the tree Typically, F for element type, P for membership proof type and N for non-membership proof type

Variants

Ok(F, P)

The value at the given index, and a proof of validity

NotInMemory

The index is valid but we do not have the leaf in memory

NotFound(N)

The index is outside the occupied range in the tree, and a non-membership proof

Implementations

impl<F, P, N> LookupResult<F, P, N>

pub fn expect_ok(self) -> Result<(F, P), MerkleTreeError>

Assert the lookup result is Ok. Return a tuple of element and membership proof.

pub fn expect_not_found(self) -> Result<N, MerkleTreeError>

Assert the lookup result is NotFound. Return a non-membership proof.

pub fn expect_not_in_memory(self) -> Result<(), MerkleTreeError>

Assert the lookup result is NotInMemory.

Trait Implementations

impl<F: Clone, P: Clone, N: Clone> Clone for LookupResult<F, P, N>

fn clone(&self) -> LookupResult<F, P, N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F: Debug, P: Debug, N: Debug> Debug for LookupResult<F, P, N>

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

Formats the value using the given formatter.

impl<F: Hash, P: Hash, N: Hash> Hash for LookupResult<F, P, N>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<F: PartialEq, P: PartialEq, N: PartialEq> PartialEq for LookupResult<F, P, N>

fn eq(&self, other: &LookupResult<F, P, N>) -> 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<F: Copy, P: Copy, N: Copy> Copy for LookupResult<F, P, N>

impl<F: Eq, P: Eq, N: Eq> Eq for LookupResult<F, P, N>

impl<F, P, N> StructuralPartialEq for LookupResult<F, P, N>