OverviewPage

JLoom template:

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

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



<%@ main () %>

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

<%@ exec Feature ("") %>
JLoom is a modular template language for text generation,
e.g. generation of source code, HTML, XML, etc.
<%/ exec %>

<%@ exec Feature ("JSP like Syntax") %>
The syntax and semantics of JLoom templates are similar to Java Server Pages (JSP).
If you already know JSP you will have no problem to write JLoom templates.
<%/ exec %>

<%@ exec Feature ("Modularity") %>
JLoom doesn't have include-tags like JSP -
which just insert other JSPs without encapsulation and parametrization.
Instead of include-tags, JLoom supports modular composition of templates.
<br>
Templates are full encapsulated like classes with parametrization and
compiletime type-checking.
Parameters are not restricted to String types - they can be any Java type,
even Generics or Varargs.
<br>
You can make a top-down/bottom-up design of the text-processing in
your application. The modular templates strongly improve the maintainability
of your code and eliminate redundancy.
<br>
In addition you can organize your templates hierarchically in packages.
And you can make modular extensions of the language with macros.
<%/ exec %>

<%@ exec Feature ("Simplicity") %>
JLoom is easy to learn.
The syntax is clean and uniform.
Because it is build upon Java it can concentrate on its core function:
building a bridge from Java to text-generation.
<br>
If you are already familiar with Java syntax, there is not much to learn.
The operators, rules for assignments and expressions are the same.
And you can make use of the most recent Java (currently Java 1.5) syntax features,
like Generics, Varargs, Autoboxing, etc.
<br>
The basic syntax is simpler than JSP Syntax. But it is very powerful by
allowing the definition of new syntax elements.
This is done by writing macros, which are nothing else than JLoom templates themselves.
The basic JLoom syntax is extended by such macros,
e.g. all these commands are macros: exec, import, for, if, incIndent, decIndent.
<br>
You can extend the language by writing your own custom macros,
which are just JLoom templates - simple and powerful.
<%/ exec %>

<%@ exec Feature ("Universality") %>
Like JSP, JLoom can be used to generate dynamic web content.
And you can use both together: a JSP which accepts the HTTP requests,
handles HTTP specific things like setting the content type and
delegates the HTML generation to a JLoom template.
<br>
But JLoom can be used for arbitrary purposes. Generating of source code (*), XML
(alternative to XSLT), documentations, Emails, configuration files, scripts
are just some other examples.
Everywhere you have text-generation in your application,
JLoom can help you to get an easy maintainable and extendable solution.
<br>
<br>
(*) JLoom let you control the indention of the generated text -
this is especially useful for code generation.
JLoom uses itself (JLoom macros) to create the generator classes and
therefore the generated Java code has correct indention.
<%/ exec %>

<%@ exec Feature ("Efficiency") %>
JLoom generates text extremely fast.
Like in JSP, JLoom generation is done in two phases.
In the first phase the template is parsed and compiled into a Java class.
This phase takes place only one time after creating/changing the template.
Subsequent generations just "throw out" the text.
<%/ exec %>

<%@ exec Feature ("") %>
If you are already familiar with JSP,
you might want to make a quick start and
take a look at the <%@ exec PageLink (Page.EXAMPLES) /%>.
<%/ exec %>

<%/ exec %>

<%/ main %>



Generator class:

OverviewPage_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 OverviewPage_JLoom extends net.gereon.jloom.homepage.core.PageGenerator {


  public void generateMain(GenerationContext context) throws IOException {
    newLine(context);
    {
      PageBorder_JLoom _generator_55 = new PageBorder_JLoom();
      _generator_55.generateMain(context, getPage());
      newLine(context);
      newLine(context);
      {
        Feature_JLoom _generator_56 = new Feature_JLoom();
        _generator_56.generateMain(context, "");
        newLine(context);
        println(context, "JLoom is a modular template language for text generation,");
        println(context, "e.g. generation of source code, HTML, XML, etc.");
        _generator_56.generateTail(context);
      }
      newLine(context);
      newLine(context);
      {
        Feature_JLoom _generator_57 = new Feature_JLoom();
        _generator_57.generateMain(context, "JSP like Syntax");
        newLine(context);
        println(context, "The syntax and semantics of JLoom templates are similar to Java Server Pages (JSP).");
        println(context, "If you already know JSP you will have no problem to write JLoom templates.");
        _generator_57.generateTail(context);
      }
      newLine(context);
      newLine(context);
      {
        Feature_JLoom _generator_58 = new Feature_JLoom();
        _generator_58.generateMain(context, "Modularity");
        newLine(context);
        println(context, "JLoom doesn\'t have include-tags like JSP -");
        println(context, "which just insert other JSPs without encapsulation and parametrization.");
        println(context, "Instead of include-tags, JLoom supports modular composition of templates.");
        println(context, "<br>");
        println(context, "Templates are full encapsulated like classes with parametrization and");
        println(context, "compiletime type-checking.");
        println(context, "Parameters are not restricted to String types - they can be any Java type,");
        println(context, "even Generics or Varargs.");
        println(context, "<br>");
        println(context, "You can make a top-down/bottom-up design of the text-processing in");
        println(context, "your application. The modular templates strongly improve the maintainability");
        println(context, "of your code and eliminate redundancy.");
        println(context, "<br>");
        println(context, "In addition you can organize your templates hierarchically in packages.");
        println(context, "And you can make modular extensions of the language with macros.");
        _generator_58.generateTail(context);
      }
      newLine(context);
      newLine(context);
      {
        Feature_JLoom _generator_59 = new Feature_JLoom();
        _generator_59.generateMain(context, "Simplicity");
        newLine(context);
        println(context, "JLoom is easy to learn.");
        println(context, "The syntax is clean and uniform.");
        println(context, "Because it is build upon Java it can concentrate on its core function:");
        println(context, "building a bridge from Java to text-generation.");
        println(context, "<br>");
        println(context, "If you are already familiar with Java syntax, there is not much to learn.");
        println(context, "The operators, rules for assignments and expressions are the same.");
        println(context, "And you can make use of the most recent Java (currently Java 1.5) syntax features,");
        println(context, "like Generics, Varargs, Autoboxing, etc.");
        println(context, "<br>");
        println(context, "The basic syntax is simpler than JSP Syntax. But it is very powerful by");
        println(context, "allowing the definition of new syntax elements.");
        println(context, "This is done by writing macros, which are nothing else than JLoom templates themselves.");
        println(context, "The basic JLoom syntax is extended by such macros,");
        println(context, "e.g. all these commands are macros: exec, import, for, if, incIndent, decIndent.");
        println(context, "<br>");
        println(context, "You can extend the language by writing your own custom macros,");
        println(context, "which are just JLoom templates - simple and powerful.");
        _generator_59.generateTail(context);
      }
      newLine(context);
      newLine(context);
      {
        Feature_JLoom _generator_60 = new Feature_JLoom();
        _generator_60.generateMain(context, "Universality");
        newLine(context);
        println(context, "Like JSP, JLoom can be used to generate dynamic web content.");
        println(context, "And you can use both together: a JSP which accepts the HTTP requests,");
        println(context, "handles HTTP specific things like setting the content type and");
        println(context, "delegates the HTML generation to a JLoom template.");
        println(context, "<br>");
        println(context, "But JLoom can be used for arbitrary purposes. Generating of source code (*), XML");
        println(context, "(alternative to XSLT), documentations, Emails, configuration files, scripts");
        println(context, "are just some other examples.");
        println(context, "Everywhere you have text-generation in your application,");
        println(context, "JLoom can help you to get an easy maintainable and extendable solution.");
        println(context, "<br>");
        println(context, "<br>");
        println(context, "(*) JLoom let you control the indention of the generated text -");
        println(context, "this is especially useful for code generation.");
        println(context, "JLoom uses itself (JLoom macros) to create the generator classes and");
        println(context, "therefore the generated Java code has correct indention.");
        _generator_60.generateTail(context);
      }
      newLine(context);
      newLine(context);
      {
        Feature_JLoom _generator_61 = new Feature_JLoom();
        _generator_61.generateMain(context, "Efficiency");
        newLine(context);
        println(context, "JLoom generates text extremely fast.");
        println(context, "Like in JSP, JLoom generation is done in two phases.");
        println(context, "In the first phase the template is parsed and compiled into a Java class.");
        println(context, "This phase takes place only one time after creating/changing the template.");
        println(context, "Subsequent generations just \"throw out\" the text.");
        _generator_61.generateTail(context);
      }
      newLine(context);
      newLine(context);
      {
        Feature_JLoom _generator_62 = new Feature_JLoom();
        _generator_62.generateMain(context, "");
        newLine(context);
        println(context, "If you are already familiar with JSP,");
        println(context, "you might want to make a quick start and");
        print(context, "take a look at the ");
        {
          PageLink_JLoom _generator_63 = new PageLink_JLoom();
          _generator_63.generateMain(context, Page.EXAMPLES);
          _generator_63.generateTail(context);
        }
        println(context, ".");
        _generator_62.generateTail(context);
      }
      newLine(context);
      newLine(context);
      _generator_55.generateTail(context);
    }
    newLine(context);
  }
}

/* TRANSLATION MAPPING:
[62 288 c] [117 329 c] [131 496 c] [135 518 c] [169 641 c]
[173 689 c] [197 805 c] [318 1048 c] [322 1096 c] [361 1227 c]
[535 1523 c] [539 1571 c] [573 1697 c] [1323 2934 c] [1327 2982 c]
[1361 3108 c] [2305 4622 c] [2309 4670 c] [2345 4798 c] [3187 6154 c]
[3191 6202 c] [3225 6328 c] [3532 6843 c] [3536 6891 c] [3560 7007 c]
[3662 7217 c] [3699 7409 c] [3713 7493 c] [3728 7590 c] */



HTML of the generated page:

index.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> Overview </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">
</td>
<td>
<center> <h2> Overview </h2> </center>
</td>
<td align="right" width="20">
  <small>
  <a href="Introduction.html"><nobr>Introduction</nobr></a>
  </small>
</td>
</tr>
</table>

<div style="padding-left:2cm; padding-right:4cm;">
<br>
<b>  </b>
<br>
<br>
JLoom is a modular template language for text generation,
e.g. generation of source code, HTML, XML, etc.
</div>
<br>

<div style="padding-left:2cm; padding-right:4cm;">
<br>
<b> JSP like Syntax </b>
<br>
<br>
The syntax and semantics of JLoom templates are similar to Java Server Pages (JSP).
If you already know JSP you will have no problem to write JLoom templates.
</div>
<br>

<div style="padding-left:2cm; padding-right:4cm;">
<br>
<b> Modularity </b>
<br>
<br>
JLoom doesn't have include-tags like JSP -
which just insert other JSPs without encapsulation and parametrization.
Instead of include-tags, JLoom supports modular composition of templates.
<br>
Templates are full encapsulated like classes with parametrization and
compiletime type-checking.
Parameters are not restricted to String types - they can be any Java type,
even Generics or Varargs.
<br>
You can make a top-down/bottom-up design of the text-processing in
your application. The modular templates strongly improve the maintainability
of your code and eliminate redundancy.
<br>
In addition you can organize your templates hierarchically in packages.
And you can make modular extensions of the language with macros.
</div>
<br>

<div style="padding-left:2cm; padding-right:4cm;">
<br>
<b> Simplicity </b>
<br>
<br>
JLoom is easy to learn.
The syntax is clean and uniform.
Because it is build upon Java it can concentrate on its core function:
building a bridge from Java to text-generation.
<br>
If you are already familiar with Java syntax, there is not much to learn.
The operators, rules for assignments and expressions are the same.
And you can make use of the most recent Java (currently Java 1.5) syntax features,
like Generics, Varargs, Autoboxing, etc.
<br>
The basic syntax is simpler than JSP Syntax. But it is very powerful by
allowing the definition of new syntax elements.
This is done by writing macros, which are nothing else than JLoom templates themselves.
The basic JLoom syntax is extended by such macros,
e.g. all these commands are macros: exec, import, for, if, incIndent, decIndent.
<br>
You can extend the language by writing your own custom macros,
which are just JLoom templates - simple and powerful.
</div>
<br>

<div style="padding-left:2cm; padding-right:4cm;">
<br>
<b> Universality </b>
<br>
<br>
Like JSP, JLoom can be used to generate dynamic web content.
And you can use both together: a JSP which accepts the HTTP requests,
handles HTTP specific things like setting the content type and
delegates the HTML generation to a JLoom template.
<br>
But JLoom can be used for arbitrary purposes. Generating of source code (*), XML
(alternative to XSLT), documentations, Emails, configuration files, scripts
are just some other examples.
Everywhere you have text-generation in your application,
JLoom can help you to get an easy maintainable and extendable solution.
<br>
<br>
(*) JLoom let you control the indention of the generated text -
this is especially useful for code generation.
JLoom uses itself (JLoom macros) to create the generator classes and
therefore the generated Java code has correct indention.
</div>
<br>

<div style="padding-left:2cm; padding-right:4cm;">
<br>
<b> Efficiency </b>
<br>
<br>
JLoom generates text extremely fast.
Like in JSP, JLoom generation is done in two phases.
In the first phase the template is parsed and compiled into a Java class.
This phase takes place only one time after creating/changing the template.
Subsequent generations just "throw out" the text.
</div>
<br>

<div style="padding-left:2cm; padding-right:4cm;">
<br>
<b>  </b>
<br>
<br>
If you are already familiar with JSP,
you might want to make a quick start and
take a look at the <a href="HelloExamples.html"><nobr>Hello World Examples</nobr></a>.
</div>
<br>

<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/OverviewPage_Browser.html"
   target="homebrowser"
   title="Show in Template Browser"
   >OverviewPage</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