Struct Diff 

pub struct Diff {
    pub created_nodes: BTreeSet<Cid>,
    pub deleted_nodes: BTreeSet<Cid>,
    pub ops: Vec<RecordOp>,
    pub proof_nodes: BTreeSet<Cid>,
}

What changed between two roots.

The two node sets are the difference of the trees as blocks, and they are not symmetric with the records: a node can be created without any record changing inside it, because a sibling changed and the node above both had to be rewritten.

Fields

created_nodes: BTreeSet<Cid>

Nodes the second tree has and the first does not.

deleted_nodes: BTreeSet<Cid>

Nodes the first tree has and the second does not.

ops: Vec<RecordOp>

The records that changed, in path order.

proof_nodes: BTreeSet<Cid>

The blocks that prove those record changes against the second root.

One walk per changed path, over the tree after the change: an inclusion proof for a record that is now there, an exclusion proof for one that is now gone. It is usually the created nodes over again, and it is neither a subset nor a superset of them in general — a deletion can be proved by a node that was already there, and a node can be created that no changed path walks through.

Trait Implementations

impl Clone for Diff

fn clone(&self) -> Diff

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Diff

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

Formats the value using the given formatter.

impl PartialEq for Diff

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

impl StructuralPartialEq for Diff