Class PebbleTemplateImpl

java.lang.Object
io.pebbletemplates.pebble.template.PebbleTemplateImpl
All Implemented Interfaces:
PebbleTemplate
public class PebbleTemplateImpl extends Object implements PebbleTemplate
The actual implementation of a PebbleTemplate

  • Field Details

    • engine

      private final PebbleEngine engine
      A template has to store a reference to the main engine so that it can compile other templates when using the "import" or "include" tags.

      It will also retrieve some stateful information such as the default locale when necessary. Luckily, the engine is immutable so this should be thread safe.

    • blocks

      private final Map<String,Block> blocks
      Blocks defined inside this template.

    • macros

      private final Map<String,Macro> macros
      Macros defined inside this template.

    • rootNode

      private final RenderableNode rootNode
      The root node of the AST to be rendered.

    • name

      private final String name
      Name of template. Used to help with debugging.

  • Constructor Details

    • PebbleTemplateImpl

      public PebbleTemplateImpl(PebbleEngine engine, RenderableNode root, String name)
      Constructor
      Parameters:
      engine - The pebble engine used to construct this template
      root - The root not to evaluate
      name - The name of the template

  • Method Details

    • evaluate

      public void evaluate(Writer writer) throws IOException
      Description copied from interface: PebbleTemplate
      Evaluate the template without any provided variables. This will use the default locale provided by the PebbleEngine.
      Specified by:
      evaluate in interface PebbleTemplate
      Parameters:
      writer - The results of the evaluation are written to this writer.
      Throws:
      IOException - An IO exception during the evaluation

    • evaluate

      public void evaluate(Writer writer, Locale locale) throws IOException
      Description copied from interface: PebbleTemplate
      Evaluate the template with a particular locale but without any provided variables.
      Specified by:
      evaluate in interface PebbleTemplate
      Parameters:
      writer - The results of the evaluation are written to this writer.
      locale - The locale used during the evaluation of the template.
      Throws:
      IOException - An IO exception during the evaluation

    • evaluate

      public void evaluate(Writer writer, Map<String,Object> map) throws IOException
      Description copied from interface: PebbleTemplate
      Evaluate the template with a set of variables and the default locale provided by the PebbleEngine
      Specified by:
      evaluate in interface PebbleTemplate
      Parameters:
      writer - The results of the evaluation are written to this writer.
      map - The variables used during the evaluation of the template.
      Throws:
      IOException - An IO exception during the evaluation

    • evaluate

      public void evaluate(Writer writer, Map<String,Object> map, Locale locale) throws IOException
      Description copied from interface: PebbleTemplate
      Evaluate the template with a particular locale and a set of variables.
      Specified by:
      evaluate in interface PebbleTemplate
      Parameters:
      writer - The results of the evaluation are written to this writer.
      map - The variables used during the evaluation of the template.
      locale - The locale used during the evaluation of the template.
      Throws:
      IOException - An IO exception during the evaluation

    • evaluateBlock

      public void evaluateBlock(String blockName, Writer writer) throws IOException
      Description copied from interface: PebbleTemplate
      Evaluate the template but only render the contents of a specific block.
      Specified by:
      evaluateBlock in interface PebbleTemplate
      Parameters:
      blockName - The name of the template block to return.
      writer - The results of the evaluation are written to this writer.
      Throws:
      IOException - An IO exception during the evaluation

    • evaluateBlock

      public void evaluateBlock(String blockName, Writer writer, Locale locale) throws IOException
      Description copied from interface: PebbleTemplate
      Evaluate the template but only render the contents of a specific block.
      Specified by:
      evaluateBlock in interface PebbleTemplate
      Parameters:
      blockName - The name of the template block to return.
      writer - The results of the evaluation are written to this writer.
      locale - The locale used during the evaluation of the template.
      Throws:
      IOException - An IO exception during the evaluation

    • evaluateBlock

      public void evaluateBlock(String blockName, Writer writer, Map<String,Object> map) throws IOException
      Description copied from interface: PebbleTemplate
      Evaluate the template but only render the contents of a specific block.
      Specified by:
      evaluateBlock in interface PebbleTemplate
      Parameters:
      blockName - The name of the template block to return.
      writer - The results of the evaluation are written to this writer.
      map - The variables used during the evaluation of the template.
      Throws:
      IOException - An IO exception during the evaluation

    • evaluateBlock

      public void evaluateBlock(String blockName, Writer writer, Map<String,Object> map, Locale locale) throws IOException
      Description copied from interface: PebbleTemplate
      Evaluate the template but only render the contents of a specific block.
      Specified by:
      evaluateBlock in interface PebbleTemplate
      Parameters:
      blockName - The name of the template block to return.
      writer - The results of the evaluation are written to this writer.
      map - The variables used during the evaluation of the template.
      locale - The locale used during the evaluation of the template.
      Throws:
      IOException - An IO exception during the evaluation

    • evaluate

      private void evaluate(Writer writer, EvaluationContextImpl context) throws IOException
      This is the authoritative evaluate method. It will evaluate the template starting at the root node.
      Parameters:
      writer - The writer used to write the final output of the template
      context - The evaluation context
      Throws:
      IOException - Thrown from the writer object

    • initContext

      private EvaluationContextImpl initContext(Locale locale)
      Initializes the evaluation context with settings from the engine.
      Parameters:
      locale - The desired locale
      Returns:
      The evaluation context

    • shallowCopy

      private PebbleTemplateImpl shallowCopy()
      Return a shallow copy of this template.
      Returns:
      A new template instance with the same data

    • importTemplate

      public void importTemplate(EvaluationContextImpl context, String name)
      Imports a template.
      Parameters:
      context - The evaluation context
      name - The template name

    • importNamedTemplate

      public void importNamedTemplate(EvaluationContextImpl context, String name, String alias)
      Imports a named template.
      Parameters:
      context - The evaluation context
      name - The template name
      alias - The template alias

    • importNamedMacrosFromTemplate

      public void importNamedMacrosFromTemplate(String name, List<Pair<String,String>> namedMacros)
      Imports named macros from specified template.
      Parameters:
      name - The template name
      namedMacros - named macros

    • getNamedImportedTemplate

      public PebbleTemplateImpl getNamedImportedTemplate(EvaluationContextImpl context, String alias)
      Returns a named template.
      Parameters:
      context - The evaluation context
      alias - The template alias

    • includeTemplate

      public void includeTemplate(Writer writer, EvaluationContextImpl context, String name, Map<?,?> additionalVariables) throws IOException
      Includes a template with name into this template.
      Parameters:
      writer - the writer to which the output should be written to.
      context - the context within which the template is rendered in.
      name - the name of the template to include.
      additionalVariables - the map with additional variables provided with the include tag to add within the include tag.
      Throws:
      IOException - Any error during the loading of the template

    • embedTemplate

      public void embedTemplate(int lineNo, Writer writer, EvaluationContextImpl context, String name, Map<?,?> additionalVariables, List<BlockNode> overriddenBlocks) throws IOException
      Embed a template with name into this template and override its child blocks. This has the effect of essentially "including" a template (as with the `include` tag), but its blocks may be overridden in the calling template similar to extending a template.
      Parameters:
      lineNo - the line number of the node being evaluated
      writer - the writer to which the output should be written to.
      context - the context within which the template is rendered in.
      name - the name of the template to include.
      additionalVariables - the map with additional variables provided with the include tag to add within the embed tag.
      overriddenBlocks - the blocks parsed out of the parent template that should override blocks in the embedded template
      Throws:
      IOException - Any error during the loading of the template

    • hasMacro

      public boolean hasMacro(String macroName)
      Checks if a macro exists
      Parameters:
      macroName - The name of the macro
      Returns:
      Whether or not the macro exists

    • hasBlock

      public boolean hasBlock(String blockName)
      Checks if a block exists
      Parameters:
      blockName - The name of the block
      Returns:
      Whether or not the block exists

    • resolveRelativePath

      public String resolveRelativePath(String relativePath)
      This method resolves the given relative path based on this template file path.
      Parameters:
      relativePath - the path which should be resolved.
      Returns:
      the resolved path.

    • registerBlock

      public void registerBlock(Block block)
      Registers a block.
      Parameters:
      block - The block

    • registerMacro

      public void registerMacro(Macro macro)
      Registers a macro
      Parameters:
      macro - The macro

    • registerMacro

      public void registerMacro(String alias, Macro macro)
      Registers a macro with alias
      Parameters:
      macro - The macro
      Throws:
      PebbleException - Throws exception if macro already exists with the same name

    • block

      public void block(Writer writer, EvaluationContextImpl context, String blockName, boolean ignoreOverriden) throws IOException
      A typical block declaration will use this method which evaluates the block using the regular user-provided writer.
      Parameters:
      writer - The writer
      context - The evaluation context
      blockName - The name of the block
      ignoreOverriden - Whether or not to ignore overriden blocks
      Throws:
      IOException - Thrown from the writer object

    • macro

      public SafeString macro(EvaluationContextImpl context, String macroName, ArgumentsNode args, boolean ignoreOverriden, int lineNumber)
      Invokes a macro
      Parameters:
      context - The evaluation context
      macroName - The name of the macro
      args - The arguments
      ignoreOverriden - Whether or not to ignore macro definitions in child template
      Returns:
      The results of the macro invocation

    • setParent

      public void setParent(EvaluationContextImpl context, String parentName)

    • getName

      public String getName()
      Returns the template name
      Specified by:
      getName in interface PebbleTemplate
      Returns:
      The name of the template