guglhupf.net

You can call every Java - Member function of every Value in the XTL. For Example "foo" is a value and it's type is "String", so
you can call in your xtl file:
variable = "foo".equals("foo");

variable is then a value too, and it's type is Boolean.

Additionally, you can call the following functions without an object:

Everything in the input file which is now written between the (user defined) starting and ending tags will be
copied to the output file as is. The starting and ending tags might for example be <?xtl and ?> when
you write templates which output html code.

!Statements

An XTL file consists of a sequence of statements. A statement can be:
* An If - Statement
* A For-Each - Loop
* An Output - Statement
* A Value (followed by a semicolon)
* A Function Definition
* A Block - Statement
* The "include" - Directive
* A Return - Statement
* A While - Loop

!!If - Statement
EBNF:
If = "if" "(" Value ")" Statement ("else" Statement)?.
Constraint: The Value must evaluate to a boolean value.

If you have edited the "start.sh" file (or "run.bat" under windows) as described in "Installation", you can simply
start XTE with this file. You will get a "usage" - message when you start it without any command line arguments.
./start.sh

You can run the two examples which are shipped with the XTE source distribution with the following commands (use square

__You can get all the required libraries with the "guglhupf commons resource repository" using apache ant. See step 2 for details.__

Unpack the jar file.
mkdir XTE
cd XTE
jar -xf (Path)/GuglhupfXTE-(Version).jar

It is recommended to build the sources with apache ant ( http://ant.apache.org ), which is also the easiest way to use gc-rr.

The Guglhupf XML Transformation Engine is a set of tools for transforming XML files. It is meant to be
a simpler way of transforming xml than XSLT is. You can use XTE either as a command line tool, or as a
Java framework to extend the functionality of your Java application.

Please report any bugs in our Mantis Bug Tracking System. There you

GAP is a platform for developing and running Java applications. It can load multiple applications in the same Java Virtual Machine,
and it can even manage different versions of applications or components at the same time.

__All of the following features are either planned or only partially implemented at the moment. In general, the whole GAP is very unstable at the moment. It will be releast to the general public as soon as this makes sense. If you want to try it out before we release it to the public you can contact me.__

!!!Features

!!Guglhupf commons
GAP is built on top of the Guglhupf Commons libraries, so as a developer and also
as a user you take advantages from these libraries, including:

* Managing different versions of components and applications and their dependencies with gc-rr. This also makes downloading and installing components and applications easier: here you can also benefit from gc-rr. This doesn't nessessarily mean that GAP is only for open source software - as a vendor you still have the control about you intellectual property.
* gc-toolkit provides an abstract model for toolkits. This means you applications can run with any supported toolkit (even as web applications or rich thin client applications) without any changes in the code of the application (see gc-toolkit for details.
* In many parts of the guglhupf commons and the GAP internationalisation is enforced by forcing the developer to provide keys to gc-resource instead of the resource itself.
* Managing users and their rights within the applications using gc-security, which is an easy to use yet effectife extension to JAAS.
* Managing the configurations of your components / applications is easy because of gc-config. The GAP provides Configuration objects to each component and application.

!!GAP Features

* GAP specifies it's own component model, which was designed to fit the needs of this application platform best. A component basically consists of the component.xml file, some Java classes and gc-resource resources.
* GAP provides a unified view to components from different component models to a developer. This means, as long as you just use components (and not develop them) you don't have to care if they are GAP components or EJB session beans or something else. You use them all the same way.
* GAP specifies it's own application format. A GAP application consits of the application.xml file, where you provide information about your application and link all the used components, two Java classes, gc-resource resources, gc-toolkit XMLViews and maybe more.
* GAP can run multiple applications in the same Java Virtual Machine. It can even run different versions of the same application at the same time. These different versions can reference different versions of the same component, which is handled too by the platform (at least for native GAP components).
* GAP applications can provide services and they can depend on services. A service in this case is something like "Text Editor", "Web Browser", or "Email Client". For example, if an application needs a web browser to display it's help system, it can acces the browser in a unified way, no matter which specific web browser is installed.

This project is maintained by Dave