Struct SnapshotDiff 

pub struct SnapshotDiff {
    pub a: ZsnapHeader,
    pub b: ZsnapHeader,
    pub added: Vec<String>,
    pub removed: Vec<String>,
    pub changed: Vec<KeyChange>,
    pub unchanged: u64,
    pub truncated: u64,
    pub origin_map: Asked<Vec<OriginPair>>,
    pub unmapped: Vec<Unmapped>,
    pub by_subject: Asked<Vec<SubjectDelta>>,
}

What two snapshots disagree about (RFC 13 §4.4): both spans stated, the facets kept apart, and an origin that could not be paired listed rather than dropped.

Fields

a: ZsnapHeader

The earlier side’s header — its span is half of what a diff MUST state.

b: ZsnapHeader

The later side’s header.

added: Vec<String>

Keys in b and not in a.

removed: Vec<String>

Keys in a and not in b.

changed: Vec<KeyChange>

Keys in both whose value, verdict, registration, holder or stamp moved — each facet reported on its own.

unchanged: u64

Keys in both that are identical on every facet.

truncated: u64

Differing keys past the listing bound — counted, never dropped (O6). Absent at zero.

origin_map: Asked<Vec<OriginPair>>

The origin alignment across deployments, when one was asked for (#220). Absent when not.

unmapped: Vec<Unmapped>

Origins the alignment could not pair — listed, never dropped (RFC 13 §4.4). Absent when empty.

by_subject: Asked<Vec<SubjectDelta>>

The per-subject roll-up, when asked for. Absent when not — and absent on a refused diff, where the alignment was asked and the comparison declined.

Implementations

impl SnapshotDiff

pub fn refused(&self) -> bool

The alignment was asked and left origins unpaired, so the comparison was not made (#220): the pairs and the unpaired ride the report, nothing is listed as added, removed or changed, and the judgement is the reserved non-verdict — a diff that compared around an origin it could not place would be confident nonsense.

pub fn differs(&self) -> bool

Whether anything at all differs — added, removed, changed, or differences past the bound.

pub fn to_judgement(&self) -> Judgement

The RFC 13 §1.2 projection: a difference is the finding (Established, exit 1), identity the clean answer. A diff over two parsed files is always asked; the one unestablished pole is a refused alignment, where the observation cannot carry the claim (Unobservable, exit 2).

Trait Implementations

impl Clone for SnapshotDiff

fn clone(&self) -> SnapshotDiff

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SnapshotDiff

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SnapshotDiff

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for SnapshotDiff

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for SnapshotDiff

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for SnapshotDiff