urbanisation-si

urbanisation-si

Ingénierie Dirigée par les Modèles (IDM)


Query View Transform (QVT) Operational : tutoriel, plus simple tu meurs !

query-view-transform-qvt-operational-tutoriel.png

Le métamodèle source et cible. 

 

Mes derniers articles sont consacrés au langage de transformation de modèles ATL (Atlas Transformation Language). 

Voir par exemple le tutoriel complet :

http://www.urbanisation-si.com/ingenierie-dirigee-par-les-modeles-idm-tutoriel-atl-atlas-transformation-language-le-da-vinci-code-de-la-transformation-atl

ou bien le cours complet qui commence :

http://www.urbanisation-si.com/ingenierie-dirigee-par-les-modeles-idm-documentation-atl-atlas-transformation-language-vous-saurez-tout-ou-presque-sur-les-modules

 

ATL est un langage opensource, largement utilisé utilisé dans l'industrie. Son implémentation est robuste et performante. Et surtout il existe des outils fiables comme le plugin pour Eclipse.

 

Mais ATL n'est pas une norme.

 

Son concurrent à l'avantage d'être une norme de l'OMG Object Management Group , l'organisation qui a fait notamment UML, MDA, ...

Il s'agit de QVT (Query View Transform). Il existe 2 types de QVT : QVTd (déclaratif, diisé en QVTr Relation et QVTc Core), équivalent des "matched rules" ATL et QVT Operational (impératif), équivalent des "called rules" ATL.

QVT avec son pédigré, pourrait être "La Solution" ultime pour transformer des modèles.

Seulement voilà, comme très souvent dans les normes, QVT souffre d'une grande complexité.

Mais il y a pire ! Les outils l'implémentant sont rares et incomplet. Seul QVTo commence à être implémenté alors que QVT-Relation est à l'état d'embryon.

 

Eclipse propose un plugin pour QVT Operational et un autre non finalsé pour QVT Relation.

 

Pour l'installer :

  1. http://projects.eclipse.org/projects/modeling.mmt.qvt-oml/downloads
  2. Décompressez le zip dans un répertoire.
  3. Dans Eclipse, allez dans le menu Help - Install new software - Add - Local - sélecionnez le répertoire - nommez et OK

N'échapperons pas à la règle de commencer par le traditionnel "Hello world" que font tous les débutants dans un langage.

 

Tout d'abord le métamodèle source et cible dans notre cas de tutoriel "plus simple tu meurs", voici son fichier Ecore (ABC.ecore) : 

 

<?xml version="1.0" encoding="UTF-8"?>
<ecore:EPackage xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" name="ABC" nsURI="http:///ABC.ecore" nsPrefix="ABC">
<eClassifiers xsi:type="ecore:EClass" name="Root">
<eStructuralFeatures xsi:type="ecore:EReference" name="element" upperBound="-1"
eType="#//Element" containment="true"/>
</eClassifiers>
<eClassifiers xsi:type="ecore:EClass" name="A" eSuperTypes="#//Element">
<eStructuralFeatures xsi:type="ecore:EAttribute" name="a" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
</eClassifiers>
<eClassifiers xsi:type="ecore:EClass" name="B" eSuperTypes="#//Element">
<eStructuralFeatures xsi:type="ecore:EAttribute" name="b" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
</eClassifiers>
<eClassifiers xsi:type="ecore:EClass" name="C" eSuperTypes="#//Element">
<eStructuralFeatures xsi:type="ecore:EAttribute" name="c" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
</eClassifiers>
<eClassifiers xsi:type="ecore:EClass" name="Element" abstract="true">
<eStructuralFeatures xsi:type="ecore:EAttribute" name="id" lowerBound="1" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EInt"/>
<eStructuralFeatures xsi:type="ecore:EReference" name="abc" upperBound="-1" eType="#//Element"
containment="true"/>
</eClassifiers>
</ecore:EPackage>

Créer un nouveau projet : File - New - Project - Eclipse Modeling Framework -Empty EMF Project

 

Clic droit sur ABC.ecore - Initialize ecore diagram : pour générer le diagramme du modèle, cela ne peut pas faire de mal !

 

Double clic droit sur ABC.genmodel - clic droit sur ABC (2 ème icône dans la hiérarchie) - Generate All

 

Clic droit sur le projet - run As - Run Configurations - onglet Arguments - VM arguments :

-Dosgi.requiredJavaVersion=1.6  -Xms256m  -Xmx768m  -XX:MaxPermSize=256m

puis Run

 

Une nouvelle instance d'Eclipse se lance pour exécuter le nouveau plugin.

 

File - New - Project - Model to Model Transformation - Operational QVT Project.

Nommez votre projet

 

Ecrire le source de la transformation :

 

modeltype ABC uses ABC('http:///ABC.ecore');

transformation NewTransformation(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!";
}

 A est transformé en B, en utilisant le même id et en concaténant l'attribut "a" à la chaîne "World" pour créer l'attribut "b".

 

Créer le modèle à transformer : 

Clic droit sur le projet - New - Other - Example EMF Model Creation Wizards - ABC Model 

Double clic sur le modèle vide - clic droit sur Root - New chlid - ajouter et modifier dans la vue Properties : 

  • A: id=1, A=”Hello”
  • A: id=-1, A=”World”
  • C: id=1, C=”C'est quoi ce truc ?”

query-view-transform-qvt-operational-tutoriel-1.png

 

Pour exécuter la transformation :

Clic droit sur le fichier de transformation (.qvto) - Run As - Run Configuration - Operational QVT Interpreter - New_configuration - Run

 

query-view-transform-qvt-operational-tutoriel-2.png

 

Le modèle transformé se trouve dans le fichier "sortie.abc" :

 

query-view-transform-qvt-operational-tutoriel-3.png

 

 

"La vraie valeur d'un homme réside, non dans ce qu'il a, mais dans ce qu'il est."
Oscar Wilde

 

Voir aussi :  

 

http://urbanisation-si.wix.com/blog

http://urbanisme-si.wix.com/blog

http://urbanisation-si.wix.com/urbanisation-si

http://urbanisation-si.over-blog.com/

http://rhonamaxwel.over-blog.com/

http://urbanisation-des-si.blogspot.fr/

http://bonnes-pratiques-si.eklablog.com/

http://urbanisation-si.eklablog.com/


20/10/2015
0 Poster un commentaire

Le plugin ATL (ATLAS Transformation Language) pour Eclipse : les étapes pour réaliser une transformation (2/2)

Surcharge de module et exécution de la configuration de lancement

plugin-eclipse-atlas-transformation-language-surcharge-module.png

Tandis que les modules et requêtes ATL sont exécutés un par un, il est aussi possible d'exécuter des modules par dessus d'autres.

Le résultat final est une transformation contenant l'union de toutes les règles de transformations et helpers, quand il est possible pour un module de surcharger des règles et helpers du module inférieur.

 

Exemple :

 

 

Ce module est réutilisé et surchargé quand c'est nécessaire par le module :

 

La transformation UML2Copy inclu la règle de transformation pour chaque instance de méta-classe qu'il doit copier.

Ce qui fait approximativement 200 règles pour la totalité du métamodèle  

 

Chaque transformation spécifique doit copier toutes les méta-classse exceptées les quelques méta-classes qui sont redéfinies.

La transformation UML2Profiles applique un profil aux instances de "uml::Model" instance, tous les autres éléments sont juste copiés.

Pour terminer, le module UML2Profiles est exécuté par dessus le module UML2Copy.

Il redéfini la règle "Model" qui copie chaque instance de "uml::Model", avec une version vérifiant que le profil que nous voulons appliqué  a déjà été appliqué.

Il introduit aussi une nouvelle règle "ModelProfile", qui vérifie que le profil que nous voulons appliquer n'a pas été appliqué et dans ce cas applique le profil.

Le résultat de la transformation contient toutes les règles figurant ci-dessus qui n'ont pas été barrées.  

La surimpression se est faite à l'exécution : il n'y a pas de module représentant la surimpression des différents modules les uns par dessus les autres.

Il y a juste plusieurs modules chargés les uns au dessus des autres, surchargeant les règles existantes et en ajoutant des nouvelles.

 

La surimpression est configurée dans l'onglet "Advanced",  "Run..."  de la configuration de l'exécution.

Attention : quand on ajoute des modules en surimpression, dans l'onglet "Advanced",  ils surchargent le module "main" spécifié dans l'onglet  "ATL Main Configuration".

 

Exécution de la configuration

Une fois la configuration de la transformation correctement effectuée, elle peut être lancée autant de fois que l'on désire.

Il suffit juste d'aller dans la fenêtre Run,  pour sélectionner la transformation et clique sur "Run".

 
"Tu dois devenir l'homme que tu es. Fais ce que toi seul peux faire. Deviens sans cesse celui que tu es, sois le maître et le sculpteur de toi-même."
Friedrich Nietzsche

 

Voir aussi :  

 

http://urbanisation-si.wix.com/blog

http://urbanisme-si.wix.com/blog

http://urbanisation-si.wix.com/urbanisation-si

http://urbanisation-si.over-blog.com/

http://rhonamaxwel.over-blog.com/

http://urbanisation-des-si.blogspot.fr/

http://bonnes-pratiques-si.eklablog.com/

http://urbanisation-si.eklablog.com/


18/10/2015
0 Poster un commentaire

Le plugin ATL (ATLAS Transformation Language) pour Eclipse : les étapes pour réaliser une transformation (1/2)

Comment réaliser une transformation ATL avec l'IDE ATL d'Eclipse

 

plugin-eclipse-atlas-transformation-language-concevoir-une-transformation-1.png
    

Check liste des fichiers :

  • métamodèle source (ecore)
  • métamodèle  cible (ecore)
  • modèle source à transformer (xmi)
  • fichier de transformation (atl)

 

Créer un projet ATL.

Les métamodèles source et cible peuvent être importés. La tache la plus ardue consistant bien sur à concevoir la transformation elle même.

Pour créer un projet ATL :  New->ATL Project

Une bonne pratique de nommage consiste à nommer le projet avec le nom du métamodèle source, puis "2" et pour finir le nom du métamodèle cible  (par ex.  Author2Person).

Pour avoir la  "completion" des éléments de modèle, vous devez préciser en début de fichier ATL :

 

  1. '-- @nsURI' : l'URI d'un métamodèle pour le charger à partir de l'EMF registry,
  2. '-- @path' : le chemin d'un métamodèle, si vous voulez le charger dynamiquement à partir d'un fichier ecore.  

Seuls les métamodèles EMF sont supportés.

Vous devez spécifier les chemins relatifs des fichiers dans le workspace.

Exemple du début d'une transformation "UML2AnyMM" :

 

-- @path AnyMM=/AnyProject/AnyFolder/AnyMM.ecore
-- @nsURI UML=http://www.eclipse.org/uml2/2.1.0/UML
module Class2Relational;
create OUT : AnyMM from IN : UML;
-- ...transformation helpers and rules

 

La "completion" est exécutée en appuyant sur  Ctrl + espace, ou en tapant un espace si le contexte le permet.

Pour inclure la liste des librairies dans la completion :

 


'-- @lib' : le chemin relatif par rapport au workspace de la librairie.

 

Création du fichier ATL

Il existe 2 manière de créer un fichier ATL de transformation :

  1. l'assistant
  2. directement en créant le fichier source atl

L'assistant ATL

Il est appelé par New->ATL File dans le menu contextuel, vous pouvez spécifier :

  • le nom du module
  • le type (module, query ou librairie)
  • les noms des variables  métamodèles, modéles sources et cibles
  • les librairies
  • L'entête est généré avec ces informations.

Vous pouvez optionnellement généré les URIs ou chemins aux métamodèles pour activer la completion.

La checkbox "Generate configuration" génère la configuration de lancement en donnant les chemins des modèles.

Sinon vous créez le fichier atl "from scratch".

 

Compilation du fichier ATL

La compilation génère le fichier ASM.

 

La configuration de l'exécution

Elle donne toutes les information nécessaire à l'exécution de la transformation : les chemins des fichiers ATL, modèles, métamodèles et librairies).

L'onglet ATL Configuration permet de spécifier les chemins et URIs de la configuration de lancement. Les champs sont pré-remplis à partir du module ATL, mais vous pouvez en ajouter.

 

plugin-eclipse-atlas-transformation-language-concevoir-une-transformation-2.png

 

L'onglet Advanced permet de configurer :

  1. des modules supplémentaires en  surimposition avec les boutons  Add/Remove.
  2. l'ATL Virtual Machine
  3. les paramètres de lancement

plugin-eclipse-atlas-transformation-language-concevoir-une-transformation-3.png

 

L'onglet Common offre aux développeurs la possibilité de configurer l'environnement d'exécution de la transformation.

 

plugin-eclipse-atlas-transformation-language-concevoir-une-transformation-4.png

 

  1. Le bouton Save as permet se sauvegarder la configuration de lancement dans un fichier par ex. Author2Person.launch.
  2. Display in favorites : la configuration apparaît dans les menus Run et/ou Debug.
  3. Console Encoding : le type d'encodage pour la console
  4. Vous pouvez définir les entrées et les sorties
  5. La dernière option permet d'exécuter la transformation en tache de fond.

 
"Se réunir est un début ; rester ensemble est un progrès ; travailler ensemble est la réussite." 
Henry Ford

 

Voir aussi :  

 

http://urbanisation-si.wix.com/blog

http://urbanisme-si.wix.com/blog

http://urbanisation-si.wix.com/urbanisation-si

http://urbanisation-si.over-blog.com/

http://rhonamaxwel.over-blog.com/

http://urbanisation-des-si.blogspot.fr/

http://bonnes-pratiques-si.eklablog.com/

http://urbanisation-si.eklablog.com/


18/10/2015
0 Poster un commentaire

Cours complet sur ATL (ATLAS Transformation Language) : pour terminer, une dernière chose à laquelle il faut prendre garde !

cours-complet-atlas-transformation-language-atl-piege-et-fin.png

 

Dans l'article précédent :

http://www.urbanisation-si.com/cours-complet-sur-atl-atlas-transformation-language-les-mots-cles-atl

nous avion abordé les mots clés ATL. Voyons à présent pour terminer, une dernière chose à laquelle il faut prendre garde !

 

Avec ATL, un élément du modèle d'entrée ne peut pas être mis en correspondance plus d'une fois.

Cette contrainte n'est pas vérifiée à la compilation et peut conduire à des résultats inattendus.

Un cas typique de correspondance multiple se produit lorsque dans le modèle d'entrée, on est en présence d'un héritage avec la super classe qui n'est pas abstraite :

 

                       

La correspondance multiple apparaît ici en essayant respectivement de faire correspondre A et B dans les règles ( ruleA et ruleB).

Avec la pattern source : MM!A, la règle ruleA correspondra avec l'élément  A ainsi qu'un élément B.

Comme ce dernier aura une correspondance dans ruleB, on aura le problème de la correspondance multiple.  

Pour résoudre ce problème, on doit s'assurer que ruleA fait les correspondances avec seulement les éléments strictement A (et pas hérités).

Pour cela il faut filtrer dans le pattern source de la règle ruleA, le type d'élément mis en correspondance par la règle :

 

rule ruleA {
      from
            a : MM!A (
                  a.oclIsTypeOf(MM!A)
            )
 ...

 

La fonction OCL oclIsTypeOf  teste si dans le modèle d'entrée, les éléments sont des instances du métamodèle  passé en paramètre.

 

Et voilà qui termine ce cours sur le langage ATL, nous passerons bientôt à une application dans le domaine du processus d'urbanisation du système d'information pour les projections (transformations) des cartographies.

 

"Je veux être fort, non pour dominer mon frère, mais pour vaincre mon plus grand ennemi - moi-même."
Chef Iakota Yellow Lark

 

Voir aussi :  

 

http://urbanisation-si.wix.com/blog

http://urbanisme-si.wix.com/blog

http://urbanisation-si.wix.com/urbanisation-si

http://urbanisation-si.over-blog.com/

http://rhonamaxwel.over-blog.com/

http://urbanisation-des-si.blogspot.fr/

http://bonnes-pratiques-si.eklablog.com/

http://urbanisation-si.eklablog.com/


17/10/2015
0 Poster un commentaire

Cours complet sur ATL (ATLAS Transformation Language) : les mots clés ATL

cours-atlas-transformation-language-atl-les-mots-cles.jpg

 

Dans l'article précédent :

http://www.urbanisation-si.com/cours-complet-sur-atl-atlas-transformation-language-les-requetes-atl

nous avion abordé les requêtes ATL. Voyons à présent les mots clés ATL.

 

Voici la liste des mots réservés, ils se divisent en 3 catégories :

  1. les constantes : true, false;
  2. les types : Bag, Set, OrderedSet, Sequence, Tuple, Integer, Real, Boolean, String, TupleType, Map;
  3. le langage : not, and, or, xor, implies, module, create, from, uses, helper, def, context, rule, using, derived, to, mapsTo, distinct, foreach, in, do, if, then, else, endif, let, library, query, for, div, refining, entrypoint.

Attention la chaîne "main" ne peut pas être utilisée comme nom de variable, de règle ni d'attribut défini dans le contexte du module ATTL.

 

"Jour de vent, jour de pluie, il fait gris, mais dans ton cœur, il y a la vie, ce soleil qui jaillit, offre-le d'un sourire à autrui."

Jo Coeijmans

 

Voir aussi :  

 

http://urbanisation-si.wix.com/blog

http://urbanisme-si.wix.com/blog

http://urbanisation-si.wix.com/urbanisation-si

http://urbanisation-si.over-blog.com/

http://rhonamaxwel.over-blog.com/

http://urbanisation-des-si.blogspot.fr/

http://bonnes-pratiques-si.eklablog.com/

http://urbanisation-si.eklablog.com/


17/10/2015
0 Poster un commentaire


Recherche

Vous recherchez ? :