org.apache.commons.jexl3

## Interface JxltEngine.Template

- Enclosing class:
    JxltEngine

      public static interface JxltEngine.Template

  A template is a JEXL script that evaluates by writing its content through a Writer.

  The source text is parsed considering each line beginning with '$$' (as default pattern) as JEXL script code and all others as Unified JEXL expressions; those expressions will be invoked from the script during evaluation and their output gathered through a writer. It is thus possible to use looping or conditional construct "around" expressions generating output.

  For instance:

  >      $$ for(var x : [1, 3, 5, 42, 169]) {
  >      $$   if (x == 42) {
  >      Life, the universe, and everything
  >      $$   } else if (x > 42) {
  >      The value $(x} is over forty-two
  >      $$   } else {
  >      The value ${x} is under forty-two
  >      $$   }
  >      $$ }

  Will evaluate as:

  >      The value 1 is under forty-two
  >      The value 3 is under forty-two
  >      The value 5 is under forty-two
  >      Life, the universe, and everything
  >      The value 169 is over forty-two

  During evaluation, the template context exposes its writer as '$jexl' which is safe to use in this case. This allows writing directly through the writer without adding new-lines as in:

  >      $$ for(var cell : cells) { $jexl.print(cell); $jexl.print(';') }

  A template is expanded as one JEXL script and a list of template expressions; each template expression is being replaced in the script by a call to jexl:print(expr) (the expr is in fact the expr number in the template). This integration uses a specialized JexlContext (TemplateContext) that serves as a namespace (for jexl:) and stores the template expression array and the writer (java.io.Writer) that the 'jexl:print(...)' delegates the output generation to.

  Since:
    3.0

- - ### Method Summary

    All Methods Instance Methods Abstract Methods
    Modifier and Type | Method and Description
    --- | ---
    `String` | `asString()` Recreate the template source from its inner components.
    `void` | `evaluate(JexlContext context, Writer writer)` Evaluates this template.
    `void` | `evaluate(JexlContext context, Writer writer, Object... args)` Evaluates this template.
    `String[]` | `getParameters()` Gets the list of parameters expected by this template.
    `Map<String,Object>` | `getPragmas()` Gets this script pragmas.
    `Set<List<String>>` | `getVariables()` Gets the list of variables accessed by this template.
    `JxltEngine.Template` | `prepare(JexlContext context)` Prepares this template by expanding any contained deferred TemplateExpression.

- - ### Method Detail

    - #### asString

          String asString()

      Recreate the template source from its inner components.
      Returns:
        the template source rewritten

    - #### evaluate

          void evaluate(JexlContext context,
                        Writer writer)

      Evaluates this template.
      Parameters:
        `context` - the context to use during evaluation
        `writer` - the writer to use for output

    - #### evaluate

          void evaluate(JexlContext context,
                        Writer writer,
                        Object... args)

      Evaluates this template.
      Parameters:
        `context` - the context to use during evaluation
        `writer` - the writer to use for output
        `args` - the arguments

    - #### prepare

          JxltEngine.Template prepare(JexlContext context)

      Prepares this template by expanding any contained deferred TemplateExpression.
      Parameters:
        `context` - the context to prepare against
      Returns:
        the prepared version of the template

    - #### getVariables

          Set<List<String>> getVariables()

      Gets the list of variables accessed by this template.

      This method will visit all nodes of the sub-expressions and extract all variables whether they are written in 'dot' or 'bracketed' notation. (a.b is equivalent to a['b']).

      Returns:
        the set of variables, each as a list of strings (ant-ish variables use more than 1 string) or the empty set if no variables are used

    - #### getParameters

          String[] getParameters()

      Gets the list of parameters expected by this template.
      Returns:
        the parameter names array

    - #### getPragmas

          Map<String,Object> getPragmas()

      Gets this script pragmas.
      Returns:
        the (non null, may be empty) pragmas map
      Since:
        3.1

Copyright © 2001–2021 The Apache Software Foundation. All rights reserved.