Struct gtmpl::Template

pub struct Template<'a> {
    pub name: &'a str,
    pub text: &'a str,
    pub funcs: Vec<&'a HashMap<String, Func>>,
    pub tree_ids: HashMap<usize, String>,
    pub tree_set: HashMap<String, Tree<'a>>,
}

The main template structure.

Fields

name: &'a str

text: &'a str

funcs: Vec<&'a HashMap<String, Func>>

tree_ids: HashMap<usize, String>

tree_set: HashMap<String, Tree<'a>>

Methods

impl<'a> Template<'a>

fn with_name(name: &'a str) -> Template<'a>

Creates a new empty template with a given name.

fn add_funcs(&mut self, funcs: &'a HashMap<String, Func>)

Adds custom functions to the template.

Example

use std::any::Any;
use std::collections::HashMap;
use std::sync::Arc;

use gtmpl::{Context, Func, Value};

fn hello_world(_args: &[Arc<Any>]) -> Result<Arc<Any>, String> {
  Ok(Arc::new(Value::from("Hello World!")) as Arc<Any>)
}

let mut funcs = HashMap::new();
funcs.insert(String::from("helloWorld"), hello_world as Func);
let mut tmpl = gtmpl::Template::default();
tmpl.add_funcs(&funcs);
tmpl.parse("{{ helloWorld }}").unwrap();
let output = tmpl.render(&Context::empty());
assert_eq!(&output.unwrap(), "Hello World!");

fn parse(&mut self, text: &'a str) -> Result<(), String>

Parse the given text as template body.

Example

let mut tmpl = gtmpl::Template::default();
tmpl.parse("Hello World!").unwrap();

impl<'a, 'b> Template<'a>

fn execute<T: Write>(
    &mut self,
    writer: &'b mut T,
    data: &Context
) -> Result<(), String>

fn render(&mut self, data: &Context) -> Result<String, String>

Trait Implementations

impl<'a> Default for Template<'a>

fn default() -> Template<'a>

Returns the "default value" for a type.