Implement deserialize

Remove bincode crate and replace it by own written serializer

1 files changed, 35 insertions, 32 deletions

diff --git a/src/structs/ser.rs b/src/structs/ser.rs
index 8aa95a5..6833fb8 100644
--- a/src/structs/ser.rs
+++ b/src/structs/ser.rs
@@ -43,17 +43,17 @@ impl ser::Serializer for &mut ArchiveSerializer {
     }
 
     fn serialize_i16(self, v: i16) -> StructResult<()> {
-        self.bytes.append(&mut self.settings.byte_order.i16(v));
+        self.bytes.append(&mut self.settings.byte_order.form_i16(v));
         Ok(())
     }
 
     fn serialize_i32(self, v: i32) -> StructResult<()> {
-        self.bytes.append(&mut self.settings.byte_order.i32(v));
+        self.bytes.append(&mut self.settings.byte_order.form_i32(v));
         Ok(())
     }
 
     fn serialize_i64(self, v: i64) -> StructResult<()> {
-        self.bytes.append(&mut self.settings.byte_order.i64(v));
+        self.bytes.append(&mut self.settings.byte_order.form_i64(v));
         Ok(())
     }
 
@@ -63,54 +63,57 @@ impl ser::Serializer for &mut ArchiveSerializer {
     }
 
     fn serialize_u16(self, v: u16) -> StructResult<()> {
-        self.bytes.append(&mut self.settings.byte_order.u16(v));
+        self.bytes.append(&mut self.settings.byte_order.form_u16(v));
         Ok(())
     }
 
     fn serialize_u32(self, v: u32) -> StructResult<()> {
-        self.bytes.append(&mut self.settings.byte_order.u32(v));
+        self.bytes.append(&mut self.settings.byte_order.form_u32(v));
         Ok(())
     }
 
     fn serialize_u64(self, v: u64) -> StructResult<()> {
-        self.bytes.append(&mut self.settings.byte_order.u64(v));
+        self.bytes.append(&mut self.settings.byte_order.form_u64(v));
         Ok(())
     }
 
     fn serialize_f32(self, v: f32) -> StructResult<()> {
-        self.bytes.append(&mut self.settings.byte_order.f32(v));
+        self.bytes.append(&mut self.settings.byte_order.form_f32(v));
         Ok(())
     }
 
     fn serialize_f64(self, v: f64) -> StructResult<()> {
-        self.bytes.append(&mut self.settings.byte_order.f64(v));
+        self.bytes.append(&mut self.settings.byte_order.form_f64(v));
         Ok(())
     }
 
     fn serialize_char(self, v: char) -> StructResult<()> {
-        self.bytes.push(v as u8);
-        Ok(())
+        Err(StructError::SerializationNotSupported { type_name: "char" }.into())
     }
 
-    fn serialize_str(self, v: &str) -> StructResult<()> {
-        self.bytes.append(&mut v.as_bytes().to_vec());
-        Ok(())
+    fn serialize_str(self, _v: &str) -> StructResult<()> {
+        Err(StructError::SerializationNotSupported { type_name: "str" }.into())
     }
 
-    fn serialize_bytes(self, v: &[u8]) -> StructResult<()> {
-        self.bytes.append(&mut v.to_vec());
-        Ok(())
+    fn serialize_bytes(self, _v: &[u8]) -> StructResult<()> {
+        Err(StructError::SerializationNotSupported { type_name: "bytes" }.into())
     }
 
     fn serialize_none(self) -> StructResult<()> {
-        Ok(())
+        Err(StructError::SerializationNotSupported {
+            type_name: "optional",
+        }
+        .into())
     }
 
     fn serialize_some<T>(self, value: &T) -> StructResult<()>
     where
         T: ?Sized + Serialize,
     {
-        value.serialize(self)
+        Err(StructError::SerializationNotSupported {
+            type_name: "optional",
+        }
+        .into())
     }
 
     fn serialize_unit(self) -> StructResult<()> {
@@ -131,7 +134,7 @@ impl ser::Serializer for &mut ArchiveSerializer {
             &mut self
                 .settings
                 .variant_index_type
-                .cast(variant_index, &self.settings.byte_order)?,
+                .cast(variant_index, &self.settings.byte_order),
         );
         Ok(())
     }
@@ -157,13 +160,13 @@ impl ser::Serializer for &mut ArchiveSerializer {
             &mut self
                 .settings
                 .variant_index_type
-                .cast(variant_index, &self.settings.byte_order)?,
+                .cast(variant_index, &self.settings.byte_order),
         );
         value.serialize(self)
     }
 
     fn serialize_seq(self, _len: Option<usize>) -> StructResult<Self::SerializeSeq> {
-        Ok(self)
+        Err(StructError::SerializationNotSupported { type_name: "seq" }.into())
     }
 
     fn serialize_tuple(self, _len: usize) -> StructResult<Self::SerializeTuple> {
@@ -189,13 +192,13 @@ impl ser::Serializer for &mut ArchiveSerializer {
             &mut self
                 .settings
                 .variant_index_type
-                .cast(variant_index, &self.settings.byte_order)?,
+                .cast(variant_index, &self.settings.byte_order),
         );
         Ok(self)
     }
 
     fn serialize_map(self, _len: Option<usize>) -> StructResult<Self::SerializeMap> {
-        Ok(self)
+        Err(StructError::SerializationNotSupported { type_name: "map" }.into())
     }
 
     fn serialize_struct(
@@ -217,7 +220,7 @@ impl ser::Serializer for &mut ArchiveSerializer {
             &mut self
                 .settings
                 .variant_index_type
-                .cast(variant_index, &self.settings.byte_order)?,
+                .cast(variant_index, &self.settings.byte_order),
         );
         Ok(self)
     }
@@ -227,15 +230,15 @@ impl ser::SerializeSeq for &mut ArchiveSerializer {
     type Ok = ();
     type Error = ArchiveError<StructError>;
 
-    fn serialize_element<T>(&mut self, value: &T) -> StructResult<()>
+    fn serialize_element<T>(&mut self, _value: &T) -> StructResult<()>
     where
         T: ?Sized + Serialize,
     {
-        value.serialize(&mut **self)
+        Err(StructError::SerializationNotSupported { type_name: "seq" }.into())
     }
 
     fn end(self) -> StructResult<()> {
-        Ok(())
+        Err(StructError::SerializationNotSupported { type_name: "seq" }.into())
     }
 }
 
@@ -291,22 +294,22 @@ impl ser::SerializeMap for &mut ArchiveSerializer {
     type Ok = ();
     type Error = ArchiveError<StructError>;
 
-    fn serialize_key<T>(&mut self, key: &T) -> StructResult<()>
+    fn serialize_key<T>(&mut self, _key: &T) -> StructResult<()>
     where
         T: ?Sized + Serialize,
     {
-        key.serialize(&mut **self)
+        Err(StructError::SerializationNotSupported { type_name: "map" }.into())
     }
 
-    fn serialize_value<T>(&mut self, value: &T) -> StructResult<()>
+    fn serialize_value<T>(&mut self, _value: &T) -> StructResult<()>
     where
         T: ?Sized + Serialize,
     {
-        value.serialize(&mut **self)
+        Err(StructError::SerializationNotSupported { type_name: "map" }.into())
     }
 
     fn end(self) -> StructResult<()> {
-        Ok(())
+        Err(StructError::SerializationNotSupported { type_name: "map" }.into())
     }
 }