Struct MapDelta 

pub struct MapDelta<K, V, D> {
    pub add: Vec<(K, V)>,
    pub remove: Vec<K>,
    pub change: Vec<KeyedDelta<K, D>>,
}

A keyed diff between two collections of entries.

The three parts are deliberately asymmetric, and that asymmetry is the whole point of the field type: add carries whole entries because the receiver has never seen them, while remove carries bare keys and change carries deltas, because for those the receiver already holds the rest.

Nothing here records position — see SeqDelta for that.

Fields

add: Vec<(K, V)>

Entries whose keys are in the new collection but not the old one.

remove: Vec<K>

Keys that were in the old collection but are not in the new one.

change: Vec<KeyedDelta<K, D>>

Keys in both collections whose values differ, and how.

Implementations

impl<K, V, D> MapDelta<K, V, D>

pub fn is_empty(&self) -> bool

Whether the two collections held the same entries, and so nothing needs sending.

Trait Implementations

impl<K: Clone, V: Clone, D: Clone> Clone for MapDelta<K, V, D>

fn clone(&self) -> MapDelta<K, V, D>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<K: Debug, V: Debug, D: Debug> Debug for MapDelta<K, V, D>

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

Formats the value using the given formatter.

impl<K, V, D> Default for MapDelta<K, V, D>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, K, V, D> Deserialize<'de> for MapDelta<K, V, D>

where K: Deserialize<'de>, V: Deserialize<'de>, D: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<K: Eq, V: Eq, D: Eq> Eq for MapDelta<K, V, D>

impl<K: PartialEq, V: PartialEq, D: PartialEq> PartialEq for MapDelta<K, V, D>

fn eq(&self, other: &MapDelta<K, V, D>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<K, V, D> Serialize for MapDelta<K, V, D>

where K: Serialize, V: Serialize, D: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<K: PartialEq, V: PartialEq, D: PartialEq> StructuralPartialEq for MapDelta<K, V, D>