[−][src]Trait track::preclude::SerdeDiff
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,
&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>,
&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.
Implementations on Foreign Types
impl SerdeDiff for NonZeroU16
[src]
fn diff<S>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &NonZeroU16
) -> Result<bool, <S as SerializeSeq>::Error> where
S: SerializeSeq,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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>,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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>,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&mut self,
seq: &mut A,
ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
A: SeqAccess<'de>,
impl SerdeDiff for IpAddr
[src]
fn diff<S>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &IpAddr
) -> Result<bool, <S as SerializeSeq>::Error> where
S: SerializeSeq,
[src]
&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>,
[src]
&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>,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&mut self,
seq: &mut A,
ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
A: SeqAccess<'de>,
impl SerdeDiff for f32
[src]
fn diff<S>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &f32
) -> Result<bool, <S as SerializeSeq>::Error> where
S: SerializeSeq,
[src]
&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>,
[src]
&mut self,
seq: &mut A,
ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
A: SeqAccess<'de>,
impl SerdeDiff for Duration
[src]
fn diff<S>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Duration
) -> Result<bool, <S as SerializeSeq>::Error> where
S: SerializeSeq,
[src]
&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>,
[src]
&mut self,
seq: &mut A,
ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
A: SeqAccess<'de>,
impl SerdeDiff for f64
[src]
fn diff<S>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &f64
) -> Result<bool, <S as SerializeSeq>::Error> where
S: SerializeSeq,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&mut self,
seq: &mut A,
ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
A: SeqAccess<'de>,
impl SerdeDiff for Ipv4Addr
[src]
fn diff<S>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Ipv4Addr
) -> Result<bool, <S as SerializeSeq>::Error> where
S: SerializeSeq,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&mut self,
seq: &mut A,
ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
A: SeqAccess<'de>,
impl SerdeDiff for u16
[src]
fn diff<S>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &u16
) -> Result<bool, <S as SerializeSeq>::Error> where
S: SerializeSeq,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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>,
[src]
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,
[src]
&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>,
[src]
&mut self,
seq: &mut A,
ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
A: SeqAccess<'de>,
impl SerdeDiff for SocketAddrV4
[src]
fn diff<S>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &SocketAddrV4
) -> Result<bool, <S as SerializeSeq>::Error> where
S: SerializeSeq,
[src]
&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>,
[src]
&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>,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&mut self,
seq: &mut A,
ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
A: SeqAccess<'de>,
impl SerdeDiff for isize
[src]
fn diff<S>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &isize
) -> Result<bool, <S as SerializeSeq>::Error> where
S: SerializeSeq,
[src]
&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>,
[src]
&mut self,
seq: &mut A,
ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
A: SeqAccess<'de>,
impl SerdeDiff for i32
[src]
fn diff<S>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &i32
) -> Result<bool, <S as SerializeSeq>::Error> where
S: SerializeSeq,
[src]
&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>,
[src]
&mut self,
seq: &mut A,
ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
A: SeqAccess<'de>,
impl SerdeDiff for u64
[src]
fn diff<S>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &u64
) -> Result<bool, <S as SerializeSeq>::Error> where
S: SerializeSeq,
[src]
&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>,
[src]
&mut self,
seq: &mut A,
ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
A: SeqAccess<'de>,
impl SerdeDiff for NonZeroU8
[src]
fn diff<S>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &NonZeroU8
) -> Result<bool, <S as SerializeSeq>::Error> where
S: SerializeSeq,
[src]
&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>,
[src]
&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>,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&mut self,
seq: &mut A,
ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
A: SeqAccess<'de>,
impl SerdeDiff for PathBuf
[src]
fn diff<S>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &PathBuf
) -> Result<bool, <S as SerializeSeq>::Error> where
S: SerializeSeq,
[src]
&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>,
[src]
&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>,
[src]
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,
[src]
&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>,
[src]
&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>,
[src]
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,
[src]
&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>,
[src]
&mut self,
seq: &mut A,
ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
A: SeqAccess<'de>,
impl SerdeDiff for SystemTime
[src]
fn diff<S>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &SystemTime
) -> Result<bool, <S as SerializeSeq>::Error> where
S: SerializeSeq,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&mut self,
seq: &mut A,
ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
A: SeqAccess<'de>,
impl SerdeDiff for ()
[src]
fn diff<S>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &()
) -> Result<bool, <S as SerializeSeq>::Error> where
S: SerializeSeq,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&mut self,
seq: &mut A,
ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
A: SeqAccess<'de>,
impl SerdeDiff for i16
[src]
fn diff<S>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &i16
) -> Result<bool, <S as SerializeSeq>::Error> where
S: SerializeSeq,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&mut self,
seq: &mut A,
ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
A: SeqAccess<'de>,
impl SerdeDiff for OsString
[src]
fn diff<S>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &OsString
) -> Result<bool, <S as SerializeSeq>::Error> where
S: SerializeSeq,
[src]
&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>,
[src]
&mut self,
seq: &mut A,
ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
A: SeqAccess<'de>,
impl SerdeDiff for String
[src]
fn diff<S>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &String
) -> Result<bool, <S as SerializeSeq>::Error> where
S: SerializeSeq,
[src]
&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>,
[src]
&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>,
[src]
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,
[src]
&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>,
[src]
&mut self,
seq: &mut A,
ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
A: SeqAccess<'de>,
impl SerdeDiff for char
[src]
fn diff<S>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &char
) -> Result<bool, <S as SerializeSeq>::Error> where
S: SerializeSeq,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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>,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&mut self,
seq: &mut A,
ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
A: SeqAccess<'de>,
impl SerdeDiff for i128
[src]
fn diff<S>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &i128
) -> Result<bool, <S as SerializeSeq>::Error> where
S: SerializeSeq,
[src]
&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>,
[src]
&mut self,
seq: &mut A,
ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
A: SeqAccess<'de>,
impl SerdeDiff for CString
[src]
fn diff<S>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &CString
) -> Result<bool, <S as SerializeSeq>::Error> where
S: SerializeSeq,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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>,
[src]
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,
[src]
&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>,
[src]
&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>,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&mut self,
seq: &mut A,
ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
A: SeqAccess<'de>,
impl SerdeDiff for NonZeroU32
[src]
fn diff<S>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &NonZeroU32
) -> Result<bool, <S as SerializeSeq>::Error> where
S: SerializeSeq,
[src]
&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>,
[src]
&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>,
[src]
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,
[src]
&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>,
[src]
&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>,
[src]
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,
[src]
&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>,
[src]
&mut self,
seq: &mut A,
ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
A: SeqAccess<'de>,
impl SerdeDiff for usize
[src]
fn diff<S>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &usize
) -> Result<bool, <S as SerializeSeq>::Error> where
S: SerializeSeq,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&mut self,
seq: &mut A,
ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
A: SeqAccess<'de>,
impl SerdeDiff for bool
[src]
fn diff<S>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &bool
) -> Result<bool, <S as SerializeSeq>::Error> where
S: SerializeSeq,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&mut self,
seq: &mut A,
ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
A: SeqAccess<'de>,
impl SerdeDiff for SocketAddr
[src]
fn diff<S>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &SocketAddr
) -> Result<bool, <S as SerializeSeq>::Error> where
S: SerializeSeq,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&mut self,
seq: &mut A,
ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
A: SeqAccess<'de>,
impl SerdeDiff for Ipv6Addr
[src]
fn diff<S>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Ipv6Addr
) -> Result<bool, <S as SerializeSeq>::Error> where
S: SerializeSeq,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&mut self,
seq: &mut A,
ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
A: SeqAccess<'de>,
impl SerdeDiff for SocketAddrV6
[src]
fn diff<S>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &SocketAddrV6
) -> Result<bool, <S as SerializeSeq>::Error> where
S: SerializeSeq,
[src]
&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>,
[src]
&mut self,
seq: &mut A,
ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
A: SeqAccess<'de>,
impl SerdeDiff for u8
[src]
fn diff<S>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &u8
) -> Result<bool, <S as SerializeSeq>::Error> where
S: SerializeSeq,
[src]
&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>,
[src]
&mut self,
seq: &mut A,
ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
A: SeqAccess<'de>,
impl SerdeDiff for i8
[src]
fn diff<S>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &i8
) -> Result<bool, <S as SerializeSeq>::Error> where
S: SerializeSeq,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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>,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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>,
[src]
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,
[src]
&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>,
[src]
&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>,
[src]
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,
[src]
&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>,
[src]
&mut self,
seq: &mut A,
ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
A: SeqAccess<'de>,
impl SerdeDiff for i64
[src]
fn diff<S>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &i64
) -> Result<bool, <S as SerializeSeq>::Error> where
S: SerializeSeq,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&mut self,
seq: &mut A,
ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
A: SeqAccess<'de>,
impl<T> SerdeDiff for [T; 32] where
T: SerdeDiff + Deserialize<'a> + Serialize,
[src]
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,
[src]
&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>,
[src]
&mut self,
seq: &mut A,
ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
A: SeqAccess<'de>,
impl SerdeDiff for NonZeroU64
[src]
fn diff<S>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &NonZeroU64
) -> Result<bool, <S as SerializeSeq>::Error> where
S: SerializeSeq,
[src]
&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>,
[src]
&mut self,
seq: &mut A,
ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
A: SeqAccess<'de>,
impl SerdeDiff for u128
[src]
fn diff<S>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &u128
) -> Result<bool, <S as SerializeSeq>::Error> where
S: SerializeSeq,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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>,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&mut self,
seq: &mut A,
ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
A: SeqAccess<'de>,
impl SerdeDiff for u32
[src]
fn diff<S>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &u32
) -> Result<bool, <S as SerializeSeq>::Error> where
S: SerializeSeq,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&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,
[src]
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,
[src]
&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>,
[src]
&mut self,
seq: &mut A,
ctx: &mut ApplyContext
) -> Result<bool, <A as SeqAccess<'de>>::Error> where
A: SeqAccess<'de>,