Add support for arrays

src/ezcad/array_of.rs

@@ -0,0 +1,42 @@
+use std::ops::{DerefMut, Deref};
+
+use binrw::{binrw, BinRead, BinWrite};
+
+/// Wrapper to prefix array of single type
+#[binrw]
+#[derive(Debug, PartialEq)]
+pub struct ArrayOf<T>
+where
+    T: for<'a> BinRead<Args<'a> = ()> + 'static,
+    T: for<'a> BinWrite<Args<'a> = ()> + 'static,
+{
+    // Temporary variable that holds number of elements
+    #[br(temp)]
+    #[bw(try_calc(u32::try_from(value.len())))]
+    size: u32,
+
+    #[br(count = size)]
+    pub value: Vec<T>,
+}
+
+impl<T> Deref for ArrayOf<T> 
+where
+    T: for<'a> BinRead<Args<'a> = ()> + 'static,
+    T: for<'a> BinWrite<Args<'a> = ()> + 'static,
+{
+    type Target = Vec<T>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.value
+    }
+}
+
+impl<T> DerefMut for ArrayOf<T>
+where
+    T: for<'a> BinRead<Args<'a> = ()> + 'static,
+    T: for<'a> BinWrite<Args<'a> = ()> + 'static,
+{
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.value
+    }
+}

src/ezcad/field_of.rs

@@ -1,14 +1,13 @@
-use binrw::{binread, binwrite, BinRead, BinWrite};
+use binrw::{BinRead, BinWrite, binrw};
 use std::{mem::size_of, ops::{DerefMut, Deref}};
 
 /// Wrapper to prefix arbitrary structs with size of struct as u32
-#[binwrite]
-#[binread]
+#[binrw]
 #[derive(Debug, PartialEq)]
 pub struct FieldOf<T>
 where
-    T: for<'a> BinRead<Args<'a> = ()> + Default,
-    T: for<'a> BinWrite<Args<'a> = ()> + Default,
+    T: for<'a> BinRead<Args<'a> = ()>,
+    T: for<'a> BinWrite<Args<'a> = ()>,
 {
     // Temporary variable that must match size of value
     #[br(temp, assert(size == size_of::<T>().try_into().unwrap()))]
@@ -20,8 +19,8 @@ where
 
 impl<T> Deref for FieldOf<T> 
 where
-    T: for<'a> BinRead<Args<'a> = ()> + Default,
-    T: for<'a> BinWrite<Args<'a> = ()> + Default,
+    T: for<'a> BinRead<Args<'a> = ()>,
+    T: for<'a> BinWrite<Args<'a> = ()>,
 {
     type Target = T;
 
@@ -32,8 +31,8 @@ where
 
 impl<T> DerefMut for FieldOf<T>
 where
-    T: for<'a> BinRead<Args<'a> = ()> + Default,
-    T: for<'a> BinWrite<Args<'a> = ()> + Default,
+    T: for<'a> BinRead<Args<'a> = ()>,
+    T: for<'a> BinWrite<Args<'a> = ()>,
 {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.value

src/ezcad/mod.rs

@@ -1,2 +1,3 @@
+pub mod array_of;
 pub mod basic_field;
 pub mod field_of;

tests/array_of.rs

@@ -0,0 +1,40 @@
+use std::io::Cursor;
+
+use binrw::{BinRead, BinWrite};
+use ezcad::array_of::ArrayOf;
+
+#[test]
+fn array_of_be() {
+    let encoded: Vec<u8> = vec![0x00, 0x00, 0x00, 0x02, 0x0A, 0x0B, 0x0C, 0x0D, 0x01, 0x02, 0x03, 0x04];
+    let decoded: ArrayOf<u32> = ArrayOf {
+        value: vec![0x0A0B0C0D, 0x01020304]
+    };
+
+    let mut stream: Cursor<Vec<u8>> = Cursor::new(encoded.clone());
+    assert_eq!(
+        ArrayOf::<u32>::read_be(&mut stream).unwrap(),
+        decoded
+    );
+
+    let mut buffer: Cursor<Vec<u8>> = Cursor::new(vec![]);
+    decoded.write_be(&mut buffer).unwrap();
+    assert_eq!(buffer.into_inner(), encoded);
+}
+
+#[test]
+fn array_of_le() {
+    let encoded: Vec<u8> = vec![0x02, 0x00, 0x00, 0x00, 0x0A, 0x0B, 0x0C, 0x0D, 0x01, 0x02, 0x03, 0x04];
+    let decoded: ArrayOf<u32> = ArrayOf {
+        value: vec![0x0D0C0B0A, 0x04030201]
+    };
+
+    let mut stream: Cursor<Vec<u8>> = Cursor::new(encoded.clone());
+    assert_eq!(
+        ArrayOf::<u32>::read_le(&mut stream).unwrap(),
+        decoded
+    );
+
+    let mut buffer: Cursor<Vec<u8>> = Cursor::new(vec![]);
+    decoded.write_le(&mut buffer).unwrap();
+    assert_eq!(buffer.into_inner(), encoded);
+}