simdata: refactor RmpData trait to accept generic RmpRead/Write traits

src/simdata.rs

@@ -1,7 +1,7 @@
-use rmp::{Marker, decode::{ExtMeta, RmpRead, ValueReadError}, encode::{RmpWrite, ValueWriteError}};
+use rmp::{decode::{ExtMeta, RmpRead, RmpReadErr, ValueReadError}, encode::{RmpWrite, RmpWriteErr, ValueWriteError}};
 
 pub trait RmpData: Sized {
-    fn from_rmp<Reader: RmpRead>(reader: &mut Reader) -> Result<Self, SimDataError<ValueReadError<Reader::Error>>>;
+    fn from_rmp<Reader: RmpRead<Error = E>, E: RmpReadErr + RmpWriteErr>(reader: &mut Reader) -> Result<Self, SimDataError<E>>;
     fn write_rmp<Writer: RmpWrite>(&self, writer: &mut Writer) -> Result<(), ValueWriteError<Writer::Error>>;
 }
 
@@ -11,12 +11,13 @@ pub trait EventRecord: RmpData {
 }
 
 #[derive(Debug)]
-pub enum SimDataError<E> {
+pub enum SimDataError<E: RmpReadErr + RmpWriteErr> {
     StreamIndexMissing,
     InvalidChunkSize { expected: usize, found: usize },
     MissingTimecode,
     BadString,
-    DecodeError(E),
+    DecodeError(ValueReadError<E>),
+    EncodeError(ValueWriteError<E>),
     EndOfStream,
     UnsupportedStreamType(ExtMeta),
     EventHeaderMissing,
@@ -24,12 +25,18 @@ pub enum SimDataError<E> {
     NotEnoughSpace
 }
 
-impl<E> From<E> for SimDataError<E> {
+impl<E: RmpReadErr + RmpWriteErr> From<ValueReadError<E>> for SimDataError<E> {
-    fn from(value: E) -> Self {
+    fn from(value: ValueReadError<E>) -> Self {
         SimDataError::DecodeError(value)
     }
 }
 
+impl<E: RmpReadErr + RmpWriteErr> From<ValueWriteError<E>> for SimDataError<E> {
+    fn from(value: ValueWriteError<E>) -> Self {
+        SimDataError::EncodeError(value)
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum StreamType {
     IMU,
@@ -69,11 +76,11 @@ pub struct StreamIndex {
 }
 
 impl RmpData for StreamIndex {
-    fn from_rmp<Reader: RmpRead>(reader: &mut Reader) -> Result<Self, SimDataError<ValueReadError<Reader::Error>>> {
+    fn from_rmp<Reader: RmpRead<Error = E>, E: RmpReadErr + RmpWriteErr>(reader: &mut Reader) -> Result<Self, SimDataError<E>> {
         if rmp::decode::read_u16(reader)? != 0xDA1A {
             Err(SimDataError::StreamIndexMissing)
         } else {
-            rmp::decode::read_array_len(reader).map(|count| {
+            rmp::decode::read_u64(reader).map(|count| {
                 Self {
                     count: count as usize
                 }
@@ -83,7 +90,7 @@ impl RmpData for StreamIndex {
 
     fn write_rmp<Writer: RmpWrite>(&self, writer: &mut Writer) -> Result<(), ValueWriteError<Writer::Error>> {
         rmp::encode::write_u16(writer, 0xDA1A)?;
-        rmp::encode::write_array_len(writer, self.count as u32)?;
+        rmp::encode::write_u64(writer, self.count as u64)?;
         Ok(())
     }
 }
@@ -96,7 +103,7 @@ pub struct BundleEventHeader {
 }
 
 impl RmpData for BundleEventHeader {
-    fn from_rmp<Reader: RmpRead>(reader: &mut Reader) -> Result<Self, SimDataError<ValueReadError<Reader::Error>>> {
+    fn from_rmp<Reader: RmpRead<Error = E>, E: RmpReadErr + RmpWriteErr>(reader: &mut Reader) -> Result<Self, SimDataError<E>> {
         let meta = rmp::decode::read_i8(reader)?;
         if let Ok(id) = meta.try_into() {
             Ok(Self {
@@ -119,7 +126,7 @@ pub struct StreamHeader {
 }
 
 impl RmpData for StreamHeader {
-    fn from_rmp<Reader: RmpRead>(reader: &mut Reader) -> Result<Self, SimDataError<ValueReadError<Reader::Error>>> {
+    fn from_rmp<Reader: RmpRead<Error = E>, E: RmpReadErr + RmpWriteErr>(reader: &mut Reader) -> Result<Self, SimDataError<E>> {
         let meta = rmp::decode::read_ext_meta(reader)?;
         if let Ok(id) = meta.typeid.try_into() {
             Ok(Self {
@@ -143,14 +150,14 @@ pub struct EventStreamHeader {
 }
 
 impl RmpData for EventStreamHeader {
-    fn from_rmp<Reader: RmpRead>(reader: &mut Reader) -> Result<Self, SimDataError<ValueReadError<Reader::Error>>> {
+    fn from_rmp<Reader: RmpRead<Error = E>, E: RmpReadErr + RmpWriteErr>(reader: &mut Reader) -> Result<Self, SimDataError<E>> {
         Ok(Self {
-            count: rmp::decode::read_array_len(reader)? as usize
+            count: rmp::decode::read_u32(reader)? as usize
         })
     }
 
     fn write_rmp<Writer: RmpWrite>(&self, writer: &mut Writer) -> Result<(), ValueWriteError<Writer::Error>> {
-        rmp::encode::write_array_len(writer, self.count as u32)?;
+        rmp::encode::write_u32(writer, self.count as u32)?;
         Ok(())
     }
 }
@@ -162,7 +169,7 @@ pub struct StreamEvent<Event: EventRecord> {
 }
 
 impl<Event: EventRecord> RmpData for StreamEvent<Event> {
-    fn from_rmp<Reader: RmpRead>(reader: &mut Reader) -> Result<Self, SimDataError<ValueReadError<Reader::Error>>> {
+    fn from_rmp<Reader: RmpRead<Error = E>, E: RmpReadErr + RmpWriteErr>(reader: &mut Reader) -> Result<Self, SimDataError<E>> {
         let chunk_len = rmp::decode::read_array_len(reader).map_err(|_| { SimDataError::EventHeaderMissing })? as usize;
         // Add 1 to the field count for the timestamp
         if chunk_len != Event::field_count() + 1 {
@@ -210,7 +217,7 @@ impl EventRecord for IMUReading {
 }
 
 impl RmpData for GPSReading {
-    fn from_rmp<Reader: RmpRead>(reader: &mut Reader) -> Result<Self, SimDataError<ValueReadError<Reader::Error>>> {
+    fn from_rmp<Reader: RmpRead<Error = E>, E: RmpReadErr + RmpWriteErr>(reader: &mut Reader) -> Result<Self, SimDataError<E>> {
         Ok(Self {
             lat: rmp::decode::read_f64(reader)?,
             lon: rmp::decode::read_f64(reader)?
@@ -234,7 +241,7 @@ pub struct IMUReading {
 }
 
 impl RmpData for IMUReading {
-    fn from_rmp<Reader: RmpRead>(reader: &mut Reader) -> Result<Self, SimDataError<ValueReadError<Reader::Error>>> {
+    fn from_rmp<Reader: RmpRead<Error = E>, E: RmpReadErr + RmpWriteErr>(reader: &mut Reader) -> Result<Self, SimDataError<E>> {
         Ok(Self {
             accel_x: rmp::decode::read_f64(reader)?,
             accel_y: rmp::decode::read_f64(reader)?,
@@ -264,7 +271,7 @@ pub struct AnnotationReading {
 }
 
 impl RmpData for AnnotationReading {
-    fn from_rmp<Reader: RmpRead>(reader: &mut Reader) -> Result<Self, SimDataError<ValueReadError<Reader::Error>>> {
+    fn from_rmp<Reader: RmpRead<Error = E>, E: RmpReadErr + RmpWriteErr>(reader: &mut Reader) -> Result<Self, SimDataError<E>> {
         let mut buf = [0; 32];
         rmp::decode::read_str(reader, &mut buf).map_err(|_| { SimDataError::BadString })?;
         Ok(Self {