Deal with nulls and 0s in 'store' fields

This properly filters out 0s and nulls for our longterm data, Store,
while allowing them in updates to represent removing or emptying that
particular resource.

Author: daboross

src/websocket/types/room/objects/spawn.rs

@@ -91,7 +91,7 @@ mod test {
             "y": 28
         });
 
-        let mut obj = StructureSpawn::deserialize(json).unwrap();
+        let obj = StructureSpawn::deserialize(json).unwrap();
 
         assert_eq!(
             obj,

src/websocket/types/room/objects/terminal.rs

@@ -104,7 +104,7 @@ mod test {
                 ..
             } if user == "5788389e3fd9069e6b546e2d"
                 && id == "59a5cc4f4733bb4c785ec4e7"
-                && *store == store! {Energy: 25000, Catalyst: 50189, CatalyzedGhodiumAcid: 0} =>
+                && *store == store! {Energy: 25000, Catalyst: 50189} =>
             {
                 ()
             }
@@ -139,4 +139,29 @@ mod test {
 
         assert_eq!(obj.cooldown_time, 0);
     }
+
+    #[test]
+    fn parse_npc_terminal_with_null_store() {
+        let json = json!({
+            "_id": "57cd3a30c0551957424a1f0b",
+            "room": "E40N40",
+            "store": {
+                "H": null,
+                "K": null,
+                "L": null,
+                "O": null,
+                "U": null,
+                "X": null,
+                "Z": null,
+                "energy": 0,
+                "power": null
+            },
+            "storeCapacity": 0,
+            "type": "terminal",
+            "x": 35,
+            "y": 45
+        });
+        let obj = StructureTerminal::deserialize(json).unwrap();
+        assert_eq!(obj.store, store!());
+    }
 }

src/websocket/types/room/objects/tombstone.rs

@@ -48,7 +48,7 @@ impl Tombstone {
 mod test {
     use serde::Deserialize;
 
-    use super::{ResourceType, Tombstone};
+    use super::{Tombstone};
 
     #[test]
     fn parse_simple_tombstone() {

src/websocket/types/room/resources.rs

@@ -1,5 +1,7 @@
 //! Managing and parsing resource
-use std::collections::HashMap;
+use std::{cmp, collections::HashMap, fmt};
+
+use serde::de::{Deserialize, Deserializer, MapAccess, Visitor};
 
 use crate::websocket::room_object_macros::Updatable;
 
@@ -202,7 +204,7 @@ impl ResourceType {
 }
 
 /// The resources and amounts of each resource some game object holds.
-#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, Eq)]
+#[derive(Serialize, Clone, Debug, Default, PartialEq, Eq)]
 #[serde(transparent)]
 pub struct Store(pub HashMap<ResourceType, i32>);
 
@@ -218,21 +220,110 @@ impl Store {
     }
 }
 
+struct StoreVisitor;
+
+impl<'de> Visitor<'de> for StoreVisitor {
+    type Value = Store;
+
+    fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str("a map")
+    }
+
+    #[inline]
+    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+    where
+        A: MapAccess<'de>,
+    {
+        // Adopted from `HashMap` `Deserialize` impl from
+        // https://github.com/serde-rs/serde/blob/master/serde/src/de/impls.rs
+        let mut values = HashMap::with_capacity(cmp::min(map.size_hint().unwrap_or(0), 4096));
+
+        while let Some((key, value)) = map.next_entry::<_, Option<i32>>()? {
+            let value = value.unwrap_or(0);
+            if value != 0 {
+                values.insert(key, value);
+            }
+        }
+
+        Ok(Store(values))
+    }
+}
+
+impl<'de> Deserialize<'de> for Store {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_map(StoreVisitor)
+    }
+}
+
+/// Update structure for Store. The difference is that StoreUpdate allows 0 values.
+#[derive(Serialize, Clone, Debug, Default, PartialEq, Eq)]
+#[serde(transparent)]
+pub struct StoreUpdate(pub HashMap<ResourceType, i32>);
+
+/// Like `StoreVisitor`, but keeps 0s and nulls.
+struct StoreUpdateVisitor;
+
+impl<'de> Visitor<'de> for StoreUpdateVisitor {
+    type Value = StoreUpdate;
+
+    fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str("a map")
+    }
+
+    #[inline]
+    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+    where
+        A: MapAccess<'de>,
+    {
+        // Adopted from `HashMap` `Deserialize` impl from
+        // https://github.com/serde-rs/serde/blob/master/serde/src/de/impls.rs
+        let mut values = HashMap::with_capacity(cmp::min(map.size_hint().unwrap_or(0), 4096));
+
+        while let Some((key, value)) = map.next_entry::<_, Option<i32>>()? {
+            let value = value.unwrap_or(0);
+            values.insert(key, value);
+        }
+
+        Ok(StoreUpdate(values))
+    }
+}
+
+impl<'de> Deserialize<'de> for StoreUpdate {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_map(StoreUpdateVisitor)
+    }
+}
+
 impl Updatable for Store {
     type Update = Store;
     fn apply_update(&mut self, update: Self::Update) {
-        self.0.extend(update.0);
+        for (key, value) in update.0 {
+            if value == 0 {
+                self.0.remove(&key);
+            } else {
+                self.0.insert(key, value);
+            }
+        }
     }
 
     fn create_from_update(update: Self::Update) -> Option<Self> {
-        Some(update)
+        let mut values = update.0;
+        values.retain(|_k, v| *v != 0);
+        Some(Store(values))
     }
 }
 
 #[cfg(test)]
 macro_rules! store {
     ($($name:ident: $val:expr),*$(,)?) => (
         {
+            #[allow(unused_mut)]
             let mut store = crate::websocket::types::room::resources::Store::default();
 
             $(