Trait track::preclude::SerdeDiff

pub trait SerdeDiff {
    fn diff<S>(
        &self, 
        ctx: &mut DiffContext<'a, S>, 
        other: &Self
    ) -> Result<bool, <S as SerializeSeq>::Error>
    where
        S: SerializeSeq;
    fn apply<'de, A>(
        &mut self, 
        seq: &mut A, 
        ctx: &mut ApplyContext
    ) -> Result<bool, <A as SeqAccess<'de>>::Error>
    where
        A: SeqAccess<'de>;
}

Anything diffable implements this trait

Required methods

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &Self
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

Recursively walk the struct, invoking serialize_element on each member if the element is different. Returns true if any changes exist, otherwise false. After this call, the DiffContext will contain the data that has changed.

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

Applies the diff to the struct. Returns true if the struct was changed, otherwise false.

Loading content...

Implementations on Foreign Types

impl<T> SerdeDiff for [T; 32] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 32]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl SerdeDiff for f64

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &f64
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl SerdeDiff for CString

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &CString
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl SerdeDiff for NonZeroU64

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &NonZeroU64
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 384] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 384]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 160] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 160]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 16] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 16]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl SerdeDiff for u64

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &u64
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for Option<T> where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &Option<T>
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 48] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 48]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 21] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 21]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 224] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 224]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> SerdeDiff for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) where
    T0: SerdeDiff + Serialize + Deserialize<'a>,
    T1: SerdeDiff + Serialize + Deserialize<'a>,
    T10: SerdeDiff + Serialize + Deserialize<'a>,
    T2: SerdeDiff + Serialize + Deserialize<'a>,
    T3: SerdeDiff + Serialize + Deserialize<'a>,
    T4: SerdeDiff + Serialize + Deserialize<'a>,
    T5: SerdeDiff + Serialize + Deserialize<'a>,
    T6: SerdeDiff + Serialize + Deserialize<'a>,
    T7: SerdeDiff + Serialize + Deserialize<'a>,
    T8: SerdeDiff + Serialize + Deserialize<'a>,
    T9: SerdeDiff + Serialize + Deserialize<'a>, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 10] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 10]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 96] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 96]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl SerdeDiff for Ipv6Addr

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &Ipv6Addr
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl SerdeDiff for String

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &String
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 22] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 22]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 15] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 15]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 50] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 50]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for Vec<T> where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &Vec<T>
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl SerdeDiff for u8

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &u8
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl SerdeDiff for SocketAddrV6

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &SocketAddrV6
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 64] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 64]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T0, T1> SerdeDiff for (T0, T1) where
    T0: SerdeDiff + Serialize + Deserialize<'a>,
    T1: SerdeDiff + Serialize + Deserialize<'a>, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &(T0, T1)
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl SerdeDiff for SystemTime

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &SystemTime
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 19] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 19]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl SerdeDiff for char

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &char
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T0, T1, T2, T3, T4, T5, T6, T7> SerdeDiff for (T0, T1, T2, T3, T4, T5, T6, T7) where
    T0: SerdeDiff + Serialize + Deserialize<'a>,
    T1: SerdeDiff + Serialize + Deserialize<'a>,
    T2: SerdeDiff + Serialize + Deserialize<'a>,
    T3: SerdeDiff + Serialize + Deserialize<'a>,
    T4: SerdeDiff + Serialize + Deserialize<'a>,
    T5: SerdeDiff + Serialize + Deserialize<'a>,
    T6: SerdeDiff + Serialize + Deserialize<'a>,
    T7: SerdeDiff + Serialize + Deserialize<'a>, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &(T0, T1, T2, T3, T4, T5, T6, T7)
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl SerdeDiff for i64

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &i64
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<K, V> SerdeDiff for BTreeMap<K, V> where
    K: SerdeDiff + Serialize + Deserialize<'a> + Ord,
    V: SerdeDiff + Serialize + Deserialize<'a>, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &BTreeMap<K, V>
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 32768] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 32768]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 27] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 27]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T0, T1, T2, T3> SerdeDiff for (T0, T1, T2, T3) where
    T0: SerdeDiff + Serialize + Deserialize<'a>,
    T1: SerdeDiff + Serialize + Deserialize<'a>,
    T2: SerdeDiff + Serialize + Deserialize<'a>,
    T3: SerdeDiff + Serialize + Deserialize<'a>, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &(T0, T1, T2, T3)
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 72] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 72]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> SerdeDiff for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where
    T0: SerdeDiff + Serialize + Deserialize<'a>,
    T1: SerdeDiff + Serialize + Deserialize<'a>,
    T10: SerdeDiff + Serialize + Deserialize<'a>,
    T11: SerdeDiff + Serialize + Deserialize<'a>,
    T2: SerdeDiff + Serialize + Deserialize<'a>,
    T3: SerdeDiff + Serialize + Deserialize<'a>,
    T4: SerdeDiff + Serialize + Deserialize<'a>,
    T5: SerdeDiff + Serialize + Deserialize<'a>,
    T6: SerdeDiff + Serialize + Deserialize<'a>,
    T7: SerdeDiff + Serialize + Deserialize<'a>,
    T8: SerdeDiff + Serialize + Deserialize<'a>,
    T9: SerdeDiff + Serialize + Deserialize<'a>, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 26] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 26]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl SerdeDiff for PathBuf

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &PathBuf
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 100] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 100]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl SerdeDiff for Duration

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &Duration
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl SerdeDiff for NonZeroU16

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &NonZeroU16
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl SerdeDiff for i16

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &i16
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 12] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 12]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 23] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 23]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 13] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 13]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 4] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 4]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 14] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 14]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 40] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 40]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 128] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 128]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> SerdeDiff for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) where
    T0: SerdeDiff + Serialize + Deserialize<'a>,
    T1: SerdeDiff + Serialize + Deserialize<'a>,
    T10: SerdeDiff + Serialize + Deserialize<'a>,
    T11: SerdeDiff + Serialize + Deserialize<'a>,
    T12: SerdeDiff + Serialize + Deserialize<'a>,
    T13: SerdeDiff + Serialize + Deserialize<'a>,
    T14: SerdeDiff + Serialize + Deserialize<'a>,
    T15: SerdeDiff + Serialize + Deserialize<'a>,
    T2: SerdeDiff + Serialize + Deserialize<'a>,
    T3: SerdeDiff + Serialize + Deserialize<'a>,
    T4: SerdeDiff + Serialize + Deserialize<'a>,
    T5: SerdeDiff + Serialize + Deserialize<'a>,
    T6: SerdeDiff + Serialize + Deserialize<'a>,
    T7: SerdeDiff + Serialize + Deserialize<'a>,
    T8: SerdeDiff + Serialize + Deserialize<'a>,
    T9: SerdeDiff + Serialize + Deserialize<'a>, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl SerdeDiff for Ipv4Addr

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &Ipv4Addr
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T0, T1, T2, T3, T4, T5> SerdeDiff for (T0, T1, T2, T3, T4, T5) where
    T0: SerdeDiff + Serialize + Deserialize<'a>,
    T1: SerdeDiff + Serialize + Deserialize<'a>,
    T2: SerdeDiff + Serialize + Deserialize<'a>,
    T3: SerdeDiff + Serialize + Deserialize<'a>,
    T4: SerdeDiff + Serialize + Deserialize<'a>,
    T5: SerdeDiff + Serialize + Deserialize<'a>, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &(T0, T1, T2, T3, T4, T5)
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> SerdeDiff for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) where
    T0: SerdeDiff + Serialize + Deserialize<'a>,
    T1: SerdeDiff + Serialize + Deserialize<'a>,
    T10: SerdeDiff + Serialize + Deserialize<'a>,
    T11: SerdeDiff + Serialize + Deserialize<'a>,
    T12: SerdeDiff + Serialize + Deserialize<'a>,
    T2: SerdeDiff + Serialize + Deserialize<'a>,
    T3: SerdeDiff + Serialize + Deserialize<'a>,
    T4: SerdeDiff + Serialize + Deserialize<'a>,
    T5: SerdeDiff + Serialize + Deserialize<'a>,
    T6: SerdeDiff + Serialize + Deserialize<'a>,
    T7: SerdeDiff + Serialize + Deserialize<'a>,
    T8: SerdeDiff + Serialize + Deserialize<'a>,
    T9: SerdeDiff + Serialize + Deserialize<'a>, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 192] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 192]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> SerdeDiff for (T0, T1, T2, T3, T4, T5, T6, T7, T8) where
    T0: SerdeDiff + Serialize + Deserialize<'a>,
    T1: SerdeDiff + Serialize + Deserialize<'a>,
    T2: SerdeDiff + Serialize + Deserialize<'a>,
    T3: SerdeDiff + Serialize + Deserialize<'a>,
    T4: SerdeDiff + Serialize + Deserialize<'a>,
    T5: SerdeDiff + Serialize + Deserialize<'a>,
    T6: SerdeDiff + Serialize + Deserialize<'a>,
    T7: SerdeDiff + Serialize + Deserialize<'a>,
    T8: SerdeDiff + Serialize + Deserialize<'a>, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &(T0, T1, T2, T3, T4, T5, T6, T7, T8)
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl SerdeDiff for NonZeroU32

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &NonZeroU32
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl SerdeDiff for i8

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &i8
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 7] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 7]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 3] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 3]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 8] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 8]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 29] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 29]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 30] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 30]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl SerdeDiff for OsString

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &OsString
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 20] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 20]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 8192] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 8192]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T0, T1, T2, T3, T4, T5, T6> SerdeDiff for (T0, T1, T2, T3, T4, T5, T6) where
    T0: SerdeDiff + Serialize + Deserialize<'a>,
    T1: SerdeDiff + Serialize + Deserialize<'a>,
    T2: SerdeDiff + Serialize + Deserialize<'a>,
    T3: SerdeDiff + Serialize + Deserialize<'a>,
    T4: SerdeDiff + Serialize + Deserialize<'a>,
    T5: SerdeDiff + Serialize + Deserialize<'a>,
    T6: SerdeDiff + Serialize + Deserialize<'a>, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &(T0, T1, T2, T3, T4, T5, T6)
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 56] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 56]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T0, T1, T2> SerdeDiff for (T0, T1, T2) where
    T0: SerdeDiff + Serialize + Deserialize<'a>,
    T1: SerdeDiff + Serialize + Deserialize<'a>,
    T2: SerdeDiff + Serialize + Deserialize<'a>, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &(T0, T1, T2)
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 11] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 11]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 512] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 512]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T0, T1, T2, T3, T4> SerdeDiff for (T0, T1, T2, T3, T4) where
    T0: SerdeDiff + Serialize + Deserialize<'a>,
    T1: SerdeDiff + Serialize + Deserialize<'a>,
    T2: SerdeDiff + Serialize + Deserialize<'a>,
    T3: SerdeDiff + Serialize + Deserialize<'a>,
    T4: SerdeDiff + Serialize + Deserialize<'a>, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &(T0, T1, T2, T3, T4)
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 9] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 9]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl SerdeDiff for bool

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &bool
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl SerdeDiff for SocketAddrV4

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &SocketAddrV4
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 2048] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 2048]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl SerdeDiff for NonZeroU8

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &NonZeroU8
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 768] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 768]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 5] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 5]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 16384] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 16384]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl SerdeDiff for IpAddr

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &IpAddr
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<K, V> SerdeDiff for HashMap<K, V, RandomState> where
    K: SerdeDiff + Serialize + Deserialize<'a> + Hash + Eq,
    V: SerdeDiff + Serialize + Deserialize<'a>, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &HashMap<K, V, RandomState>
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl SerdeDiff for u32

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &u32
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 28] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 28]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 18] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 18]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl SerdeDiff for SocketAddr

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &SocketAddr
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 25] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 25]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 1024] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 1024]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl SerdeDiff for usize

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &usize
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl SerdeDiff for u16

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &u16
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> SerdeDiff for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) where
    T0: SerdeDiff + Serialize + Deserialize<'a>,
    T1: SerdeDiff + Serialize + Deserialize<'a>,
    T10: SerdeDiff + Serialize + Deserialize<'a>,
    T11: SerdeDiff + Serialize + Deserialize<'a>,
    T12: SerdeDiff + Serialize + Deserialize<'a>,
    T13: SerdeDiff + Serialize + Deserialize<'a>,
    T14: SerdeDiff + Serialize + Deserialize<'a>,
    T2: SerdeDiff + Serialize + Deserialize<'a>,
    T3: SerdeDiff + Serialize + Deserialize<'a>,
    T4: SerdeDiff + Serialize + Deserialize<'a>,
    T5: SerdeDiff + Serialize + Deserialize<'a>,
    T6: SerdeDiff + Serialize + Deserialize<'a>,
    T7: SerdeDiff + Serialize + Deserialize<'a>,
    T8: SerdeDiff + Serialize + Deserialize<'a>,
    T9: SerdeDiff + Serialize + Deserialize<'a>, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 200] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 200]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl SerdeDiff for i32

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &i32
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> SerdeDiff for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) where
    T0: SerdeDiff + Serialize + Deserialize<'a>,
    T1: SerdeDiff + Serialize + Deserialize<'a>,
    T10: SerdeDiff + Serialize + Deserialize<'a>,
    T11: SerdeDiff + Serialize + Deserialize<'a>,
    T12: SerdeDiff + Serialize + Deserialize<'a>,
    T13: SerdeDiff + Serialize + Deserialize<'a>,
    T2: SerdeDiff + Serialize + Deserialize<'a>,
    T3: SerdeDiff + Serialize + Deserialize<'a>,
    T4: SerdeDiff + Serialize + Deserialize<'a>,
    T5: SerdeDiff + Serialize + Deserialize<'a>,
    T6: SerdeDiff + Serialize + Deserialize<'a>,
    T7: SerdeDiff + Serialize + Deserialize<'a>,
    T8: SerdeDiff + Serialize + Deserialize<'a>,
    T9: SerdeDiff + Serialize + Deserialize<'a>, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> SerdeDiff for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) where
    T0: SerdeDiff + Serialize + Deserialize<'a>,
    T1: SerdeDiff + Serialize + Deserialize<'a>,
    T2: SerdeDiff + Serialize + Deserialize<'a>,
    T3: SerdeDiff + Serialize + Deserialize<'a>,
    T4: SerdeDiff + Serialize + Deserialize<'a>,
    T5: SerdeDiff + Serialize + Deserialize<'a>,
    T6: SerdeDiff + Serialize + Deserialize<'a>,
    T7: SerdeDiff + Serialize + Deserialize<'a>,
    T8: SerdeDiff + Serialize + Deserialize<'a>,
    T9: SerdeDiff + Serialize + Deserialize<'a>, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 65536] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 65536]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 2] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 2]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 6] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 6]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl SerdeDiff for isize

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &isize
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 24] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 24]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl SerdeDiff for f32

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &f32
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 4096] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 4096]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 31] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 31]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 256] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 256]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 1] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 1]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl SerdeDiff for i128

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &i128
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl SerdeDiff for ()

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &()
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl SerdeDiff for u128

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &u128
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T0> SerdeDiff for (T0,) where
    T0: SerdeDiff + Serialize + Deserialize<'a>, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &(T0,)
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

impl<T> SerdeDiff for [T; 17] where
    T: SerdeDiff + Deserialize<'a> + Serialize, 

fn diff<S>(
    &self,
    ctx: &mut DiffContext<'a, S>,
    other: &[T; 17]
) -> Result<bool, <S as SerializeSeq>::Error> where
    S: SerializeSeq, 

fn apply<'de, A>(
    &mut self,
    seq: &mut A,
    ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
    A: SeqAccess<'de>, 

Loading content...

Implementors

Loading content...