Started testing enum deserialization.

crates/node/src/serde_blocktree/de.rs

@@ -7,6 +7,7 @@ use serde::de::{
     Visitor,
     DeserializeSeed
 };
+use std::marker::PhantomData;
 
 pub struct Deserializer<'de, T: Read + ?Sized> {
     input: &'de mut T,
@@ -210,29 +211,30 @@ impl<'de, 'a, T: Read> de::Deserializer<'de> for &'a mut Deserializer<'de, T> {
     }
 
     fn deserialize_tuple<V: Visitor<'de>>(self, len: usize, visitor: V) -> Result<V::Value> {
-        Err(Error::Message("NOT IMPLEMENTED".to_string()))
+        visitor.visit_seq(SeqAccess { elements_left: try_from(len)?, deserializer: self})
     }
 
     fn deserialize_tuple_struct<V: Visitor<'de>>(
-        self, name: &'static str, len: usize, visitor: V
+        self, _name: &'static str, len: usize, visitor: V
     ) -> Result<V::Value> {
-        Err(Error::Message("NOT IMPLEMENTED".to_string()))
+        self.deserialize_tuple(len, visitor)
     }
 
     fn deserialize_map<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
-        Err(Error::Message("NOT IMPLEMENTED".to_string()))
+        let len = self.read_u32()?;
+        visitor.visit_map(SeqAccess { elements_left: len, deserializer: self})
     }
 
     fn deserialize_struct<V: Visitor<'de>>(
-        self, name: &'static str, fields: &'static [&'static str], visitor: V
+        self, _name: &'static str, _fields: &'static [&'static str], visitor: V
     ) -> Result<V::Value> {
-        Err(Error::Message("NOT IMPLEMENTED".to_string()))
+        visitor.visit_newtype_struct(self)
     }
 
     fn deserialize_enum<V: Visitor<'de>>(
-        self, name: &'static str, variants: &'static [&'static str], visitor: V
+        self, _name: &'static str, _variants: &'static [&'static str], visitor: V
     ) -> Result<V::Value> {
-        Err(Error::Message("NOT IMPLEMENTED".to_string()))
+        visitor.visit_enum(self)
     }
 
     fn deserialize_identifier<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
@@ -256,7 +258,20 @@ struct SeqAccess<'a, 'de, T: Read> {
 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>> {
+    fn next_element_seed<S: DeserializeSeed<'de>>(&mut self, seed: S) -> Result<Option<S::Value>> {
+        if 0 == self.elements_left {
+            return Ok(None)
+        }
+
+        self.elements_left -= 1;
+        seed.deserialize(&mut *self.deserializer).map(Some)
+    }
+}
+
+impl<'a, 'de, T: Read> de::MapAccess<'de> for SeqAccess<'a, 'de, T> {
+    type Error = Error;
+
+    fn next_key_seed<S: DeserializeSeed<'de>>(&mut self, seed: S) -> Result<Option<S::Value>> {
         if 0 == self.elements_left {
             return Ok(None)
         }
@@ -264,9 +279,46 @@ impl<'a, 'de, T: Read> de::SeqAccess<'de> for SeqAccess<'a, 'de, T> {
         self.elements_left -= 1;
         seed.deserialize(&mut *self.deserializer).map(Some)
     }
+
+    fn next_value_seed<U: DeserializeSeed<'de>>(&mut self, seed: U) -> Result<U::Value> {
+        seed.deserialize(&mut *self.deserializer)
+    }
+}
+
+impl<'de, T: Read> de::VariantAccess<'de> for &mut Deserializer<'de, T> {
+    type Error = Error;
+
+    fn unit_variant(self) -> Result<()> {
+        Ok(())
+    }
+
+    fn newtype_variant_seed<S: DeserializeSeed<'de>>(self, seed: S) -> Result<S::Value> {
+        seed.deserialize(self)
+    }
+
+    fn tuple_variant<V: Visitor<'de>>(self, len: usize, visitor: V) -> Result<V::Value> {
+        de::Deserializer::deserialize_tuple(self, len, visitor)
+    }
+
+    fn struct_variant<V: Visitor<'de>>(
+        self, fields: &'static [&'static str], visitor: V
+    ) -> Result<V::Value> {
+        de::Deserializer::deserialize_struct(self, "", fields, visitor)
+    }
+}
+
+impl<'a, 'de, T: Read> de::EnumAccess<'de> for &mut Deserializer<'de, T> {
+    type Error = Error;
+    type Variant = Self;
+    
+    fn variant_seed<S: DeserializeSeed<'de>>(self, seed: S) -> Result<(S::Value, Self::Variant)> {
+        let value = seed.deserialize(&mut *self)?;
+        Ok((value, self))
+    }
 }
 
 mod test {
+    use serde::Deserialize;
     #[allow(unused_imports)]
     use super::{Result, Deserializer};
     
@@ -278,4 +330,16 @@ mod test {
         assert_eq!(&vec.as_slice(), de.input);
         Ok(())
     }
+
+    #[test]
+    fn deserialize_enum() -> Result<()> {
+        #[derive(Debug, PartialEq, Deserialize)]
+        enum Emotions { Anguish, Catharsis }
+        let vec: Vec<u8> = vec![0x01];
+        let mut slice = vec.as_slice();
+        let mut de = Deserializer::new(&mut slice);
+        let value = Deserialize::deserialize(&mut de)?;
+        assert_eq!(Emotions::Catharsis, value);
+        Ok(())
+    }
 }