Enum Edit

pub enum Edit<'a, T: Diffable<'a> + ?Sized> {
    Copy(&'a T),
    Insert(&'a T),
    Remove(&'a T),
    Change(T::Diff),
}

Variants

Copy(&'a T)

Insert(&'a T)

Remove(&'a T)

Change(T::Diff)

Implementations

impl<'a, T: Diffable<'a> + ?Sized> Edit<'a, T>

pub fn is_insert(&self) -> bool

pub fn is_remove(&self) -> bool

pub fn is_copy(&self) -> bool

pub fn is_change(&self) -> bool

pub fn insert(&self) -> Option<&'a T>

pub fn remove(&self) -> Option<&'a T>

pub fn change(&self) -> Option<&T::Diff>

pub fn copy(&self) -> Option<&'a T>

Trait Implementations

impl<'a, T: Debug + Diffable<'a> + ?Sized> Debug for Edit<'a, T>

where T::Diff: Debug,

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

Formats the value using the given formatter.

impl<'a, Diff, T: Diffable<'a, Diff = Diff> + 'a> Into<Edit<'a, T>> for Edit<'a, T>

fn into(self) -> Edit<'a, T>

Converts this type into the (usually inferred) input type.

impl<'a, T: PartialEq + Diffable<'a> + ?Sized> PartialEq for Edit<'a, T>

where T::Diff: PartialEq,

fn eq(&self, other: &Edit<'a, T>) -> 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, T: Diffable<'a> + ?Sized> StructuralPartialEq for Edit<'a, T>