[−][src]Trait serde_diff::SerdeDiff
Anything diffable implements this trait
Required methods
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
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.
pub 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>,
Applies the diff to the struct. Returns true if the struct was changed, otherwise false.
Implementations on Foreign Types
impl<T: SerdeDiff + Serialize + for<'a> Deserialize<'a>> SerdeDiff for Vec<T>
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 1]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 2]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 3]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 4]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 5]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 6]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 7]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 8]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 9]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 10]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 11]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 12]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 13]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 14]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 15]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 16]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 17]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 18]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 19]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 20]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 21]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 22]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 23]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 24]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 25]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 26]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 27]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 28]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 29]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 30]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 31]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 32]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 40]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 48]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 50]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 56]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 64]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 72]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 96]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 100]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 128]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 160]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 192]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 200]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 224]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 256]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 384]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 512]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 768]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 1024]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 2048]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 4096]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 8192]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 16384]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 32768]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for [T; 65536]
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + for<'a> Deserialize<'a>,
[src]
T0: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + for<'a> Deserialize<'a>,
T1: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
[src]
T0: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T1: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + for<'a> Deserialize<'a>,
T1: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T2: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
[src]
T0: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T1: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T2: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + for<'a> Deserialize<'a>,
T1: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T2: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T3: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
[src]
T0: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T1: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T2: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T3: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + for<'a> Deserialize<'a>,
T1: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T2: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T3: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T4: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
[src]
T0: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T1: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T2: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T3: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T4: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + for<'a> Deserialize<'a>,
T1: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T2: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T3: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T4: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T5: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
[src]
T0: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T1: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T2: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T3: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T4: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T5: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + for<'a> Deserialize<'a>,
T1: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T2: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T3: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T4: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T5: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T6: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
[src]
T0: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T1: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T2: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T3: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T4: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T5: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T6: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + for<'a> Deserialize<'a>,
T1: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T2: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T3: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T4: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T5: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T6: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T7: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
[src]
T0: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T1: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T2: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T3: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T4: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T5: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T6: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T7: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + for<'a> Deserialize<'a>,
T1: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T2: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T3: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T4: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T5: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T6: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T7: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T8: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
[src]
T0: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T1: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T2: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T3: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T4: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T5: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T6: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T7: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T8: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + for<'a> Deserialize<'a>,
T1: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T2: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T3: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T4: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T5: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T6: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T7: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T8: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T9: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
[src]
T0: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T1: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T2: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T3: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T4: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T5: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T6: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T7: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T8: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T9: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + for<'a> Deserialize<'a>,
T1: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T2: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T3: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T4: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T5: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T6: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T7: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T8: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T9: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T10: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
[src]
T0: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T1: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T2: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T3: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T4: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T5: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T6: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T7: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T8: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T9: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T10: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + for<'a> Deserialize<'a>,
T1: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T2: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T3: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T4: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T5: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T6: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T7: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T8: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T9: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T10: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T11: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
[src]
T0: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T1: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T2: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T3: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T4: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T5: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T6: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T7: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T8: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T9: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T10: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T11: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + for<'a> Deserialize<'a>,
T1: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T2: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T3: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T4: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T5: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T6: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T7: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T8: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T9: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T10: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T11: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T12: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
[src]
T0: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T1: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T2: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T3: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T4: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T5: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T6: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T7: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T8: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T9: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T10: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T11: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T12: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + for<'a> Deserialize<'a>,
T1: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T2: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T3: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T4: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T5: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T6: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T7: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T8: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T9: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T10: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T11: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T12: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T13: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
[src]
T0: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T1: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T2: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T3: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T4: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T5: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T6: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T7: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T8: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T9: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T10: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T11: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T12: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T13: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + for<'a> Deserialize<'a>,
T1: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T2: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T3: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T4: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T5: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T6: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T7: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T8: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T9: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T10: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T11: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T12: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T13: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T14: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
[src]
T0: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T1: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T2: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T3: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T4: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T5: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T6: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T7: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T8: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T9: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T10: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T11: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T12: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T13: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T14: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + for<'a> Deserialize<'a>,
T1: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T2: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T3: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T4: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T5: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T6: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T7: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T8: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T9: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T10: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T11: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T12: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T13: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T14: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T15: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
[src]
T0: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T1: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T2: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T3: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T4: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T5: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T6: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T7: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T8: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T9: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T10: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T11: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T12: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T13: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T14: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
T15: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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> where
K: SerdeDiff + Serialize + for<'a> Deserialize<'a> + Hash + Eq,
V: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
[src]
K: SerdeDiff + Serialize + for<'a> Deserialize<'a> + Hash + Eq,
V: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + for<'a> Deserialize<'a> + Ord,
V: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
[src]
K: SerdeDiff + Serialize + for<'a> Deserialize<'a> + Ord,
V: SerdeDiff + Serialize + for<'a> Deserialize<'a>,
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 NonZeroU16
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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 + Serialize + for<'a> Deserialize<'a>> SerdeDiff for Option<T>
[src]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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]
pub fn diff<'a, S: SerializeSeq>(
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
[src]
&self,
ctx: &mut DiffContext<'a, S>,
other: &Self
) -> Result<bool, S::Error>
pub 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>,