Add an API for persisting arbitrary fields

nih_plug_derive/src/lib.rs

@@ -4,7 +4,7 @@ use proc_macro::TokenStream;
 use quote::quote;
 use syn::spanned::Spanned;
 
-#[proc_macro_derive(Params, attributes(id))]
+#[proc_macro_derive(Params, attributes(id, persist))]
 pub fn derive_params(input: TokenStream) -> TokenStream {
     let ast = syn::parse_macro_input!(input as syn::DeriveInput);
 
@@ -24,19 +24,23 @@ pub fn derive_params(input: TokenStream) -> TokenStream {
         }
     };
 
-    // We only care about fields with an `id` attribute. We'll build a that creates a hashmap
-    // containing pointers to those parmaeters.
-    let mut param_insert_tokens = Vec::new();
+    // We only care about fields with `id` and `persist` attributes. For the `id` fields we'll build
+    // a mapping function that creates a hashmap containing pointers to those parmaeters. For the
+    // `persist` function we'll create functions that serialize and deserialize those fields
+    // individually (so they can be added and removed independently of eachother) using JSON.
+    let mut param_mapping_insert_tokens = Vec::new();
+    let mut field_serialize_tokens = Vec::new();
+    let mut field_deserialize_tokens = Vec::new();
     for field in fields.named {
         let field_name = match &field.ident {
             Some(ident) => ident,
             _ => continue,
         };
 
-        // We'll add another attribute for persistent fields later, and that's going to be mutually
-        // exclusive with this id attribute
-        let mut id_attr = None;
-        for attr in field.attrs {
+        // These two attributes are mutually exclusive
+        let mut id_attr: Option<String> = None;
+        let mut persist_attr: Option<String> = None;
+        for attr in &field.attrs {
             if attr.path.is_ident("id") {
                 match attr.parse_meta() {
                     Ok(syn::Meta::NameValue(syn::MetaNameValue {
@@ -60,14 +64,83 @@ pub fn derive_params(input: TokenStream) -> TokenStream {
                         .into()
                     }
                 };
+            } else if attr.path.is_ident("persist") {
+                match attr.parse_meta() {
+                    Ok(syn::Meta::NameValue(syn::MetaNameValue {
+                        lit: syn::Lit::Str(s),
+                        ..
+                    })) => {
+                        if persist_attr.is_none() {
+                            persist_attr = Some(s.value());
+                        } else {
+                            return syn::Error::new(attr.span(), "Duplicate persist attribute")
+                                .to_compile_error()
+                                .into();
+                        }
+                    }
+                    _ => {
+                        return syn::Error::new(
+                            attr.span(),
+                            "The persist attribute should be a key-value pair with a string argument: #[persist = \"foo_bar\"]",
+                        )
+                        .to_compile_error()
+                        .into()
+                    }
+                };
             }
         }
 
-        if let Some(param_id) = id_attr {
-            // The specific parameter types know how to convert themselves into the correct ParamPtr
-            // variant
-            param_insert_tokens
-                .push(quote! { param_map.insert(#param_id, self.#field_name.as_ptr()); });
+        match (id_attr, persist_attr) {
+            (Some(param_id), None) => {
+                // The specific parameter types know how to convert themselves into the correct ParamPtr
+                // variant
+                param_mapping_insert_tokens
+                    .push(quote! { param_map.insert(#param_id, self.#field_name.as_ptr()); });
+            }
+            (None, Some(stable_name)) => {
+                // We don't know anything about the field types, but because we can generate this
+                // function we get type erasure for free since we only need to worry about byte
+                // vectors
+                field_serialize_tokens.push(quote! {
+                    match ::nih_plug::params::serialize_field(&self.#field_name) {
+                        Ok(data) => {
+                            serialized.insert(String::from(#stable_name), data);
+                        }
+                        Err(err) => {
+                            ::nih_plug::nih_log!(
+                                "Could not serialize '{}': {}",
+                                #stable_name,
+                                err
+                            )
+                        }
+                    };
+                });
+                field_deserialize_tokens.push(quote! {
+                     #stable_name => {
+                         match ::nih_plug::params::deserialize_field(&data) {
+                             Ok(deserialized) => {
+                                 self.#field_name = deserialized;
+                             }
+                             Err(err) => {
+                                 ::nih_plug::nih_log!(
+                                     "Could not deserialize '{}': {}",
+                                     #stable_name,
+                                     err
+                                 )
+                             }
+                         };
+                     }
+                });
+            }
+            (Some(_), Some(_)) => {
+                return syn::Error::new(
+                    field.span(),
+                    "The id and persist attributes are mutually exclusive",
+                )
+                .to_compile_error()
+                .into();
+            }
+            (None, None) => (),
         }
     }
 
@@ -78,10 +151,27 @@ pub fn derive_params(input: TokenStream) -> TokenStream {
             ) -> std::collections::HashMap<&'static str, nih_plug::params::ParamPtr> {
                 let mut param_map = std::collections::HashMap::new();
 
-                #(#param_insert_tokens)*
+                #(#param_mapping_insert_tokens)*
 
                 param_map
             }
+
+            fn serialize_fields(&self) -> ::std::collections::HashMap<String, Vec<u8>> {
+                let mut serialized = ::std::collections::HashMap::new();
+
+                #(#field_serialize_tokens)*
+
+                serialized
+            }
+
+            fn deserialize_fields(&mut self, serialized: ::std::collections::HashMap<&str, Vec<u8>>) {
+                for (field_name, data) in serialized {
+                    match field_name {
+                        #(#field_deserialize_tokens)*
+                        _ => nih_log!("Unknown field name: {}", field_name),
+                    }
+                }
+            }
         }
     }
     .into()