Package groovy.text

## Class SimpleTemplateEngine

- java.lang.Object
- - groovy.text.TemplateEngine
  - - groovy.text.SimpleTemplateEngine

-     public class SimpleTemplateEngine
      extends TemplateEngine

  Processes template source files substituting variables and expressions into placeholders in a template source text to produce the desired output.

  The template engine uses JSP style <% %> script and <%= %> expression syntax or GString style expressions. The variable '`out`' is bound to the writer that the template is being written to.

  Frequently, the template source will be in a file but here is a simple example providing the template as a string:

       def binding = [
           firstname : "Grace",
           lastname  : "Hopper",
           accepted  : true,
           title     : 'Groovy for COBOL programmers'
       ]
       def engine = new groovy.text.SimpleTemplateEngine()
       def text = '''\
       Dear <%= firstname %> $lastname,

       We <% if (accepted) print 'are pleased' else print 'regret' %> \
       to inform you that your paper entitled
       '$title' was ${ accepted ? 'accepted' : 'rejected' }.

       The conference committee.
       '''
       def template = engine.createTemplate(text).make(binding)
       println template.toString()

  This example uses a mix of the JSP style and GString style placeholders but you can typically use just one style if you wish. Running this example will produce this output:

       Dear Grace Hopper,

       We are pleased to inform you that your paper entitled
       'Groovy for COBOL programmers' was accepted.

       The conference committee.

  The template engine can also be used as the engine for `TemplateServlet` by placing the following in your `web.xml` file (plus a corresponding servlet-mapping element):

       <servlet>
         <servlet-name>SimpleTemplate</servlet-name>
         <servlet-class>groovy.servlet.TemplateServlet</servlet-class>
         <init-param>
           <param-name>template.engine</param-name>
           <param-value>groovy.text.SimpleTemplateEngine</param-value>
         </init-param>
       </servlet>

  In this case, your template source file should be HTML with the appropriate embedded placeholders.

- - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `SimpleTemplateEngine()` |
    `SimpleTemplateEngine​(boolean verbose)` |
    `SimpleTemplateEngine​(GroovyShell groovyShell)` |
    `SimpleTemplateEngine​(ClassLoader parentLoader)` |

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `Template` | `createTemplate​(Reader reader)` | Creates a template by reading content from the Reader.
    `boolean` | `isEscapeBackslash()` |
    `boolean` | `isVerbose()` |
    `void` | `setEscapeBackslash​(boolean escapeBackslash)` |
    `void` | `setVerbose​(boolean verbose)` |

    - ### Methods inherited from class groovy.text.TemplateEngine

      `createTemplate, createTemplate, createTemplate, createTemplate, createTemplate`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### SimpleTemplateEngine

          public SimpleTemplateEngine()

    - #### SimpleTemplateEngine

          public SimpleTemplateEngine​(boolean verbose)

    - #### SimpleTemplateEngine

          public SimpleTemplateEngine​(ClassLoader parentLoader)

    - #### SimpleTemplateEngine

          public SimpleTemplateEngine​(GroovyShell groovyShell)

  - ### Method Detail

    - #### createTemplate

          public Template createTemplate​(Reader reader)
                                  throws CompilationFailedException,
                                         IOException

      Description copied from class: `TemplateEngine`
      Creates a template by reading content from the Reader.
      Specified by:
        `createTemplate` in class `TemplateEngine`
      Throws:
        `CompilationFailedException`
        `IOException`

    - #### setVerbose

          public void setVerbose​(boolean verbose)

      Parameters:
        `verbose` - true if you want the engine to display the template source file for debugging purposes

    - #### isVerbose

          public boolean isVerbose()

    - #### isEscapeBackslash

          public boolean isEscapeBackslash()

    - #### setEscapeBackslash

          public void setEscapeBackslash​(boolean escapeBackslash)