Struct diem_types::proof::accumulator::InMemoryAccumulator

pub struct InMemoryAccumulator<H> { /* private fields */ }

The Accumulator implementation.

Implementations

impl<H> InMemoryAccumulator<H>where H: CryptoHasher,

pub fn new( frozen_subtree_roots: Vec<HashValue>, num_leaves: LeafCount ) -> Result<Self>

Constructs a new accumulator with roots of existing frozen subtrees. Returns error if the number of frozen subtree roots does not match the number of leaves.

pub fn from_leaves(leaves: &[HashValue]) -> Self

Constructs a new accumulator with given leaves.

pub fn append(&self, leaves: &[HashValue]) -> Self

Appends a list of new leaves to an existing accumulator. Since the accumulator is immutable, the existing one remains unchanged and a new one representing the result is returned.

pub fn append_subtrees( &self, subtrees: &[HashValue], num_new_leaves: LeafCount ) -> Result<Self>

Appends a list of new subtrees to the existing accumulator. This is similar to append except that the new leaves themselves are not known and they are represented by subtrees. As an example, given the following accumulator that currently has 10 leaves, the frozen subtree roots and the new subtrees are annotated below. Note that in this case subtrees[0] represents two new leaves A and B, subtrees[1] represents four new leaves C, D, E and F, subtrees[2] represents four new leaves G, H, I and J, and the last subtrees[3] represents one new leaf K.

                                                                          new_root
                                                                        /          \
                                                                      /              \
                                                                    /                  \
                                                                  /                      \
                                                                /                          \
                                                              /                              \
                                                            /                                  \
                                                          /                                      \
                                                        /                                          \
                                                      /                                              \
                                                    /                                                  \
                                                  /                                                      \
                                                /                                                          \
                                        old_root                                                            o
                                       /        \                                                          / \
                                     /            \                                                       /   placeholder
                                   /                \                                                    /
                                 /                    \                                                 /
                               /                        \                                              /
                             /                            \                                           o
                           /                                \                                        / \
                         /                                    \                                     /    \
                       /                                       o                                  /        \
frozen_subtree_roots[0]                                      /   \                              /            \
                   /   \                                    /     \                           /                \
                  /     \                                  /       \                        /                    \
                 o       o                                o         subtrees[1]  subtrees[2]                     o
                / \     / \                              / \                / \          / \                    / \
               o   o   o   o      frozen_subtree_roots[1]   subtrees[0]    o   o        o   o                  o   placeholder
              / \ / \ / \ / \                         / \           / \   / \ / \      / \ / \                / \
              o o o o o o o o                         o o           A B   C D E F      G H I J  K (subtrees[3]) placeholder

pub fn root_hash(&self) -> HashValue

Returns the root hash of the accumulator.

pub fn version(&self) -> u64

pub fn frozen_subtree_roots(&self) -> &Vec<HashValue>

Returns the set of frozen subtree roots in this accumulator

pub fn num_leaves(&self) -> LeafCount

Returns the total number of leaves in this accumulator.

pub fn is_empty(&self) -> bool

Returns true if this accumulator is empty and has no leaves.

Trait Implementations

impl<H: Clone> Clone for InMemoryAccumulator<H>

fn clone(&self) -> InMemoryAccumulator<H>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<H: Debug> Debug for InMemoryAccumulator<H>

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

Formats the value using the given formatter.

impl<H> Default for InMemoryAccumulator<H>where H: CryptoHasher,

fn default() -> Self

Returns the “default value” for a type.

impl<'de, H> Deserialize<'de> for InMemoryAccumulator<H>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<H> PartialEq<InMemoryAccumulator<H>> for InMemoryAccumulator<H>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<H> Serialize for InMemoryAccumulator<H>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<H> Eq for InMemoryAccumulator<H>