Dependencies to use for Eclipse 4

Dependencies to use for Eclipse 4

When you develop with Eclipse 4, you need to use a lot of new classes and annotations that are defined in several plugins. It is a little tricky to know these dependencies without any documentation.

Here is a table to summarize the dependency that must be used for each class or annotation.

You can also find more information in the Eclipse wiki

How to properly override the generated EMF code?

How to properly override the generated EMF code?

EMF allows generating code from the model. By parameterizing the .genmodel file, we can generate 3 sources of code: model, edit and editor, which contain the java sources that let exploit the defined model.
In order to override the generated code, the traditional method consists in directly modifying the generated code by adding a ‘NOT’ behind the @generated tags. Additionally, the ‘mint’ plugin (in emftool) allows distinguishing the overridden methods (in red) from the added methods (in black) and the generated methods (in blue):

The overridden code with @generated

This method is acceptable if little code is modified, however, in the event of projects in which a lot of generated job code has to be added, then it is recommended to:

• clearly separate the generated code from manual code
• automatically generate the code when starting the build process
• take out the generated code from the configuration version system (cvs, svn, git, …) and generate it again when the delivery is made

EMF and Eclipse offer simple solutions to answer this need.
 

1. Separating the src-gen and the src

In order to work properly, it is important to take ‘sealing’ measures, by clearly separating the generated code from the overriddden code. To do this, parameterize the model using the following instructions:

Parameterizing of the genmodel

This operation can be repeated for the edit layer and editor layer.
Then, create a src directory (folder source), dedicated to override the project:

src directory for the override

This new source directory will contain a new EMF factory for creating the instances of the overridden classes. This factory comes from the generated factory and permits object creation with the new interfaces:

New factory that creates the new instances

We will complete the methods of this factory as we override the classes of the generated model.

So, the implementation of the factory is simple:

Implementation of the overridden factory

Then, you just need to link the new factory to EMF by using the extension point factory_override:

extension point override_factory

This new factory will automatically be used by EMF during the object creation by a call to RentalFactory.eInstance.

Then, the modeled classes only need to be overridden with EMF. In this way, helper methods (add, remove) can be added in the interfaces … :

Adding access methods in the interface

… and the modelized operations can be overridden in the implementation:

Implementation of the job methods in the interface

2. Generating the code in Eclipse during the build

If we totally separate the generated code from the overridden code, it can be useful to automate the code generation from the model.

EMF offers us an ant task (emf.Ecore2Java) that allows generating code from a genmodel. Writing the ant file is straightforward:

Ant file to generate EMF code

To execute it, it is important to use the JRE from the workspace (parameter of the build launch, in the JRE tab).

This ant file can then be integrated to the project builder by putting it in the first position in order to ensure that that the generated code is present for the compilation:

3. Generating the code during the build, outside Eclipse

In the build headless process, without having and Eclipse IDE launched, we can generate code both ways,

• using the application org.eclipse.ant.core.antRunner which calls the generation ant which can contain the following tasks
• using the application org.eclipse.emf.codegen.ecore.Generator which only does generation

In both cases, the launch environment has to be set up:

• cd {Installation directory of Eclipse Modeling}
• export LAUNCHER=plugins/org.eclipse.equinox.launcher_1.2.0.v20110502.jar

Generating with the antRunner :

Launch of the build with the antRunner :
java -jar $LAUNCHER -application org.eclipse.ant.core.antRunner -nosplash -buildfile {pathToAntFile}/ecore2java.xml

This method is useful if the ant file does a bit more than that of the code generation.

Generating with the ecore.Generator

This method is useful if there is only code to generate from the model:

The parameters of the application are: java -jar $LAUNCHER -application org.eclipse.emf.codegen.ecore.Generator
Usage arguments: [-projects ]
[-dynamicTemplates] [-forceOverwrite | -diff]
[-generateSchema] [-nonNLSMarkers]
[-codeFormatting { default | } ]
[-model] [-edit] [-editor] [-tests]
[-autoBuild true | false ]
genmodel-file [ target-root-directory ]

Example:

• export PROJECT_HOME={path to your project}
• java -jar $LAUNCHER -application org.eclipse.emf.codegen.ecore.Generator -projects $PROJECT_HOME -model -nosplash $PROJECT_HOME/model/rental.genmodel $PROJECT_HOME

In order to go deeper in these notions, I advise you to read this general article on the matter, presented atinfoq and written by Sven Efftinge (XText project manager)

Feel free to comment this article if you have remarks !

Eclipse 4 Context Explorer

Eclipse 4 context explorer

For the presentation that I have given at Eclipse Con in Boston, I had to develop a small tool to help  the understanding of my slides.

This tool happens to be very practical, so I have decided to publish it on github (under EPL license). Since its first release, it has evolved a lot and I use it for each Eclipse 4 training.

Overall, it’s a E4 ‘Part’ containing a  TreeViewer and a synchronized TableViewer that display all the available contexts and which allows to see all available objects for each context.  The root elements in the tree are all the E4 contexts created for each bundle (the default one is the context for org.eclipse.e4.ui.workbench).

Here’s the result:

You have also a search box to find all the keys or classes containing the string (the nodes of the tree are also colored in blue if the associated context contains the string).

In order to use it, import the github project in your workspace, add a dependency (optional or not) on this plugin, then reference the part to where you need it in your application model by using the following URL:

bundleclass://com.opcoach.e4.contextExplorer/com.opcoach.e4.contextExplorer.parts.ContextExplorerPart

So for example we get:

This is useful during the development phase. I also heard that there is an equivalent in E4 tools, but nobody really knows where exactly!

I am inviting you to look  at the code. Perhaps, this will help you understand a bit better how injection works.

EclipseCon in Boston

Like every year, OPCoach participates in the EclipseCon North America held in Boston in March.

The presentation I proposed about injection into Eclipse 4 was accepted by the selection committee, so I will be a speaker again this year.
 

 
The Foundation has also made a real effort on registration fees. I invite you to sign up to ‘advance’ before 14th February. After this date, it will cost you 20% more.

Eclipse 4 talk during Eclipse Day 2012 In Toulouse

• Eclipse 4 talk (french) 
• Eclipse 4 talk (english)

I propose to comment this post if you have any idea or remark on Eclipse 4. Indeed, I have had feedback during informal discussions, but it would be nice to open a discussion here !

So feel free to add your comment(s)  to this post!

Eclipse Day in Toulouse on 24 may 2012

Happy new Year !

OPCoach whishes you an happy new year !

Lots of technologies to be used this year : Xtext, Xtend, Eclipse 4…

Eclipse Con Europe 2011

OPCoach will participate in Eclipse Con Europe 2011.

Paris EMF Training – 7th, 8th & 9th March 2011

• Eclipse
• Modeling
• EMF / Ecore
• Editeurs de modèles
• Générateurs de code
• Model to Text (M2T)
• Editeurs graphiques (GMF)
• EuGEnia