Struct Diff 

pub struct Diff<'a> {
    pub changes: &'a [Change<'a>],
}

What changed in a write, as the applicability index’s key.

The diff has to be computed to evaluate anything, so diffing is the indexing step: a write’s changed paths are walked through the tree once, and a write matching no policy has paid only for that walk.

The contract is exact: changes holds every path whose value differs between before and after, where absence is a value — so a create lists every path it introduces, a delete lists every path it removes, and there is no case where an evaluator sees an empty diff for a write that changed something. The server computes this, holding both sides of the write already, so it is enforced once in the write path rather than trusted from whatever produced the write.

This is a minimal, storage-agnostic view, deliberately not the richer diff type that didbot-data’s merkle search tree produces. That type carries proof material this crate has no use for, and coupling the policy core to one storage engine’s diff shape would be a dependency in the wrong direction.

Fields

changes: &'a [Change<'a>]

Every path that changed, each with its value before and after.

Trait Implementations

impl<'a> Clone for Diff<'a>

fn clone(&self) -> Diff<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Diff<'a>

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

Formats the value using the given formatter.

impl<'a> Default for Diff<'a>

fn default() -> Diff<'a>

Returns the “default value” for a type.

impl<'a> PartialEq for Diff<'a>

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

impl<'a> Eq for Diff<'a>

impl<'a> StructuralPartialEq for Diff<'a>