Struct minijinja::Template

pub struct Template<'env> { /* private fields */ }

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

impl<'env> Template<'env>

pub fn name(&self) -> &str

Returns the name of the template.

pub fn source(&self) -> &str

Returns the source code of the template.

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 eiher 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());

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.

use std::io::stdout;

let tmpl = env.get_template("hello").unwrap();
tmpl.render_to_write(context!(name => "John"), &mut stdout()).unwrap();

Trait Implementations

impl<'env> Clone for Template<'env>

fn clone(&self) -> Template<'env>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'env> Debug for Template<'env>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'env> Copy for Template<'env>