Patching nested maps

[d3d9]

Hi again, thank you for the help with the previous issue.
I'm now implementing the full requirements for my config, which includes various kinds of nesting and option usage, which I was able to use.
I am however struggling with what to do after the introduction of maps. In my example LinearMap is from heapless but it shouldn't be relevant whether we use something like BTreeMap or LinearMap.
I saw that there are solutions regarding extendable (however I need to use Patch, not Filler) or Addable, however I can't find documentation on that and I'm confused if it means there would be a difference between using .patch() or the operators.

My goal is to be able to do this:

• If the patch map has a key that already exists in the map, apply the patch to the existing value normally
• If the patch map has a key that does not exist in the map, add a new value to the map.
• Since the patch value might be incomplete, maybe use the same logic like with option so I can use for example none_as_default.
• There should be some way to say that I want an existing map entry with a specific key to be removed (Similar to how I can use Some(None) in a patch to set an Option field to None)

Is there any chance this can be done with the existing or new macros, or with a custom patch implementation, or something like that?

#[derive(Debug, Clone, Copy, Serialize_repr, Deserialize_repr, PartialEq, Eq, Ord, PartialOrd)]
#[repr(u8)]
pub enum KeyA {
    TEST1 = 1,
    TEST2 = 2
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, Default, PartialEq, Eq, Patch)]
#[patch(attribute(derive(Debug, Default, Deserialize)))]
pub struct ExampleA {
    pub test1: u32,
    pub test2: u16,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Patch)]
#[patch(attribute(derive(Debug, Default, Deserialize)))]
pub struct ExampleB {
    pub foo: Option<NonZero<u16>>,
    pub bar: Option<NonZero<u16>>
}

#[derive(Debug, Clone, Serialize, Default, PartialEq, Eq, Patch)]
#[patch(attribute(derive(Debug, Default, Deserialize)))]
pub struct InnerConfig {
    // TODO #[???]
    pub example_a: LinearMap<KeyA, ExampleA, 4>,
    // TODO #[???]
    pub example_b: LinearMap<String<10>, ExampleB, 4>,
}

#[derive(Debug, Clone, Serialize, Default, Patch)]
#[patch(attribute(derive(Debug, Default, Deserialize)))]
pub struct Config {
    #[patch(nesting)]
    pub inner: InnerConfig,
}

[d3d9]

I've come up with this for now. With LinearMap I had some problems regarding into_iter and the capacity is also a special case compared to the alloc maps. I feel like this is very specific and complicated, so it probably won't be able to be integrated into the existing macros. But it works for me with the requirements I mentioned above (+ I added the ability to clear the whole map as well using yet another Option..), so I can proceed in my project with this for now.

macro_rules! linear_map_patchable {
    (
        $Wrapper:ident,
        $WrapperPatch:ident,
        $K:ty,
        $V:ty,
        $P:ty,
        $N:expr
    ) => {
        #[derive(Debug, Clone, Default, Serialize, Deserialize, Eq, PartialEq)]
        #[repr(transparent)]
        #[serde(transparent)]
        pub struct $Wrapper(pub LinearMap<$K, $V, $N>);

        #[derive(Debug, Default, Deserialize)]
        #[repr(transparent)]
        #[serde(transparent)]
        pub struct $WrapperPatch(pub Option<Option<LinearMap<$K, Option<$P>, $N>>>);
        // Option< - if None, we don't touch this field at all
        // Option<Option< - if None, clear the existing map, else patch it
        // Option<$P> - if None, remove the existing entry, else patch it

        impl struct_patch::traits::Status for $WrapperPatch {
            fn is_empty(&self) -> bool {
                if self.0.is_some() {
                    return false;
                }
                true
            }
        }
        impl struct_patch::traits::Patch<$WrapperPatch> for $Wrapper {
            fn apply(&mut self, patch: $WrapperPatch) {
                if let Some(patch_opt) = patch.0 { // If patch is None, nothing is to be changed
                    if let Some(mut patch) = patch_opt { // If the inner option is Some, apply patches
                        for (k, v) in patch.iter_mut() {
                            match (self.0.get_mut(k), v) {
                                // Remove entry
                                (None, None) => {},
                                (Some(_), None) => { self.0.remove(k); },
                                // New entry
                                (None, entry_patch @ Some(_)) => {
                                    let mut value = <$V>::default();
                                    value.apply(entry_patch.take().unwrap());
                                    // the clone() is stupid but into_iter of LinearMap gave me references..
                                    self.0.insert(k.clone(), value).ok(); // This silently ignores an error if it is full!!
                                },
                                // Patch existing
                                (Some(existing), entry_patch @ Some(_)) => {
                                    existing.apply(entry_patch.take().unwrap());
                                },
                            }
                        }
                    } else { // If inner is none, clear
                        self.0.clear();
                    }
                }
            }
            fn into_patch(self) -> $WrapperPatch {
                // same into_iter problem as above
                $WrapperPatch(Some(Some(self.0.into_iter().map(|(k, v)| (k.clone(), Some(v.into_patch()))).collect())))
            }
            fn into_patch_by_diff(self, previous_struct: Self) -> $WrapperPatch {
                $WrapperPatch(todo!()) // TODO
            }
            fn new_empty_patch() -> $WrapperPatch {
                $WrapperPatch(None)
            }
        }
        impl core::ops::Shl<$WrapperPatch> for $Wrapper {
            type Output = Self;
            fn shl(mut self, rhs: $WrapperPatch) -> Self {
                struct_patch::traits::Patch::apply(&mut self, rhs);
                self
            }
        }
        impl core::ops::Add<Self> for $WrapperPatch {
            type Output = Self;
            fn add(self, rhs: Self) -> Self {
                Self(match (self.0, rhs.0) {
                        (Some(_), Some(_)) => { panic!("Conflict in Add") },
                        (Some(a), None) => Some(a),
                        (None, Some(b)) => Some(b),
                        (None, None) => None,                
                    }
                )
            }
        }
    };
}

[yanganto]

I will check your message and full response later.
Just one thing ahead, it will always welcome to add feature or new macros with test cases if you feel any others will run into the same issue with you. 😄