Started working on sequence deserialization.

crates/node/src/serde_blocktree/de.rs

@@ -4,13 +4,8 @@ use std::io::Read;
 use super::error::{Error, Result, MapError};
 use serde::de::{
     self,
-    DeserializeSeed,
-    EnumAccess,
-    IntoDeserializer,
-    MapAccess,
-    SeqAccess,
-    VariantAccess,
     Visitor,
+    DeserializeSeed
 };
 
 pub struct Deserializer<'de, T: Read + ?Sized> {
@@ -71,10 +66,20 @@ impl<'de, T: Read + ?Sized> Deserializer<'de, T> {
         try_from(value)
     }
 
-    fn read_string(&mut self) -> Result<String> {
+    fn read_bool(&mut self) -> Result<bool> {
+        let byte = self.read_u8()?;
+        Ok(byte > 0)
+    }
+
+    fn read_vec(&mut self) -> Result<Vec<u8>> {
         let len = self.read_u32()?;
         let mut vec = Vec::with_capacity(try_from(len)?);
         self.read_exact(&mut vec)?;
+        Ok(vec)
+    }
+
+    fn read_string(&mut self) -> Result<String> {
+        let vec = self.read_vec()?;
         let value = String::from_utf8(vec).or_else(|_| Err(Error::TypeConversion))?;
         Ok(value)
     }
@@ -88,8 +93,8 @@ impl<'de, 'a, T: Read> de::Deserializer<'de> for &'a mut Deserializer<'de, T> {
     }
 
     fn deserialize_bool<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
-        let value = self.read_u8()?;
-        visitor.visit_bool(value > 0)
+        let value = self.read_bool()?;
+        visitor.visit_bool(value)
     }
 
     fn deserialize_i8<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
@@ -164,35 +169,44 @@ impl<'de, 'a, T: Read> de::Deserializer<'de> for &'a mut Deserializer<'de, T> {
     }
 
     fn deserialize_bytes<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
-        Err(Error::Message("NOT IMPLEMENTED".to_string()))
+        let value = self.read_vec()?;
+        visitor.visit_bytes(value.as_slice())
     }
 
     fn deserialize_byte_buf<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
-        Err(Error::Message("NOT IMPLEMENTED".to_string()))
+        let value = self.read_vec()?;
+        visitor.visit_byte_buf(value)
     }
 
     fn deserialize_option<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
-        Err(Error::Message("NOT IMPLEMENTED".to_string()))
+        let some = self.read_bool()?;
+        if some {
+            visitor.visit_some(self)
+        } 
+        else {
+            visitor.visit_none()
+        }
     }
 
     fn deserialize_unit<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
-        Err(Error::Message("NOT IMPLEMENTED".to_string()))
+        visitor.visit_unit()
     }
 
     fn deserialize_unit_struct<V: Visitor<'de>>(
-        self, name: &'static str, visitor: V
+        self, _name: &'static str, visitor: V
     ) -> Result<V::Value> {
-        Err(Error::Message("NOT IMPLEMENTED".to_string()))
+        visitor.visit_unit()
     }
 
     fn deserialize_newtype_struct<V: Visitor<'de>>(
-        self, name: &'static str, visitor: V
+        self, _name: &'static str, visitor: V
     ) -> Result<V::Value> {
-        Err(Error::Message("NOT IMPLEMENTED".to_string()))
+        visitor.visit_newtype_struct(self)
     }
 
     fn deserialize_seq<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
-        Err(Error::Message("NOT IMPLEMENTED".to_string()))
+        let len = self.read_u32()?;
+        visitor.visit_seq(SeqAccess { elements_left: len, deserializer: self})
     }
 
     fn deserialize_tuple<V: Visitor<'de>>(self, len: usize, visitor: V) -> Result<V::Value> {
@@ -234,16 +248,34 @@ impl<'de, 'a, T: Read> de::Deserializer<'de> for &'a mut Deserializer<'de, T> {
     }
 }
 
+struct SeqAccess<'a, 'de, T: Read> {
+    elements_left: u32,
+    deserializer: &'a mut Deserializer<'de, T>
+}
+
+impl<'a, 'de, T: Read> de::SeqAccess<'de> for SeqAccess<'a, 'de, T> {
+    type Error = Error;
+
+    fn next_element_seed<U: DeserializeSeed<'de>>(&mut self, seed: U) -> Result<Option<U::Value>> {
+        if 0 == self.elements_left {
+            return Ok(None)
+        }
+
+        self.elements_left -= 1;
+        seed.deserialize(&mut *self.deserializer).map(Some)
+    }
+}
+
 mod test {
     #[allow(unused_imports)]
     use super::{Result, Deserializer};
     
-    //#[test]
-    //fn new() -> Result<()> {
-    //    let mut vec: Vec<u8> = vec![0xA1];
-    //    let slice = &mut vec[..];
-    //    let de = Deserializer::new(slice);
-    //    assert_eq!(slice, de.input);
-    //    Ok(())
-    //}
+    #[test]
+    fn new() -> Result<()> {
+        let vec: Vec<u8> = vec![0xA1, 0x42, 0x71, 0xAC];
+        let mut slice = vec.as_slice();
+        let de = Deserializer::new(&mut slice);
+        assert_eq!(&vec.as_slice(), de.input);
+        Ok(())
+    }
 }

crates/node/src/serde_blocktree/ser.rs

@@ -162,14 +162,15 @@ impl<'a, T: Write> ser::Serializer for &'a mut Serializer<T> {
         self.serialize_bytes(v.as_bytes())
     }
 
-    /// The none variant is stored as a zero byte.
+    /// The none variant is stored by serializing false.
     fn serialize_none(self) -> Result<Self::Ok> {
-        self.output.write_all(&[0]).map_error()?;
+        self.serialize_bool(false)?;
         Ok(())
     }
 
-    /// A some variant is just stored using the representation of its value.
+    /// A some variant is stored by serializing true before the of its value.
     fn serialize_some<U: ?Sized + Serialize>(self, value: &U) -> Result<Self::Ok> {
+        self.serialize_bool(true)?;
         value.serialize(self)?;
         Ok(())
     }
@@ -562,7 +563,7 @@ mod test {
         // Sometimes I use decimal, sometimes I use hex. So what, want to fight about it?
         let some: Option<i32> = Option::Some(0x02D8);
         let buffer = super::to_vec(&some)?;
-        assert_eq!(vec![0xD8, 0x02, 0x00, 0x00], buffer);
+        assert_eq!(vec![0x01, 0xD8, 0x02, 0x00, 0x00], buffer);
         Ok(())
     }