remove need for external buffers

Author: coder543

examples/derive_example.rs

@@ -25,7 +25,7 @@ struct Provider {
     provider_code: u32,
 }
 
-fn sqrt(_data: &Person, args: &[f64], input: f64) -> f64 {
+fn sqrt(_data: &Person, _args: &[f64], input: f64) -> f64 {
     input.sqrt()
 }
 
@@ -47,11 +47,11 @@ fn main() {
         "{{provider}} {{provider_code + 4}} {{id}} {{name | toupper}} {{age | sqrt}} {{weight / 2.2 | round 2}}kg\n";
 
     let env = Provider {
-        provider: "apns".to_string(),
+        provider: "john doe".to_string(),
         provider_code: 31,
     };
 
-    let bytecode = match compile(template, &env) {
+    let mut bytecode = match compile(template, &env) {
         Ok(bc) => bc,
         Err(err) => {
             eprintln!("error compiling template: {}", err);
@@ -72,15 +72,10 @@ fn main() {
         });
     }
 
-    // reuse these allocations throughout the output process
-    let mut buffer = String::with_capacity(8);
-    let mut stack = Vec::with_capacity(8);
     let stdout = stdout();
     let mut stdout_lock = stdout.lock();
 
     for person in group {
-        bytecode
-            .run_with(&person, &mut buffer, &mut stack, &mut stdout_lock)
-            .unwrap();
+        bytecode.run_with(&person, &mut stdout_lock).unwrap();
     }
 }

examples/example.rs

@@ -139,11 +139,11 @@ fn main() {
     let template = "{{provider}} {{provider_code + 4}} {{id}} {{name | toupper}} {{age | sqrt}} {{weight / 2.2 | round 2}}kg\n";
 
     let env = Provider {
-        provider: "apns".to_string(),
+        provider: "john doe".to_string(),
         provider_code: 31,
     };
 
-    let bytecode = match compile(template, &env) {
+    let mut bytecode = match compile(template, &env) {
         Ok(bc) => bc,
         Err(err) => {
             eprintln!("error compiling template: {}", err);
@@ -164,15 +164,10 @@ fn main() {
         });
     }
 
-    // reuse these allocations throughout the output process
-    let mut buffer = String::with_capacity(8);
-    let mut stack = Vec::with_capacity(8);
     let stdout = stdout();
     let mut stdout_lock = stdout.lock();
 
     for person in group {
-        bytecode
-            .run_with(&person, &mut buffer, &mut stack, &mut stdout_lock)
-            .unwrap();
+        bytecode.run_with(&person, &mut stdout_lock).unwrap();
     }
 }

src/bytecode.rs

@@ -30,6 +30,8 @@ enum Instr<NumEnum, StrEnum, FilterEnum> {
 #[allow(unused)]
 #[derive(Debug)]
 pub struct Bytecode<NumEnum, StrEnum, FilterEnum> {
+    buffer: String,
+    stack: Vec<f64>,
     raw_text: String,
     instructions: Vec<Instr<NumEnum, StrEnum, FilterEnum>>,
 }
@@ -53,6 +55,8 @@ impl<
         env: &Env,
     ) -> Result<Bytecode<NumEnum, StrEnum, FilterEnum>, String> {
         let mut ret_val = Bytecode {
+            buffer: String::with_capacity(8),
+            stack: Vec::with_capacity(8),
             raw_text: String::new(),
             instructions: vec![],
         };
@@ -65,12 +69,12 @@ impl<
     }
 
     pub fn run_with(
-        &self,
+        &mut self,
         runner: &Runner<NumEnum, StrEnum, FilterEnum>,
-        buffer: &mut String,
-        stack: &mut Vec<f64>,
         output: &mut Write,
     ) -> Result<(), ::std::io::Error> {
+        let stack = &mut self.stack;
+        let buffer = &mut self.buffer;
         for instr in &self.instructions {
             match *instr {
                 Instr::PushImm(val) => stack.push(val),