alex/nih-plug
1
0
Fork 0
Code Activity

Preserve order for grouped params, fix persist

Browse source 
...for nested but not grouped parameters. This was a regression in
4affa40244.
This commit is contained in:
Robbert van der Helm 2022-11-17 18:13:13 +01:00
parent cc313fcc2c
commit a69526c758
1 changed files with 21 additions and 43 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

64
nih_plug_derive/src/params.rs
View file

@ -27,13 +27,12 @@ pub fn derive_params(input: TokenStream) -> TokenStream {
// parameters. 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. The `nested` fields should also implement the `Params` trait and their fields will be
// inherited and added to this field's lists. We'll also enforce that there are no duplicate
// keys at compile time.
// inherited and added to this field's param mapping list. The order follows the declaration
// order We'll also enforce that there are no duplicate keys for `id` fields at compile time.
// TODO: This duplication check doesn't work for nested fields since we don't know anything
// about the fields on the nested structs
let mut params: Vec<Param> = Vec::new();
let mut persistent_fields: Vec<PersistentField> = Vec::new();
let mut group_params: Vec<NestedParams> = Vec::new();
for field in fields.named {
let field_name = match &field.ident {
Some(ident) => ident,
@ -133,7 +132,7 @@ pub fn derive_params(input: TokenStream) -> TokenStream {
}
};
} else if attr.path.is_ident("nested") {
// This one is more complicated. Support an `array` attribute, an `id_prefix =
// This one is more complicated. Supports an `array` attribute, an `id_prefix =
// "foo"` attribute, and a `group = "group name"` attribute. All are optional, and
// the first two are mutually exclusive.
let mut nested_array = false;
@ -207,7 +206,7 @@ pub fn derive_params(input: TokenStream) -> TokenStream {
}
}
let param = match (nested_array, nested_id_prefix) {
params.push(Param::Nested(match (nested_array, nested_id_prefix) {
(true, None) => NestedParams::Array {
field: field_name.clone(),
group: nested_group,
@ -229,20 +228,7 @@ pub fn derive_params(input: TokenStream) -> TokenStream {
.to_compile_error()
.into()
}
};
// Grouped parameters are handled differently than nested parameters:
// DAWs that support grouped parameters usually display parameter groups below "regular" ones
// in a tree view. To keep the order consistent with those, group parameters are collected
// separately, so they can be inserted at the end of the parameter list.
// Nested parameters without a group on the other hand are merely an implementation detail of
// the plugin and thus should not behave different than regular parameters to the user. Because
// of this, they are inserted alongside the "regular" ones.
if param.is_group() {
group_params.push(param);
} else {
params.push(Param::Nested(param));
}
}));
processed_attribute = true;
}
@ -263,8 +249,7 @@ pub fn derive_params(input: TokenStream) -> TokenStream {
// The next step is build the gathered information into tokens that can be spliced into a
// `Params` implementation
let param_map_tokens = {
let param_mapping_self_tokens = params.into_iter().map(|p| p.to_token());
let param_mapping_group_tokens = group_params.iter().map(|p| p.to_token());
let param_mapping_tokens = params.iter().map(|p| p.param_map_tokens());
quote! {
// This may not be in scope otherwise, used to call .as_ptr()
@ -272,8 +257,7 @@ pub fn derive_params(input: TokenStream) -> TokenStream {
#[allow(unused_mut)]
let mut param_map = Vec::new();
#(param_map.extend(#param_mapping_self_tokens); )*
#(param_map.extend(#param_mapping_group_tokens); )*
#(param_map.extend(#param_mapping_tokens); )*
param_map
}
@ -330,8 +314,12 @@ pub fn derive_params(input: TokenStream) -> TokenStream {
.unzip();
let (serialize_fields_nested_tokens, deserialize_fields_nested_tokens): (Vec<_>, Vec<_>) =
group_params
params
.iter()
.filter_map(|p| match p {
Param::Single { .. } => None,
Param::Nested(nested) => Some(nested),
})
.map(|nested| match nested {
NestedParams::Inline { field, .. } | NestedParams::Prefixed { field, .. } => (
// TODO: For some reason the macro won't parse correctly if you inline this
@ -419,12 +407,14 @@ enum Param {
}
impl Param {
fn to_token(&self) -> proc_macro2::TokenStream {
/// Generate the tokens needed for a field (or nested parameter struct) to add itself to the
/// parameter map.
fn param_map_tokens(&self) -> proc_macro2::TokenStream {
match self {
Param::Single { field, id } => {
quote! { [(String::from(#id), self.#field.as_ptr(), String::new())] }
}
Param::Nested(params) => params.to_token(),
Param::Nested(params) => params.param_map_tokens(),
}
}
}
@ -464,27 +454,15 @@ enum NestedParams {
}
impl NestedParams {
fn is_group(&self) -> bool {
let group = match self {
NestedParams::Inline { field: _, group } => group,
NestedParams::Prefixed {
field: _,
id_prefix: _,
group,
} => group,
NestedParams::Array { field: _, group } => group,
};
group.is_some()
}
fn to_token(&self) -> proc_macro2::TokenStream {
/// Constrruct an iterator that iterates over all parmaeters of a nested parameter object. This
/// takes ID prefixes and suffixes into account, and prefixes the group to the parameter's
/// existing groups if the `group` attribute on the `#[nested]` macro was specified.
fn param_map_tokens(&self) -> proc_macro2::TokenStream {
// How nested parameters are handled depends on the `NestedParams` variant.
// These are pairs of `(parameter_id, param_ptr, param_group)`. The specific
// parameter types know how to convert themselves into the correct ParamPtr variant.
// Top-level parameters have no group, and we'll prefix the group name specified in
// the `#[nested(...)]` attribute to fields coming from nested groups
// the `#[nested(...)]` attribute to fields coming from nested groups.
match self {
// TODO: No idea how to splice this as an `Option<&str>`, so this involves some
// copy-pasting