Ingénierie Dirigée par les Modèles (IDM) : documentation ATL (ATLAS Transformation Language), vous saurez tout ou presque sur les modules

Un module ATL correspond à une transformation de modèles, voir les articles :

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

https://www.urbanisation-si.com/model-driven-engineering-mde-modeles-metamodeles-metametamodeles-meta

ATL permet de produire un ensemble de modèles cibles à partir d'un ensemble de modèles sources.

Le modèles sources et cibles doivent être des instances de leurs métamodèles respectifs.

Un module ATL est composé des sections :

header
import
helpers
rules

1) La section "Header"

Elle définie le nom de la transformation et les noms des variables correspondant aux modèles sources et cibles.

module module_name; create output_models [from|refining] input_models;

De manière similaire à Java, le nom du fichier ATL ( .atl ) doit avoir exactement le même nom que le module.

Le mot clé create précise le modèle source et from ( en mode normall ) et refining ( dans le cas où on raffine la transformation ) pour le modèle source.

La déclaration multiple de modèles, séparés par des virgules, en entrée/sortie est possible.

module Book2Publication; create OUT : Publication from IN : Book;

2) La section Import

Elle est facultative et permet de déclarer des librairies ATL.

uses extensionless_library_file_name;

3) La section Helpers

C'est vraiment l'équivalent des helpers Java, ils offrent la possibilité de factoriser du code.

helper context Integer def : max(x : Integer) : Integer = ...;

4) La section Rules

3 types de règles :

"Matched rules" : constituent la partie déclarative de la transformation. On doit spécifier :

pour quels types d'éléments sources, des éléments cibles doivent être générés.
la manière dont les éléments cibles sont initialisés

Une "matched rule" est identifiée par son nom. Elle correspond à un type d'élément du modèle source et génère un ou plusieurs éléments du modèle cible.

rule Author {
from
a : MMAuthor!Author
to
p : MMPerson!Person (
name <- a.name,
surname <- a.surname
)
}

Cette règle "Author", a pour but de transformer les éléments du modèle source Author ( à partir du métamodèle source MMAuthor ) en éléments du modèle cible Person ( MMPerson ) . Elle ne contient pas de filtres ce qui signifie que toutes les classes de MMAuthor correspondent au pattern.

La règle concernant le pattern cible contient un simple pattern qui instancie la classe Person de MMPerson du métamodèle cible pour chaque éléments source correspondant au pattern source.

Lazy rules ne sont appliquées seulement lorsqu'elles sont appelées par une autre règle.

Called rules permet au développeur de programmer de manière impérative ( à la manière d'un langage classique d'un langage de programmation Java, C++, C#, ... ).

Gardons en peu pour les prochains articles.

"N'oublie pas que chaque nuage, si noir soit-il, a toujours une face ensoleillée, tournée vers le ciel."
Friedrich Wilhelm Weber

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/09/2015