Merge pull request #191 from epage/arc

perf: Reduce allocations

Author: epage

src/interpreter/context.rs

@@ -1,4 +1,5 @@
 use std::collections::HashMap;
+use std::sync;
 
 use error::{Error, Result};
 use value::{Index, Object, Value};
@@ -39,7 +40,7 @@ pub struct Context {
     cycles: HashMap<String, usize>,
 
     // Public for backwards compatability
-    filters: HashMap<&'static str, BoxedValueFilter>,
+    filters: sync::Arc<HashMap<&'static str, BoxedValueFilter>>,
 }
 
 impl Context {
@@ -53,8 +54,8 @@ impl Context {
         self
     }
 
-    pub fn with_filters(mut self, filters: HashMap<&'static str, BoxedValueFilter>) -> Self {
-        self.filters = filters;
+    pub fn with_filters(mut self, filters: &sync::Arc<HashMap<&'static str, BoxedValueFilter>>) -> Self {
+        self.filters = sync::Arc::clone(filters);
         self
     }
 
@@ -76,10 +77,6 @@ impl Context {
         Ok(Some(val))
     }
 
-    pub fn add_filter(&mut self, name: &'static str, filter: BoxedValueFilter) {
-        self.filters.insert(name, filter);
-    }
-
     pub fn get_filter<'b>(&'b self, name: &str) -> Option<&'b FilterValue> {
         self.filters.get(name).map(|f| {
             let f: &FilterValue = f;

src/parser.rs

@@ -2,6 +2,7 @@ use std::collections::HashMap;
 use std::fs::File;
 use std::io::prelude::Read;
 use std::path;
+use std::sync;
 
 use super::Template;
 use compiler;
@@ -203,14 +204,15 @@ impl ParserBuilder {
             tags,
             include_source,
         };
+        let filters = sync::Arc::new(filters);
         Parser { options, filters }
     }
 }
 
 #[derive(Default, Clone)]
 pub struct Parser {
     options: compiler::LiquidOptions,
-    filters: HashMap<&'static str, interpreter::BoxedValueFilter>,
+    filters: sync::Arc<HashMap<&'static str, interpreter::BoxedValueFilter>>,
 }
 
 impl Parser {
@@ -236,7 +238,7 @@ impl Parser {
     pub fn parse(&self, text: &str) -> Result<Template> {
         let tokens = compiler::tokenize(text)?;
         let template = compiler::parse(&tokens, &self.options).map(interpreter::Template::new)?;
-        let filters = self.filters.clone();
+        let filters = sync::Arc::clone(&self.filters);
         Ok(Template { template, filters })
     }
 

src/tags/for_block.rs

@@ -300,10 +300,14 @@ pub fn for_block(
 
 #[cfg(test)]
 mod test {
-    use super::*;
+    use std::collections::HashMap;
+    use std::sync;
+
     use compiler;
     use interpreter;
 
+    use super::*;
+
     fn options() -> LiquidOptions {
         let mut options = LiquidOptions::default();
         options
@@ -634,13 +638,13 @@ mod test {
             &options(),
         ).unwrap();
 
-        let mut data: Context = Default::default();
-        data.add_filter(
-            "shout",
+        let mut filters: HashMap<&'static str, interpreter::BoxedValueFilter> = HashMap::new();
+        filters.insert("shout",
             ((|input, _args| Ok(Value::scalar(input.to_str().to_uppercase())))
                 as interpreter::FnFilterValue)
                 .into(),
-        );
+                    );
+        let mut data = Context::new().with_filters(&sync::Arc::new(filters));
 
         data.set_global_val(
             "array",

src/tags/include_tag.rs

@@ -53,14 +53,18 @@ pub fn include_tag(
 
 #[cfg(test)]
 mod test {
-    use super::*;
-    use compiler;
-    use filters;
-    use interpreter;
     use std::iter::FromIterator;
     use std::path;
+    use std::collections::HashMap;
+    use std::sync;
+
     use tags;
     use value;
+    use compiler;
+    use filters;
+    use interpreter;
+
+    use super::*;
 
     fn options() -> LiquidOptions {
         let include_path = path::PathBuf::from_iter("tests/fixtures/input".split('/'));
@@ -88,10 +92,11 @@ mod test {
             .map(interpreter::Template::new)
             .unwrap();
 
-        let mut context = Context::new();
+        let mut filters: HashMap<&'static str, interpreter::BoxedValueFilter> = HashMap::new();
+        filters.insert("size",(filters::size as interpreter::FnFilterValue).into());
+        let mut context = Context::new().with_filters(&sync::Arc::new(filters));
         context.set_global_val("num", value::Value::scalar(5f64));
         context.set_global_val("numTwo", value::Value::scalar(10f64));
-        context.add_filter("size", (filters::size as interpreter::FnFilterValue).into());
         let output = template.render(&mut context).unwrap();
         assert_eq!(output, Some("5 wat wot\n".to_owned()));
     }
@@ -104,10 +109,11 @@ mod test {
             .map(interpreter::Template::new)
             .unwrap();
 
-        let mut context = Context::new();
+        let mut filters: HashMap<&'static str, interpreter::BoxedValueFilter> = HashMap::new();
+        filters.insert("size",(filters::size as interpreter::FnFilterValue).into());
+        let mut context = Context::new().with_filters(&sync::Arc::new(filters));
         context.set_global_val("num", value::Value::scalar(5f64));
         context.set_global_val("numTwo", value::Value::scalar(10f64));
-        context.add_filter("size", (filters::size as interpreter::FnFilterValue).into());
         let output = template.render(&mut context).unwrap();
         assert_eq!(output, Some("5 wat wot\n".to_owned()));
     }

src/template.rs

@@ -1,4 +1,5 @@
 use std::collections::HashMap;
+use std::sync;
 
 use super::Object;
 use error::Result;
@@ -8,14 +9,14 @@ use interpreter::Renderable;
 
 pub struct Template {
     pub(crate) template: interpreter::Template,
-    pub(crate) filters: HashMap<&'static str, interpreter::BoxedValueFilter>,
+    pub(crate) filters: sync::Arc<HashMap<&'static str, interpreter::BoxedValueFilter>>,
 }
 
 impl Template {
     /// Renders an instance of the Template, using the given globals.
     pub fn render(&self, globals: &Object) -> Result<String> {
         let mut data = interpreter::Context::new()
-            .with_filters(self.filters.clone())
+            .with_filters(&self.filters)
             .with_values(globals.clone());
         let output = self.template
             .render(&mut data)?