urbanisation-si.com

Dans l'article précédent :

https://www.urbanisation-si.com/cours-complet-sur-atl-atlas-transformation-language-quelques-trucs-et-astuces-sur-les-expressions

nous avion abordé les trucs et astuces sur les expressions. Voyons à présent les helpers ATL.

Les “Helpers” ATL

Les “helpers” ATL permettent aux développeurs de définir leurs propres methods dans les différentes unités d’ATL.

Dans le contexte d’ATL, ces méthodes sont appelées “helpers”. Comme toutes méthodes, ils permettent de factoriser du code ATL que l’on peut appeler à différents endroits du programme.

Il existe 2 type de “helpers” : fonctionnel et attribut. Tous les 2 sont définis dans le contexte d’une entité donnée. Un “attribut helper” est utilize comme un attribute alors qu’un “fonctionnel helper” accepte des paramètres.

Syntaxe

helper [context context_type]? def : helper_name(parameters) : return_type = exp;

Si le context est omis alors le “helper” est associé au context global du module ATL, c’est à dire que “self” fait reference         au module/query.

Le mot clé de fest utilize pour nommer le “helper”. La signature du “helper” comprend le context, le nom, les paramètres et le type de retour.

Les paramètres sont typés (n’importe quell type ATL) et dséparés par des virgules et le corps n’importe quelle expression valide OCL.

Exemple :

helper def : averageLowerThan(s : Sequence(Integer), value : Real) : Boolean =

        let avg : Real = s->sum()/s->size() in avg < value;

Ce “helper” nommé averageLowerThan, est défini dans le context du module ATL (pas de contexte  explicite) fait la moyenne d’une sequence d’entiers et renvoie vrai si elle inférieure à une certaine valeur.

Appel au helper de la super classe

class A {}

class B extends A {}

helper context A def: test() : Integer = 1;

helper context B def: test() : Integer = super.test() + 1;

Attribut

C’est une constante spécifiée dans un contexte spécifique. Il n’y a bien sur aucun paramètres.

Syntaxe :

helper [context context_type]? def : attribute_name : return_type = exp;

Exemple :  

helper def : getYoungest : MMPerson!Person =

        let allPersons : Sequence(MMPerson!Person) =

               MMPerson!Person.allInstances()->asSequence() in

        allPersons->iterate(p; y : MMPerson!Person = allPersons->first() |

               if p.age < y.age

               then

                       p

               else

                       y

               endif

        );

Cet attribute getYoungest, est défini dans le contexte du module ATL. Il s’applique à un métamodèle source MMPerson contenant Person comme élément de modèle. Le but est de renvoyer la pesonne la plus jeune (le type de reour est MMPerson!Person). Le corps de l’attribut est une "let" expression définissant la variable allPersons qui est une séquence de MMPerson!Person contenant toutes les personnes ( le « set » doit être casté en séquence ). La séquence est itérée, la variable p représente la personne itérée courante. Le résultat de l’itération est de type MMPerson!Person et correspond à la personne la plus jeune. Ce résultat est placé dans la variable y, initialisée avec la 1ère personne de la sequence  allPersons (pour avoir cette 1^ère personne dans l’ordre, il faut une sequence qui est ordonné  plutôt qu’un set qui ne l’est pas). Le corps de l’expression iterate consiste en un "if" comparant l’age  de la plus jeune personne courante à la personne itérée courante. Suivant le résultat du if, on renvoie la personne courante (p) ou la plus jeune courante (y).

Un helper sans paramètrs est équivalent à un attribut.

ATTENTION : le code d’un helper est exécuté à chaque fois qu’il est invoqué contrairement à un attribut qui pour un élémént de modèle donné en enrée, retourne toujours la même valeur. Le moteur ATL interprête une seule fois la valeut retournée d’un attribute, soit à la 1^ère invocation soit à l’initialisation de la transformation/query pour ceux qui sont déclarés dans le contexte du module ATL.

Limitations

L’implémentation courante a 3 limitations :

La 1^ère limitation concerne les paramètres qui ne font pas encore partie de la signature. Ce qui entraîne que tous les helpers définis dans un contexte ATL donné, doivent avoir des noms distincts. Cela concerne aussi les helpers contenus des librairies importées.

La 2^ème limitation concerne la définition de helpers dans un contexte de collection qui n’est pas supportée. La solution de contournement est de passer la collection en paramètre et de déclarer le helper dans le contexte du module ATL.

Exemple :

helper context Set(MMPerson!Person) def : getYoungPersons(age : Integer) :

        Set(MMPerson!Person) =

        self->select(p | p.age < age);

Compte de la limitation, il faudra definer le helper de la manière suivante :

helper def : getYoungPersons(s : Set(MMPerson!Person), age : Integer) :

        Set(MMPerson!Person) =

        s->select(p | p.age < age);

La dernière limitation  est le fait que l’implémentation courante  ne supporte pas la définition d’attributs dans une librairie ATL. La solution de contournement et de déclarer un helper sans paramètre pour chaque attribut de la librairie.

Exemple, dans une librairie,  l’attribut suivant :

helper context String def : getFirstChar : String = self.substring(1, 1);

doit être remplacé par le helper :

helper context String def : getFirstChar() : String = self.substring(1, 1);

"Si l'automobile avait suivi le même développement que les ordinateurs, une Rolls Royce coûterait aujourd'hui 500 francs, ferait du 700 kilomètres heure et exploserait une fois par an en faisant 10 morts."
Robert Cringely

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/