Trait dipa::Diffable

pub trait Diffable<'s, 'e, Other: ?Sized> {
    type Delta;
    type DeltaOwned;
    fn create_delta_towards(
        &'s self, 
        end_state: &'e Other
    ) -> CreatedDelta<Self::Delta>;
}

Allows a type to be diffed with another type.

Associated Types

type Delta

This will typically hold references to data from the structs that are being diffed.

type DeltaOwned

This will typically be an owned version of Self::Delta.

Required methods

fn create_delta_towards(
    &'s self,
    end_state: &'e Other
) -> CreatedDelta<Self::Delta>

Diff self with some target end state, generating a patch that would convert self -> end_state.

Implementations on Foreign Types

impl<'s, 'e, T: 'e + Diffable<'s, 'e, T>> Diffable<'s, 'e, Vec<T, Global>> for Vec<T> where
    T: PartialEq,
    &'e T: Serialize, 

type Delta = Vec<SequenceModificationDelta<'e, T>>

type DeltaOwned = Vec<SequenceModificationDeltaOwned<T>>

fn create_delta_towards(&self, end_state: &'e Self) -> CreatedDelta<Self::Delta>

impl<'s, 'e, T: 'e + Diffable<'s, 'e, T>> Diffable<'s, 'e, [T]> for &[T] where
    T: PartialEq,
    &'e T: Serialize, 

type Delta = Vec<SequenceModificationDelta<'e, T>>

type DeltaOwned = Vec<SequenceModificationDeltaOwned<T>>

fn create_delta_towards(&self, end_state: &'e [T]) -> CreatedDelta<Self::Delta>

impl<'s, 'e> Diffable<'s, 'e, bool> for bool

type Delta = bool

type DeltaOwned = bool

fn create_delta_towards(&self, end_state: &bool) -> CreatedDelta<Self::Delta>

impl<'s, 'e, 'a, T> Diffable<'s, 'e, Cow<'a, T>> for Cow<'a, T> where
    T: ToOwned,
    T: ?Sized,
    T: Diffable<'s, 'e, T>, 

type Delta = <T as Diffable<'s, 'e, T>>::Delta

type DeltaOwned = <T as Diffable<'s, 'e, T>>::DeltaOwned

fn create_delta_towards(
    &'s self,
    end_state: &'e Cow<'a, T>
) -> CreatedDelta<Self::Delta>

impl<'s, 'e> Diffable<'s, 'e, f32> for f32

type Delta = Option<f32>

type DeltaOwned = Option<f32>

fn create_delta_towards(&self, end_state: &f32) -> CreatedDelta<Self::Delta>

impl<'s, 'e> Diffable<'s, 'e, f64> for f64

type Delta = Option<f64>

type DeltaOwned = Option<f64>

fn create_delta_towards(&self, end_state: &f64) -> CreatedDelta<Self::Delta>

impl<'s, 'e> Diffable<'s, 'e, u8> for u8

type Delta = u8

type DeltaOwned = u8

fn create_delta_towards(&self, end_state: &u8) -> CreatedDelta<Self::Delta>

impl<'s, 'e> Diffable<'s, 'e, i8> for i8

type Delta = i8

type DeltaOwned = i8

fn create_delta_towards(&self, end_state: &i8) -> CreatedDelta<Self::Delta>

impl<'s, 'e> Diffable<'s, 'e, u16> for u16

type Delta = Option<u16>

type DeltaOwned = Option<u16>

fn create_delta_towards(&self, end_state: &u16) -> CreatedDelta<Self::Delta>

impl<'s, 'e> Diffable<'s, 'e, i16> for i16

type Delta = Option<i16>

type DeltaOwned = Option<i16>

fn create_delta_towards(&self, end_state: &i16) -> CreatedDelta<Self::Delta>

impl<'s, 'e> Diffable<'s, 'e, u32> for u32

type Delta = Option<u32>

type DeltaOwned = Option<u32>

fn create_delta_towards(&self, end_state: &u32) -> CreatedDelta<Self::Delta>

impl<'s, 'e> Diffable<'s, 'e, i32> for i32

type Delta = Option<i32>

type DeltaOwned = Option<i32>

fn create_delta_towards(&self, end_state: &i32) -> CreatedDelta<Self::Delta>

impl<'s, 'e> Diffable<'s, 'e, u64> for u64

type Delta = Option<u64>

type DeltaOwned = Option<u64>

fn create_delta_towards(&self, end_state: &u64) -> CreatedDelta<Self::Delta>

impl<'s, 'e> Diffable<'s, 'e, i64> for i64

type Delta = Option<i64>

type DeltaOwned = Option<i64>

fn create_delta_towards(&self, end_state: &i64) -> CreatedDelta<Self::Delta>

impl<'s, 'e> Diffable<'s, 'e, u128> for u128

type Delta = Option<u128>

type DeltaOwned = Option<u128>

fn create_delta_towards(&self, end_state: &u128) -> CreatedDelta<Self::Delta>

impl<'s, 'e> Diffable<'s, 'e, i128> for i128

type Delta = Option<i128>

type DeltaOwned = Option<i128>

fn create_delta_towards(&self, end_state: &i128) -> CreatedDelta<Self::Delta>

impl<'s, 'e, K, V> Diffable<'s, 'e, HashMap<K, V, RandomState>> for HashMap<K, V> where
    K: 's + 'e + Eq + Hash,
    V: 'e + Diffable<'s, 'e, V>,
    <V as Diffable<'s, 'e, V>>::Delta: Serialize,
    <V as Diffable<'s, 'e, V>>::DeltaOwned: DeserializeOwned, 

type Delta = MapDelta<'s, 'e, K, V>

type DeltaOwned = MapDeltaOwned<'s, 'e, K, V>

fn create_delta_towards(
    &'s self,
    end_state: &'e HashMap<K, V>
) -> CreatedDelta<Self::Delta>

impl<'s, 'e, K, V> Diffable<'s, 'e, BTreeMap<K, V>> for BTreeMap<K, V> where
    K: 's + 'e + Eq + Hash + Ord,
    V: 'e + Diffable<'s, 'e, V>,
    <V as Diffable<'s, 'e, V>>::Delta: Serialize,
    <V as Diffable<'s, 'e, V>>::DeltaOwned: DeserializeOwned, 

type Delta = MapDelta<'s, 'e, K, V>

type DeltaOwned = MapDeltaOwned<'s, 'e, K, V>

fn create_delta_towards(
    &'s self,
    end_state: &'e BTreeMap<K, V>
) -> CreatedDelta<Self::Delta>

impl<'s, 'e> Diffable<'s, 'e, ()> for ()

type Delta = ()

type DeltaOwned = ()

fn create_delta_towards(&self, _end_state: &()) -> CreatedDelta<Self::Delta>

impl<'s, 'e, T: Diffable<'s, 'e, T>> Diffable<'s, 'e, Option<T>> for Option<T> where
    T: 'e,
    <T as Diffable<'s, 'e, T>>::Delta: Serialize,
    <T as Diffable<'s, 'e, T>>::DeltaOwned: DeserializeOwned, 

type Delta = OptionDelta<'s, 'e, T>

type DeltaOwned = OptionDeltaOwned<'s, 'e, T>

fn create_delta_towards(
    &'s self,
    end_state: &'e Option<T>
) -> CreatedDelta<Self::Delta>

impl<'s, 'e, K> Diffable<'s, 'e, HashSet<K, RandomState>> for HashSet<K> where
    K: 's + 'e + Eq + Hash, 

type Delta = SetDelta<'s, 'e, K>

type DeltaOwned = SetDeltaOwned<K>

fn create_delta_towards(
    &'s self,
    end_state: &'e HashSet<K>
) -> CreatedDelta<Self::Delta>

impl<'s, 'e, K> Diffable<'s, 'e, BTreeSet<K>> for BTreeSet<K> where
    K: 's + 'e + Eq + Hash + Ord, 

type Delta = SetDelta<'s, 'e, K>

type DeltaOwned = SetDeltaOwned<K>

fn create_delta_towards(
    &'s self,
    end_state: &'e BTreeSet<K>
) -> CreatedDelta<Self::Delta>

impl<'s, 'e> Diffable<'s, 'e, String> for String

type Delta = Vec<SequenceModificationDelta<'e, u8>>

type DeltaOwned = Vec<SequenceModificationDeltaOwned<u8>>

fn create_delta_towards(
    &self,
    end_state: &'e String
) -> CreatedDelta<Self::Delta>

impl<'s, 'e> Diffable<'s, 'e, str> for str

type Delta = Vec<SequenceModificationDelta<'e, u8>>

type DeltaOwned = Vec<SequenceModificationDeltaOwned<u8>>

fn create_delta_towards(
    &'s self,
    end_state: &'e str
) -> CreatedDelta<Self::Delta>

impl<'s, 'e, A: Diffable<'s, 'e, A>, B: Diffable<'s, 'e, B>> Diffable<'s, 'e, (A, B)> for (A, B)

type Delta = Delta2<<A as Diffable<'s, 'e, A>>::Delta, <B as Diffable<'s, 'e, B>>::Delta>

type DeltaOwned = DeltaOwned2<<A as Diffable<'s, 'e, A>>::DeltaOwned, <B as Diffable<'s, 'e, B>>::DeltaOwned>

fn create_delta_towards(
    &'s self,
    end_state: &'e (A, B)
) -> CreatedDelta<Self::Delta>

Implementors