Struct bracket::registry::Registry

pub struct Registry<'reg, 'source> { /* fields omitted */ }

Registry is the entry point for compiling and rendering templates.

A template name is always required for error messages.

Implementations

impl<'reg, 'source> Registry<'reg, 'source>

pub fn new() -> Self

Create an empty registry.

pub fn set_strict(&mut self, strict: bool)

Set the strict mode.

pub fn strict(&self) -> bool

Get the strict mode.

pub fn set_escape(&mut self, escape: EscapeFn)

Set the escape function for rendering.

pub fn escape(&self) -> &EscapeFn

The escape function to use for rendering.

pub fn helpers(&self) -> &HelperRegistry<'reg>

Helper registry.

pub fn helpers_mut(&mut self) -> &mut HelperRegistry<'reg>

Mutable reference to the helper registry.

pub fn templates(&self) -> &Templates<'source>

Template registry.

For partials to be located they must exist in this templates collection.

pub fn templates_mut(&mut self) -> &mut Templates<'source>

Mutable reference to the templates registry.

pub fn compile(
    &self,
    template: &'source str,
    options: ParserOptions
) -> Result<Template<'source>>

Compile a string to a template.

pub fn parse(
    &self,
    name: &str,
    template: &'source str
) -> Result<Template<'source>>

Compile a string to a template using the given name.

pub fn lint(&self, name: &str, template: &'source str) -> Result<Vec<Error>>

Lint a template.

pub fn once<T>(&self, name: &str, source: &str, data: &T) -> Result<String> where
    T: Serialize, 

Render a template without registering it and return the result as a string.

This function buffers the template nodes before rendering.

pub fn render<T>(&self, name: &str, data: &T) -> Result<String> where
    T: Serialize, 

Render a named template and buffer the result to a string.

The named template must exist in the templates collection.

pub fn render_template<T>(
    &self,
    name: &str,
    template: &Template<'source>,
    data: &T
) -> Result<String> where
    T: Serialize, 

Render a compiled template without registering it and buffer the result to a string.

pub fn render_to_write<T>(
    &self,
    name: &str,
    data: &T,
    writer: &mut impl Output
) -> Result<()> where
    T: Serialize, 

Render a named template to a writer.

The named template must exist in the templates collection.

Trait Implementations

impl<'reg, 'source> From<Templates<'source>> for Registry<'reg, 'source>

Create a registry using a collection of templates.

fn from(templates: Templates<'source>) -> Self

Performs the conversion.