IntroductionPage

JLoom template:

IntroductionPage.jloom
<%@ jloom net.gereon.jloom.homepage.core.PageGenerator /%>

<%@ import net.gereon.jloom.homepage.core.* /%>



<%@ main () %>
<%@ exec PageBorder (getPage()) %>

<h3> Simple Template Mechanisms </h3>

<p>
Think about the following problem:
You have to generate a text document, for example HTML, XML,
source-code, email, or documentation.
</p>
<p>
A template mechanism helps you to add dynamic content. Imagine that the produced document slightly changes every time
you generate it. For example, in an email the salutation could depend on
the receiver of the mail. This is called <b>dynamic content</b>,
by contrast the fixed text is called <b>static content</b>.
</p>
<p>
Generally a template consists of the static content plus special tags at
places where dynamic content has to be inserted.
The following shows an example template for an email.
</p>
<%@ exec ExampleCode ("email.template") /%>
<p>
This template uses the syntax <code>&lt;%= variable %&gt;</code>
to insert dynamic content.
The syntax is the same in JSP and JLoom where these elements
are called <b>Expressions</b>, because they could not only contain
String variables but Java-expressions which resolve to a String,
for example you could call methods on an object:
<code>&lt;%= user.getFirstName() + " " + user.getLastName() %&gt;</code>
</p>
<br>

<h3> JSP-like Template Mechanisms </h3>

<p>
Such mechanisms take two steps to generate the document:
<br>
The first step is called <b>translation</b>.
In this step the template is translated to a Java class,
called <b>generator class</b>.
<br>
The second step is called <b>generation</b>.
In this step the generator class is used to generate the document.
</p>
<p>
This is the clue of these template mechanisms because it
allows to write Java code in the template.
Besides the translation has to be done only once and any subsequent generation
is extremely fast.
<br>
In JSP and JLoom these code blocks are called <b>scriptlets</b>
and have the following syntax:
<br>
<code>&lt;% /*Java-code*/ %&gt;</code>
<br>
<br>
This allows to use all the powerful features of the Java language,
e.g. conditional statements and loops (*).
And people who already know Java, don't have to learn a special
template syntax and operators, expression rules, assignment rules, etc.
Furthermore, enhancements of the underlying programming language (Java)
are immediately available, e.g. Generics of Java 1.5.
<br>
<small>
<b>
(*) JLoom lets you use this power in a structured way -
each template is an encapsulated parameterized module.
</b>
</small>
<br>
<br>
A template for our email example could look like this:
<%@ exec ExampleCode ("email-for.template") /%>
<p>
The syntax of this template is the same as the JSP or JLoom syntax,
more precisely it could be a code fragment of a JLoom template.
This applies also for the next example, which shows a conditional statement:
</p>
<p>
<%@ exec ExampleCode ("email-if.template") /%>
</p>
<br>

<h3> JLoom </h3>

<p>
The email-if.template would look like this in JLoom:
</p>
<%@ exec ExampleCode ("EmailIf.jloom") /%>
<p>
The name of the template changed, because this name will be the prefix
of a Java classname and hyphens are not allowed in Java names.
Also it is better to start the name with an uppercase letter
(Java naming convention),
but this is not required.
</p>
<p>
You may have noticed the two new tags, which start with
<code>&lt;%@</code>,
these are <b>commands</b> and are explained in the
<%@ exec PageLink (Page.COMMANDS) /%>.
<br>
Another new tag is
<code>&lt;%-- credit is ok --%&gt;</code>,
this is a <b>comment</b> - the same syntax as in JSP.
Comments will just be ignored.
Because the scriptlet is self-explanatory,
this is a good example for a bad comment.
</p>
<p>
This template will be translated into the following generator class:
<br>
(shown just for demonstration purpose -
 you don't have to worry about this code because JLoom creates it for you)
<%@ exec ExampleCode ("EmailIf_JLoom.java") /%>
</p>
<p>
JLoom also defines commands for loops and if-statements,
which can make your template code a bit more readable.
Furthermore they make use of JLoom commands for indention,
which result in correct indention of blocks in the generator Java code
(whereas the if-block above is not indented correctly),
which can be helpful for debugging.
By the way, this is a big advantage of such template mechanisms,
you can look at the generator code and immediately see
how your template was interpreted - extremely helpful in the real world!
<br>
In <%@ exec PageLink (Page.EXAMPLES) /%> you can find a more detailed
example.
</p>

<%/ exec %>
<%/ main %>



Generator class:

IntroductionPage_JLoom.java
/* JLoom 1.4.0 generator class */

/* AUTO-GENERATED */
/* Do not edit! Changes will be overwritten! */

package net.gereon.jloom.homepage.templates;

import java.io.*;
import net.gereon.jloom.core.*;
import net.gereon.jloom.util.*;
import static net.gereon.jloom.util.GenerationTools.*;
import net.gereon.jloom.homepage.core.*;



public class IntroductionPage_JLoom extends net.gereon.jloom.homepage.core.PageGenerator {


  public void generateMain(GenerationContext context) throws IOException {
    {
      PageBorder_JLoom _generator_46 = new PageBorder_JLoom();
      _generator_46.generateMain(context, getPage());
      newLine(context);
      newLine(context);
      println(context, "<h3> Simple Template Mechanisms </h3>");
      newLine(context);
      println(context, "<p>");
      println(context, "Think about the following problem:");
      println(context, "You have to generate a text document, for example HTML, XML,");
      println(context, "source-code, email, or documentation.");
      println(context, "</p>");
      println(context, "<p>");
      println(context, "A template mechanism helps you to add dynamic content. Imagine that the produced document slightly changes every time");
      println(context, "you generate it. For example, in an email the salutation could depend on");
      println(context, "the receiver of the mail. This is called <b>dynamic content</b>,");
      println(context, "by contrast the fixed text is called <b>static content</b>.");
      println(context, "</p>");
      println(context, "<p>");
      println(context, "Generally a template consists of the static content plus special tags at");
      println(context, "places where dynamic content has to be inserted.");
      println(context, "The following shows an example template for an email.");
      println(context, "</p>");
      {
        ExampleCode_JLoom _generator_47 = new ExampleCode_JLoom();
        _generator_47.generateMain(context, "email.template");
        _generator_47.generateTail(context);
      }
      newLine(context);
      println(context, "<p>");
      println(context, "This template uses the syntax <code>&lt;%= variable %&gt;</code>");
      println(context, "to insert dynamic content.");
      println(context, "The syntax is the same in JSP and JLoom where these elements");
      println(context, "are called <b>Expressions</b>, because they could not only contain");
      println(context, "String variables but Java-expressions which resolve to a String,");
      println(context, "for example you could call methods on an object:");
      println(context, "<code>&lt;%= user.getFirstName() + \" \" + user.getLastName() %&gt;</code>");
      println(context, "</p>");
      println(context, "<br>");
      newLine(context);
      println(context, "<h3> JSP-like Template Mechanisms </h3>");
      newLine(context);
      println(context, "<p>");
      println(context, "Such mechanisms take two steps to generate the document:");
      println(context, "<br>");
      println(context, "The first step is called <b>translation</b>.");
      println(context, "In this step the template is translated to a Java class,");
      println(context, "called <b>generator class</b>.");
      println(context, "<br>");
      println(context, "The second step is called <b>generation</b>.");
      println(context, "In this step the generator class is used to generate the document.");
      println(context, "</p>");
      println(context, "<p>");
      println(context, "This is the clue of these template mechanisms because it");
      println(context, "allows to write Java code in the template.");
      println(context, "Besides the translation has to be done only once and any subsequent generation");
      println(context, "is extremely fast.");
      println(context, "<br>");
      println(context, "In JSP and JLoom these code blocks are called <b>scriptlets</b>");
      println(context, "and have the following syntax:");
      println(context, "<br>");
      println(context, "<code>&lt;% /*Java-code*/ %&gt;</code>");
      println(context, "<br>");
      println(context, "<br>");
      println(context, "This allows to use all the powerful features of the Java language,");
      println(context, "e.g. conditional statements and loops (*).");
      println(context, "And people who already know Java, don\'t have to learn a special");
      println(context, "template syntax and operators, expression rules, assignment rules, etc.");
      println(context, "Furthermore, enhancements of the underlying programming language (Java)");
      println(context, "are immediately available, e.g. Generics of Java 1.5.");
      println(context, "<br>");
      println(context, "<small>");
      println(context, "<b>");
      println(context, "(*) JLoom lets you use this power in a structured way -");
      println(context, "each template is an encapsulated parameterized module.");
      println(context, "</b>");
      println(context, "</small>");
      println(context, "<br>");
      println(context, "<br>");
      println(context, "A template for our email example could look like this:");
      {
        ExampleCode_JLoom _generator_48 = new ExampleCode_JLoom();
        _generator_48.generateMain(context, "email-for.template");
        _generator_48.generateTail(context);
      }
      newLine(context);
      println(context, "<p>");
      println(context, "The syntax of this template is the same as the JSP or JLoom syntax,");
      println(context, "more precisely it could be a code fragment of a JLoom template.");
      println(context, "This applies also for the next example, which shows a conditional statement:");
      println(context, "</p>");
      println(context, "<p>");
      {
        ExampleCode_JLoom _generator_49 = new ExampleCode_JLoom();
        _generator_49.generateMain(context, "email-if.template");
        _generator_49.generateTail(context);
      }
      newLine(context);
      println(context, "</p>");
      println(context, "<br>");
      newLine(context);
      println(context, "<h3> JLoom </h3>");
      newLine(context);
      println(context, "<p>");
      println(context, "The email-if.template would look like this in JLoom:");
      println(context, "</p>");
      {
        ExampleCode_JLoom _generator_50 = new ExampleCode_JLoom();
        _generator_50.generateMain(context, "EmailIf.jloom");
        _generator_50.generateTail(context);
      }
      newLine(context);
      println(context, "<p>");
      println(context, "The name of the template changed, because this name will be the prefix");
      println(context, "of a Java classname and hyphens are not allowed in Java names.");
      println(context, "Also it is better to start the name with an uppercase letter");
      println(context, "(Java naming convention),");
      println(context, "but this is not required.");
      println(context, "</p>");
      println(context, "<p>");
      println(context, "You may have noticed the two new tags, which start with");
      println(context, "<code>&lt;%@</code>,");
      println(context, "these are <b>commands</b> and are explained in the");
      {
        PageLink_JLoom _generator_51 = new PageLink_JLoom();
        _generator_51.generateMain(context, Page.COMMANDS);
        _generator_51.generateTail(context);
      }
      println(context, ".");
      println(context, "<br>");
      println(context, "Another new tag is");
      println(context, "<code>&lt;%-- credit is ok --%&gt;</code>,");
      println(context, "this is a <b>comment</b> - the same syntax as in JSP.");
      println(context, "Comments will just be ignored.");
      println(context, "Because the scriptlet is self-explanatory,");
      println(context, "this is a good example for a bad comment.");
      println(context, "</p>");
      println(context, "<p>");
      println(context, "This template will be translated into the following generator class:");
      println(context, "<br>");
      println(context, "(shown just for demonstration purpose -");
      println(context, " you don\'t have to worry about this code because JLoom creates it for you)");
      {
        ExampleCode_JLoom _generator_52 = new ExampleCode_JLoom();
        _generator_52.generateMain(context, "EmailIf_JLoom.java");
        _generator_52.generateTail(context);
      }
      newLine(context);
      println(context, "</p>");
      println(context, "<p>");
      println(context, "JLoom also defines commands for loops and if-statements,");
      println(context, "which can make your template code a bit more readable.");
      println(context, "Furthermore they make use of JLoom commands for indention,");
      println(context, "which result in correct indention of blocks in the generator Java code");
      println(context, "(whereas the if-block above is not indented correctly),");
      println(context, "which can be helpful for debugging.");
      println(context, "By the way, this is a big advantage of such template mechanisms,");
      println(context, "you can look at the generator code and immediately see");
      println(context, "how your template was interpreted - extremely helpful in the real world!");
      println(context, "<br>");
      print(context, "In ");
      {
        PageLink_JLoom _generator_53 = new PageLink_JLoom();
        _generator_53.generateMain(context, Page.EXAMPLES);
        _generator_53.generateTail(context);
      }
      println(context, " you can find a more detailed");
      println(context, "example.");
      println(context, "</p>");
      newLine(context);
      _generator_46.generateTail(context);
    }
  }
}

/* TRANSLATION MAPPING:
[62 288 c] [117 329 c] [133 500 c] [167 623 c] [881 1845 c]
[924 2036 c] [2696 5151 c] [2743 5346 c] [2973 5754 c] [3019 5948 c]
[3120 6271 c] [3162 6461 c] [3563 7170 c] [3600 7352 c] [4051 8168 c]
[4098 8363 c] [4656 9281 c] [4693 9463 c] [4753 9661 c] */



HTML of the generated page:

Introduction.html
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
  <meta http-equiv="content-type" content="text/html; charset=ISO-8859-1">
  <meta name="description"
        content="JLoom is a JSP like template language for text generation. JLoom templates are modular encapsulated and can declare arbitrary parameters, not only Strings. They can be used to generate source code, HTML, XML, etc. There is a plugin for Eclipse.">
  <meta name="keywords"
        content="Java, HTML, XML, code generation, Eclipse, JSP, dynamic content, template, templates, text generation">
  <meta http-equiv="expires" content="0">
  <meta http-equiv="cache-control" content="no-cache">
  <meta http-equiv="pragma" content="no-cache">
  <link rel="stylesheet" type="text/css" href="/etc/style.css">
  <title> Introduction </title>
</head>

<body leftmargin="0" topmargin="0" marginwidth="0" marginheight="0">
<table cellspacing="0" cellpadding="20" height="100%">
<tr>

<td valign="top" style="background-color:#d7d7ee">
<a href="http://sourceforge.net" target="_top" title="Goto Sourceforge"
   ><img src="http://sflogo.sourceforge.net/sflogo.php?group_id=160273&amp;type=2"
     width="125" height="37" border="0" alt="SourceForge.net Logo"/>
</a>
<br>
<br>
<a href="http://sourceforge.net/projects/jloom" target="_top"
   title="Goto JLoom at Sourceforge"
   style="color:black; text-decoration:none;">
  <nobr>
  <img src="/images/jloom_3.png" border="0" alt="JLoom Logo"/>
  <span style="font-family:Verdana; font-size:4em;">JLoom</span>
  </nobr>
</a>
<br>
<br>
<br>
  <a href="/index.html" style="color:#4646aa; font-size:1.8em; text-decoration:none;">
<b> Overview </b>
</a>
<br>
<br>
  <a href="/Introduction.html" style="color:#4646aa; font-size:1.8em; text-decoration:none;">
<b> Introduction </b>
</a>
<br>
<br>
  <a href="/Commands.html" style="color:#4646aa; font-size:1.8em; text-decoration:none;">
<b> Commands </b>
</a>
<br>
<br>
  <a href="/HelloExamples.html" style="color:#4646aa; font-size:1.8em; text-decoration:none;">
<b> Hello World Examples </b>
</a>
<br>
<br>
  <a href="/Installation.html" style="color:#4646aa; font-size:1.8em; text-decoration:none;">
<b> Installation / Usage </b>
</a>
<br>
<br>
  <a href="/Eclipse.html" style="color:#4646aa; font-size:1.8em; text-decoration:none;">
<b> Eclipse Plugin </b>
</a>
<br>
<br>
  <a href="/Download.html" style="color:#4646aa; font-size:1.8em; text-decoration:none;">
<b> Download </b>
</a>
<br>
<br>

</td>

<td valign="top">
<table width="100%">
<tr>
<td width="20">
  <small>
  <a href="index.html"><nobr>Overview</nobr></a>
  </small>
</td>
<td>
<center> <h2> Introduction </h2> </center>
</td>
<td align="right" width="20">
  <small>
  <a href="Commands.html"><nobr>Commands</nobr></a>
  </small>
</td>
</tr>
</table>

<h3> Simple Template Mechanisms </h3>

<p>
Think about the following problem:
You have to generate a text document, for example HTML, XML,
source-code, email, or documentation.
</p>
<p>
A template mechanism helps you to add dynamic content. Imagine that the produced document slightly changes every time
you generate it. For example, in an email the salutation could depend on
the receiver of the mail. This is called <b>dynamic content</b>,
by contrast the fixed text is called <b>static content</b>.
</p>
<p>
Generally a template consists of the static content plus special tags at
places where dynamic content has to be inserted.
The following shows an example template for an email.
</p>
<table cellspacing="0" cellpadding="0">
<tr>
<td style="background-color:#7777ff; font-family:Verdana;">
<small> <b> email.template </b> </small>
</td>
</tr>
<tr>
<td class="code">
<span class="code">
Hello&nbsp;Mr.&nbsp;<span class="jloom-b">&lt;<span class="jloom">%=&nbsp;name&nbsp;%</span>&gt;</span>,
<br>

<br>
your&nbsp;account&nbsp;will&nbsp;expire&nbsp;on&nbsp;<span class="jloom-b">&lt;<span class="jloom">%=&nbsp;date&nbsp;%</span>&gt;</span>.
<br>
Please&nbsp;login&nbsp;on&nbsp;our&nbsp;homepage&nbsp;and&nbsp;don't&nbsp;hesitate&nbsp;to&nbsp;click&nbsp;our&nbsp;banners.
<br>

<br>
Thank&nbsp;you!
<br>
<span class="jloom-b">&lt;<span class="jloom">%=&nbsp;adminName&nbsp;%</span>&gt;</span></span>
</td>
</tr>
</table>
<p>
This template uses the syntax <code>&lt;%= variable %&gt;</code>
to insert dynamic content.
The syntax is the same in JSP and JLoom where these elements
are called <b>Expressions</b>, because they could not only contain
String variables but Java-expressions which resolve to a String,
for example you could call methods on an object:
<code>&lt;%= user.getFirstName() + " " + user.getLastName() %&gt;</code>
</p>
<br>

<h3> JSP-like Template Mechanisms </h3>

<p>
Such mechanisms take two steps to generate the document:
<br>
The first step is called <b>translation</b>.
In this step the template is translated to a Java class,
called <b>generator class</b>.
<br>
The second step is called <b>generation</b>.
In this step the generator class is used to generate the document.
</p>
<p>
This is the clue of these template mechanisms because it
allows to write Java code in the template.
Besides the translation has to be done only once and any subsequent generation
is extremely fast.
<br>
In JSP and JLoom these code blocks are called <b>scriptlets</b>
and have the following syntax:
<br>
<code>&lt;% /*Java-code*/ %&gt;</code>
<br>
<br>
This allows to use all the powerful features of the Java language,
e.g. conditional statements and loops (*).
And people who already know Java, don't have to learn a special
template syntax and operators, expression rules, assignment rules, etc.
Furthermore, enhancements of the underlying programming language (Java)
are immediately available, e.g. Generics of Java 1.5.
<br>
<small>
<b>
(*) JLoom lets you use this power in a structured way -
each template is an encapsulated parameterized module.
</b>
</small>
<br>
<br>
A template for our email example could look like this:
<table cellspacing="0" cellpadding="0">
<tr>
<td style="background-color:#7777ff; font-family:Verdana;">
<small> <b> email-for.template </b> </small>
</td>
</tr>
<tr>
<td class="code">
<span class="code">
Hello&nbsp;Mr.&nbsp;<span class="jloom-b">&lt;<span class="jloom">%=&nbsp;name&nbsp;%</span>&gt;</span>,
<br>

<br>
you&nbsp;have&nbsp;the&nbsp;following&nbsp;items&nbsp;in&nbsp;your&nbsp;shopping&nbsp;basket:
<br>
<span class="jloom-b">&lt;<span class="jloom">%
<br>
Item[]&nbsp;items&nbsp;=&nbsp;getShoppingItems();
<br>
for&nbsp;(int&nbsp;i=0;&nbsp;i&lt;items.lenght;&nbsp;i++)&nbsp;{
<br>
&nbsp;&nbsp;%</span>&gt;</span>
<br>
&nbsp;&nbsp;<span class="jloom-b">&lt;<span class="jloom">%=&nbsp;items[i].getName()&nbsp;%</span>&gt;</span>
<br>
&nbsp;&nbsp;<span class="jloom-b">&lt;<span class="jloom">%
<br>
}
<br>
%</span>&gt;</span>
<br>

<br>
Happy&nbsp;shopping!</span>
</td>
</tr>
</table>
<p>
The syntax of this template is the same as the JSP or JLoom syntax,
more precisely it could be a code fragment of a JLoom template.
This applies also for the next example, which shows a conditional statement:
</p>
<p>
<table cellspacing="0" cellpadding="0">
<tr>
<td style="background-color:#7777ff; font-family:Verdana;">
<small> <b> email-if.template </b> </small>
</td>
</tr>
<tr>
<td class="code">
<span class="code">
Hello&nbsp;Mr.&nbsp;<span class="jloom-b">&lt;<span class="jloom">%=&nbsp;name&nbsp;%</span>&gt;</span>,
<br>

<br>
<span class="jloom-b">&lt;<span class="jloom">%
<br>
if&nbsp;(hasCredit)&nbsp;{
<br>
&nbsp;&nbsp;%</span>&gt;</span>
<br>
&nbsp;&nbsp;Happy&nbsp;shopping!
<br>
&nbsp;&nbsp;<span class="jloom-b">&lt;<span class="jloom">%
<br>
}
<br>
else&nbsp;{
<br>
&nbsp;&nbsp;%</span>&gt;</span>
<br>
&nbsp;&nbsp;Have&nbsp;a&nbsp;nice&nbsp;day!
<br>
&nbsp;&nbsp;<span class="jloom-b">&lt;<span class="jloom">%
<br>
}
<br>
%</span>&gt;</span></span>
</td>
</tr>
</table>
</p>
<br>

<h3> JLoom </h3>

<p>
The email-if.template would look like this in JLoom:
</p>
<table cellspacing="0" cellpadding="0">
<tr>
<td style="background-color:#7777ff; font-family:Verdana;">
<small> <b> EmailIf.jloom </b> </small>
</td>
</tr>
<tr>
<td class="code">
<span class="code">
<span class="jloom-b">&lt;<span class="jloom">%@&nbsp;jloom&nbsp;template&nbsp;/%</span>&gt;</span>
<br>

<br>
<span class="jloom-b">&lt;<span class="jloom">%@&nbsp;main&nbsp;(String&nbsp;name,&nbsp;boolean&nbsp;hasCredit)&nbsp;%</span>&gt;</span>
<br>
Hello&nbsp;Mr.&nbsp;<span class="jloom-b">&lt;<span class="jloom">%=&nbsp;name&nbsp;%</span>&gt;</span>,
<br>
<span class="jloom-b">&lt;<span class="jloom">%
<br>
if&nbsp;(hasCredit)&nbsp;{
<br>
&nbsp;&nbsp;%</span>&gt;</span>
<br>
&nbsp;&nbsp;<span class="comment">&lt;&#37;--&nbsp;credit&nbsp;is&nbsp;ok&nbsp;--&#37;&gt;</span>
<br>
&nbsp;&nbsp;Happy&nbsp;shopping!
<br>
&nbsp;&nbsp;<span class="jloom-b">&lt;<span class="jloom">%
<br>
}
<br>
else&nbsp;{
<br>
&nbsp;&nbsp;%</span>&gt;</span>
<br>
&nbsp;&nbsp;Have&nbsp;a&nbsp;nice&nbsp;day!
<br>
&nbsp;&nbsp;<span class="jloom-b">&lt;<span class="jloom">%
<br>
}
<br>
%</span>&gt;</span>
<br>
<span class="jloom-b">&lt;<span class="jloom">%/&nbsp;main&nbsp;%</span>&gt;</span></span>
</td>
</tr>
</table>
<p>
The name of the template changed, because this name will be the prefix
of a Java classname and hyphens are not allowed in Java names.
Also it is better to start the name with an uppercase letter
(Java naming convention),
but this is not required.
</p>
<p>
You may have noticed the two new tags, which start with
<code>&lt;%@</code>,
these are <b>commands</b> and are explained in the
<a href="Commands.html"><nobr>Commands</nobr></a>.
<br>
Another new tag is
<code>&lt;%-- credit is ok --%&gt;</code>,
this is a <b>comment</b> - the same syntax as in JSP.
Comments will just be ignored.
Because the scriptlet is self-explanatory,
this is a good example for a bad comment.
</p>
<p>
This template will be translated into the following generator class:
<br>
(shown just for demonstration purpose -
 you don't have to worry about this code because JLoom creates it for you)
<table cellspacing="0" cellpadding="0">
<tr>
<td style="background-color:#7777ff; font-family:Verdana;">
<small> <b> EmailIf_JLoom.java </b> </small>
</td>
</tr>
<tr>
<td class="code">
<span class="code">
/*&nbsp;JLoom&nbsp;1.4.0&nbsp;generator&nbsp;class&nbsp;*/
<br>

<br>
/*&nbsp;AUTO-GENERATED&nbsp;*/
<br>
/*&nbsp;Do&nbsp;not&nbsp;edit!&nbsp;Changes&nbsp;will&nbsp;be&nbsp;overwritten!&nbsp;*/
<br>

<br>
package&nbsp;net.gereon.jloom.homepage.examples;
<br>

<br>
import&nbsp;java.io.*;
<br>
import&nbsp;net.gereon.jloom.core.*;
<br>
import&nbsp;net.gereon.jloom.util.*;
<br>
import&nbsp;static&nbsp;net.gereon.jloom.util.GenerationTools.*;
<br>

<br>

<br>

<br>
public&nbsp;class&nbsp;EmailIf_JLoom&nbsp;extends&nbsp;net.gereon.jloom.core.GeneratorBase&nbsp;{
<br>

<br>

<br>
&nbsp;&nbsp;public&nbsp;void&nbsp;generateMain(GenerationContext&nbsp;context,&nbsp;String&nbsp;name,&nbsp;boolean&nbsp;hasCredit)&nbsp;throws&nbsp;IOException&nbsp;{
<br>
&nbsp;&nbsp;&nbsp;&nbsp;print(context,&nbsp;"Hello&nbsp;Mr.&nbsp;");
<br>
&nbsp;&nbsp;&nbsp;&nbsp;print(context,&nbsp;""&nbsp;+&nbsp;(name));
<br>
&nbsp;&nbsp;&nbsp;&nbsp;println(context,&nbsp;",");
<br>
&nbsp;&nbsp;&nbsp;&nbsp;if&nbsp;(hasCredit)&nbsp;{
<br>
&nbsp;&nbsp;&nbsp;&nbsp;println(context,&nbsp;"&nbsp;&nbsp;Happy&nbsp;shopping!");
<br>
&nbsp;&nbsp;&nbsp;&nbsp;}
<br>
&nbsp;&nbsp;&nbsp;&nbsp;else&nbsp;{
<br>
&nbsp;&nbsp;&nbsp;&nbsp;println(context,&nbsp;"&nbsp;&nbsp;Have&nbsp;a&nbsp;nice&nbsp;day!");
<br>
&nbsp;&nbsp;&nbsp;&nbsp;}
<br>
&nbsp;&nbsp;}
<br>
}
<br>

<br>
/*&nbsp;TRANSLATION&nbsp;MAPPING:
<br>
[26&nbsp;287&nbsp;c]&nbsp;[70&nbsp;472&nbsp;c]&nbsp;[82&nbsp;506&nbsp;c]&nbsp;[93&nbsp;539&nbsp;c]&nbsp;[96&nbsp;566&nbsp;c]
<br>
[100&nbsp;570&nbsp;s]&nbsp;[148&nbsp;587&nbsp;c]&nbsp;[171&nbsp;630&nbsp;c]&nbsp;[175&nbsp;634&nbsp;s]&nbsp;[178&nbsp;640&nbsp;s]
<br>
[190&nbsp;647&nbsp;c]&nbsp;[214&nbsp;691&nbsp;c]&nbsp;[218&nbsp;695&nbsp;s]&nbsp;[223&nbsp;697&nbsp;c]&nbsp;*/
<br>
</span>
</td>
</tr>
</table>
</p>
<p>
JLoom also defines commands for loops and if-statements,
which can make your template code a bit more readable.
Furthermore they make use of JLoom commands for indention,
which result in correct indention of blocks in the generator Java code
(whereas the if-block above is not indented correctly),
which can be helpful for debugging.
By the way, this is a big advantage of such template mechanisms,
you can look at the generator code and immediately see
how your template was interpreted - extremely helpful in the real world!
<br>
In <a href="HelloExamples.html"><nobr>Hello World Examples</nobr></a> you can find a more detailed
example.
</p>

<br>
<br>
<table width="100%">
<tr>
<td>
<div class="info">
<nobr>
&nbsp;
Generated by
<a href="http://jloom.sourceforge.net" target="_top"
   title="Goto JLoom Home"
   style="color:black; text-decoration:none;">
  <img src="/images/jloom_milli.png" border="0" alt="JLoom Logo"
       style="margin-right:2;vertical-align:sub;"/>JLoom
</a>
November 29, 2007
&nbsp; &#149; &nbsp;
You can view the template here:

<a href="homebrowser/IntroductionPage_Browser.html"
   target="homebrowser"
   title="Show in Template Browser"
   >IntroductionPage</a>
&nbsp;
</nobr>
</div>
</td>
<td width="100%">
</td>
<td align="right">
<a href="http://sourceforge.net" target="_top" title="Goto Sourceforge"
   ><img src="http://sflogo.sourceforge.net/sflogo.php?group_id=160273&amp;type=1"
     width="88" height="31" border="0" alt="SourceForge.net Logo" /></a>
</td>
</tr>
</table>
</td>

</tr>
</table>
</body>
</html>



  Generated by JLoom LogoJLoom November 29, 2007   •   You can view the template here: HomeBrowserView  
SourceForge.net Logo