Struct Change 

pub struct Change<'a> {
    pub path: &'a str,
    pub before: Option<&'a Value>,
    pub after: Option<&'a Value>,
}

One field’s value before and after a write, at a dotted path such as "displayName" or "profile.bio".

before and after are None when the path was absent on that side — absence is a value, not a missing entry. This is what lets a rule like “displayName may not change to a different value” resolve without an action special case: it is before.is_some() && after != before. A create has before: None everywhere, so it never trips such a rule — correct, there is no prior identity to protect. A delete has after: None everywhere; whether that counts as a change to the path is the evaluator’s reading of WriteAction, which is carried alongside the diff for exactly that decision.

Fields

path: &'a str

The field path this change is at, passed through exactly as the caller supplied it.

What a path segment is — where one ends, what a . or a [0] means, whether a literal dot in a field name is possible — is per-engine, not this crate’s to decide or canonicalize. An evaluator reads this string with whatever segmentation its own engine uses; this crate does not reinterpret it before handing it over. (The applicability index’s own path_prefixes matching does split on . internally, and treats an [index] subscript as a segment boundary too, so a prefix naming a field matches the elements of that field when it holds an array. That is this crate’s own declarative convention for routing — a cheap, structural pre-filter over which policies are even asked — not a claim about what path means to the evaluator a matched policy names.)

before: Option<&'a Value>

The value before the write, or None if the path was absent.

after: Option<&'a Value>

The value after the write, or None if the path is now absent.

Trait Implementations

impl<'a> Clone for Change<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Change<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for Change<'a>

fn eq(&self, other: &Change<'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 Change<'a>

impl<'a> Eq for Change<'a>

impl<'a> StructuralPartialEq for Change<'a>