add op feature for filler

Author: yanganto

derive/src/filler.rs

@@ -141,6 +141,46 @@ impl Filler {
         #[cfg(not(feature = "status"))]
         let status_impl = quote!();
 
+        #[cfg(feature = "op")]
+        let op_impl = quote! {
+            impl #generics core::ops::Shl<#name #generics> for #struct_name #generics #where_clause {
+                type Output = Self;
+
+                fn shl(mut self, rhs: #name #generics) -> Self {
+                    struct_patch::traits::Filler::apply(&mut self, rhs);
+                    self
+                }
+            }
+
+            impl #generics core::ops::Add<Self> for #name #generics #where_clause {
+                type Output = Self;
+
+                fn add(mut self, rhs: Self) -> Self {
+                    #(
+                        self.#native_value_field_names = self.#native_value_field_names + rhs.#native_value_field_names;
+                    )*
+                    #(
+                        self.#extendable_field_names.extend(rhs.#extendable_field_names.into_iter());
+                    )*
+                    #(
+                        if let Some(v) = self.#option_field_names {
+                            if let Some(u) = rhs.#option_field_names {
+                                self.#option_field_names = Some(v + &u);
+                            } else {
+                                self.#option_field_names = Some(v);
+                            }
+                        } else {
+                            self.#option_field_names = rhs.#option_field_names;
+                        }
+                    )*
+                    self
+                }
+            }
+        };
+
+        #[cfg(not(feature = "op"))]
+        let op_impl = quote!();
+
         let filler_impl = quote! {
             impl #generics struct_patch::traits::Filler< #name #generics > for #struct_name #generics #where_clause  {
                 fn apply(&mut self, filler: #name #generics) {
@@ -177,6 +217,7 @@ impl Filler {
             #filler_struct
             #status_impl
             #filler_impl
+            #op_impl
         })
     }
 

lib/examples/filler.rs

@@ -5,7 +5,7 @@ use struct_patch::Filler;
 use struct_patch::Status;
 
 // NOTE: Default, Extend, IntoIterator, is_empty are required for extendable type
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 struct WrapVec {
     inner: Vec<usize>,
 }
@@ -30,8 +30,8 @@ impl WrapVec {
     }
 }
 
-#[derive(Default, Filler)]
-#[filler(attribute(derive(Debug, Default)))]
+#[derive(Clone, Default, Filler)]
+#[filler(attribute(derive(Clone, Debug, Default)))]
 struct Item {
     field_complete: bool,
     // Will check the field is equal to the value to define the field is empty or not
@@ -127,4 +127,36 @@ fn main() {
     filler.field_int = 5;
     item.apply(filler);
     assert_eq!(item.field_int, 7);
+
+    #[cfg(feature = "op")]
+    {
+        let item = Item::default();
+
+        let mut filler1: ItemFiller = Item::new_empty_filler();
+        filler1.field_int = 7;
+        filler1.list = vec![1, 2];
+
+        let mut filler2: ItemFiller = Item::new_empty_filler();
+        filler2.field_int = 8;
+        filler2.list = vec![3, 4];
+        filler2.maybe_field_string = Some("Something".into());
+
+        let final_item_from_added_fillers = item.clone() << (filler1.clone() + filler2.clone());
+
+        assert_eq!(final_item_from_added_fillers.field_int, 15);
+        assert_eq!(final_item_from_added_fillers.list, vec![1, 2, 3, 4]);
+        assert_eq!(
+            final_item_from_added_fillers.maybe_field_string,
+            Some("Something".into())
+        );
+
+        let final_item_after_fillers_applied = item << filler1 << filler2;
+
+        assert_eq!(final_item_after_fillers_applied.field_int, 7);
+        assert_eq!(final_item_after_fillers_applied.list, vec![1, 2]);
+        assert_eq!(
+            final_item_after_fillers_applied.maybe_field_string,
+            Some("Something".into())
+        );
+    }
 }