Derive Macro serde_diff_derive::SerdeDiff

#[derive(SerdeDiff)]
{
    // Attributes available to this derive:
    #[serde_diff]
}

Examples

Minimal example of implementing diff support for a struct

use serde_diff::SerdeDiff;
use serde::{Serialize, Deserialize};
#[derive(SerdeDiff)]
struct MySimpleStruct {
   val: u32,
}

Example of an opaque (non-recursive diff) implementation of SerdeDiff using #[serde_diff(opaque)] on the struct. Field types are not required to implement SerdeDiff in this case, only Serialize + Deserialize + PartialEq.

use serde_diff::SerdeDiff;
use serde::{Serialize, Deserialize};
#[derive(SerdeDiff, Serialize, Deserialize, PartialEq)]
#[serde_diff(opaque)]
struct OpaqueTest(i32);

Example of a struct with an opaque field using #[serde_diff(opaque)] on a field.

use serde_diff::SerdeDiff;
use serde::{Serialize, Deserialize};
#[derive(SerdeDiff)]
struct MyInnerStruct {
    #[serde_diff(opaque)]
    heap: std::collections::HashSet<i32>,
}

Example of diffing a target struct MySimpleStruct that is being used for serialization instead of the struct MyComplexStruct itself. Useful for cases where derived data is present at runtime, but not wanted in the serialized form.

use serde_diff::SerdeDiff;
use serde::{Serialize, Deserialize};
#[derive(SerdeDiff, Serialize, Deserialize, Clone)]
#[serde(from = "MySimpleStruct", into = "MySimpleStruct")]
#[serde_diff(target = "MySimpleStruct")]
struct MyComplexStruct {
   val: u32,
   derived_val: String,
}

#[derive(SerdeDiff, Serialize, Deserialize, Default)]
#[serde(rename = "MyComplexStruct", default)]
struct MySimpleStruct {
   val: u32,
}

impl From<MySimpleStruct> for MyComplexStruct {
   fn from(my_simple_struct: MySimpleStruct) -> Self {
       MyComplexStruct {
           val: my_simple_struct.val,
           derived_val: my_simple_struct.val.to_string(),
       }
   }
}

impl Into<MySimpleStruct> for MyComplexStruct {
    fn into(self) -> MySimpleStruct {
        MySimpleStruct {
            val: self.val,
        }
    }
}