Map serde support

Cargo.toml

@@ -24,6 +24,7 @@ exclude = [
 
 [dependencies]
 serde = { version = "^1.0.80", default-features = false, features = ["alloc"] }
+serde-cw-value = "0.7.0"
 
 [dev-dependencies]
 serde_derive = "^1.0.80"

src/de/map.rs

@@ -163,11 +163,11 @@ impl<'de, 'a> de::Deserializer<'de> for MapKey<'a, 'de> {
         self.de.deserialize_str(visitor)
     }
 
-    fn deserialize_string<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
     where
         V: Visitor<'de>,
     {
-        unreachable!()
+        self.deserialize_str(visitor)
     }
 
     fn deserialize_bytes<V>(self, _visitor: V) -> Result<V::Value, Self::Error>

src/de/mod.rs

@@ -576,22 +576,7 @@ impl<'a, 'de> de::Deserializer<'de> for &'a mut Deserializer<'de> {
         self.deserialize_seq(visitor)
     }
 
-    /// Unsupported. Can’t make an arbitrary-sized map in no-std. Use a struct with a
-    /// known format, or implement a custom map deserializer / visitor:
-    /// https://serde.rs/deserialize-map.html
-    fn deserialize_map<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        unreachable!()
-    }
-
-    fn deserialize_struct<V>(
-        self,
-        _name: &'static str,
-        _fields: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value>
+    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
     {
@@ -608,6 +593,19 @@ impl<'a, 'de> de::Deserializer<'de> for &'a mut Deserializer<'de> {
         } else {
             Err(Error::InvalidType)
         }
+
+    }
+
+    fn deserialize_struct<V>(
+        self,
+        _name: &'static str,
+        _fields: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_map(visitor)
     }
 
     fn deserialize_enum<V>(

src/lib.rs

@@ -65,6 +65,8 @@ pub use self::ser::{to_string, to_vec};
 
 #[cfg(test)]
 mod test {
+    use std::collections::BTreeMap;
+
     use super::*;
     use serde_derive::{Deserialize, Serialize};
 
@@ -95,6 +97,7 @@ mod test {
         published: bool,
         comments: Vec<CommentId>,
         stats: Stats,
+        balances: BTreeMap<String,u16>,
     }
 
     #[test]
@@ -107,7 +110,10 @@ mod test {
             published: false,
             comments: vec![],
             stats: Stats { views: 0, score: 0 },
+            balances:  BTreeMap::new(),
         };
+        let mut balances: BTreeMap<String,u16> = BTreeMap::new();
+        balances.insert("chareen".into(), 347);
         let max = Item {
             model: Model::Post {
                 category: "fun".to_string(),
@@ -122,6 +128,7 @@ mod test {
                 views: std::u64::MAX,
                 score: std::i64::MIN,
             },
+            balances,
         };
 
         // binary
@@ -172,6 +179,9 @@ mod test {
             author: Address("[email protected]".to_owned()),
         });
 
+        let mut balances: BTreeMap<String,u16> = BTreeMap::new();
+        balances.insert("chareen".into(), 347);
+
         let item = ModelOrItem::Item(Item {
             model: Model::Comment,
             title: "Title".to_owned(),
@@ -183,6 +193,7 @@ mod test {
                 views: 110,
                 score: 12,
             },
+            balances
         });
 
         assert_eq!(

src/ser/map.rs

@@ -0,0 +1,48 @@
+use serde::ser;
+
+use crate::ser::{Error, Result, Serializer};
+
+pub struct SerializeMap<'a>
+{
+    ser: &'a mut Serializer,
+    first: bool,
+}
+
+impl<'a> SerializeMap<'a>
+{
+    pub(crate) fn new(ser: &'a mut Serializer) -> Self {
+        SerializeMap { ser, first: true }
+    }
+}
+
+impl<'a> ser::SerializeMap for SerializeMap<'a>
+{
+    type Ok = ();
+    type Error = Error;
+
+    fn end(self) -> Result<Self::Ok> {
+        self.ser.buf.push(b'}');
+        Ok(())
+    }
+
+    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<()>
+    where
+        T: ser::Serialize,
+    {
+        if !self.first {
+            self.ser.buf.push(b',');
+        }
+        self.first = false;
+        key.serialize(&mut *self.ser)?;
+        self.ser.buf.extend_from_slice(b":");
+        Ok(())
+    }
+
+    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<()>
+    where
+        T: ser::Serialize,
+    {
+        value.serialize(&mut *self.ser)?;
+        Ok(())
+    }
+}

src/ser/mod.rs

@@ -8,9 +8,12 @@ use std::vec::Vec;
 
 use self::seq::SerializeSeq;
 use self::struct_::SerializeStruct;
+use self::map::SerializeMap;
 
 mod seq;
 mod struct_;
+mod map;
+
 
 /// Serialization result
 pub type Result<T> = ::core::result::Result<T, Error>;
@@ -153,7 +156,7 @@ impl<'a> ser::Serializer for &'a mut Serializer {
     type SerializeTuple = SerializeSeq<'a>;
     type SerializeTupleStruct = Unreachable;
     type SerializeTupleVariant = SerializeSeq<'a>;
-    type SerializeMap = Unreachable;
+    type SerializeMap = SerializeMap<'a>;
     type SerializeStruct = SerializeStruct<'a>;
     type SerializeStructVariant = SerializeStruct<'a>;
 
@@ -400,7 +403,8 @@ impl<'a> ser::Serializer for &'a mut Serializer {
     }
 
     fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
-        unreachable!()
+        self.buf.push(b'{');
+        Ok(SerializeMap::new(self))
     }
 
     fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {

src/ser/struct_.rs

@@ -3,13 +3,13 @@ use serde::ser;
 use crate::ser::{Error, Result, Serializer};
 
 pub struct SerializeStruct<'a> {
-    de: &'a mut Serializer,
+    ser: &'a mut Serializer,
     first: bool,
 }
 
 impl<'a> SerializeStruct<'a> {
-    pub(crate) fn new(de: &'a mut Serializer) -> Self {
-        SerializeStruct { de, first: true }
+    pub(crate) fn new(ser: &'a mut Serializer) -> Self {
+        SerializeStruct { ser, first: true }
     }
 }
 
@@ -23,21 +23,21 @@ impl<'a> ser::SerializeStruct for SerializeStruct<'a> {
     {
         // XXX if `value` is `None` we not produce any output for this field
         if !self.first {
-            self.de.buf.push(b',');
+            self.ser.buf.push(b',');
         }
         self.first = false;
 
-        self.de.buf.push(b'"');
-        self.de.buf.extend_from_slice(key.as_bytes());
-        self.de.buf.extend_from_slice(b"\":");
+        self.ser.buf.push(b'"');
+        self.ser.buf.extend_from_slice(key.as_bytes());
+        self.ser.buf.extend_from_slice(b"\":");
 
-        value.serialize(&mut *self.de)?;
+        value.serialize(&mut *self.ser)?;
 
         Ok(())
     }
 
     fn end(self) -> Result<Self::Ok> {
-        self.de.buf.push(b'}');
+        self.ser.buf.push(b'}');
         Ok(())
     }
 }
@@ -52,24 +52,24 @@ impl<'a> ser::SerializeStructVariant for SerializeStruct<'a> {
     {
         // XXX if `value` is `None` we not produce any output for this field
         if !self.first {
-            self.de.buf.push(b',');
+            self.ser.buf.push(b',');
         }
         self.first = false;
 
-        self.de.buf.push(b'"');
-        self.de.buf.extend_from_slice(key.as_bytes());
-        self.de.buf.extend_from_slice(b"\":");
+        self.ser.buf.push(b'"');
+        self.ser.buf.extend_from_slice(key.as_bytes());
+        self.ser.buf.extend_from_slice(b"\":");
 
-        value.serialize(&mut *self.de)?;
+        value.serialize(&mut *self.ser)?;
 
         Ok(())
     }
 
     fn end(self) -> Result<Self::Ok> {
         // close struct
-        self.de.buf.push(b'}');
+        self.ser.buf.push(b'}');
         // close surrounding enum
-        self.de.buf.push(b'}');
+        self.ser.buf.push(b'}');
         Ok(())
     }
 }