Transformations de diagrammes de classes simplifiés

Ce TP consiste à exécuter et tester la transformation de modèle d'ajout d'accesseur vue en cours puis à développer d'autres transformations de diagrammes de classes.

L'archive ClassDiagram.zip contient un projet Eclipse complet et fonctionnel. Pour l'importer dans Eclipse, décompressez l'archive et placez le répertoire "ClassDiagram" résultant dans votre workspace courant. Ensuite, sous Eclipse, importez le projet : File -> Import -> General -> Existing Projet into Workspace -> clic sur Workspace + Ok immédiat -> sélectionner le projet -> Finish.

Contenu du projet :

• Répertoire "model" : le méta-modèle "ClassDiagram.ecore" et un modèle "Banque.xmi".
• Répertoire "transfos" : l'implémentation en ATL de l'ajout d'accesseurs (fichiers "AddAccessor.atl") ainsi qu'une transformation ATL "DuplicateClassDiagram.atl" faisant un copier/coller d'un diagramme de classes (cela sera utile pour implémenter d'autres transformations ATL).
• Répertoire "src" : le programme "ClassDiagramManipulation.java" qui implémente l'ajout d'accesseurs en Java/EMF.

Travail à réaliser

Affichage de modèles en Java / EMF

Etudiez le méta-modèle ainsi que l'exemple de diagramme (fichier "Banque.xmi") puis implémentez en Java une méthode qui permet d'afficher dans la console le contenu d'un diagramme de classes en complétant la méthode "printModel()" du fichier "ClassDiagramManipulation.java".

Pour le modèle "Banque.xmi", l'affichage à obtenir est le suivant :

**** Class Account
-- attributes :
   id : integer
   overdraft : integer
   balance : integer
-- methods :
   integer getOverdraft ( )
   void changeOverdraft ( val : integer )
   integer getId ( )
-- interfaces :
   IOperations

**** Class Client
-- attributes :
   name : string
   addr : string
-- methods :
   string getName ( )
   void changeAddr ( addr : string )
-- interfaces :

**** Interface IOperations
   void whitdraw ( val : integer )
   void deposit ( val : integer )
-- implemented by :
   Account

**** Associations
-- Account [ accounts , 1..* ] <- -> Client [ owner , 1..1 ]

Transformations

Exécutez la transformation d'ajouts d'accesseurs en ATL et en Java et regardez les résultats.

Implémentez d'autres transformations en ATL et Java/EMF :

• Une transformation qui ajoute pour chaque classe s'appellant "MaClasse" une interface "IMaClasse" à la liste des interfaces implémentées par cette classe puis déplace toutes les méthodes de la classe dans cette interface.
• Modifiez la transformation précédente pour ne pas déplacer les accesseurs des attributs dans l'interface.
• Une transformation qui supprime les associations entre classes et à la place insère les attributs requis avec les bons types et multiplicités dans les classes.

Aide technique en ATL

Lancement d'une transformation

Pour lancer une transformation ATL, il faut d'abord créer une configuration d'exécution : clic droit -> Run As -> Run Configurations... Dans la fenêtre qui s'ouvre, double-cliquez sur "ATL Transformation". Ensuite remplissez les champs en sélectionnant le fichier "AddAccessor.atl". Vous retrouvez alors les 3 noms placés en début de transformation : "ClassDiagram" à qui il faut associer le méta-modèle Ecore et "source" et "cible" qui sont associés aux modèles source et cible pour l'exécution de la transformation. Cliquez sur "Apply" pour sauver la transformation et "Run" pour la lancer. Ensuite en sélectionnant le fichier ATL dans le navigateur de fichiers et avec le clic droit et Run As -> ATL transformation, la configuration sauvegardée s'exécute directement.

La fenêtre d'exécution doit être la suivante :

Affichage dans la console

Comme le langage ATL est déclaratif, il n'est pas aussi simple que comme dans du code Java de mettre des affichages dans la console pour faciliter le débogage de votre code au fur et à mesure de son exécution. Il y a deux façons de faire en ATL pour afficher du texte dans la console d'Eclipse :

• Appeler la méthode debug sur un objet dans une expression OCL avec éventuellement une chaine en paramètre
• Dans une règle de transformation, rajouter un champ impératif "do" et utiliser la fonction println qu'on applique sur une chaine

Voici comment cela peut s'utiliser sur l'exemple de la transformation d'ajouts d'accesseurs du diagramme de classes.

Fonction Debug

La fonction debug est une fonction OCL (spécifique à ATL) qui affiche l'objet avec la chaine passée en paramètre et qui retourne l'objet OCL sur lequel elle s'applique. On peut donc l'utiliser dans une expression OCL comme dans un helper mais pour la mélanger avec les autres expressions OCL qui sont souvent booléennes, ce que vous pouvez faire est de comparer le debug avec l'objet sur lequel vous l'appliquez : cela retournera par principe true vu que debug retourne l'objet.

Voici la modification du helper "hasGetter" pour afficher chaque méthode qui est testée par rapport à un attribut :

Fonction Println

La fonction println est plus simple à utiliser, il suffit de définir une chaine et vous appelez la fonction dessus. Par contre cet appel doit se faire dans la partie impérative d'une transformation (non utilisée dans la transformation de l'ajout d'accesseurs). En pratique, il suffit de rajouter un champ "do" après le "to" d'une règle.

Par exemple, pour afficher le nom de chaque classe qui est traitée par la règle de duplication des classes :

Exemple d'affichage en console

C'est le moteur ATL qui exécute les règles et appelle les helpers OCL dans l'ordre qu'il a décidé en faisant éventuellement plusieurs passes. En conséquence, vous ne maitrisez pas l'ordre où les affichages se feront dans la console. Voici ce que peut donner l'affichage pour l'exemple de la banque avec les 2 modifications d'affichage ci-dessus :

Le contenu précédent de la console reste affiché quand on relance une transformation. Pour l'effacer, faire un clic droit dans la console puis Clear.

Manuels d'utilisation ATL

• Documentation ATL (HTML)
• Ancienne documentation ATL (PDF)