0.7.1 starting to optimize codegen

Author: maciejhirsz

src/codegen.rs

@@ -1,32 +1,19 @@
 use JsonValue;
 
-pub struct Generator {
-    pub minify: bool,
-    code: String,
-    dent: u16,
-    spaces_per_indent: u16,
-}
+pub trait Generator {
+    fn new_line(&mut self) {}
 
-impl Generator {
-    pub fn new(minify: bool, spaces: u16) -> Self {
-        Generator {
-            minify: minify,
-            code: String::with_capacity(1024),
-            dent: 0,
-            spaces_per_indent: spaces
-        }
-    }
+    fn write(&mut self, slice: &str);
 
-    pub fn new_line(&mut self) {
-        if !self.minify {
-            self.code.push('\n');
-            for _ in 0..(self.dent * self.spaces_per_indent) {
-                self.code.push(' ');
-            }
-        }
-    }
+    fn write_min(&mut self, slice: &str, minslice: &str);
+
+    fn write_char(&mut self, ch: char);
 
-    pub fn write_json(&mut self, json: &JsonValue) {
+    fn indent(&mut self) {}
+
+    fn dedent(&mut self) {}
+
+    fn write_json(&mut self, json: &JsonValue) {
         match *json {
             JsonValue::String(ref string) => {
                 self.write_char('"');
@@ -92,31 +79,84 @@ impl Generator {
         }
     }
 
-    pub fn write(&mut self, slice: &str) {
+    fn consume(self) -> String;
+}
+
+pub struct DumpGenerator {
+    code: String,
+}
+
+impl DumpGenerator {
+    pub fn new() -> Self {
+        DumpGenerator {
+            code: String::with_capacity(1024),
+        }
+    }
+}
+
+impl Generator for DumpGenerator {
+    fn write(&mut self, slice: &str) {
         self.code.push_str(slice);
     }
 
-    pub fn write_min(&mut self, slice: &str, minslice: &str) {
-        if self.minify {
-            self.write(minslice);
-        } else {
-            self.write(slice);
+    fn write_min(&mut self, _: &str, minslice: &str) {
+        self.write(minslice);
+    }
+
+    fn write_char(&mut self, ch: char) {
+        self.code.push(ch);
+    }
+
+    fn consume(self) -> String {
+        self.code
+    }
+}
+
+pub struct PrettyGenerator {
+    code: String,
+    dent: u16,
+    spaces_per_indent: u16,
+}
+
+impl PrettyGenerator {
+    pub fn new(spaces: u16) -> Self {
+        PrettyGenerator {
+            code: String::with_capacity(1024),
+            dent: 0,
+            spaces_per_indent: spaces
+        }
+    }
+}
+
+impl Generator for PrettyGenerator {
+    fn new_line(&mut self) {
+        self.code.push('\n');
+        for _ in 0..(self.dent * self.spaces_per_indent) {
+            self.code.push(' ');
         }
     }
 
-    pub fn write_char(&mut self, ch: char) {
+    fn write(&mut self, slice: &str) {
+        self.code.push_str(slice);
+    }
+
+    fn write_min(&mut self, slice: &str, _: &str) {
+        self.write(slice);
+    }
+
+    fn write_char(&mut self, ch: char) {
         self.code.push(ch);
     }
 
-    pub fn indent(&mut self) {
+    fn indent(&mut self) {
         self.dent += 1;
     }
 
-    pub fn dedent(&mut self) {
+    fn dedent(&mut self) {
         self.dent -= 1;
     }
 
-    pub fn consume(self) -> String {
+    fn consume(self) -> String {
         self.code
     }
 }

src/lib.rs

@@ -194,7 +194,7 @@ pub use value::JsonValue::Null;
 pub type JsonResult<T> = Result<T, JsonError>;
 
 pub use parser::parse;
-use codegen::Generator;
+use codegen::{ Generator, PrettyGenerator, DumpGenerator };
 
 use std::collections::HashMap;
 use std::collections::BTreeMap;
@@ -206,15 +206,15 @@ pub type Object = BTreeMap<String, JsonValue>;
 impl JsonValue {
     /// Prints out the value as JSON string.
     pub fn dump(&self) -> String {
-        let mut gen = Generator::new(true, 0);
+        let mut gen = DumpGenerator::new();
         gen.write_json(self);
         gen.consume()
     }
 
     /// Pretty prints out the value as JSON string. Takes an argument that's
     /// number of spaces to indent new blocks with.
     pub fn pretty(&self, spaces: u16) -> String {
-        let mut gen = Generator::new(false, spaces);
+        let mut gen = PrettyGenerator::new(spaces);
         gen.write_json(self);
         gen.consume()
     }