Struct Diff

pub struct Diff<T> {
    pub patch: Patch<T>,
    pub checkpoint: CommitProof,
    pub last_commit: Option<CommitHash>,
}

Diff between local and remote.

Fields

patch: Patch<T>

Contents of the patch.

checkpoint: CommitProof

Checkpoint for the diff patch.

For checked patches this must match the proof of HEAD before the patch was created.

For unchecked force merges this checkpoint references the commit proof of HEAD after applying the patch.

last_commit: Option<CommitHash>

Last commit hash before the patch was created.

This can be used to determine if the patch is to be used to initialize a new set of events when no last commit is available.

For example, for file event logs which are lazily instantiated once external files are created.

Implementations

impl<T> Diff<T>

pub fn new( patch: Patch<T>, checkpoint: CommitProof, last_commit: Option<CommitHash>, ) -> Diff<T>

Create a diff.

Trait Implementations

impl<T> Clone for Diff<T>

where T: Clone,

fn clone(&self) -> Diff<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Diff<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for Diff<T>

where T: Default,

fn default() -> Diff<T>

Returns the “default value” for a type.

impl<T> PartialEq for Diff<T>

where T: PartialEq,

fn eq(&self, other: &Diff<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<T> Eq for Diff<T>

where T: Eq,

impl<T> StructuralPartialEq for Diff<T>