urbanisation-si.com

https://www.urbanisation-si.com/cours-complet-sur-atl-atlas-transformation-language-le-code-imperatif-atl-linstruction-daffectation

09/10/2015

0 J'aime 0 Poster un commentaire

Cours complet sur ATL (ATLAS Transformation Language) : le code impératif ATL, l’instruction de test : if

Dans l'article précédent :

nous avion abordé le code impératif ATL et l’instruction d’affectation. Voyons à présent l’instruction de test : if

L’instruction if

Syntaxe :

if(condition) {
statements1
}
[else {
statements2
}]?

La condition doit être une condition OCL renvoyant une booléen.

ATTENTION : le "then" est obligatoire et le “else” est facultatif. Je ne vais pas vous faire l’affront de vous expliquez à quoi sert in “if” et comment il fonctionne. Google est votre ami, vous trouverez des milliards de sites traitant de la programmation pour débutant.

Voici tout de même des exemples :

if(aPerson.gender = #male) {
thisModule.menNb <- thisModule.menNb + 1;
thisModule.men->including(aPerson);
}

if(aPerson.gender = #male) {
thisModule.fullName <- 'Mr. ' + aPerson.name + ' ' + aPerson.surname;
}
else {
if(aPerson.isSingle) {
thisModule.fullName <- 'Miss ' + aPerson.name;
thisModule.surname <- aPerson.surname;
}
else {
thisModule.fullName <- 'Mrs. ' + aPerson.name;
thisModule.surname <- aPerson.marriedTo.surname;
}
hisModule.fullName <- thisModule.fullName + ' ' + thisModule.surname;
}

if(aPerson.gender = #male)
thisModule.men->including(aPerson);
else
thisModule.women->including(aPerson);

"L'enthousiasme est une maladie qui se gagne."
Voltaire

Voir aussi :

https://www.urbanisation-si.com/cours-complet-sur-atl-atlas-transformation-language-introduction-aux-regles-atl

08/10/2015

0 J'aime 0 Poster un commentaire

Cours complet sur ATL (ATLAS Transformation Language) : le code impératif ATL, l’instruction d’affectation

Dans l'article précédent :

nous avion abordé une introduction aux règles ATL. Voyons à présent le code impératif ATL et l’instruction d’affectation.

Le code impératif ATL

ATL permet aux développeurs de spécifier du code impératif à l’intérieur de blocs dédiés ou dans une règle appelée (“called rule”). Un bloc impératif est composé de sequenceé d’instructioné impérativeé et comme en Java, C ou C++ ou bien d’autres encore, elles sont terminées par un point virgule (";").

L’instruction d’affectation

Permet d’assigner une valeur à des attributs définis dans le contexte du module ATL ou à des éléments du modèle cible.

Syntaxe :

target <- exp;

Exemple, soit un compteur entier déclaré et initialisé à 0 :

helper def: counter : Integer = 0;

La valeur du compteur peut être incrémentée dans la portée du bloc impératif :

thisModule.counter <- thisModule.counter + 1;

Exemple avec un attribut :

aPerson.father.age <- aPerson.age + 25;

Exemple d’affectation de référence d’instance à l’intérieur d’une même règle :

aPerson.father <- anotherPerson;

De même il est possible d’affecter une référence d’un élément de modèle généré par une autre règle de correspondence (matched rule). Si l’élément assigné n’est pas l’élément source correspondant ou s’il ne s’agit pas de la règle par défaut d’un élément alors on doit utiliser l’opération resolveTemp().

ATTENTION : l’opération resolveTemp() doit être appelée lorsque la phase de correspondance de la transformation est terminée. Cela signifie, que resolveTemp ne peut pas être invoquée du point d’entrée d’une règle appelée ni d’une autre règle appelée invoquée à partir de ce point d’entrée.

"Nous tissons notre destin, nous le tirons de nous comme l'araignée sa toile."
François Mauriac

Voir aussi :

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

07/10/2015

0 J'aime 0 Poster un commentaire

Cours complet sur ATL (ATLAS Transformation Language) : introduction aux règles ATL

Dans l'article précédent :

nous avion abordé les helpers ATL. Voyons à présent une introduction aux règles ATL.

Introduction aux règles ATL

Dans le langage ATL language, la génération du modèle cible est réalisée grâce aux spécifications des règles de transformation.

ATL défini 2 types de règles de transformation : les règles de correspondance (« matched ») et les règles appelées (« called »).

Une règle de correspondance permet de faire correspondre certain éléments du modèle source et de générer à partir de ces éléments certains éléments du modèle cible.

A l’opposé des règles de correspondance , les règles appelées doivent être invoquées à partir d’un bloc impératif ATL pour être exécutés. Le code impératif ATL peut être défine soit dans un bloc “action” d’une règle de correspondance soit dans le corps d’une règle appelée

"On n'est vieux que le jour où on le décide."
Jean Anouilh

Voir aussi :

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

06/10/2015

0 J'aime 0 Poster un commentaire

Cours complet sur ATL (ATLAS Transformation Language) : les helpers

Dans l'article précédent :

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

               else

               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 :

https://www.urbanisation-si.com/cours-complet-sur-atl-atlas-transformation-language-les-expressions-declaratives-dans-ocl-atl

05/10/2015

0 J'aime 3 Poster un commentaire

Cours complet sur ATL (ATLAS Transformation Language) : quelques trucs et astuces sur les expressions

Dans l'article précédent :

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

Quelques trucs et astuces sur les expressions

Les langages issus de la grande famille du “C” (C++, Java, C#, JavaScript, …), possèdent un optimiseur d’expression booléenne. Par exemple l’évaluation s’arrête quand le 1er membre est vrai et l’opérateur suivant est un or ou bien encore quand le 1er membre est false et que l’opérateur est un and.

Ce n’est pas la cas dans OCL. Toutes les expressions seront entièrement évaluées.

Parconséquent certaines expressions à priori correctes généreront une erreur dans ATL !

Exemples :

not person.oclIsUndefined() and person.name = 'Isabel'

Cette expression génère bien une erreur dans ATL dans le cas ou person n’est pas défini, une erreur est générée à l’évaluation de person.name.

Pour être certain de n’avoir aucune erreur :

if person.oclIsUndefined()

then

        false

else

        person.name = 'Isabel'

endif

Idem avec un or :

person.oclIsUndefined() or person.name = 'Isabel'

Pour être à l’abri d’erreurs comme précédemment :

if person.oclIsUndefined()

then

        true

else

        person.name = 'Isabel'

endif

Autre exemple :

collection->select(person | not person.oclIsUndefined() and person.name = 'Isabel')

La bonne solution pour être tranquille :

collection->select(person |

        if person.oclIsUndefined()

        then

               false

        else

               person.name = 'Isabel'

        endif

Plusieurs solutions existent, en voici une 2ème :

collection

        ->select(person | not person.oclIsUndefined())

        ->select(person | person.name = 'Isabel')

En terme de performance la 1ère solution est préférable à la 2ème car l’itération sur la collection est effectuée qu’une seule fois.

"Faites ce que vous aimez, pensez ce que vous ressentez et vivez de la façon dont vous voulez."
Santosh Kalwar

Voir aussi :

https://www.urbanisation-si.com/cours-complet-sur-atl-atlas-transformation-language-les-elements-de-modeles-des-metamodeles

03/10/2015

0 J'aime 0 Poster un commentaire

Cours complet sur ATL (ATLAS Transformation Language) : Les expressions déclaratives dans OCL / ATL

Dans l'article précédent :

nous avion abordé les énumérations ATL. Voyons à présent les les expressions déclaratives dans OCL / ATL.

Les expressions déclaratives dans OCL

Il existe dans OCL 2 instructions de contrôle : if et let

Le « if »

Il s’agit du if que l’on trouve dans tous les langages de programmation.

ATTENTION le else est obligatoire :

if condition
then
   exp1
else
   exp2
endif

Je ne vous ferais l’affront de vous expliquez comment ça marche, même les apprentis geek de 10 ans savent ce que c’est qu’un if.

Un petit exemple juste pour la forme :

if 3 > 2

then

        'three is greater than two'

else

        'this case should never occur'

endif

if mySequence->notEmpty()

then

        if mySequence->includes(myElement)

        then

               'the element is at position '

               + mySequence->indexOf(myElement).toString()

        else

               'the sequence does not contain the element'

        endif

else

        'the sequence is empty'

endif

L’expression « let »

Elle permet de définir une variable :

let var_name : var_type = var_init_exp in exp

Exemples :

let a : Integer = 1 in a + 1

let x : Real =

        if aNumber > 0

        then

               aNumber.sqrt()

        else

               aNumber.square()

        endif

in let y : Real = 2 in x/y

Une variable OCL est visible à partir de sa déclaration jusqu’à la fin de l’expression OCL à laquelle elle appartient.

ATTENTION : il n’est pas conseillé qu’un développeur déclare plusieurs varaibles avec le même nom à l’intérieur d’une expression. Si tel était le cas, la dernière masquerait toutes les autres.

Très utile pour déboguer, par exemple dans l’espression suivante, si la la collection est vide, l’opération first() renvoie la valeur OclUndefined. L’opération square() invoquée sur OclUndefined,va renvoyer une erreur au runtime. Donc dans ce cas il est intéressant pour pouvoir le verifier de stocker le 1^er element de la séquence dans une variable.

aSequence->first().square()

let firstElt : Real = aSequence->first() in firstElt.square()

"Pour différentes raisons, la plupart des gens sont tellement pris par leur quotidien qu'ils n'ont pas le temps de s'étonner de la vie."
Jostein Gaarder

Voir aussi :

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

02/10/2015

0 J'aime 0 Poster un commentaire

Cours complet sur ATL (ATLAS Transformation Language) : les éléments de modèles des métamodèles

Dans l'article précédent :

nous avion abordé les énumérations ATL. Voyons à présent les types des éléments du modèle.

Les types des éléments du modèle

Il s’agit des types ou classes des métamodèles source et cible.

Dans ATL, une variable d’un élément de modèle est référencée par metamodel!class où metamodel identifie un des métamodèles gérés par la transformation, et où class pointe sur un élément de modèle (classe) de ce métamodèle.

La notation OCL ne précise pas le métamodèle contrairement à ATL qui gère plusieurs métamodèles en même temps.

Un élément de modèle possède des propriétés qui sont des attributs et des références. Les 2 sont accessibles avec la notation « point » self.propriete.

Exemple : dans le contexte du métamodèle MMAuthor, anAuthor.name permet d’accéder à l’attribut name de l’instance anAuthor de la classe Author class.

Dans ATL, un élément de modèle ne peut être généré que dans une règle ATL (matched ou called rules). L’initialisation d’un nouvel élément de modèle se fait avec les règles de correspondance avec le modèle cible.

L’opération oclIsUndefined(), definie dans le type OclAny, teste si la valeur d’une expression est indefinite. Cette opération est utile lorqu’un attribut à une multiplicité 0..1 (void ou non). Les attributs avec la multiplicité * sont représentés par une collection vide ou non.

Nom complet pour référencer une classe du métamodèle

<Package1Name>::<Package2Name>::<ClassifierName>

Comme le parseur ATL ne supporte pas le "::", on doit ajouter des ".

MM!"P1::C1"

MM!"P1::P2::C2"

MM!"P3::C3"

Cas ou cette notation est obligatoire :

package P1 {

  class C1 {}

  package P2 {

    class C1 {}

package P3 {

  class C1 {}

MM!C1 n’est pas correct car il y a ambiguité. Un avertissement est généré dans la console. L’expression correcte est la suivante :

MM!"P1::C1"

MM!"P1::P2::C1"

MM!"P3::C1"

Exemples

Voici des exemples d’expression d’OCL utilisant des propriétés d’éléments de modèle. Ils sont définis dans le context du MOF métamodèlele :

Récupérer toutes les classes du MOF :

MOF!Class.allInstances()->collect(e | e.name)

Récupérer tous les types primitifs du MOF :

MOF!DataType.allInstances()

       ->select(e | e.oclIsTypeOf(MOF!PrimitiveType))

       ->collect(e| e.name)

La même chose mais en plus simple (mais pourquoi faire simple quand on peut faire compliquer ? ) :

MOF!PrimitiveType.allInstances()->collect(e| e.name)

Une énumaration du MOF :

MOF!VisibilityKind.labels

Récupérer le nom de toutes les classes qui héritent de plus d’une classe :

MOF!Class.allInstances()

       ->select(e | e.supertypes->size() > 1)

       ->collect(e | e.name)

Les commentaires ATL

Exemples :

-- this is an example of a comment

Pour specifier la documentation des ATL helpers et règles qui apparaissent dans l’aide automatique :

--- Evaluates whether the context has the given stereotype or not.

helper context UML!Element def: hasStereotype(stereotype : String) : Boolean =

        self.getAppliedStereotypes() -> collect(st | st.name) -> includes(stereotype);

"C'est quand on serre une femme de trop près qu'elle trouve qu'on va trop loin."
Alphonse Allais

Voir aussi :

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

02/10/2015

0 J'aime 0 Poster un commentaire

Cours complet sur ATL (ATLAS Transformation Language) : les tuples

Dans l'article précédent :

nous avion abordé les énumérations ATL. Voyons à présent les tuples.

Le type tuple

Le type tuple permet de mettre plusieurs valeurs dans une seule variable.

Un tuple est constitué de champs nommés pouvant avoir des types différents.

ATTENTION : un tuple type n’est pas nommé, donc à chaque fois que l’on doit l’identifier, il faut mentionner sa déclaration au complet !

La declaration d’un tuple :

TupleType(var_name1 : var_type1, ..., var_nameN : var_typeN)

L’ordre de declaration n’est pas significatif.

Exemple de déclaration :

TupleType(a : MMAuthor!Author, title : String, editor : String)

L’instanciation d’une variable tuple :

Tuple{var_name1 [: var_type1]? = init_exp1, ..., var_namen [: var_typen]? = init_expn}

Les 2 instanciations de tuple suivantes sont équivalentes :

Tuple{editeur : String = 'www.urbanisation-si.com', titre : String = 'Cours complet ATL', a : MMAuthor!Author = unAuteur}

Tuple{titre = 'Cours complet ATL', a = unAuteur, editeur = 'www.urbanisation-si.com'}

Pour accéder à un memebre du tuple :

Tuple{titre = 'Cours complet ATL', a = unAuteur, editeur = 'www.urbanisation-si.com'}.titre

Le type tuple possède une operation asMap() renvoyant une map dans laquelle les noms des champs du tuple sont associés avec leurs valeurs respectives.

Le type Map

Ce type a été ajouté dans ATL et n’existe pas dans OCL. Il est identique à la classe Map de Java. Chaque valeur est associée à une unique clé d’accès.

La declaration suit la syntaxe suivante :

Map(key_type, value_type)

Comme pour le tuple, un type map n’est pas nommé, ce qui oblige à répêter la declaration complete à chaque que l’on veut y faire référence.

Map(Integer, MMAuthor!Author)

L’instantiating suit la syntaxe :

Map{(key1, value1), ..., (keyn, valuen)}

Exemple :

Map{(0, anAuthor1), (1, anAuthor2)}

Le type map possède les operations suivantes :

get(key : oclAny) renvoie la valeur associée à key (ou OclUndefined si key n’est pas une clé de self);
including(key : oclAny, val : oclAny) renvoie une copie de self dans laquelle le couple ( key, val) a été inséré à la condition que key ne soit pas déjà une clé de self
union(m : Map) renvoie une map contenant tous les éléments de self auxquels sont ajoutés les éléments de m à condition que leurs clés n’existent pas dans self
getKeys() renvoie un set contenant toutes les clés de self
getValues()renvoie un bag contenant toutes les valeurs de self

Une robe de femme, doit être comme une plaidoirie : assez longue pour couvrir le sujet, assez courte pour être suivie.

Voir aussi :

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

30/09/2015

0 J'aime 0 Poster un commentaire

Cours complet sur ATL (ATLAS Transformation Language) : les énumérations

Dans l'article précédent :

nous avion abordé de manière extrêmement détaillée les collections ATL.

Après les collections, viennent bien sur les énumérations.

Le type Enumeration

Comme dans tous les langages (C, C++, Java, C#, …) on trouve dans ATL le type énumeration (OclType).

Il doit être défini dans les métamodèles source et cible.

En OCL, pour accéder aux valeurs d’une énumeration "Gender" définissant 2 valeurs male et female, la syntaxe est la suivante : Gender::female

ATTENTION en ATL, il suffit de faire : #female. (le nom de l’énumération n’est pas requis).

Une énumération ne contient aucune opération.

"Les politiques grecs ne reconnaissent d'autre force que celle de la vertu. Ceux d'aujourd'hui ne vous parlent que de manufactures, de commerce, de finances, de richesses et de luxe même."
Montesquieu

Voir aussi :