From fa5f4394a962285d0e729c66d88fae48010c7aea Mon Sep 17 00:00:00 2001
From: Matt Bilker <me@mbilker.us>
Date: Wed, 5 Sep 2018 21:38:54 +0000
Subject: [PATCH] node(definition): capturing into_node -> non-capturing
 as_node

---
 src/node/definition.rs | 57 +++++++++++++++++++++++++-----------------
 src/printer.rs         | 10 ++++++++
 2 files changed, 44 insertions(+), 23 deletions(-)

diff --git a/src/node/definition.rs b/src/node/definition.rs
index 0ec9840..5b5ff77 100644
--- a/src/node/definition.rs
+++ b/src/node/definition.rs
@@ -8,7 +8,7 @@ use node_types::StandardType;
 use sixbit::{Sixbit, SixbitSize};
 use value::Value;
 
-#[derive(Debug)]
+#[derive(Clone, Copy, Debug)]
 pub enum Key<'buf> {
   Compressed {
     size: SixbitSize,
@@ -20,7 +20,7 @@ pub enum Key<'buf> {
   },
 }
 
-#[derive(Debug)]
+#[derive(Clone, Copy, Debug)]
 pub enum NodeData<'buf> {
   Some {
     key: Key<'buf>,
@@ -29,7 +29,7 @@ pub enum NodeData<'buf> {
   None,
 }
 
-#[derive(Debug)]
+#[derive(Clone, Copy, Debug)]
 pub struct NodeDefinition<'buf> {
   encoding: EncodingType,
   pub node_type: StandardType,
@@ -82,36 +82,24 @@ impl<'buf> NodeDefinition<'buf> {
     }
   }
 
-  pub fn into_node(self) -> Result<Node, KbinError> {
-    trace!("parsing definition: {:?}", self);
+  pub fn value(&self) -> Result<Value, KbinError> {
     match (self.node_type, self.data) {
-      (StandardType::NodeEnd, _) |
-      (StandardType::FileEnd, _) => {
-        return Err(KbinErrorKind::InvalidNodeType(self.node_type).into());
-      },
-      (StandardType::NodeStart, NodeData::Some { key, .. }) => {
-        let key = key.to_string()?;
-        Ok(Node::new(key))
-      },
-      (StandardType::Attribute, NodeData::Some { key, value_data }) => {
-        let key = key.to_string()?;
+      (StandardType::Attribute, NodeData::Some { ref value_data, .. }) => {
         let data = strip_trailing_null_bytes(value_data);
         let value = self.encoding.decode_bytes(data)?;
-        Ok(Node::with_value(key, Value::Attribute(value)))
+        Ok(Value::Attribute(value))
       },
-      (StandardType::String, NodeData::Some { key, value_data }) => {
-        let key = key.to_string()?;
+      (StandardType::String, NodeData::Some { ref value_data, .. }) => {
         let data = strip_trailing_null_bytes(value_data);
         let value = self.encoding.decode_bytes(data)?;
-        Ok(Node::with_value(key, Value::String(value)))
+        Ok(Value::String(value))
       },
-      (node_type, NodeData::Some { key, value_data }) => {
-        let key = key.to_string()?;
+      (node_type, NodeData::Some { ref value_data, .. }) => {
         let value = Value::from_standard_type(node_type, self.is_array, value_data)?;
         debug!("value: {:?}", value);
         match value {
-          Some(value) => Ok(Node::with_value(key, value)),
-          None => Ok(Node::new(key)),
+          Some(value) => Ok(value),
+          None => Err(KbinErrorKind::InvalidNodeType(node_type).into()),
         }
       },
       (node_type, NodeData::None) => {
@@ -119,4 +107,27 @@ impl<'buf> NodeDefinition<'buf> {
       },
     }
   }
+
+  pub fn as_node(&self) -> Result<Node, KbinError> {
+    trace!("parsing definition: {:?}", self);
+    match (self.node_type, self.data) {
+      (StandardType::NodeEnd, _) |
+      (StandardType::FileEnd, _) => {
+        Err(KbinErrorKind::InvalidNodeType(self.node_type).into())
+      },
+      (StandardType::NodeStart, NodeData::Some { key, .. }) => {
+        let key = key.to_string()?;
+        Ok(Node::new(key))
+      },
+      (_, NodeData::Some { key, .. }) => {
+        let key = key.to_string()?;
+        let value = self.value()?;
+        debug!("value: {:?}", value);
+        Ok(Node::with_value(key, value))
+      },
+      (node_type, NodeData::None) => {
+        Err(KbinErrorKind::InvalidNodeType(node_type).into())
+      },
+    }
+  }
 }
diff --git a/src/printer.rs b/src/printer.rs
index eaad98d..d2e5a6d 100644
--- a/src/printer.rs
+++ b/src/printer.rs
@@ -45,6 +45,16 @@ impl Printer {
       };
     }
 
+    for def in &definitions {
+      match def.node_type {
+        StandardType::NodeEnd |
+        StandardType::FileEnd => {},
+        _ => {
+          eprintln!("node: {:?}", def.as_node());
+        },
+      }
+    }
+
     let collection = NodeCollection::from_iter(definitions.into_iter());
     eprintln!("collection: {:#?}", collection);