Dynamic overriding is used thanks to the extension point "org.eclipse.acceleo.engine.dynamic.templates". It is not advisable to use it in order to create a generator, it should mainly be used in order to customize an existing generator. Let's consider that you have a great UML to Java generator but you have to customize the generator for a specific project (specific naming convention for examples or maybe you want to generator a specific kind of Java for a J2EE framework). You have several options:

+

Dynamic overriding is used thanks to the extension point "org.eclipse.acceleo.engine.dynamic.templates". It is not advisable to use it in order to create a generator, it should mainly be used in order to customize an existing generator. Let's consider that you have a great UML to Java generator but you have to customize the generator for a specific project (specific naming convention for example or maybe you want to generate a specific kind of Java for a J2EE framework). You have several options:

* you are generating some Java and JMerge tags (@generated) are enough for you to customize directly the generated code.

* you are generating some Java and JMerge tags (@generated) are enough for you to customize directly the generated code.

My generation fails with a 'package not found' exception

Q : Whenever I launch an Acceleo generation, it fails with the message package with URI '*' not found'.

A : This error message indicates that the package which NsURI is '*' hasn't been registered in the Package registry. Most of the time, that means you either
a) launched your program standalone and didn't register the package correctly or
b) you haven't installed the plug-in that provides that metamodel.

Solving it is easy : it is a matter of registering the needed packages (and, optionally, resource factories). How is it done? Here is the most classic example with UML :

The same goes for every metamodel you might need, simply change UMLPackage by XxxPackage according to your metamodel. The Resource Factory is mandatory for UML, but your metamodel might not need one; simply ignore this line if you don't have a custom factory.

You need these two lines to be before the point where your model is loaded. For Acceleo, this is done in the generated Java launcher : simply change the implementation of the registerPackages and registerResourceFactories method to add these needed lines.

How can I run a generation in a standalone environment?

Q : Can I run an Acceleo generation outside of Eclipse?

A : Yes, Acceleo has been developed with standalone execution in mind. All you have to do is to launch the main method of the generated Java launcher.

How can I compile my mtl files in a standalone environment?

Q : Can I use the Acceleo compiler to recompile mtl files outside of Eclipse?

A : Yes, though this requires a little more work than "simply" launching the generation. The easiest is to define your own ANT task for that job. It should extend the AcceleoCompiler ANT task that's provided along with Acceleo (the latest version of the jar containing this class can be retrieved here, or you could simply look at its source code and reproduce something similar).

The bare minimum your class would need in order to compile mtl files in a standalone environment would be :

Can Acceleo work with ClearCase?

Q : I have to (re)generate files in (a) project(s) that is versionned using ClearCase. Will Acceleo ask for check out when generating?

A : Yes, but you'll have to cope with two limitations : first, you have to change the generated Java launcher and second, you will no longer be able to launch your generations in a standalone mode. The modification that has to be done is to override the getGenerationStrategy() method of the generated launcher. Specifically, you want it to look like :

Do not forget to remove the @generated tag from the Javadoc of this method (or change it to @generated NOT)!

How to migrate from Acceleo 2 to Acceleo 3?

Acceleo 3 has some differences with Acceleo 2, especially for the new syntax elements based on the Model-to-text OMG standard.

The question is : How to create the 3.x '.mtl' file from the 2.x '.mt' file?

The tooling will initialize the migration process... Just right click on the Acceleo 2.x project.

We know that the migration can't be perfect, because the MTL standard is statically typed. Sometimes you need human understanding to provide the right context and get the right equivalence. You will probably have to change the way you organize your code generators. We are confident that Acceleo 2.x users will move easily to Acceleo 3.0.

Don't worry, the Acceleo Team will continue to maintain the 2.x syntax of Acceleo. However, the new major versions and the new features will take place on Eclipse.org.

There aren't a lot of differences between the old version of acceleo and the new one. It's not so long to migrate from a syntax to another. Acceleo 3.0 comes with an equivalence documentation.

How to write '[' or ']' in the generated code?

Q : I need to generate open brackets ( [ ) or close brackets ( ] ) through Acceleo. How can I escape them?

A : The [ and ] symbols can be generated through respectively [ '[' /] and [ ']' /].

How do I compare data to an enumeration value?

Q : I want to know whether a given Class is of private, public or protected visibility, which are defined in the VisibilityKind Enumeration.

A : You need to qualify the access to the enumeration value. For example, if (operation.visibility = VisibilityKind::public).

Feature 'startHeaderPosition' not found

org.eclipse.emf.ecore.xmi.FeatureNotFoundException: Feature 'startHeaderPosition' not found

If the feature "startHeaderPosition" is not found it means that you are trying to launch an emtl file compiled by Acceleo 3.1.x in Acceleo 3.0.x. To resolve that problem, you can compile your emtl files with Acceleo 3.0.x or you can tell EMF to ignore the unknown features during the loading.

How to use a Java service in Acceleo

Acceleo allow the user to call a method from a Java class thanks to the "invoke" operation.

Java service in Acceleo.

My query is only executed once

Queries in Acceleo have their result stored in a cache. If you call a query with the same parameter twice, we won't execute it twice. The second time we will only look for the already computed result in our cache. If you want to invoke a Java service with the same parameters several times in a generation with different results, you should call it from a template.

If you really want to use a query or if for performance reason you want to deactivate the cache (the result of all the queries is stored in memory, it can be big if you have a lot of queries on a big model), you can do it programmatically :

AcceleoPreferences.switchQueryCache(false);

You can put this code before the launch of your Acceleo generator.

How can I use multiple metamodels in an Acceleo module ?

How does the overriding system works in Acceleo ?

Acceleo features two different systems in order to overrides the behavior of a template a static one and a dynamic one. Those two mechanism are addressing different kinds of problems:

Static overriding

Static overriding should be used in order to create a generator. Let's consider the following modules:

It does not have access to private template/queries from the module A.

Static overriding feels like overriding in an object oriented language like Java but it is different because modules are not objects, they are more similar to namespaces. In order to see the difference, let's consider the following elements:

If you are calling templateB from the module C, these are the templates that will be called:

B.templateB (the entry point)

A.templateB (the call to super)

A.templateA (not B.templateA, the call is not dispatched to the "subModule" contrary to Java)

The call to templateB will call the templateB in the module A but the keywords "extends" is just a modifier for the visibility of the module elements of the module A in relation to the module B it does not really create a relation between a "module A" and a "module B", those are not objects there are "just" namespaces. You could consider that the "extends" keyword should be used to give a namespace the content of public and protected elements from another namespace.

Dynamic overriding

Dynamic overriding is used thanks to the extension point "org.eclipse.acceleo.engine.dynamic.templates". It is not advisable to use it in order to create a generator, it should mainly be used in order to customize an existing generator. Let's consider that you have a great UML to Java generator but you have to customize the generator for a specific project (specific naming convention for example or maybe you want to generate a specific kind of Java for a J2EE framework). You have several options:

you are generating some Java and JMerge tags (@generated) are enough for you to customize directly the generated code.

protected areas have been defined in the generator and you just have to change the generated code in the protected area in order to make your project work.

you need real changes in the generator and you have access to the source code of the generator and redeploying the generator is not a problem, you can create new modules that are extending the old ones and you can import them instead of the old ones, you can change a minimal amount of your generator and you can add the new behavior.

you don't have access to the code of the generator or you cannot redeploy it. The only solution left is the dynamic overriding.

With the dynamic overriding, you can add new modules to an existing generator but those modules and the templates that they contain will be used in priority. For example, let's consider those modules:

If you are calling in you existing generator the templateA from the the moduleB, the dynamic template C.templateA will be used instead. The existing generator does not know about the new generator and it has no dependencies with this other generator but since we have installed the new generator as a plugin in the same Eclipse instance as the existing generator and since the new generator uses the dynamic module extension point, all its templates that are overriding a template from the original generator will be used instead of the original templates. In that way, it is closer to aspect oriented programming.