urbanisation-si.com

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 :

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

30/09/2015

0 J'aime 0 Poster un commentaire

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

Dans l'article précédent :

nous avion abordé de manière quick and dirty les types primitifs ATL.

La suite logique est de voir les collections, qui sont en fait les 4 collections définies dans OCL :

Set : sans doublon et non ordonnée
OrderedSet : sans doublon et ordonnée
Bag : avec doublon possible et non ordonnée
Sequence : avec doublon possible et ordonnée

Opérations sur les collection

size() renvoie le nombre d'éléments de la collection self
includes(o : oclAny) renvoie un booléen si l'objet o fait partie de la collection self
excludes(o : oclAny) renvoie un booléen si l'objet o ne fait pas partie de la collection self
count(o : oclAny) renvoie le nombre de fois ou l'objet o apparaît dans la collection self
includesAll(c : Collection) renvoie un booléen si tous les objets de la collection c sont contenus dans la collection self
excludesAll(c : Collection) renvoie un booléen si aucun des objets de la collection c sont contenus dans la collection self
isEmpty() renvoie un booléen si la collection self est vide
notEmpty() renvoie un booléen si la collection self n'est pas vide
sum() renvoie une valeur correspondant à l'addition de tous les éléments de la collection self. Les types des éléments doivent être supportés par l'opérateur +

ATL défini des opérations supplémentaires par rapport à OCL :

asBag() renvoie un bag contenant tous les éléments de la collection self.
asSequence() renvoie une sequence contenant tous les éléments de la collection self en introduisant un ordre pour un bag ou un set.
asSet() renvoie un set contenant tous les éléments de la collection self en perdant l’ordre pour un sequence ou un orderedset.Les doublons d’un bag ou d’une sequence sont éliminés.

Les opérations sur les séquences

union(c : Collection) renvoie une séquence composée de tous les éléments de self suivi de ceux de c
flatten() renvoie une séquence contenant le fils de la collection interne contenu dans self
append(o : oclAny) renvoie une copie de self avec les éléments de o ajoutés à la fin de la séquence
prepend(o : oclAny) renvoie une copie de self avec les éléments de o ajoutés au début de la séquence
insertAt(n : Integer, o : oclAny), renvoie une copie de self avec les éléments de o ajoutésau rang nde la séquence
subSequence(lower : Integer, upper : Integer) une sous séquence de self commençant à lower jusqu’à upper (tous les 2 inclus)
at(n : Integer) renvoie l’élément du rang n de self
indexOf(o : oclAny) renvoie le rang de la 1^ère occurrence de o dans self
first() renvoie le rang de la 1^er élément de self (oclUndefined si self est vide);
last()renvoie le rang de la dernier élément de self (oclUndefined si self est vide);
including(o : oclAny) renvoie une copie de self avec les éléments de o ajoutés à la fin de la séquence
excluding(o : oclAny) renvoie une copie de self avec toutes les occurrences de l’élément o supprimées.

Les opérations sur le type Set

union(c : Collection) renvoie un set composé des éléments de self et de c avec les doublons
intersection(c : Collection) renvoie un set composé des éléments qui apparaissent à la fois dans self et dans c
operator - (s : Set) renvoie un set composé des éléments de self qui ne sont pas dans s
including(o : oclAny), renvoie une copie de self avec les éléments de o s’ils ne sont pas présent dans self
excluding(o : oclAny), renvoie une copie de self avec les éléments de o supprimés du set
symetricDifference(s : Set) renvoie un set composé des éléments de self ou de s mais des 2

Les opérations sur le type OrderedSet

append(o : oclAny) renvoie une copie de self avec l’élément o ajouté à la fin s’il n’existait pas déjà dans self
prepend(o : oclAny) renvoie une copie de self avec l’élément o ajouté au début de l’orderedset s’il n’existait pas déjà dans self
insertAt(n : Integer, o : oclAny), renvoie une copie de self avec l’élément o ajouté au rang n de l’orderedset s’il n’existait pas déjà dans self
subOrderedSet (lower : Integer, upper : Integer) renvoie une sous séquence de self commençant au rang lower et finissant au rang upper (les 2 inclus)
at(n : Integer) renvoie l’élément du rang n de self
indexOf(o : oclAny) renvoie le rang de la 1^ère occurrence de o dans self
first()renvoie le 1^er élément de self (oclUndefined si self est vide)
last()renvoie le dernier élément de self (oclUndefined si self est vide)
union(c : Collection) renvoie un orderedset composé des elements de self suivis des elements de c avec les doublons supprimés, ils apparaissent entre c et self
flatten()renvoie un orderedset contenant directement le fils de la collection interne à la collection contenant self
including(o : oclAny) renvoie une copie de self avec l’élément o ajouté à la fin de l’orderedset s’il n’apparaît pas déjà dans self
excluding(o : oclAny) renvoie une copie de self avec l’élément o supprimé

Les opérations sur le type Bag

including(o : oclAny) renvoie une copie de self avec l’élément o ajouté à la fin de l’orderedset s’il n’apparaît pas déjà dans self
excluding(o : oclAny) renvoie une copie de self avec l’élément o supprimé
flatten()renvoie un orderedset contenant directement le fils de la collection interne à la collection contenant self

Itérer sur les collections

La principale difference entre une operation classique et une expression iterative sur les collections est que l’itérateur accepte une expression comme parameter.

La collection itérée est celle dont on fait reference comme source
Les variables d’itération déclarées dont on fait référence comme itérateurs
L’expression passée comme parameter de l’opération dont on fait reference dans le corps de l’itérateur

source->operation_name(iterators | body)

ATL supporte les expression itératives suivantes

exists(body) renvoie une valeur booléenne suivant qu’il existe au moins un élément de source dans le body
forAll(body) renvoie une valeur booléenne suivant que body est évalué à vrai pour tous les éléments de source
isUnique(body) renvoie une valeur booléenne suivant que body est évalué à une valeur différente pour chaque élément de source
any(body) renvoie un élément de source pour laquelle body est évalué à vrai. Si body n’est jamais évalué à vrai, l’opération renvoie OclUndefined;
one(body) renvoie une valeur booléenne s’il existe exactement un élément de source pour laquelle body est évalué à vrai
collect(body) renvoie une collection d’éléments resultant de l’application de body à chaque élément de la collection source
select(body) renvoie un sous ensemble de la collection source pour laquelle body est évalué à vrai
reject(body) renvoie un sous ensemble de la collection source pour laquelle body est évalué à faux (équivalent à select(not body));
sortedBy(body) renvoie une collection ordonnée suivant body à partir de la plus petite valeur jusqu’à la plus grande. Les éléments de la collection source doivent avoir l’opérateur < défini

OCL spécifie un itérateur encore plus générique appelé iterate() dont l’expression posséde un iterator, un accumulator et un body. L’accumulator correspond à une variable initialiée. Le body est une expression qui utilise iterator et accumulator. La valeur renvoyée par iterate() correspond à la valeur de la variable accumulator une fois que la dernière iteration s’est exécutée.

source->iterate(iterator; variable_declaration = init_exp |

body

)

Exemples

declaration d’une sequence d’entiers : Sequence(Integer)
une sequence d’entiers : Sequence{1, 2, 3}
declaration d’un ensemble de sequence de String : Set(Sequence(String))
un ensemble de sequence de String : Set{Sequence{'monday'}, Sequence{'march', 'april', 'may'}}
test si un bag est vide : Bag{1, 2, 3}->isEmpty()
1. false
2. Set{1, 2, 3}->includes(1)
  1. true
3. Set{1, 2, 3}->includesAll(Set{3, 2})
  1. true
4. Sequence{1, 2, 3}->size()
  1. 3
  2. ATTENTION : Set{3, 3, 3}->size() est évalué à 1 car un set élimine les doublons
5. OrderedSet{1, 2, 3}->first()
  1. 1
6. Sequence{1, 2, 3}->union(Sequence{7, 3, 5})
  1. Sequence{1, 2, 3, 7, 3, 5}
7. Set{1, 2, 3}->union(Set{7, 3, 5})
  1. Set{1, 2, 3, 7}
8. Sequence{Sequence{1, 2}, Sequence{3, 5, 2}, Sequence{1}}->flatten()
  1. Sequence{1, 2, 3, 5, 2, 1}
9. Sequence{Sequence{1, 2}, Sequence{3, 5, 2}, Sequence{1}}->subSequence(2, 3)
  1. Sequence{ Sequence{3, 5, 2}, Sequence{1}}
10. Sequence{5, 15, 20}->insertAt(2, 10)
  1. Sequence{5, 10, 15, 20}
11. Set{1, 2, 3}->intersection(Set{7, 3, 5})
  1. Set{3}
12. Set{1, 2, 3}->symetricDifference(Set{7, 3, 5})
  1. Set{1, 2, 7, 5}
13. Sequence{1, 2, 3, 4, 5, 6}->select(i | i <= 3)
  1. Set{1, 2, 3}
14. Récupérer tous les noms des classes du MOF : MOF!Class.allInstances()->collect(e | e.name)
15. Vérifier que tous les éléments d’une séquence sont plus grand que 2 : Sequence{12, 13, 12}->forAll(i | i > 2)
  1. true
16. Vérifier s’il y a un unique élément d’une séquence plus grand que 2 : Sequence{12, 13, 12}->one(i | i > 2)
  1. false
17. Vérifier s’il existe un nombre dans la séquence plus grand que 2 : Sequence{12, 13, 12}->exists(i | i > 2)
  1. evaluates to true
18. Sequence{8, -1, 2, 2, -3}->iterate(e; res : Integer = 0 |
  if e > 0
  then res + e
  else res
  endif
  )
  1. 12;
  2. équivalent à Sequence{8, -1, 2, 2, -3}->select(e | e > 0)->sum()

"Si mon esprit peut le concevoir, et mon cœur peut le croire, alors je peux le réaliser."
Muhammad Ali

Voir aussi :