Struct OwnedChange 

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

One field path whose value differs between before and after a write, as this crate computes and holds it.

before/after are None exactly when the path was absent on that side — absence is a value, not a missing OwnedChange. A path present with an identical value on both sides is not represented at all: this is a diff, and an unchanged path did not change.

path is an owned String here rather than a borrow into the record: the paths themselves are computed while walking the structure ("foo.bar[2]" is built, not found), and something has to own the result. Change is the borrowed view of this a gate actually receives — see OwnedChange::as_change — so the ownership lives here, once, rather than at every call site that needs one.

Fields

path: String

Dot-and-bracket notation from the record’s root: "displayName", "labels.values[0].val".

before: Option<&'a Value>

What this path held before the write. None if it was absent.

after: Option<&'a Value>

What this path holds after the write. None if it is now absent.

Implementations

impl OwnedChange<'_>

pub fn as_change(&self) -> Change<'_>

Borrows this as the shape a gate receives.

A cheap reborrow, not a clone of the values: path is borrowed for as long as this OwnedChange is, and before/after were already borrowed from the record.

Trait Implementations

impl<'a> Clone for OwnedChange<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for OwnedChange<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for OwnedChange<'a>

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