Add minimal record reading support

src/lib.rs

@@ -61,3 +61,4 @@ pub use crate::npy::{
 };
 #[cfg(feature = "npz")]
 pub use crate::npz::{NpzReader, NpzWriter, ReadNpzError, WriteNpzError};
+pub use py_literal;

src/npy/elements/mod.rs

@@ -200,3 +200,5 @@ mod bool;
 #[cfg(feature = "num-complex-0_4")]
 mod complex;
 mod num;
+mod record;
+pub use record::RecordFromSlice;

src/npy/elements/record.rs

@@ -0,0 +1,30 @@
+//! Currently only little-endian is supported
+
+use crate::{ReadDataError, ReadableElement};
+// pub use ndarray_derive::RecordFromSlice;
+use py_literal;
+
+pub trait RecordFromSlice: Sized {
+    fn compatible_schema(type_descr: &py_literal::Value) -> bool;
+
+    fn from_raw_slice<R: std::io::Read>(reader: &mut R) -> Result<Self, ReadDataError>;
+}
+
+impl<T: RecordFromSlice> ReadableElement for T {
+    fn read_to_end_exact_vec<R: std::io::Read>(
+        mut reader: R,
+        type_desc: &py_literal::Value,
+        len: usize,
+    ) -> Result<Vec<Self>, ReadDataError> {
+        if !T::compatible_schema(type_desc) {
+            return Err(ReadDataError::WrongDescriptor(type_desc.clone()));
+        }
+
+        let mut out = Vec::with_capacity(len);
+        for _ in 0..len {
+            out.push(RecordFromSlice::from_raw_slice(&mut reader)?);
+        }
+
+        Ok(out)
+    }
+}

src/npy/mod.rs

@@ -4,6 +4,7 @@
 
 mod elements;
 pub mod header;
+pub use elements::RecordFromSlice;
 
 use self::header::{
     FormatHeaderError, Header, Layout, ParseHeaderError, ReadHeaderError, WriteHeaderError,

tests/integration/examples.rs

@@ -440,3 +440,64 @@ fn zeroed() {
     assert_eq!(arr, Array3::<i32>::zeros(SHAPE));
     assert!(arr.is_standard_layout());
 }
+
+#[cfg(target_endian = "little")]
+#[test]
+fn record_reading() {
+    use ndarray_npy::npy::RecordFromSlice;
+
+    #[derive(PartialEq, Debug)]
+    struct Record {
+        x: i32,
+        y: i32,
+    }
+
+    impl RecordFromSlice for Record {
+        fn from_raw_slice<R: std::io::Read>(
+            reader: &mut R,
+        ) -> Result<Self, ndarray_npy::ReadDataError> {
+            let mut buf = [0u8; 4];
+
+            reader
+                .read_exact(&mut buf)
+                .map_err(ndarray_npy::ReadDataError::Io)?;
+            let x = i32::from_le_bytes(buf);
+            reader
+                .read_exact(&mut buf)
+                .map_err(ndarray_npy::ReadDataError::Io)?;
+            let y = i32::from_le_bytes(buf);
+            Ok(Record { x, y })
+        }
+
+        // NOTE: partial validation
+        fn compatible_schema(type_descr: &py_literal::Value) -> bool {
+            match type_descr {
+                py_literal::Value::List(values) => matches!(
+                    &values[..],
+                    // 2 Values per record
+                    [py_literal::Value::Tuple(..), py_literal::Value::Tuple(..)]
+                ),
+                _ => false,
+            }
+        }
+    }
+
+    // np.save("example_xy_little_endian_record", np.rec.array([(42, 42), (35, 35)], dtype=[('x', np.int32), ('y', np.int32)]))
+    let record_array: Array1<Record> =
+        ndarray_npy::read_npy("resources/example_xy_little_endian_record.npy")
+            .expect("Failed to load npy");
+
+    assert_eq!(record_array[0], Record { x: 42, y: 42 });
+    assert_eq!(record_array[1], Record { x: 35, y: 35 });
+    assert_eq!(record_array.len(), 2);
+
+    // np.save("example_xy_little_endian_record_2d.npy", np.rec.array([[(42, 42), (35, 35)]], dtype=[('x', np.int32), ('y', np.int32)]))
+    let record_array: Array2<Record> =
+        ndarray_npy::read_npy("resources/example_xy_little_endian_record_2d.npy")
+            .expect("Failed to load npy");
+
+    assert_eq!(record_array[[0, 0]], Record { x: 42, y: 42 });
+    assert_eq!(record_array[[0, 1]], Record { x: 35, y: 35 });
+    assert_eq!(record_array.len_of(Axis(0)), 1);
+    assert_eq!(record_array.len_of(Axis(1)), 2);
+}