Acceleo 2.6 User Tutorial

ACCELEO
User Tutorial
This handbook is the exclusive ownership of its authors and was conceded to the profit of Obeo SARL. This
handbook is protected by intellectual ownership rights.
It deals with a software product called ACCELEO, currently distributed under the open source Eclipse Public
License (EPL). The distribution of this handbook is however not free.
This handbook makes it possible to fully take advantage of the many advanced functionalities of ACCELEO
software and required on behalf of its authors and of OBEO an important compilation and synthesis work, as
well as consequent financial and time investments. Nevertheless, there may still be mistakes left in this
document, OBEO shall not be held responsible for any resulting inconvenience. ACCELEO as well as the
content of this document may be altered without prior notice.
This document is not under Free license. This document can be downloaded without any fee from the
OBEO website after proper registering. You may read and use it for any activity, commercial or not, related to
ACCELEO. Yet permission of copying, translating or distributing freely or commercially this manual is subject
to prior approval by OBEO.
____________________
OBEO, ACCELEO, as well as OBEO and ACCELEO logos are registered trademarks of Obeo in France
and in other countries.
All other names, titles, drawings, and logos are the exclusive ownership of their authors and are protected by
intellectual ownership rights.
This handbook was written with the following tools: OpenOffice
____________________
Authors: Jonathan MUSSET, tienne JULIOT, Stphane LACRAMPE
With the participation of: Goulwen LE FUR, Julien DUPONT, Guillaume RAIMBAULT, Nathalie LEPINE,
William PIERS, Cdric BRUN, and Laurent GOUBET
Copyright 2006 2008 Obeo. All rights reserved.
Summary
1 - Introduction.......................................................................................................................1
1.1 - Minimum knowledge required...................................................................................1
1.2 - Documentation for Acceleo.......................................................................................1
2 - Installation.........................................................................................................................2
3 - Quick Startup....................................................................................................................3
3.1 - Import a Project into Eclipse.....................................................................................3
3.2 - Launch the Generation Chain...................................................................................5
4 - Modeling...........................................................................................................................7
4.1 - Definition....................................................................................................................7
4.2 - The Modelers.............................................................................................................8
4.2.1 - The UML2 Meta-Model with the EMF Modeler..................................................8
4.2.1.1 - Creating a Project.......................................................................................9
4.2.1.2 - Creating a UML2 Model............................................................................10
4.2.1.2.a - Creating a Package...........................................................................11
4.2.1.2.b - Creating a Class................................................................................12
4.2.1.2.c - Creating an Attribute..........................................................................12
4.2.1.2.d - Adding a Profile to a Model...............................................................13
4.2.1.2.e - Create an Association.......................................................................14
4.2.1.2.f - Validate the Model..............................................................................16
4.2.2 - Using the Example...........................................................................................16
4.2.2.1 - Importing a Project into Eclipse................................................................17
4.2.2.2 - Creating a Project Dynamic Web Project ............................................19
4.2.2.3 - The model WebLog_fr.uml.......................................................................22
4.2.2.4 - Creating a Model......................................................................................23
5 - Initializing a Project.........................................................................................................26
5.1 - Importing Generation Modules................................................................................26
5.2 - Code Generation Files............................................................................................27
5.2.1 - Previewing the Results.....................................................................................27
5.2.1.1 - Synchronizing the Model Code.................................................................29
5.3 - Creating the Generation Chain...............................................................................30
5.3.1 - Creating a Generation Chain Using the Assistant...........................................30
5.3.2 - Creating a Generation Chain without the Assistant.........................................34
5.3.2.1 - Adding a Model.........................................................................................35
5.3.2.2 - Adding a Target Folder.............................................................................37
5.3.2.3 - Adding a Log.............................................................................................37
5.3.2.4 - Adding a Meta-Model...............................................................................38
5.3.2.5 - Adding the Generation File.......................................................................38
6 - Generation......................................................................................................................41
6.1 - Running a Generation Chain...................................................................................41
6.2 - Importing a Tomcat server......................................................................................42
6.2.1 - Importing the Tomcat Libraries........................................................................45
6.3 - Testing the Application............................................................................................47
7 - Parameters.....................................................................................................................49
7.1 - The Generation Chains...........................................................................................49
7.1.1 - Modifying a Generation Chain.........................................................................49
7.2 - The logs ..............................................................................................................50
7.3 - The Properties Files............................................................................................51
7.3.1 - Creating a Properties File............................................................................51
8 - Update Management......................................................................................................54
8.1 - Manual Development..............................................................................................54
8.1.1 - Adding code to the servlets.............................................................................54
8.2 - Functional Updates.................................................................................................55
8.2.1 - Modification of the Input Model........................................................................55
8.2.1.1 - Modification of an Attribute.......................................................................55
8.2.1.2 - Adding a Class..........................................................................................56
8.2.1.3 - Deleting a Class........................................................................................57
8.2.1.4 - Renaming a class.....................................................................................58
8.2.1.5 - Adding/Modifying a Relationship (association / inheritance)...................58
8.3 - The Lost Files.....................................................................................................58
8.4 - Acceleo Traceability................................................................................................60
9 - Advanced Use................................................................................................................61
9.1 - Launching a Generation Chain Automatically from within Eclipse.........................61
10 - Additional Environments ..............................................................................................62
10.1 - Managing Different Versions.................................................................................62
10.1.1 - Sharing a New Project...................................................................................62
10.1.2 - Sharing Modifications.....................................................................................63
10.1.3 - Loading the Modifications from Another User...............................................63
Acceleo 2.6: User Tutorial

Page 1/62
1 - Introduction
This document is a detailed tutorial aimed at allowing users to master the code generator Acceleo, a product
developed by Obeo.
The functions dealt with will permit the creation of generation modules within projects, as well as
management of products created using Acceleo over their life cycle.
Acceleo is designed for people willing to profit from MDA technologies to increase their software development
productivity. It allows the generation of files using UML, MOF, and EMF modules.
This plug-in features:
Complete integration with both the Eclipse environment and the EMF framework
Code/model Synchronization
Incremental generation
Smooth adaptation for any industrial projects
Ease of update and management of templates
Syntax coloring, auto-completion and error detection
1.1 - Minimum knowledge required

The present guide does not intend to provide a training course for all of the issues addressed by the MDA or
Acceleo. This guide assumes the readers has some knowledge in the fields of :
Java
modeling (for example: UML)
Eclipse
Knowledge of the following concepts would also be an advantage, but none is essential for the understanding
of this document:
meta-models
UML2 meta-model
development of Eclipse Plug-Ins
MDA or MDD
1.2 - Documentation for Acceleo

This tutorial is part of a set offered by Obeo. Each document of this set deals with a different aspect of
mastering Acceleo:
Reference: description and explanation of each keyword of the Acceleo script syntax
User Guide: documentation of Acceleo's functions
Architectural Tutorial: guide for creating and personalizing generation modules.

Page 2/62
2 - Installation
Acceleo is an open source project, licensed under the Eclipse Public License (EPL), it can be downloaded
and used free of charge.
The first step in installing Acceleo is then to download and install the Eclipse platform along with EMF. It is
then possible to download and install Acceleo.
Acceleo can be installed in a number of distinct ways. Each is specific to the manner your Eclipse platform
has been installed.
The recommended installation
http://www.acceleo.org/update/.
method
is
to
make
use
Each type of installation is detailed step-by-step in the User's Guide.
of
the
following
update
site

Page 3/62
3 - Quick Startup
This section of the tutorial is designed for those who wish to directly execute the example provided on the
Acceleo site: http://www.acceleo.org/pages/download-sample-modules/en.
Extract the contents of the archive into the directory of your choice.
The archive should contain three sub directories:
free.demo.weblog
free.uml2.gen.java
free.uml14.gen.java
3.1 - Import a Project into Eclipse

Import free.demo.weblog into Eclipse :
Select "File" => Import... (cf. Figure 1).
Select the assistant Existing Project Into Workspace (cf. Figure 2).
Click Next .
Figure 1: Import a project (1)

Page 4/62
Click Browse... (cf. Figure 3) in order to open a window which contains all the files on the disk
Select the location that contains free.demo.weblog (cf. Figure 4).
Click OK .
free.demo.weblog is added to the list (cf. Figure 5). Once the list contains all the desired files Click
Finish to add the project to Eclipse.
Figure 5: Import a Project (5)

The project free.demo.weblog is a Dynamic Web Project (cf. 4.2.2.2 Creating a project Dynamic Web
Project ).
Repeat the above-described procedure to import the project free.uml2.gen.java .

Page 5/62
Please note that the directory src is empty (cf. Figure 6). The generation will fill this directory.
Figure 6: Tree for both projects
3.2 - Launch the Generation Chain

Once both projects are imported, the free.demo.weblog>weblog.chain>Launch generation chain must be
launched (cf. Figure 7).
Figure 7: Launch the

generation chain
Figure 8: The generated

files
Note : The files generated are based on the UML model WebLog_fr.uml, which has been designed in

Page 6/62
French. An English version of the model is also provided with the example. The following pages of this guide
shows pictures using the French version of the model, but it would work the same with the English version.
After clicking Launch , a progress bar shows up and once finished, the subdirectory src will contain three
packages with the generated Java files. (cf. Figure 8).

Page 7/62
4 - Modeling
The Acceleo tool offers different modeling possibilities:
UML1.x
UML2
Ecore
DSL
Others (Merise, SADT, OMT, proprietary tools..)
4.1 - Definition
The following is a reminder of some UML specific definitions which could be helpful to
understand the tutorial.
Profile:
A profile is a standard extension mechanism for the UML language that allows the specialization of a UML
scheme for a particular domain.
It consists of a coherent set of stereotypes, tagged-values and constraints
NOTE: We do not add meta-classes, but rather annotations to existing UML meta-classes .
Standard profiles do exist: profile CORBA (OMG), profile EJB 1.0 (JCP), etc.
Stereotypes:
The stereotype concept enables elements to be classified (annotated) and acts as a new meta-model
element.
A stereotype is a GeneralizableElement . An inherited relation is therefore possible for stereotypes. It is
also possible to define abstract stereotypes in order to avoid duplications when stereotypes have common
properties.
Tagged-value:
The concept of tagged-values enables information to be added to classes. A tagged-value can be considered
as a new meta-attribute.
Constraints:
The concept of constraints is used to express the relationship between stereotypes and tagged-values.

Page 8/62
4.2 - The Modelers

The models produced by numerous modelers are compatible with Acceleo because of its use of standard
and open formats.
Acceleo is natively based on EMF, and is thus directly compatible with tools created around this framework.
Examples include RSM, Together, and Omondo. Not all modelers are integrated with Eclipse, but most of
them offer an XMI-type export function to ensure compatibility with other tools.
Acceleo has been successfully tested with export tools using models UML 1.4 with XMI 1.x: Poseidon,
Objecteering, Sparx, ArgoUML, etc.
In order to read an XMI that is different from EMF, right-click on the XMI file and choose Convert XMI .
The procedure is always the same:
Either the modeler is integrated with Eclipse and Acceleo can directly use the XMI files, or the modeler is
external, and in this case, the XMI file must be exported to a sub-directory in the workspace, and the file must
be updated in Eclipse.
The following is a cinematic diagram in a DSM created via GMF :
Figure 9: Cinematic diagram in a DSM

This model is directly compatible with Acceleo because it is based on EMF.
4.2.1 - The UML2 Meta-Model with the EMF Modeler

Acceleo uses the EMF editor to open models based on UML2. This modeler is present in the Example EMF
Model Creation Wizards section.
A project must have been created before creating a UML2 model.

Page 9/62
4.2.1.1 - Creating a Project

To create a project, simply select the new project creation wizard:
File>New>Other>General>Project (Figure 11).
Figure 11: Creating a

project (1)
Figure 10: Creating a project (2)
Enter fr.obeo.pim.demo.tutorial as the Project Name field.
Click Finish to add the project to Eclipse (figure 12).

Page 10/62
We will now create a model folder (cf. Figure 14) in this new project.
To do so :
Right-click on the project root and select the folder creation assistant New>Folder (cf. Figure 13).
Figure 13: Creating a folder
Figure 14: Naming a folder
Fill in the field Folder name
Click Finish to add the folder to Eclipse. An empty folder will then be created in the project.
4.2.1.2 - Creating a UML2 Model

To create a UML2 model:
Right-click on the model folder
Select the EMF model creation assistant New>Other>Example EMF Model Creation Wizards>UML2
Model (cf. Figure 15).
Click Next .
Enter the model name Tutorial.uml in the File name field. (cf. Figure 16).
Click Next .

Page 11/62
Figure 15: Creation of a model
Figure 16: Naming a model

In the Model Object field, choose Model (cf. Figure 17).
Click Finish for the model to be created.
Figure 17: Selecting a model object

An empty model has been created. Now we can create the desired model.
4.2.1.2.a - Creating a Package

The first step consists of creating a package:
Right-click on the root element named Model
From the Child list, select the Package element. (Figure 18)

Page 12/62
Figure 18: Creating a package

Figure 19:
Displaying the
property view
The properties of this new Package element can be found in the Properties view. If this view is not
currently displayed by Eclipse, right-click on your new package and select ShowProperties View (cf. Figure
19).
Filling in the name field is required. Let's call this package myFirstPackage (Figure 20).
Figure 20: Property name

Clicking on a model element allows its properties to be modified in the Properties view.
4.2.1.2.b - Creating a Class

Now that the package has been created, let's add a class "MyClass" within it. The following operations will
help you do so:
Right-click on the myFirstPackage package, select the menu item " New Child>Class
Fill in the name field of the new class with as myClass.
4.2.1.2.c - Creating an Attribute

Now, to add an attribute to this class, complete the following operations:
Right-click on the class myClass, select the New Child>Property menu item.
Fill in the name field with myAttribute.
Try and fill in the type of the attribute myAttribute. The type of an attribute is modified via the corresponding
property. Yet in this case, clicking on the field "type" will not allow you to use primitive types (such as String).

Page 13/62
To use primitive types, UML2 profiles must be employed.
4.2.1.2.d - Adding a Profile to a Model

In order to set a UML2 profile, simply right-click on one of the model elements and select Load Resource...
(cf. Figure 21)
Figure 21: Add a profile(1)
In the dialog that just appeared, the URI of the profile to load must be entered. The profile containing the
primitive types (integer, character string, boolean...) has the URI:
pathmap://UML_PROFILES/Standard.profile.uml. (cf. Figure 22)
Figure 22: Add a profile (2)

Page 14/62
Two new resources are then loaded within the model (cf. Figure 23).
Figure 23: New profile
It is now possible to select "String" as the type of myAttribute: select it in the modeler and modify the "type"
property (cf. Figure 24).
Figure 24: Choosing the String primitive type

To add a little something to the model, create a second class MySecondClass (cf. 3.2.1.2.b Create a
class) with a single attribute mySecondAttribute (cf. 3.2.1.2.c Create an attribute).
4.2.1.2.e - Create an Association

This new attribute mySecondAttribute will be of type MyClass: simply select MyClass in the type field
of the Properties view (cf. figure 25). An association between the two classes has just been created.
Figure 25: Create an association

A second method to create an association between two classes is to add the association manually: right-click
on the package and select the New Child>Association menu item.
The new association is added at the end of the model (cf. figure 26).

Page 15/62
Figure 26: Adding an association between two

classes
Fill in the memberEnd field of this association in the Properties view: you must make use of the selector
(circled on figure 27).
Figure 27: The selector

A window is now opened:
Select myAttribute and click Add
Select mySecondAttribute and click Add .
Validate via OK (cf. Figure 28).
Figure 28: Creating an association

The memberEnd field is now made up of two attributes (cf. Figure 29).

Page 16/62
Figure 29: Filled in the memberEnd field
4.2.1.2.f - Validate the Model

The model has been created. To ensure its validity, right-click on the root element, Model , and select
Validate (cf. Figure 30).
Figure 31: Validation completed
Figure 30: Validation of the model
4.2.2 - Using the Example

This part explains the way the example works.
An example of both a model and a script can be downloaded from the Acceleo website at the following URL:
http://www.acceleo.org/pages/download-sample-modules/en.
Extract the contents of the archive into the directory of your choice.
The archive should contain three sub directories:
free.demo.weblog
free.uml2.gen.java
free.uml14.gen.java

Page 17/62
4.2.2.1 - Importing a Project into Eclipse

Import free.demo.weblog into Eclipse.
Select "File" => Import... (cf. Figure 32)
Then select the Existing Project Into WorkSpace project import assistant (cf. Figure 33).
Click Next to import the project into Eclipse.
Click Browse... (cf. Figure 34) in order to open a window which contains all the files on the disk
Select the location that contains free.demo.weblog (cf. Figure 35).
Click OK .

Page 18/62

The project free.demo.weblog is added to the list (cf. Figure 36). Once the list contains all the desired files
Click Finish to add the project to Eclipse (cf. Figure 37).
Figure 37: Import a project

(6)
free.demo.weblog is a Dynamic Web Project project.

Page 19/62
4.2.2.2 - Creating a Project Dynamic Web Project

This section explains how the project free.demo.weblog was created
This section will explain how the example was created and how to create it once again.
Eclipse WTP must be installed prior to following these instructions.
Select the dynamic Web project creation assistant: File>New>Other>Web>Dynamic Web Project (cf.
Figure 38 & 39), then click Next .
NOTE: if "Dynamic Web Project" does not appear in your Eclipse, WTP is not what you installed.
Figure 39: Creation of a project (2)
Figure 38: Creation of a project (1)

Page 20/62
Fill in the Project Name field with the desired name for the project and click Next (cf. Figure 40).
Click Next (cf. figure 41).


Page 21/62
When the Open associated Perspective view (cf. figure 43) is displayed,
click Yes to obtain a J2EE perspective (cf. Figure 44)

or
No to preserve the Java perspective (cf. Figure 45).
Figure 44: J2EE perspective

To change the perspective manually later on, simply click the Open Perspective icon (circled on Figure
45).
Figure 45: Java perspective

Page 22/62
4.2.2.3 - The model WebLog_fr.uml

In order to better understand the Weblog project, here is a UML representation of the class diagram.
The first representation is of WebLog GUI (cf. Figure 46); the second models WebLog business project (cf.
Figure 47).
Figure 46: Class diagram of Weblog GUI
Figure 47: Class diagram of Weblog business project

Page 23/62
4.2.2.4 - Creating a Model

Throughout this section the reference model will be the model WebLog_fr.uml .
WebLog_en.uml is the same UML2 model, in English.
Weblog_en.uml14 is this same model, described in UML 1.4 and in English
Once the project has been created (cf: 4.2.1.1 My First Project or 4.2.2.2 Creating a Project Dynamic Web
Project ), create a directory model within it.
Right-click on this new directory and select File>New>Other>Example EMF Model Creation Wizards for
the EMF model creation assistant (cf. Figure 48).
Figure 48: Creating a model
Name the new model in the following dialog then continue to the model object selection.
In the Model Object section, choose Model (cf. Figure 49).
Next click Finish for the model to be created.

Figure 49: Creating a model (2)

Page 24/62
Open this new model, right-click on its root element and select the menu item New Child . A list of the
elements that can be added appears. (cf. Figure 50).
Figure 50: Possible children nodes
The following list describes the type of elements that can be added as children (presented above):
Profiles
Packages
Classes
Properties
Operations
Operation parameters
The attributes of these elements may be modified in the "properties" view (cf. figure 52).
If this view does not appear in Eclipse, right-click on the model (in the Reflective Editor ) and select the
Show Properties View menu item (cf. Figure 51).

Page 25/62
Figure 51: Displaying the Properties view
Figure 52: Properties view

The properties will not be described in detail in this tutorial; however a few points will be addressed.
The cardinalities:
Lower : Minimal cardinalities
Upper : Maximum cardinalities
Infinity is represented by -1 for the upper cardinality

Types:
Type modifies the attribute type.
The name:
Name changes the name of the element. This property is mandatory.
The WebLog example does not use stereotypes but keywords . The three models provided in the directory
model were created with a modeler that replaced stereotypes with keywords . keywords can be
considered the same as stereotypes.

Page 26/62
5 - Initializing a Project
The WebLog_fr.uml model will be used for this section.
5.1 - Importing Generation Modules

Because we are using WebLog_fr.uml as the reference model, the generation module corresponding to
this model must be imported. The reference module which need to be imported is:
free.uml2.gen.java
This directory can be found in the archive downloaded in part 3 (cf. 3.2.2).
To import this project, refer to part 4.2.2.1 Importing a Project into Eclipse.
The two projects should appear in Eclipse (cf. Figure 53).
Figure 53: Projects in Eclipse

For the remainder of the tutorial, it is recommended that the Acceleo perspective be open. If it needs to be
opened, simply click on the Open Perspective icon (cf. Figure 45), and choose Acceleo if it appears in the
list. If it is not present in the presented list, select Other... , Acceleo, then confirm via Ok (cf. Figure 54).
Figure 54: Acceleo perspective

Page 27/62
5.2 - Code Generation Files

The free.uml2.gen.java project contains the generator files.
These files can be found in the directory src : they use the extension .mt .
Figure 55: Code generation files

These files are generation scripts and allow the generation of the desired code.
5.2.1 - Previewing the Results

In order to preview the generation results, you first need to open a model (in this example, WebLog_en.uml).
Afterwards, right-click on either one of the model elements (does not matter which) and select the menu item
Acceleo>Select Generator (cf: Figure 56).
Figure 56: Select a code generator

Next, select the generator which result needs to be previewed. This example will use the template jdbc.mt ,
located in src>org>acceleo>modules>uml2>gen>java>dao as described on Figure 57.

Page 28/62
Figure 57: Selection of the file to preview

The model classes of defined with a keywords value of Entity are decorated with an arrow added
(cf. Figure 58)
Figure 58: Class with keywords having a value of "Entity"

Previewing the code that would be generated via this template can be done through the Source tab with
one of the decorated element selected (both circled on Figure 58).
Text in black is the code that has been dynamically generated and is related to the previously selected model
elements. In this example, the class "User".
Likewise, the purple text is the code that has been statically generated. (cf. Figure 59).

Page 29/62
Figure 59: Preview of the generated code
5.2.1.1 - Synchronizing the Model Code

The model and the generated code are synchronized. It is thus possible to find the model element that
generated a particular portion of the code, and vice versa. Simply double-click on a dynamically generated
element (one that is in black), in order for its corresponding element to be selected in the model. (cf. Figure
60).
Figure 60: Synchronization of the model code

Likewise, a single click on a model element selects the corresponding generated code. (cf. Figure 61). A
second click in the model selects the second occurrence of generated text, and so on.

Page 30/62
Figure 61: Synchronization of the model code
5.3 - Creating the Generation Chain

There are two possible ways to create a generation chain. Either use the available assistant or create it
manually.
5.3.1 - Creating a Generation Chain Using the Assistant

In this example, the generation chains (.chain) are in the free.demo.weblog project. The location of the
chain is of no importance.
To create a generation chain, it is advisable to use the Acceleo perspective (cf. Figure 45 and 54).
In the example, the generation chains have already been created. The purpose of this section is to recreate a
generation chain identical to the weblog.chain generation chain.
To create a new generation chain:
Right-click on the free.demo.weblog project.
Select New>chain (cf. Figure 62).

Page 31/62
Figure 62: Creating a new generation chain

Select the appropriate meta-model. For the purpose of this example, select the UML2 meta-model
"http://www.eclipse.org/uml2/2.0.0/UML" (cf. Figure 63), then click on Next .
Figure 63: Selection of the meta-model

Select the WebLog_en.uml model (cf. Figure 64), then carry on with Next .
Figure 64: Selecting the model

Page 32/62
Now the desired generation templates should be selected; here, all of the templates contained within the
dto , dao , and ui directories (cf. Figure: 65). Continue via Next .
Figure 65: Selecting the scripts
Finally, select the location and the name of this new generation chain (cf. Figure 66). This example chain
should be located in the free.demo.weblog directory and named MyWebLog_en.chain
Figure 66: Finalizing the generation chain

Page 33/62
This new generation chain consists of the following (cf. Figure 67):
Figure 67: Contents of a generation chain

It lists the set of resources used and the actions that must take place. The specialized editor helps the user
and allows for the validation of the tasks. There are two types elements: resources and the actions.
The resources part, also called "Repository", contains the whole set of resources used by the actions. There
are seven types of resources:
Model: Models to which the generator will be applied
Model Set : Sets of models on which the generators will be applied
Folder: Directories in which the generation will take place
Log: Logs available to record generation errors
Meta-Model: The high level meta-models describing the input models
Script: The generators that need to be applied
Custom File : Other files that could be used by actions ( Custom Action )
The actions part, also called "ActionSet", contains all the tasks that must be launched. There are seven types
of actions:
Generate: applies a generator to a model, and places the whole hierarchy of the generated files the
specified target directory. The required meta-model is the one that describes the input model.
Convert Xmi: Converts an XMI 1.x file that has been exported by a non EMF modeler into an XMI 2.0 file
based on EMF. This conversion can handle UML13 and UML14 meta-models defined for EMF with either
the http://www.obeo.fr/acceleo/uml13 URI or the http://www.obeo.fr/acceleo/uml14 URI. This action is
often used before a generation action which will be applied on the resulting converted model.
Backup: Saves all the resources from one directory to another. Several levels of backup may be defined.
The backup of a target generation directory is especially useful during the template fine-tuning phase,
when the risk of getting errors is greater. However, this action may be redundant and does not always
work well with version management tools such as CVS or SVN. It should be used with moderation!
Clear: Empties the content of each file in a selected directory, including its subdirectories. This action
does not delete the resources; it simply empties their content and produces empty files.
Remove: Permanently deletes the selected files and directories.
Call : Launches the chains with the given path ( Chain Path ), substituting the declared parameters of
the sub chain by the given arguments. A double click on the new "Call" will allow the selection of the
chain to call.

Page 34/62
Custom Action : Launch a custom action on the selected resources. To specify an action you have to put
the ID property.
5.3.2 - Creating a Generation Chain without the Assistant

To create a generation chain without the assistant, place the cursor over the free.demo.weblog directory
and right-click. Select New>Other>Acceleo>Empty Chain (cf. Figure 68).
Figure 68: Creation of a generation chain

without the assistant
Click Next and name the chain, webLog_en_sa.chain (cf. Figure 69) and click Finish to add the chain
to Eclipse.
Figure 69: Naming the generation chain
The chain is created, but is empty. The required element for its operation must be added.

Page 35/62
5.3.2.1 - Adding a Model
Open the generation chain and right-click on "Repository"
Select New Child>Model (cf. Figure 70).
Figure 70: Selection of a model

There are then two possibilities to select the desired model :
The first is to enter the URI of the model in the Path field of the properties view:
/free.demo.weblog/model/WebLog_fr.uml (cf. Figure 71).
Figure 71: URI of the model

This solution is fastidious and complicated. The second is an easier way of choosing a model in the Eclipse
workspace:
Double-click on the "Model" element in the editor. This action opens a dialog box to allow a selection to
be made from among the available models. (cf. Figure 72).
Figure 72: Double click on the model

Page 36/62
Select the model directory (on the left). This selection displays the models that are present in the
directory on the right-hand side. To select a model, simply check the box at its side and click OK (cf.
Figure 73).
Figure 73: Select a model
5.3.2.2 - Adding a Target Folder
Open the generation chain and right-click on "Repository".
Select New Child>Folder
Then select Folder and fill the Path feature in the properties view with the
/free.demo.weblog for the target directory,
or
Double click on the Folder element,
Choose the desired location (cf. Figure 74).
path

Page 37/62
Figure 74: Select the target folder
Click OK to validate the target directory selection.
5.3.2.3 - Adding a Log
Select New Child>Log
Then select the Log that has just been created, and complete the Path field of the properties view
as: /free.demo.weblog/WebLog_fr.log.txt ,
or
Double-click the Log element that has just been added to the generation chain.
Select the file that should be the generation's Error Log (cf. Figure 75).
Figure 75: Select the error log

Page 38/62
5.3.2.4 - Adding a Meta-Model
Select New Child>Emf Meta-model
Then select Emf Meta-model and fill in the Path property with:
http://www.eclipse.org/uml2/1.0.0/UML
or
Double-click on the meta-model that has just been created in the chain.
Select the desired meta-model URI from the list (cf. Figure 76).
Figure 76: Choose the desired meta-model
5.3.2.5 - Adding the Generation File
Select New Child>Generator
Complete the Path field with the location of the desired generation file (.mt):
/free.uml2.gen.java/src/org/acceleo/modules/uml2/gen/java/dao/jdbc.mt.
or
Double-click the file to choose the generation file (.mt) (cf. Figure 77).
Figure 77: Choose a generation file

Page 39/62
It is possible to add as many Generators as desired, as demonstrated in Figure 67 above.

Now let's define the generation actions:
Right-click Action Set and Select New Child>Generate .
In the Properties view, six fields must be completed.
Figure 78: The six property fields of a "Generate" action
Documentation: Name that will be displayed by the editor for this action. The generator's file name may
be used, in order to locate it easily.
Folder: Folder in which to generate the files.
Generator: Path of the generation file (.mt) to use.
Log: The error file (log) path.
Meta-model: The meta-model URI.
Model: The model path.
For each generation file (.mt) to launch, a corresponding Generate action must be defined. An example is
shown on Figure 79, that Generate corresponds to the template jdbc.mt .
For the other files, the manipulation is identical except for the Documentation property since it is a name
chosen by the user, which can be distinct for each file. (cf Figure 79).
Figure 79: The six propriety fields of a Generate action

Page 40/62
6 - Generation
6.1 - Running a Generation Chain
Now that the generation chain has been created, it is possible to generate the files. Right-click the generation
chain weblog.chain and select Launch to launch the generation (cf. Figure 80).
Figure 80: Launcher for

the generation chain
The src directory, which up to now had been empty, now contains three packages:
free.demo.weblog/src/org/acceleo/sample/dto
free.demo.weblog/src/org/acceleo/sample/ihm
free.demo.weblog/src/org/acceleo/sample/jdbc
These three packages contain the Java files that have just been generated.
One of the three packages (free.demo.weblog/src/org/acceleo/sample/ihm) presents errors though. These
can be resolved by importing a Tomcat server into the project.

Page 41/62
6.2 - Importing a Tomcat server

A version of Tomcat server must first be installed on the machine. If necessary, it may be downloaded from
the following address:
http://tomcat.apache.org/
If you did not install Eclipse WTP, its plug-ins are also required before testing this new application :
http://www.eclipse.org/webtools/main.php.
Once the server version is installed on the machine, import it so Eclipse will recognize it:
Click the Window>Show View>Other (cf. Figure 81).
Figure 81: Import a Server
Select Server>Servers (cf. Figure 82)
Figure 82: Open Servers

view

Page 42/62
The Servers view is added to Eclipse (cf.:Figure 83).
Figure 83: The view Server
Right-click in the Servers view, and Select New>Server (cf. Figure 84).
Figure 84: Select Server
Select the Apache server installed on the machine. We installed Tomcat Server 5.5 for this example (cf.
Figure 85).
Figure 85: Selection of the server

Page 43/62
Click Next then Select the server installation directory via Browse (cf. Figure 86).
Figure 86: Select the installation directory
Click Next .
Select the "free.demo.weblog" project and add it to the server by clicking on Add > (cf. Figure 87).
Figure 88: Select the project
You're done, click on Finish .
Figure 87: The project is now added

Page 44/62
6.2.1 - Importing the Tomcat Libraries

Even though the server is installed, the errors will still appear in the second package. To finally fix these
errors you need to import the Tomcat server libraries in the project. Right-click on the project, then select
Properties>Java Build Path (cf. Figure 89).
Figure 89: Adding the libraries from Tomcat
Select Add Externals JARs , find the installation directory for the Apache Software Foundation/Tomcat
5.5/common/lib server, select the servlet-api.jar file and click Open(cf. Figure 90).
Figure 90: Select the corresponding library

Page 45/62
Close this dialog box via OK (cf. Figure 91).
Figure 91: Adding the libraries to the project build path

The library is added to the project build path , and the error are all cleared.
The WebContent directory has also been modified by the generation. It now contains a jsp directory
containing the JSP files and a WEB-INF directory with, notably, the web.xml file.
Figure 92: Contents of the

various folders

Page 46/62
6.3 - Testing the Application

Once the server has been installed, the application can be tested. In order to do so, you must first launch the
server.
Right-click on the server displayed on the Servers view.
Select Start (cf. Figure 93).
Figure 93: Launch the Tomcat server
Once the server has been launched, the Started icon appears for it in the Servers view (cf. Figure 94).
Figure 94: The server is launched

The Console view can also be consulted to check that the server has been properly launched (cf. Figure
95).
Figure 95: Console view
The next step is to open a Web Browser and go to the following URL: http://localhost:8080/free.demo.weblog/

Page 47/62
A menu is then displayed on the browser. This page is the Index.html file (cf. Figure 96).
Figure 96: Menu for free.demo.weblog

The link Screen AccountEdition allows you to create a new account (cf. Figure 97).
Figure 97: Creating an account
*NOTE* The functions are not implemented only the GUI is.

Page 48/62
7 - Parameters
7.1 - The Generation Chains
In section 5.3 we detailed step-by-step how to create a generation chain. Yet the needs can change once the
generation chain has been created and it may happen that the generation chain no longer meets the its
needs.
It isn't necessary to create a new generation chain. Indeed, Acceleo allows the modification of an existing
generation chain.
7.1.1 - Modifying a Generation Chain

Open the generation chain that need be modified. (cf. Figure 98).
Figure 98: The generation chain weblog.chain

To modify an element, simply double-click on it. For example, if a generation file is to be modified, the file
extension (.mt) should be double-clicked, and a new file may then be selected. To select the new file:
Uncheck the previously selected template by clicking on it (cf. Figure 99). The file's check box will
then be cleared:

Page 49/62
Figure 99: Deselect the file

Now check the new template (cf. Figure 100). The check box shows the selection.
Figure 100: Select the new file
To validate the change, click OK .
7.2 - The logs

The logs will allow the events that prevented the generation to be recorded in when errors occur during the
execution of a generation chain.
The specified error log is displayed when an error arises during the generation. (cf. Figure 101).

Page 50/62
Figure 101: Error file

Simply double-click on this file to open it in Eclipse (cf. Figure 102).
Figure 102: Content of the error file

Erasing the content of the log before a generation makes it easier to check whether the generation chain now
runs normally or if there are still anomalies.
7.3 - The Properties Files

It's been mentioned earlier that the packages for different Java classes were parameterized according to the
script. Even though they are modular, modifying the naming standards within a company requires all of the
generators to be refactored.
Acceleo incorporated a properties mechanism that establishes generation parameters; for example, the
folder names, or package names where the files have to be generated.
This mechanism will be demonstrated by providing parameters for the package names in Weblog project.
7.3.1 - Creating a Properties File
Create a new org.acceleo.modules.uml2.utils

free.demo.weblog project.
package
in
the
src
Right-click on this new package and select the New > File menu item.
In the file creation assistant enter the name config.properties (cf. Figure 103).
directory
for
the

Page 51/62
Figure 103: Creating the config.properties

file
The new config.properties file is created in the specified package (cf : Figure 104).
Figure 104: The file "properties"
Type in the following two lines (both of which hereafter referred to as "keys"):
package.format=com.enterprise
project.name=weblog
Launch the weblog.chain chain. The files are now generated in the com.enterprise.weblog package
instead of org.acceleo.sample (cf figure 105).
Figure 105: Packages generated wit

parameterization
If it is later decided to change the naming standard for the packages, simply add a new_config.properties

Page 52/62
file alongside the weblog.chain file, and place within it a new value for the project.name key, such as
web.weblog (supposing that the type of the product is web for the weblog). The next generation will now
include the type of product "web" in the name of the packages (cf figure 106).
Figure 106: New Properties file enables the

packages to have new names

Page 53/62
8 - Update Management
8.1 - Manual Development
8.1.1 - Adding code to the servlets
It is possible to insert manual code into the generated code. Portions of the code where it is possible to insert
user code are surrounded by the tags:
//Start of user code
and
//End of user code
For example, the init(HttpServletRequest req, HttpServletResponse resp) procedure in the

free.demo.weblog/src/org/acceleo/sample/ihm/CreationCompteServland.java file can be personalized as
follows:
Within the section reserved for user code, enter:
//Start of user code init
if (nom.equals("Julien")){
returnCode = PAGE_CONNECTION;
}
//End of user code
Then the application must be restarted:
Right-click on the server in the "servers" view
Select Restart>Start (cf. Figure 107).
Figure 107: Restarting the server
Refresh the current Web Browser page (F5). The action has been recognized.
If the generation chain is launched anew, the code surrounded by user tags is preserved.
The same test may be executed by adding code outside the Start of user code tags.
The modification is recognized when the server is restarted; however the code which was added outside the

Page 54/62
tags will be deleted with the next generation.

It is therefore very important to not write code outside of the tags intended for this use.
8.2 - Functional Updates

8.2.1 - Modification of the Input Model
Modifications can of course be made to the input model.
8.2.1.1 - Modification of an Attribute

It is possible to modify an attribute. To do this:
Select the login attribute for the User class in the Business.blog package (cf. Figure 108).
Figure 108: The model
Change its name property in the Properties view: change login in identifier.
This example will be based on the /free.demo.weblog/src/org/acceleo/sample/dto/UserDto.java generated

file.

Page 55/62
Before the modification, the attributes were generated as follows:

public class UtilisateurDto implements Serializable {
// serialVersionUID is used for serialization.
private static final long serialVersionUID = 1L;
protected
protected
protected
protected
protected
String
String
String
String
String
email;
prenom;
nom;
login;
motDePasse;
In order for the modifications to be recognized, the files must be regenerated. Simply launch the generation
chain once again (cf. 6.1 Launching a Generation Chain).
The attributes are now generated as follows:
public class UtilisateurDto implements Serializable {
// serialVersionUID is used for serialization.
private static final long serialVersionUID = 1L;
protected
protected
protected
protected
protected
String
String
String
String
String
email;
prenom;
nom;
identifier;
motDePasse;
When an attribute is deleted, it is also removed from the generated files. For example, if the email attribute
is deleted from the model, it will no longer appear in the generated Java files.
8.2.1.2 - Adding a Class

It is possible to add a class to the model:
Add a new class in the blog package.
Name it Administrator.
Create two String type attributes to it; name them surname and name .
Also add to it a keywords with the value Entity . Copy Paste it from one of the existing classes. (cf.
Figure 109).
Figure 109: Adding a class

Page 56/62
Now that the class has been added to the model, the model must be saved and the generation chain must be
launch again. The new Java files have been created. (cf. Figure 110).
Figure 110: New files have

been created
If a class with a Screen stereotype (keyword Screen ) has been created, then the generation will also
have modified the web.xml file.
Likewise, if the class had not been stereotyped, Entity (keyword Entity ), no new Java files would have
been created.
8.2.1.3 - Deleting a Class

It is also possible to delete a model class.
To delete the Administrator class, right-click Administrator and select Delete .
Save the model and relaunch the generation chain.
The files corresponding to the class have not been deleted. They must be deleted manually or use
chainweblog.clean.chain. Be careful, the code that was manually inserted between the two Start of user
code tags (cf: 8.1.1 Adding Code in the Servlets) will be deleted. This generation chain should only be used
if no code was manually inserted between the guides.
8.2.1.4 - Renaming a class

It is possible to rename a class. The procedure is identical to that used to rename an attribute. (cf. 8.2.1.1
Modifying an attribute).
Once the class has been renamed and the model has been saved, you must launch the generation chain.
The result will be identical to that observed during the deletion of a class (cf. 8.2.1.3 Deletion of a class). That
is , the new Java files will have been created; yet the old ones will still exist. (cf. Figure 111). In the example
below, the class User has been renamed Blogger .

Page 57/62
Figure 111: The new files and the old

ones
8.2.1.5 - Adding/Modifying a Relationship (association / inheritance)

It is possible to add or to modify a relationship (association, inheritance). To do so, simply modify the
relationship in the model, save this modification and launch the generation chain. The modification that was
made will appear in the newly generated files.
8.3 - The Lost Files

If a modification is made to a generation file or a model that involves modifying the code generated between
the Start of user code tags, a ".lost" file will be generated.
For example if a model attribute is deleted, and this attribute was called within "user code" tags, then when
the generation chain is relaunched, the old code is placed in a file with the extension .lost .
The .lost files preserve the user code that is no longer valid due to a modification.
Figure 112: Example of a lost file

Page 58/62
8.4 - Acceleo Traceability

As a complement to Acceleo, Obeo offers the Acceleo Traceability software. Acceleo Traceability is designed
towards model/code synchronization.
Here is an example usage of Acceleo Pro Traceability which warns the user when a modification is made to
the code outside user tags, as this code would be lost on the next generation (cf. Figure 115).

Page 59/62
9 - Advanced Use
9.1 - Launching a Generation Chain Automatically from within Eclipse
It is possible to launch a generation chain from the application launch icon
within Eclipse.
Click the drop-down list of the run tab.
Select Run... .
Double-click Chain .
Fill in the Name field with the desired name for the launching configuration.
Select the launching chain by clicking Browse (cf. Figure 113).
Figure 113: Select a launching chain.

It is possible to select several launching chains.
To launch the generation chain, it can then be selected in the drop-down list on the Run tab.
(cf. Figure 114).
Figure 114: Launching the

generation chain

Page 60/62
10 - Additional Environments
10.1 - Managing Different Versions
In order to manage the different file versions, a version management tool such as CVS or SVN must be used.
These free software programs may be downloaded at http://www.nongnu.org/cvs/ (CVS) or
http://subversion.tigris.org/ (SVN). Once this software is installed, the easiest way to make use of them is to
install the corresponding Eclipse plug-ins. The CVS plug-in for Eclipse is installed by default. One of the SVN
Figure 115: Acceleo Pro Traceability : example of the tool

plug-ins for Eclipse, Subclipse, can be found at http://subclipse.tigris.org/. Once one of these plug-ins has
been installed, the version management functions may be found in the Team menu located in the pop-up
menu (right-click on a resource: project, file, folder, ...).
10.1.1 - Sharing a New Project

If a project has not already been shared, it may be shared on a server.
To do so, right-click on the project to share. From the Team menu, select Share Project... .
If more than a single version management software have been installed (CVS is installed by default), select
the one that is to be used (cf. Figure 116).

Page 61/62
Figure 116: Choosing the version management

tool
Fill in the required fields: the host, the repository, the login and the password. Click Finish ; the data may
now be used by other users.

Page 62/62
10.1.2 - Sharing Modifications
Figure 117: Commentary window with SVN

To share modifications to a project, right-click on the project. From the Team menu, click Commit . Enter
the commit message that will explain the modifications that have been made, and click OK (cf. Figure
117). The modifications are now available on the server.
10.1.3 - Loading the Modifications from Another User

To load modifications from another user, click Team > Update. The version management tool will even
manage possible conflicts, and asks the user what to do if it cannot resolve the conflict with no human
intervention. Once this operation has finished, the other user's modifications are displayed.

Acceleo 2.6 User Tutorial

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Acceleo 2.6 User Tutorial

Încărcat de

Drepturi de autor:

Formate disponibile

ACCELEO

Acceleo 2.6: User Tutorial

Smooth adaptation for any industrial projects

Ease of update and management of templates

Syntax coloring, auto-completion and error detection

1.1 - Minimum knowledge required

modeling (for example: UML)

development of Eclipse Plug-Ins

1.2 - Documentation for Acceleo

User Guide: documentation of Acceleo's functions

Architectural Tutorial: guide for creating and personalizing generation modules.

Acceleo 2.6: User Tutorial

Each type of installation is detailed step-by-step in the User's Guide.

Acceleo 2.6: User Tutorial

3.1 - Import a Project into Eclipse

Select "File" => Import... (cf. Figure 1).

Figure 1: Import a project (1)

Figure 2: Import a project (2)

Acceleo 2.6: User Tutorial

Select the location that contains free.demo.weblog (cf. Figure 4).

Figure 3: Import a project (3)

Figure 4: Import a project (4)

Figure 5: Import a Project (5)

Acceleo 2.6: User Tutorial

Figure 6: Tree for both projects

3.2 - Launch the Generation Chain

Figure 7: Launch the

Figure 8: The generated

Acceleo 2.6: User Tutorial

Acceleo 2.6: User Tutorial

Others (Merise, SADT, OMT, proprietary tools..)

Acceleo 2.6: User Tutorial

4.2 - The Modelers

Figure 9: Cinematic diagram in a DSM

4.2.1 - The UML2 Meta-Model with the EMF Modeler

Acceleo 2.6: User Tutorial

4.2.1.1 - Creating a Project

Figure 11: Creating a

Figure 10: Creating a project (2)

Enter fr.obeo.pim.demo.tutorial as the Project Name field.

Click Finish to add the project to Eclipse (figure 12).

Figure 12: Creating a project (3)

Acceleo 2.6: User Tutorial

Figure 13: Creating a folder

Figure 14: Naming a folder

Fill in the field Folder name

4.2.1.2 - Creating a UML2 Model

Right-click on the model folder

Acceleo 2.6: User Tutorial

Figure 15: Creation of a model

Figure 16: Naming a model

Click Finish for the model to be created.

Figure 17: Selecting a model object

4.2.1.2.a - Creating a Package

Right-click on the root element named Model

Acceleo 2.6: User Tutorial

Figure 18: Creating a package

Figure 20: Property name

4.2.1.2.b - Creating a Class

Fill in the name field of the new class with as myClass.

4.2.1.2.c - Creating an Attribute

Fill in the name field with myAttribute.

Acceleo 2.6: User Tutorial

To use primitive types, UML2 profiles must be employed.