pub struct Template<'env> { /* private fields */ }Expand description
Represents a handle to a template.
Templates are stored in the Environment as bytecode instructions. With the
Environment::get_template method that is looked up and returned in form of
this handle. Such a template can be cheaply copied as it only holds references.
To render the render method can be used.
Implementations§
source§impl<'env> Template<'env>
impl<'env> Template<'env>
sourcepub fn render<S: Serialize>(&self, ctx: S) -> Result<String, Error>
pub fn render<S: Serialize>(&self, ctx: S) -> Result<String, Error>
Renders the template into a string.
The provided value is used as the initial context for the template. It
can be any object that implements Serialize. You
can either create your own struct and derive Serialize for it or the
context! macro can be used to create an ad-hoc context.
let tmpl = env.get_template("hello").unwrap();
println!("{}", tmpl.render(context!(name => "John")).unwrap());Note on values: The Value type implements Serialize and can be
efficiently passed to render. It does not undergo actual serialization.
sourcepub fn render_block<S: Serialize>(
&self,
block: &str,
ctx: S
) -> Result<String, Error>
pub fn render_block<S: Serialize>( &self, block: &str, ctx: S ) -> Result<String, Error>
Renders the template block into a string.
This method works like render but it only renders a specific
block in the template. The first argument is the name of the block.
This renders only the block hi in the template:
let tmpl = env.get_template("hello").unwrap();
println!("{}", tmpl.render_block("hi", context!(name => "John")).unwrap());Note on values: The Value type implements Serialize and can be
efficiently passed to render. It does not undergo actual serialization.
sourcepub fn render_to_write<S: Serialize, W: Write>(
&self,
ctx: S,
w: W
) -> Result<(), Error>
pub fn render_to_write<S: Serialize, W: Write>( &self, ctx: S, w: W ) -> Result<(), Error>
Renders the template into a io::Write.
This works exactly like render but instead writes the template
as it’s evaluating into a io::Write.
This renders only the block hi in the template:
use std::io::stdout;
let tmpl = env.get_template("hello").unwrap();
tmpl.render_to_write(context!(name => "John"), &mut stdout()).unwrap();Note on values: The Value type implements Serialize and can be
efficiently passed to render. It does not undergo actual serialization.
sourcepub fn render_block_to_write<S: Serialize, W: Write>(
&self,
block: &str,
ctx: S,
w: W
) -> Result<(), Error>
pub fn render_block_to_write<S: Serialize, W: Write>( &self, block: &str, ctx: S, w: W ) -> Result<(), Error>
Renders the template block into a io::Write.
This works exactly like render_to_write but renders
a single block. The first argument is the name of the block.
use std::io::stdout;
let tmpl = env.get_template("hello").unwrap();
tmpl.render_block_to_write("hi", context!(name => "John"), &mut stdout()).unwrap();Note on values: The Value type implements Serialize and can be
efficiently passed to render. It does not undergo actual serialization.
sourcepub fn undeclared_variables(&self, nested: bool) -> HashSet<String>
pub fn undeclared_variables(&self, nested: bool) -> HashSet<String>
Returns a set of all undeclared variables in the template.
This returns a set of all variables that might be looked up
at runtime by the template. Since this is runs a static
analysis, the actual control flow is not considered. This
also cannot take into account what happens due to includes,
imports or extending. If nested is set to true, then also
nested trivial attribute lookups are considered and returned.
let mut env = Environment::new();
env.add_template("x", "{% set x = foo %}{{ x }}{{ bar.baz }}").unwrap();
let tmpl = env.get_template("x").unwrap();
let undeclared = tmpl.undeclared_variables(false);
// returns ["foo", "bar"]
let undeclared = tmpl.undeclared_variables(true);
// returns ["foo", "bar.baz"]