chore(data): more ser impls

Author: LizAinslie

crates/data/src/lib.rs

@@ -1,25 +1,74 @@
 use uuid::Uuid;
 
-#[cfg(feature = "serde")]
-pub mod serde;
 mod ser;
 mod error;
 
 pub struct DataType<T> {
     id: Uuid
 }
 
+#[derive(PartialEq)]
 pub enum Marker {
-    Unit = 0,
-    SeqBegin = 1,
-    SeqEnd = 2,
+    Unit,
+    SeqBegin,
+    SeqBreak,
+    SeqEnd,
+    OptBegin,
+    OptEnd,
+    StructBegin,
+    StructBreak,
+    StructEnd,
+    TupleBegin,
+    TupleBreak,
+    TupleEnd,
+    TupleStructBegin,
+    TupleStructBreak,
+    TupleStructEnd,
 }
 
-// impl From<Marker> for u8 {
-//     fn from(marker: Marker) -> Self {
-//         match marker {
-//             Marker::OptionBegin => 1,
-//             Marker::OptionEnd => 2,
-//         }
-//     }
-// }
+impl From<Marker> for u8 {
+    fn from(value: Marker) -> Self {
+        match value {
+            Marker::Unit => 0,
+            Marker::SeqBegin => 1,
+            Marker::SeqBreak => 2,
+            Marker::SeqEnd => 3,
+            Marker::OptBegin => 4,
+            Marker::OptEnd => 5,
+            Marker::StructBegin => 6,
+            Marker::StructBreak => 7,
+            Marker::StructEnd => 8,
+            Marker::TupleBegin => 9,
+            Marker::TupleBreak => 10,
+            Marker::TupleEnd => 11,
+            Marker::TupleStructBegin => 12,
+            Marker::TupleStructBreak => 13,
+            Marker::TupleStructEnd => 14,
+        }
+    }
+}
+
+impl TryFrom<u8> for Marker {
+    type Error = error::Error;
+
+    fn try_from(value: u8) -> error::Result<Self> {
+        match value {
+            0 => Ok(Marker::Unit),
+            1 => Ok(Marker::SeqBegin),
+            2 => Ok(Marker::SeqBreak),
+            3 => Ok(Marker::SeqEnd),
+            4 => Ok(Marker::OptBegin),
+            5 => Ok(Marker::OptEnd),
+            6 => Ok(Marker::StructBegin),
+            7 => Ok(Marker::StructBreak),
+            8 => Ok(Marker::StructEnd),
+            9 => Ok(Marker::TupleBegin),
+            10 => Ok(Marker::TupleBreak),
+            11 => Ok(Marker::TupleEnd),
+            12 => Ok(Marker::TupleStructBegin),
+            13 => Ok(Marker::TupleStructBreak),
+            14 => Ok(Marker::TupleStructEnd),
+            _ => Err(error::Error::Message("Unknown ".to_string()))
+        }
+    }
+}

crates/data/src/ser.rs

@@ -33,9 +33,9 @@ where
 impl<'a, TData> ser::Serializer for &'a mut DataSerializer<TData> where TData : Serialize {
     type Ok = ();
     type Error = Error;
-    type SerializeSeq = ();
-    type SerializeTuple = ();
-    type SerializeTupleStruct = ();
+    type SerializeSeq = Self;
+    type SerializeTuple = Self;
+    type SerializeTupleStruct = Self;
     type SerializeTupleVariant = ();
     type SerializeMap = ();
     type SerializeStruct = ();
@@ -141,14 +141,20 @@ impl<'a, TData> ser::Serializer for &'a mut DataSerializer<TData> where TData :
     }
 
     fn serialize_none(self) -> Result<()> {
-        self.serialize_unit()
+        self.marker(Marker::OptBegin)?;
+        self.serialize_bool(false)?; // not present
+        self.serialize_unit()?;
+        self.marker(Marker::OptEnd)
     }
 
     fn serialize_some<T>(self, value: &T) -> Result<()>
     where
         T: ?Sized + Serialize
     {
-        todo!()
+        self.marker(Marker::OptBegin)?;
+        self.serialize_bool(true)?; // present
+        value.serialize(self)?;
+        self.marker(Marker::OptEnd)
     }
 
     fn serialize_unit(self) -> Result<()> {
@@ -177,37 +183,109 @@ impl<'a, TData> ser::Serializer for &'a mut DataSerializer<TData> where TData :
         todo!()
     }
 
-    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
-        todo!()
+    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
+        if let Some(length) = len {
+            self.serialize_u64(length as u64)?;
+        }
+
+        self.marker(Marker::SeqBegin)?;
+        Ok(self)
     }
 
-    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
-        todo!()
+    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
+        self.marker(Marker::TupleBegin)?;
+        self.serialize_seq(Some(len))
     }
 
-    fn serialize_tuple_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeTupleStruct, Self::Error> {
-        todo!()
+    fn serialize_tuple_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeTupleStruct> {
+        self.serialize_seq(Some(len))
     }
 
-    fn serialize_tuple_variant(self, name: &'static str, variant_index: u32, variant: &'static str, len: usize) -> Result<Self::SerializeTupleVariant, Self::Error> {
+    fn serialize_tuple_variant(self, name: &'static str, variant_index: u32, variant: &'static str, len: usize) -> Result<Self::SerializeTupleVariant> {
         todo!()
     }
 
-    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
+    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
         todo!()
     }
 
-    fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct, Self::Error> {
+    fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
         todo!()
     }
 
-    fn serialize_struct_variant(self, name: &'static str, variant_index: u32, variant: &'static str, len: usize) -> Result<Self::SerializeStructVariant, Self::Error> {
+    fn serialize_struct_variant(self, name: &'static str, variant_index: u32, variant: &'static str, len: usize) -> Result<Self::SerializeStructVariant> {
         todo!()
     }
 }
 
-impl<'a, TData> ser::SerializeSeq for &'a mut DataSerializer<TData>
+impl<'a, TData> ser::SerializeSeq for &'a mut DataSerializer<TData> {
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
+    where
+        T: ?Sized + Serialize
+    {
+        let last_marker = Marker::try_from(&self.output[(self.output.len()-1)..][0])?;
+
+        if last_marker != Marker::SeqBegin {
+            self.marker(Marker::SeqBreak)?;
+        }
+
+        value.serialize(&mut **self)
+    }
+
+    fn end(self) -> Result<()> {
+        self.marker(Marker::SeqEnd)
+    }
+}
+
+impl<'a, TData : Serialize> ser::SerializeTuple for &'a mut DataSerializer<TData> {
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_element<TElement>(&mut self, value: &TElement) -> Result<()>
+    where
+        TElement: ?Sized + Serialize,
+    {
+        let last_marker = Marker::try_from(&self.output[(self.output.len()-1)..][0])?;
+
+        if last_marker != Marker::TupleBegin {
+            self.marker(Marker::TupleBreak)?;
+        }
+        value.serialize(&mut **self)
+    }
+
+    fn end(self) -> Result<()> {
+        self.marker(Marker::TupleEnd)?;
+        Ok(())
+    }
+}
+
+impl<'a, TData : Serialize> ser::SerializeTupleStruct for &'a mut DataSerializer<TData> {
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
+    where
+        T: ?Sized + Serialize,
+    {
+        let last_marker = Marker::try_from(&self.output[(self.output.len()-1)..][0])?;
+
+        if last_marker != Marker::TupleStructBegin {
+            self.marker(Marker::TupleStructBreak)?;
+        }
+        value.serialize(&mut **self)
+    }
+
+    fn end(self) -> Result<()> {
+        self.marker(Marker::TupleStructEnd)?;
+        Ok(())
+    }
+}
+
+
 
 trait SerializeData<TData> where TData: SerializeData<TData> {
-    fn serialize(serializer: DataSerializer<TData, dyn SerializeData<TData>>) -> io::Result<usize>;
+    fn serialize(serializer: DataSerializer<TData>) -> io::Result<usize>;
 }