Merge pull request aldanor#203 from ajtribick/field-renaming

Add hdf5 helper attribute with rename functionality

Author: mulimoen

CHANGELOG.md

@@ -5,6 +5,7 @@
 ### Added
 
 - Support for HDF5 version 1.13.0.
+- Support field renaming via `#[hdf5(rename = "new_name")]` helper attribute.
 
 ### Changed
 
@@ -25,7 +26,7 @@ Release date: Nov 21, 2021.
   extents (like tuples of integers) where `impl TryInto<Extents>` is required.
 - Support for HDF5 versions 1.12.1 and 1.10.8.
 - `#[derive(H5Type)]` now supports structs / tuple structs with `repr(packed)`.
-- `#[derive(H5Type)]` now supports structs / tuple structs with 
+- `#[derive(H5Type)]` now supports structs / tuple structs with
   `repr(transparent)` (the generated HDF5 type is equivalent to the type of
   the field and is not compound).
 
@@ -93,7 +94,7 @@ Release date: Oct 23, 2021.
   memchecker option enabled. This option is force-enabled by default if using
   a dll version of the HDF5 library on Windows.
 - Added new `DynValue` type which represents a dynamic self-describing HDF5
-  object that also knows how to deallocate itself. It supports all the HDF5 
+  object that also knows how to deallocate itself. It supports all the HDF5
   types including compound types, strings and arrays.
 - Added support for attributes and a new `Attribute` object type. The attribute
   API uses the new dataset API with some restrictions imposed by HDF5 library
@@ -113,7 +114,7 @@ Release date: Oct 23, 2021.
   - `get_all_of_type`: find all objects in a group of a given type.
   - Shortcut methods for finding all objects in a group of a given type:
     `datasets`, `groups`, `named_datatypes`, `link_external`.
-- Added to `Handle`: 
+- Added to `Handle`:
   - `id_type`: get native HDF5 object type.
   - `try_borrow`: instantiate a handle but don't take ownership of the object.
   - `Handle` now implements `Debug`.
@@ -169,7 +170,7 @@ Release date: Oct 23, 2021.
 ### Fixed
 
 - A potential memory leak of identifier handles has been identified and fixed.
-- A potential race condition occurring in multi-thread library initialisation 
+- A potential race condition occurring in multi-thread library initialisation
   has been identified and fixed.
 
 ### Removed
@@ -189,7 +190,7 @@ Release date: Jan 27, 2021.
 
 ### Changed
 
-- Dependencies are bumped to the newest major versions; `ndarray` users may 
+- Dependencies are bumped to the newest major versions; `ndarray` users may
   now use both version `0.13` and version `0.14`.
 
 ### Fixed
@@ -207,8 +208,8 @@ Release date: Aug 9, 2020.
   via `hdf5-sys/static` feature (as of this release, the version of the bundled
   sources of HDF5 is 1.10.6). CMake is required for building. For further
   details, see the docs for `hdf5-sys`.
-- Thanks to static build option, the documentation will now be built on 
-  [docs.rs](https://docs.rs/crate/hdf5); if it builds successfully, this 
+- Thanks to static build option, the documentation will now be built on
+  [docs.rs](https://docs.rs/crate/hdf5); if it builds successfully, this
   will be the official documentation source from now on.
 - Add support for HDF5 1.12 on all platforms and include it in CI.
 
@@ -227,8 +228,8 @@ Release date: Aug 9, 2020.
 - We now force the variable-length allocator that HDF5 uses when reading data
   to use `libc::malloc` and `libc::free`, so that they can be deallocated
   properly by `VarLenString` and `VarLenArray` in `hdf5-types`. Previously,
-  this could cause a rare but serious failure for Windows builds when the 
-  default allocator used for vlen types by HDF5 was not matching the 
+  this could cause a rare but serious failure for Windows builds when the
+  default allocator used for vlen types by HDF5 was not matching the
   libc deallocator.
 - Use `std::panic::catch_unwind` in all cases where we use extern C callbacks,
   so that they are panic-safe.
@@ -404,7 +405,7 @@ Release date: Mar 8, 2019.
   `Deref`-based hierarchy instead (53eff4f). `ID` and `FromID` traits have been
   removed. Traits like `Location`, `Object` and a few others have been replaced
   with real types (wrappers around HDF5 handles, same as the concrete types
-  like `File`). Subtypes then dereference into parent types, so the user can 
+  like `File`). Subtypes then dereference into parent types, so the user can
   call methods of the parent type without having to import any traits into
   scope (for instance, `File` dereferences into `Group`, which dereferences
   into `Location`, which dereferences into `Object`).
@@ -441,11 +442,11 @@ Release date: Jul 29, 2015.
 ### Added
 
 - Full support of `msvc` target on Windows. CI tests on AppVeyor now use
-  official releases of HDF5 binaries (1.8.16, VS2015, x86_x64). The `gnu` 
+  official releases of HDF5 binaries (1.8.16, VS2015, x86_x64). The `gnu`
   target are still unofficially supported but won't be tested.
 - If `HDF5_LIBDIR` is not specified when building on Windows and `PATH`
   contains what looks like the `bin` folder of HDF5 installation, the library
-  directory will be inferred automatically. The official HDF5 installers add 
+  directory will be inferred automatically. The official HDF5 installers add
   the `bin` folder to user path, so the official MSVC releases should just work
   out of the box without having to set any environment variables.
 - The library is now split into three crates: `hdf5-lib` (requests linkage to
@@ -475,7 +476,7 @@ Release date: Jul 29, 2015.
 
 ### Fixed
 
-- Fixed dangling pointer problems when strings were passed as pointers to 
+- Fixed dangling pointer problems when strings were passed as pointers to
   the C API.
 - Fixed target path not being passed correctly in `Container::link_soft`.
 

hdf5-derive/src/lib.rs

@@ -8,11 +8,11 @@ use proc_macro2::{Ident, Span, TokenStream};
 use proc_macro_error::{abort, proc_macro_error};
 use quote::{quote, ToTokens};
 use syn::{
-    parse_macro_input, AttrStyle, Attribute, Data, DeriveInput, Expr, Fields, Index, Meta,
+    parse_macro_input, AttrStyle, Attribute, Data, DeriveInput, Expr, Fields, Index, Lit, Meta,
     NestedMeta, Type, TypeGenerics, TypePath,
 };
 
-#[proc_macro_derive(H5Type)]
+#[proc_macro_derive(H5Type, attributes(hdf5))]
 #[proc_macro_error]
 pub fn derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let input = parse_macro_input!(input as DeriveInput);
@@ -67,7 +67,7 @@ fn impl_transparent(ty: &Type) -> TokenStream {
     }
 }
 
-fn impl_enum(names: &[Ident], values: &[Expr], repr: &Ident) -> TokenStream {
+fn impl_enum(names: &[String], values: &[Expr], repr: &Ident) -> TokenStream {
     let size = Ident::new(
         &format!(
             "U{}",
@@ -84,7 +84,7 @@ fn impl_enum(names: &[Ident], values: &[Expr], repr: &Ident) -> TokenStream {
                 signed: #signed,
                 members: vec![#(
                     _h5::types::EnumMember {
-                        name: stringify!(#names).to_owned(),
+                        name: #names.to_owned(),
                         value: (#values) as #repr as _,
                     }
                 ),*],
@@ -132,6 +132,28 @@ fn find_repr(attrs: &[Attribute], expected: &[&str]) -> Option<Ident> {
     None
 }
 
+fn find_hdf5_rename(attrs: &[Attribute]) -> Option<String> {
+    if let Some(attr) = attrs.iter().find(|a| a.path.is_ident("hdf5")) {
+        if let Ok(Meta::List(meta_list)) = attr.parse_meta() {
+            let rename_literal = meta_list.nested.iter().find_map(|n| {
+                if let NestedMeta::Meta(Meta::NameValue(name_value)) = n {
+                    if name_value.path.is_ident("rename") {
+                        return Some(&name_value.lit);
+                    }
+                }
+
+                None
+            });
+
+            if let Some(Lit::Str(renamed)) = rename_literal {
+                return Some(renamed.value());
+            }
+        }
+    }
+
+    None
+}
+
 fn pluck<'a, I, F, T, S>(iter: I, func: F) -> Vec<S>
 where
     I: Iterator<Item = &'a T>,
@@ -166,8 +188,11 @@ fn impl_trait(
                     impl_transparent(&fields[0].ty)
                 } else {
                     let types = pluck(fields.iter(), |f| f.ty.clone());
+                    let names = pluck(fields.iter(), |f| {
+                        find_hdf5_rename(&f.attrs)
+                            .unwrap_or_else(|| f.ident.as_ref().unwrap().to_string())
+                    });
                     let fields = pluck(fields.iter(), |f| f.ident.clone().unwrap());
-                    let names = fields.iter().map(ToString::to_string).collect::<Vec<_>>();
                     impl_compound(ty, ty_generics, &fields, &names, &types)
                 }
             }
@@ -191,7 +216,11 @@ fn impl_trait(
                     assert_eq!(fields.len(), 1);
                     impl_transparent(&fields[0].ty)
                 } else {
-                    let names = (0..fields.len()).map(|f| f.to_string()).collect::<Vec<_>>();
+                    let names = fields
+                        .iter()
+                        .enumerate()
+                        .map(|(n, f)| find_hdf5_rename(&f.attrs).unwrap_or_else(|| n.to_string()))
+                        .collect::<Vec<_>>();
                     let types = pluck(fields.iter(), |f| f.ty.clone());
                     impl_compound(ty, ty_generics, &index, &names, &types)
                 }
@@ -213,7 +242,10 @@ fn impl_trait(
             let repr = find_repr(attrs, enum_reprs).unwrap_or_else(|| {
                 abort!(ty, "`H5Type` can only be derived for enums with explicit representation")
             });
-            let names = pluck(variants.iter(), |v| v.ident.clone());
+            let names = variants
+                .iter()
+                .map(|v| find_hdf5_rename(&v.attrs).unwrap_or_else(|| v.ident.to_string()))
+                .collect::<Vec<_>>();
             let values = pluck(variants.iter(), |v| v.discriminant.clone().unwrap().1);
             impl_enum(&names, &values, &repr)
         }

tests/common/gen.rs

@@ -230,3 +230,42 @@ impl Gen for VarLenStruct {
         VarLenStruct { va: Gen::gen(rng), vu: Gen::gen(rng), vla: Gen::gen(rng) }
     }
 }
+
+#[derive(H5Type, Clone, Debug, PartialEq)]
+#[repr(C)]
+pub struct RenameStruct {
+    first: i32,
+    #[hdf5(rename = "field.second")]
+    second: i64,
+}
+
+impl Gen for RenameStruct {
+    fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {
+        RenameStruct { first: Gen::gen(rng), second: Gen::gen(rng) }
+    }
+}
+
+#[derive(H5Type, Clone, Copy, Debug, PartialEq)]
+#[repr(C)]
+pub struct RenameTupleStruct(#[hdf5(rename = "my_boolean")] bool, #[hdf5(rename = "my_enum")] Enum);
+
+impl Gen for RenameTupleStruct {
+    fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {
+        RenameTupleStruct(Gen::gen(rng), Gen::gen(rng))
+    }
+}
+
+#[derive(H5Type, Clone, Copy, Debug, PartialEq)]
+#[repr(i16)]
+pub enum RenameEnum {
+    #[hdf5(rename = "coord.x")]
+    X = -2,
+    #[hdf5(rename = "coord.y")]
+    Y = 3,
+}
+
+impl Gen for RenameEnum {
+    fn gen<R: Rng + ?Sized>(rng: &mut R) -> Self {
+        *[RenameEnum::X, RenameEnum::Y].choose(rng).unwrap()
+    }
+}

tests/test_dataset.rs

@@ -8,7 +8,10 @@ use hdf5_types::TypeDescriptor;
 
 mod common;
 
-use self::common::gen::{gen_arr, gen_slice, Enum, FixedStruct, Gen, TupleStruct, VarLenStruct};
+use self::common::gen::{
+    gen_arr, gen_slice, Enum, FixedStruct, Gen, RenameEnum, RenameStruct, RenameTupleStruct,
+    TupleStruct, VarLenStruct,
+};
 use self::common::util::new_in_memory_file;
 
 fn test_write_slice<T, R>(
@@ -267,3 +270,11 @@ fn test_create_on_databuilder() {
     let _ds = file.new_dataset::<i32>().create("ds3").unwrap();
     let _ds = file.new_dataset::<i32>().shape(2).create("ds4").unwrap();
 }
+
+#[test]
+fn test_read_write_rename_fields() -> hdf5::Result<()> {
+    test_read_write::<RenameStruct>()?;
+    test_read_write::<RenameTupleStruct>()?;
+    test_read_write::<RenameEnum>()?;
+    Ok(())
+}

tests/test_datatypes.rs

@@ -53,6 +53,24 @@ pub fn test_datatype_roundtrip() {
     });
     check_roundtrip!(X, x_desc);
 
+    #[allow(dead_code)]
+    #[derive(H5Type)]
+    #[repr(i64)]
+    enum Y {
+        #[hdf5(rename = "variant.a")]
+        A = 1,
+        B = -2,
+    }
+    let y_desc = TD::Enum(EnumType {
+        size: IntSize::U8,
+        signed: true,
+        members: vec![
+            EnumMember { name: "variant.a".into(), value: 1 },
+            EnumMember { name: "B".into(), value: -2i64 as _ },
+        ],
+    });
+    check_roundtrip!(Y, y_desc);
+
     #[derive(H5Type)]
     #[repr(C)]
     struct A {
@@ -84,6 +102,35 @@ pub fn test_datatype_roundtrip() {
         size: 2 * 8 + 4 * 32 * 16,
     });
     check_roundtrip!(C, c_desc);
+
+    #[derive(H5Type)]
+    #[repr(C)]
+    struct D {
+        #[hdf5(rename = "field.one")]
+        a: f64,
+        #[hdf5(rename = "field.two")]
+        b: u64,
+    }
+    let d_desc = TD::Compound(CompoundType {
+        fields: vec![
+            CompoundField::typed::<f64>("field.one", 0, 0),
+            CompoundField::typed::<u64>("field.two", 8, 1),
+        ],
+        size: 16,
+    });
+    check_roundtrip!(D, d_desc);
+
+    #[derive(H5Type)]
+    #[repr(C)]
+    struct E(#[hdf5(rename = "alpha")] u64, f64);
+    let e_desc = TD::Compound(CompoundType {
+        fields: vec![
+            CompoundField::typed::<u64>("alpha", 0, 0),
+            CompoundField::typed::<f64>("1", 8, 1),
+        ],
+        size: 16,
+    });
+    check_roundtrip!(E, e_desc);
 }
 
 #[test]