4.3 Typage
4.3.2 Définition des types
Le typage facilite la manipulation des éléments d’un diagramme de classes UML lors de la définition de correspondances. Le langage Malan possède ainsi six types différents :
Types primitifs. Les entiers, les flottants, les chaînes de caractères et les booléens sont des types sémantiquement équivalents à ceux du langage Java. Des variables de ces types peuvent être déclarées dans une fonction en utilisant, respectivement, les mots-clés int, float, string et bool. La sémantique des opérations autorisées sur les types primitifs est définie dans l’annexe A.2.
Classe. Une classe est un type utilisable dans le code d’une correspondance de schémas. Par exemple, la fonction suivante possède un paramètre de type Billet issu du diagramme source : 1 function i n t c a l c u l e r P o s i t i o n Y ( B i l l e t b , i n t supp ) {
2 return ( p o s i t i o n ( b)−1)∗130+30+ supp ;
3 }
La notion d’héritage est représentée en utilisant l’opération de sous-typage : soient A et B deux classes, tel que A hérite de B, alors A B.
4.3 Typage
Malan n’autorise pas l’instanciation d’une classe issue d’un diagramme source ou cible. Par exemple, il n’est pas possible de déclarer et d’instancier une variable de type Billet de la manière suivante : Billet b = new Billet(). Ce choix se justifie par le fait que Malan est un langage de correspondance permettant la navigation dans les schémas source et cible mis en relation. L’instanciation des objets cibles, conforment au schéma cible, est effectuée par l’implémentation des correspondances.
Liste. Une liste est un ensemble ordonné d’objets de même type. Elle est notamment utilisée pour représenter les relations, de cardinalité 0..n ou 1..n, d’un diagramme de classes. Une liste peut être elle-même typée à la manière des « generics » en Java ; le type de la relation billets de la classe Blog (figure 5.1, page 64) est list<Billet>, où <Billet> stipule que la liste ne contient que des objets de type Billet. Une liste se déclare comme suit :
1 " l i s t " (" <" TYPE " > " )? ID
où TYPE correspond au type des éléments de la liste et ID à son nom. Il est possible de réaliser des opérations ensemblistes sur des variables de type list, dont les principales sont :
– la concaténation ; il est possible de concaténer deux listes (de même type si celui-ci est spécifié) :
Γ ` e1 : list < τ > Γ ` e2 : list < τ >
Γ ` e1+ e2 : list < τ > (4.8)
– L’insertion d’un objet (de même type que celui de la liste si ce dernier est spécifié) au début ou à la fin d’une liste est également possible :
Γ ` e1 : τ Γ ` e2 : list < τ >
Γ ` e1+ e2 : list < τ > (4.9)
Γ ` e1: list < τ > Γ ` e2 : τ
Γ ` e1+ e2 : list < τ > (4.10)
– La suppression d’un élément dans une liste ainsi que la suppression, dans une liste, des éléments d’une autre liste s’effectue de la manière suivante :
Γ ` e1: list < τ > Γ ` e2 : τ
Γ ` e1− e2 : list < τ > (4.11)
Γ ` e1 : list < τ > Γ ` e2 : list < τ >
Γ ` e1− e2 : list < τ > (4.12)
Les listes dont le type de leurs objets n’est pas précisé se déclarent simplement list. De plus, la syntaxe concrète visant à obtenir la cardinalité d’une liste l s’obtient via l’utilisation de l’opérateur |l|, dont la sémantique est décrite par la formule 4.13. La syntaxe abstraite de cet opérateur, utilisée dans les formules de ce chapitre, est la suivante : #{l}.
Γ ` exp : ω ω list
Γ ` |exp| : int (4.13)
L’accès aux éléments d’une liste s’effectue à l’aide d’un indice définissant la position de l’élément ciblé en respectant le format suivant :
1 LISTE_SELECTION = ID " [ " EXP_ARITHMETIQUE " ] "
où ID correspond au nom de la liste et EXP_ARITHMETIQUE à l’indice. Pour illustrer ce prin-cipe, prenons les exemples suivants :
– billets[i] retourne le ième billet de la liste, avec i ∈ [1; |billets|] ; – billets[1], sélectionne le premier billet de la composition billets ; – billets[|billets|], sélectionne le dernier billet.
La formule 4.14 définit la sémantique de ce type d’expression.
Γ ` exp : ω Γ ` exp0 : int ω list < τ >
Γ ` exp[exp0] : τ (4.14)
Il est également possible de sélectionner des éléments d’une liste, dans un intervalle donné, en respectant la grammaire suivante et en se basant sur la notion de sélection dans une liste expliquée précédemment.
1 INTERVALLE = " , " ID "=" EXP_ARITHMETIQUE " . . " EXP_ARITHMETIQUE
Les deux EXP_ARITHMETIQUE de la grammaire ci-dessus définissent l’intervalle représenté par la variable ID. Expliquons ce principe par des exemples :
– billets[i], i=1..|billets|, sélectionne tous les billets ;
– billets[i], i=|billets|..1, sélectionne tous les billets mais dans le sens inverse ; – billets[j], j=1..|billets|/2, sélectionne la première moitié des billets ;
– si l’ordre n’a pas d’importance, il est possible d’écrire directement billets qui est séman-tiquement équivalent à billets[i], i=1..|billets|.
La définition de l’intervalle doit toujours se placer en fin d’instruction, comme l’illustre l’ins-truction suivante :
1 b i l l e t s [ i ] −> gg [ i ] , i = 1 . . | b i l l e t s |
Tout attribut d’une classe dont la cardinalité maximale est supérieure à 1 est considéré comme une liste et possède, par conséquent, les mêmes propriétés.
Il est également possible de sélectionner seulement certains éléments d’une liste en fonction de critères. Cette sélection par motif s’utilise de la même manière que la navigation dans une liste à la différence qu’une expression booléenne remplace l’expression arithmétique :
1 LISTE_MOTIF = ID " [ " EXP_BOOLEENNE " ] "
Le résultat d’une sélection par motif est une autre liste contenant les éléments correspondant au motif, comme le définit la formule 4.15.
Γ ` exp : list < ω > Γ ` exp0 : bool
Γ ` exp[exp0] : list < ω > (4.15)
Prenons par exemple une classe A’ héritant de la classe A et une liste l de type list<A>. L’expression l[is A’] sélectionne les éléments de l dont le type est A’. De même, l’expression billets[auteur.nom=="Arnaud"] ne sélectionne que les billets dont l’auteur est Arnaud.
Concernant les relations dont la cardinalité maximale est supérieure à 1, nous les définissons comme étant un type ρ tel que ρ < τ > list < τ >, où ρ < τ > définit une relation liée à une
4.4 Conclusion
classe cible τ . Dire qu’une relation est un sous-type d’une liste permet de l’utiliser comme s’il s’agissait d’une liste.
Forçage de type
Malan autorise le forçage de type à condition qu’une relation de sous-typage existe entre les deux types concernés, comme le stipule la formule 4.16.
Γ ` type : β Γ ` exp : β0 β0 β
Γ ` (type)exp : β (4.16)
D’un point de vue syntaxique, le forçage de type proposé par Malan est similaire à celui du langage Java : dans une correspondance, tout comme dans une fonction, le forçage d’un type vers un autre s’effectue en précédant l’expression à forcer par le type final :
1 FORCAGE_TYPE = (TYPE)EXPRESSION 2 TYPE = ID ( " . " ID ) ∗
Par exemple, L’instruction alias titre (Text)g.elements[1], de la figure 5.2, force l’ex-pression g.elements[1] à être du type Text au lieu de Element.
4.4 Conclusion
Ce premier chapitre présente le modèle de données du langage de correspondance Malan. Dans un premier temps, le choix de travailler au niveau des schémas et d’utiliser le diagramme de classes pour les représenter a été discuté. Dans un deuxième temps, le typage du langage Malan a été décrit de manière formelle.
Ce modèle de données constitue la base sur laquelle le modèle de correspondance du langage Malan se repose. Le typage statique proposé permet aux instructions des correspondances de classes d’utiliser et de naviguer dans les classes sources et cibles. Le travail au niveau des schémas assure, quant à lui, la validité des données manipulées et l’indépendance envers les plates-formes de données.
Le chapitre suivant complète la présentation du langage Malan en décrivant son modèle de correspondance.
Chapitre 5
Modèle de correspondance du
langage Malan
Sommaire 5.1 Introduction . . . . 63 5.2 Caractéristiques du langage . . . . 63 5.3 Exemple . . . . 64 5.4 Correspondance de schémas . . . . 66 5.4.1 Principe et syntaxe . . . . 66 5.4.2 Paramètre . . . . 66 5.5 Correspondance de classes . . . . 67 5.5.1 Principe et syntaxe . . . . 67 5.5.2 Alias . . . . 68 5.5.3 Navigation . . . . 69 5.5.4 Dépendance d’une correspondance de classes . . . . 72 5.5.5 Filtrage par motif . . . . 73 5.6 Instruction . . . . 73 5.6.1 Regroupement d’instructions . . . . 73 5.6.2 Correspondance de relations et d’attributs . . . . 75 5.6.3 Instruction conditionnelle . . . . 77 5.7 Fonction . . . . 78 5.8 Synthèse . . . . 795.9 Contraintes de validité d’une correspondance de schémas . . . . 79
5.10 Discussion sur différents critères d’évaluation . . . . 82
5.11 Exécution des correspondances de schémas . . . . 84
5.11.1 Ordonnancement des correspondances de classes . . . . 84 5.11.2 Génération de transformations via Malan . . . . 84 5.11.3 Implémentation des correspondances de schémas Malan . . . . 85 5.12 Conclusion . . . . 86
5.1 Introduction
5.1 Introduction
Ce chapitre présente le modèle de correspondance du langage Malan. Il spécifie comment les éléments des schémas source et cible peuvent être mis en relation. Ce modèle de correspondance se fonde sur le modèle de données défini dans le chapitre précédent. Les critères recensés qu’un modèle de correspondance doit respecter afin de pouvoir répondre au problème du lien « données-présentation » sont les suivants :
1. Manipulation des données sources. Lorsque des éléments sont mis en relation, il doit être possible de traiter les données sources concernées pour, par exemple, changer le format d’une valeur (p. ex., conversion en degré d’un angle initialement défini en radian). Ce critère n’est cependant pas spécifique à un langage de correspondance.
2. Calcul des données cibles, dont le « layout ». Travaillant au niveau de l’interface d’un SI, le modèle de correspondance doit être capable de calculer la disposition d’éléments de celle-ci.
3. Lien actif entre les données sources et cibles. Toute modification de la source doit pro-voquer automatiquement une mise à jour de la cible. Ce critère concerne essentiellement l’implémentation du langage même si ce dernier doit être conçu dans cette optique.
Ce chapitre s’organise de la manière suivante : la section 5.2 présente les caractéristiques géné-rales du langage Malan ; la section 5.3 introduit l’exemple utilisé tout au long de ce chapitre ; les sections 5.4, 5.5, 5.6 et 5.7 décrivent le cœur du modèle de correspondance, respectivement, les correspondances de schémas, les correspondances de classes, les instructions et les fonctions ; la section 5.8 présente le métamodèle de Malan ; la section 5.9 décrit les contraintes de validité d’une correspondance de schémas ; la section 5.10 est une discussion relative à l’évaluation du langage ; la section 5.11 présente les différents cas d’utilisation du langage Malan.