Implement Versionize for arrays with size up to 32

Signed-off-by: Ioana Chirca <[email protected]>

Author: ioanachirca

coverage_config_aarch64.json

@@ -1 +1 @@
-{"coverage_score": 92.8, "exclude_path": "", "crate_features": ""}
+{"coverage_score": 92.7, "exclude_path": "", "crate_features": ""}

coverage_config_x86_64.json

@@ -1 +1 @@
-{"coverage_score": 93.0, "exclude_path": "", "crate_features": ""}
+{"coverage_score": 93.2, "exclude_path": "", "crate_features": ""}

src/primitives.rs

@@ -62,6 +62,66 @@ impl_versionize!(f64);
 impl_versionize!(char);
 impl_versionize!(String);
 
+macro_rules! impl_versionize_array_with_size {
+    ($ty:literal) => {
+        impl<T> Versionize for [T; $ty]
+        where
+            T: Copy + Default + Versionize,
+        {
+            #[inline]
+            fn serialize<W: std::io::Write>(
+                &self,
+                writer: &mut W,
+                version_map: &VersionMap,
+                app_version: u16,
+            ) -> VersionizeResult<()> {
+                for element in self {
+                    element.serialize(writer, version_map, app_version)?;
+                }
+
+                Ok(())
+            }
+
+            #[inline]
+            fn deserialize<R: std::io::Read>(
+                reader: &mut R,
+                version_map: &VersionMap,
+                app_version: u16,
+            ) -> VersionizeResult<Self> {
+                let mut array = [T::default(); $ty];
+                for i in 0..$ty {
+                    array[i] = T::deserialize(reader, version_map, app_version)?;
+                }
+                Ok(array)
+            }
+
+            // Not used yet.
+            fn version() -> u16 {
+                1
+            }
+        }
+    };
+}
+
+// Conventionally, traits are available for primitive arrays only up to size 32
+// until the const generics feature is implemented.
+// [https://doc.rust-lang.org/std/primitive.array.html]
+// [https://github.com/rust-lang/rust/issues/44580]
+macro_rules! impl_versionize_arrays {
+    ($($N:literal)+) => {
+        $(
+            impl_versionize_array_with_size!($N);
+        )+
+    }
+}
+
+impl_versionize_arrays! {
+    0  1  2  3  4  5  6  7  8  9
+   10 11 12 13 14 15 16 17 18 19
+   20 21 22 23 24 25 26 27 28 29
+   30 31 32
+}
+
 impl<T> Versionize for Box<T>
 where
     T: Versionize,

tests/test.rs

@@ -636,11 +636,13 @@ fn test_versionize_struct_with_array() {
     struct TestStruct {
         a: [u32; SIZE],
         b: [u8; dummy_mod::SIZE],
+        c: Option<[i16; SIZE]>,
     }
 
     let test_struct = TestStruct {
         a: [1; SIZE],
         b: [2; dummy_mod::SIZE],
+        c: Some([3; SIZE]),
     };
 
     let mut mem = vec![0; 4096];