“Hello world” in Eclipse QVTo

Although QVT isn’t a brand new specification (its first version is from April 2008), it is very difficult to find basic information about it and about how to use it. Since I’ve been working with QVT (Relations and Operational Mapping languages) in the last few months, I’ll post some things about it – maybe it will be useful to some QVT users…

To start, I’ll present a brief tutorial of how to execute a simple transformation in Eclipse QVTo with a custom metamodel. Nowadays we have 2 options to execute a transformation in this scenario:

1. Install a plug-in metamodel in Eclipse and create the transformation.
2. Use the QVTo environment in an inner Eclipse instance.

Normally we should use the option 1, as a stable metamodel is a pre-requirement for a transformation project. In some projects you may correct the metamodel during the transformation development, but it is just a matter of regenerating a plug-in. The option 2 is more suitable for tests or unstable metamodels (whatever this means).

First of all, install Eclipse Modeling Tools and go to “Help->Install Modeling Components” and choose “Model to Model->Operational QVT”. Install it and restart Eclipse when asked.

To present the rest of the tutorial, I will start with the option 2 (Use the QVTo environment in an inner Eclipse instance). I will not discuss how to create a metamodel using EMF (an interesting step-by-step tutorial is available here). So, I will use a simple metamodel that I will use in future examples. And before we start, just notice that some steps may be executed differently from what is shown here. For instance, the step 8 (to execute the transformation) can be done using the “Run” menu. But the outcome is the same.

1. Create a new EMF Project (in “File->New->Project” and “Eclipse Modeling Framework->Empty EMF Project”). Create your metamodel or copy-it. I’ll use this metamodel in this tutorial.
   
2. Create a new “EMF Generator Model” (right click the metamodel in the package explorer, “New->Other” and “Eclipse Modeling Framework->EMF Generator Model”).
3. Open the genmodel (it is normally opened automatically) and right click in its root and select “Generate All”. The source code for a basic model editor will be generated.
4. Go in the generated “plugin.xml” and select “Launch an Eclipse application” under “Testing” section. A new eclipse instance will be opened with the plug-in working. Leave the other Eclipse instance open (the new instance is running from it).
5. Now let’s create a transformation. Go in “File->New->Project” and select “Model to Model Transformation->Operational QVT Project”. Choose a name and select “Create a simple project”. In the next window select “Create artifacts in new QVT Operational Project” and then “Operational QVT Transformation” to create a basic transformation file.
6. Write the following QVTo code:

   modeltype ABC uses ABC('http:///ABC.ecore');
   
   transformation HelloWorld(in source:ABC, out target:ABC);
   
   main() {
   	source.rootObjects()[Root]->map Root2Root();
   }
   
   mapping Root :: Root2Root() : Root {
   	element += self.element->select(a |
   		a.oclIsKindOf(A))[A]->map A2B();
   }
   
   mapping A :: A2B() : B
   	when {
   		self.id > 0
   	}
   	{
   	result.id := self.id;
   	result.b := self.a + " World!";
   }

   This code only transform an A to B, using the same id and concatenating the “a” attribute to ” World!” to create the “b” attribute.

7. Create a new model to execute in the transformation. Go in the Project Folder in the Project Explorer and right click “New->Other” and “Example EMF Model Creation Wizards->ABC Model”. Select the model root object for the model (Root in the ABC model) and add three child (use the “Properties View” for that: right click in an element and select “Show Properties View”).
   • A: id=1, A=”Hello”
   • A: id=-1, A=”World”
   • C: id=1, C=”Something”
8. Let’s execute the transformation. Select the transformation file in the “Project Explorer” and go “Run->Transformation”. Select the transformation file. Select for the “In Source” the Root for the model you’ve just created as source. For the “OUT target” you can leave the default option. Click Finish.
9. Now you will see the result in the file defined as “OUT target”. Only one element inside Root will be defined, a B with and B=”Hello World!”.

As I said before, another option is to create a plug-in and use it, instead of initiating a new instance of Eclipse. This seems to be the recommended option.

1. Create a plug-in for a metamodel. To do this, execute the steps 1 to 3 above and in the step 4 select “Export Wizard” in the “Export” section of the “plugin.xml”. Select all elements, define a directory for its destination, and click finish.
2. Close Eclipse. Copy the files that were generated in the “plugins” (“eclipse/plugins”) directory of Eclipse. Restart Eclipse.
3. Now we can go back to Step 5 of the previous option (create a Model to Model Transformation) and create our transformation.

That’s it. But be careful: DO NOT add the metamodel in the project settings (“QVT Settings->Metamodel Mappings”). If you do this, you will get an empty result no matter what you do. This seems to happen because the metamodel registered in this option conflicts with the metamodel defined in the plug-in (they define different implementation for the metaclasses in EMF). For now, this option is only used to register the target metamodel when the source and the target metamodel are different. I expect in future version of QVTo we will be able to use the source metamodel without creating a plug-in (similarly to what happens in Medini QVT). However, when this options is available, probably you will have to see the result in an “unpleasant” textual representation – as there won’t be a plug-in. But it doesn’t seem to be a problem for developers…