From 3ed8d8a9fd188edfc92f79f930eaeed67d6fc1d7 Mon Sep 17 00:00:00 2001
From: Matt Bilker <me@mbilker.us>
Date: Thu, 19 Jul 2018 15:00:59 +0000
Subject: [PATCH] de: use Struct instead of Map since they are almost identical

---
 src/de/map.rs       | 67 ---------------------------------------------
 src/de/mod.rs       |  6 ++--
 src/de/structure.rs |  9 ++----
 3 files changed, 5 insertions(+), 77 deletions(-)
 delete mode 100644 src/de/map.rs

diff --git a/src/de/map.rs b/src/de/map.rs
deleted file mode 100644
index 020a6d6..0000000
--- a/src/de/map.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-use serde::de::{DeserializeSeed, MapAccess};
-
-use de::{Deserializer, Result};
-use error::{Error, KbinErrorKind};
-use node_types::StandardType;
-
-pub struct Map<'a, 'de: 'a> {
-  de: &'a mut Deserializer<'de>,
-}
-
-impl<'de, 'a> Map<'a, 'de> {
-  pub fn new(de: &'a mut Deserializer<'de>) -> Self {
-    Self { de }
-  }
-}
-
-// TODO: FIX THIS, it's pretty broken, but it will deserialize correctly
-impl<'de, 'a> MapAccess<'de> for Map<'a, 'de> {
-  type Error = Error;
-
-  fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
-    where K: DeserializeSeed<'de>
-  {
-    trace!("--> <Map as MapAccess>::next_key_seed()");
-
-    let (node_type, _is_array) = self.de.reader.read_node_type()?;
-    debug!("<Map as MapAccess>::next_key_seed() => node_type: {:?}", node_type);
-
-    if node_type == StandardType::NodeEnd ||
-       node_type == StandardType::FileEnd
-    {
-      trace!("<Map as MapAccess>::next_key_seed() => end of map");
-      return Ok(None);
-    }
-
-    let key = seed.deserialize(&mut *self.de).map(Some)?;
-
-    self.de.node_stack.push(node_type);
-
-    Ok(key)
-  }
-
-  fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
-    where V: DeserializeSeed<'de>
-  {
-    debug!("--> <Map as MapAccess>::next_value_seed()");
-    let value = seed.deserialize(&mut *self.de)?;
-
-    let popped = self.de.node_stack.pop();
-    debug!("<Map as MapAccess>::next_value_seed() => popped: {:?}, node_stack: {:?}", popped, self.de.node_stack);
-
-    // Consume the NodeEnd
-    match popped {
-      Some(StandardType::Attribute) |
-      Some(StandardType::NodeStart) => {},
-      Some(_) => {
-        let (node_type, _is_array) = self.de.reader.read_node_type()?;
-        if node_type != StandardType::NodeEnd {
-          return Err(KbinErrorKind::TypeMismatch(*StandardType::NodeEnd, *node_type).into());
-        }
-      },
-      None => {},
-    }
-
-    Ok(value)
-  }
-}
diff --git a/src/de/mod.rs b/src/de/mod.rs
index 53d72a7..f59fb4c 100644
--- a/src/de/mod.rs
+++ b/src/de/mod.rs
@@ -8,11 +8,9 @@ use error::{Error, KbinErrorKind};
 use node_types::StandardType;
 use reader::Reader;
 
-mod map;
 mod seq;
 mod structure;
 
-use self::map::Map;
 use self::seq::Seq;
 use self::structure::Struct;
 
@@ -280,7 +278,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
     let (node_type, _, name) = self.read_node_with_name()?;
     debug!("Deserializer::deserialize_map() => node_type: {:?}, name: {:?}", node_type, name);
 
-    visitor.visit_map(Map::new(self))
+    visitor.visit_map(Struct::new(self))
   }
 
   fn deserialize_struct<V>(self, name: &'static str, fields: &'static [&'static str], visitor: V) -> Result<V::Value>
@@ -301,7 +299,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
     }
     self.first_struct = false;
 
-    let value = visitor.visit_map(Struct::new(self, fields))?;
+    let value = visitor.visit_map(Struct::new(self))?;
 
     Ok(value)
   }
diff --git a/src/de/structure.rs b/src/de/structure.rs
index 82b6f33..3338600 100644
--- a/src/de/structure.rs
+++ b/src/de/structure.rs
@@ -10,11 +10,8 @@ pub struct Struct<'a, 'de: 'a> {
 }
 
 impl<'de, 'a> Struct<'a, 'de> {
-  pub fn new(de: &'a mut Deserializer<'de>, _fields: &'static [&'static str]) -> Self {
-    Self {
-      de,
-      //fields,
-    }
+  pub fn new(de: &'a mut Deserializer<'de>) -> Self {
+    Self { de }
   }
 }
 
@@ -30,7 +27,7 @@ impl<'de, 'a> MapAccess<'de> for Struct<'a, 'de> {
     debug!("Struct::next_key_seed() => node_type: {:?}", node_type);
 
     if node_type == StandardType::NodeEnd {
-      trace!("Struct::next_key_seed() => end of map");
+      debug!("<-- <Struct as MapAccess>::next_key_seed() => end of map");
       return Ok(None);
     }