Customizing Generation with GTL

The PowerDesigner Generation Template Language (GTL) is a template-based language, which is used to generate text for the metaclasses defined in the PowerDesigner metamodel, and on any extensions that are defined in the model profile.

Each template is associated with a given metaclass (such as a CDM entity attribute, a PDM table, or an OOM operation). You can define as many templates as you want for each metaclass, and they will be available to all objects (instances) of the metaclass. For example, to examine the set of templates used to generate code for operations in a Java OOM, open the Java object language in the resource editor and expand the Profile\Operation\Templates category.

When you generate a model, PowerDesigner evaluates which metaclasses must have files generated, and creates a file for each instance of the metaclass, by applying the appropriate templates and resolving any variables.

GTL is object-oriented, and supports inheritance and polymorphism for reusability and maintainability. Macros provide generic programming structures for testing variables and iterating through collections, etc.

A GTL template can contain text, macros, and variables, and can reference:

metamodel attributes, such as the name of a class or data type of an attribute
collections, such as the list of attributes of a class or columns of a table
other elements of the model, such as environment variables

GTL templates can be either:

Simple templates - which can contain text, variables, and conditional blocks, but cannot contain macros. For example:
```
%Visibility% %DataType% %Code%
```
When this template is evaluated, the three variables Visibility, DataType, and Code will be resolved to the values of these properties for the object.
Complex templates - which can contain any element from a simple template, and also macros. For example:
```
.if (%isInner% == false) and ((%Visibility% == +)
								or (%Visibility% == *))
	[%sourceHeader%\n\n]\
	[%definition%\n\n]
	.foreach_item(ChildDependencies)
		[%isSameFile%?%InfluentObject.definition%\n\n]
	.next
	[%sourceFooter%\n]
.endif
```
This template begins with an .if macro which tests the values of the isInner and Visibility properties. Several variables are enclosed in square brackets, which ensures that the text enclosed with them (in this case, new line characters) will not be generated if the variable evaluates to void. The .foreach_item macro loops over all the members of the ChildDependencies collection.

Creating a Template and a Generated File
GTL templates are commonly used for generating files. If your template is going to be used in generation, it must be referenced in a generated file.
Accessing Object Properties
Object properties are treated as variables, and enclosed between percent signs, as follows:
Formatting Output
To control the format of your output, insert format options between the percent signs before the variable.
Using Conditional Blocks
If you have text that you want to appear only if a variable resolves to a non-null value, you should place them together between square brackets.
Accessing Collections of Sub-objects
Tables have multiple columns, classes have multiple attributes and operations. To iterate over such collections of associated objects, use a macro, such as .foreach_item.
Accessing Global Variables
You can insert information such as your user name and the current date, by accessing global variables.
GTL Variable Reference
Variables are qualified values enclosed in % characters and optionally preceded by formatting options. At evaluation-time, they are substituted by their corresponding value in the active translation scope.
GTL Macro Reference
Macros can be used to express template logic, and to loop on object collections. Each macro keyword must be preceded by a . (dot) character and has to be the first non blank character of a line. Make sure you also respect the macro syntax in terms of line breaks.