Manipulation de modèles

G. Halin

Introduction

• Les modèles deviennent des données d’un programme :

– Document XML : format XMI
– Objet : définition d’interface
• MOF to IDL : norme CORBA
• JMI : Java Metadata Interface
• EMF : Eclipse Modeling Framework
• Méthode :
– Ecrire des applications utilisant les interfaces
• Objectifs :
– Transformation de modèles
• PIM -> PSM, génération de code
• Passage d’un modèle à un autre
 Les concepts
• Deux types d’interfaces
– Taylored : définie spécifiquement
pour un modèle donné
• « taillée sur mesure »
• Offre des opérations permettant
de parcourir les modèles
instances d’un métamodèle
– Réflectives : utilisable sur tout
type de modèle
• Offre des opérations
indépendantes des modèles
• Permettent d’avoir des
informations sur le métamodèle
• Démarche des standards
– Définition d’interfaces taylored à
partir d’un métamodèle
– Les interfaces taylored héritant
des interfaces réflectives
[Blanc 05]

Exemple d’utilisation
• Taylored : un modèle m
– Nombre d’acteurs de m ?
– Ajouter ou supprimer un acteur à m.
– Liste des cas d’utilisations auxquels
participe l’acteur « internaute »
• Réflective :
– Le nom de la métaclasse système ?
– Quelles sont ses méta-associations ?
– Quels sont ses méta=attributs ?

instanciation

m
 JMI (Java Metadata Interface)
• Standard du JCP (Java Community
Process) de Sun
• Métamétamodèle repose sur le MOF
1.4

• RefBaseObject : Représente
n’importe quel élément d’un modèle ou
d’un métamodèle.
– refMetaObject() retourne la
métaclasse de l’élément.
– La métaclasse retournée est de type
RefObject.
– permet d’obtenir la métaclasse d’une
métaclasse et ainsi de remonter tous
les niveaux méta

• RefFeatured : contient toutes les

opérations permettant d’accéder aux
propriétés d’un élément (attributs,
référence et opération)
– refGetValue() et refSetValue()
permettent de lire et d’écrire les
valeurs d’une propriété.

JMI (Java Metadata Interface)

• RefClass : représente la notion de
factory
– Une usine qui permet de construire les
instances des métaclasses.

• RefObject : représente la notion d’un

élément instance d’une métaclasse.
– refIsInstance() permet de savoir si
l’élément est bien l’instance d’une
factory particulière.

• RefAssociation : représente la notion

de liens entre éléments.
– refAddLink() et refRemoveLink()
permettent l’ajout et la suppression des
liens entre éléments.

• RefPackage : représente la notion de

package
– refGetClass() permet d’obtenir les
métaclasses
 JMI : Génération d’interface taylored

• Génération à partir d’un métamodèle MOF

• Règles de génération
– Métaclasse
• Création de deux interfaces
– Instance : implémentée par les objets gérant les instances
» Hérite de RefObject
» Nom : nom_métaclasse
» Opérations de lecture et d’écriture des méta-attributs
» Opérations de navigation dans les métaréférences
– Factory : création des instances
» Hérite de RefClass
» Nom : nom_métaclasseClass
» Opérations de création des instances

JMI : Génération d’interface taylored

• Règles de génération (suite)

– Méta-association
• Création d’une interface
» Hérite de RefAssociation
» Nom : nom_méta-association
» Opérations de création d’instances (lien entre instances)
» Opérations de navigation sur les liens
– Métapaquetage
• Création d’une interface
» Hérite de RefPackage
» Nom : nom_PaquetagePackage
» Opérations permettant d’obtenir toutes les interfaces Factory des
métaclasses du paquetage
» Opérations permettant d’obtenir toutes les interfaces des méta-
associations du paquetage
 JMI : exemple de génération

• Le standard ne définit que des interfaces

• Utiliser des plateformes qui implémentent ces interfaces
– Netbean : http://mdr.netbeans.org
– Modfact : http://modfact.lip6.fr
• Exemple : un méta-modèle :

JMI : exemple de génération

• Les interfaces taylored (avec modfact)
1. Sauvegarde du métamodèle en XMI
2. Génération automatique des interfaces (TP) :

Interface de la méta-association

Interface Instance de la métaclasse

Catalogue
Interface Factory de la métaclasse Catalogue

Interface Instance métaclasse Livre

Interface Factory métaclasse Livre

Interface du métapaquetage Model

 JMI : Création d’un modèle
• Création d’un modèle à partir d’un métamodèle
1. Ecrire un programme Java utilisant les interfaces Taylored
2. Le sauvegarder en XMI
instanciation

ModelPackage pCat = ModelPackageImpl.create("metamodel_dtd.xml");

Catalogue cat = pCat.getCatalogue().createCatalogue("BiblioAcsi");

Livre l1 = pCat.getLivre().createLivre("Tout sur UML");

cat.getLivre().add(l1);

Livre l2 = pCat.getLivre().createLivre("Tout sur MOF");

cat.getLivre().add(l2);

XmiWriter writer = new XmiWriterImpl();

writer.write( new FileOutputStream("m1model.xml"), pCat ,"1.2");

JMI : Création d’un modèle

• Création d’un modèle à partir d’un métamodèle
1. Ecrire un programme Java utilisant les interfaces Réflective
2. Le sauvegarder en XMI
instanciation

…Création du m2 à partir du metamodel en XMI..

RefPackage m1 = RefPackageImpl.getM1Repository(m2);

RefObject cat = m1.refClass("Catalogue").refCreateInstance(null);

cat.refSetValue("nom","BiblioAcsi");

RefObject l1 = m1.refClass("Livre").refCreateInstance(null);
l1.refSetValue("titre","Tout sur UML");

RefObject l2 = m1.refClass("Livre").refCreateInstance(null);
l2.refSetValue("titre","Tout sur MOF");

Collection col = (Collection) cat.refGetValue("livre");

col.add(l1);
col.add(l2);

XmiWriter writer = new XmiWriterImpl();

writer.write( new FileOutputStream(« m1model.xml"), m1 ,"1.2");
 JMI : Création d’un modèle
• Le fichier xmi obtenu pour le m1

<?xml version="1.0" encoding="ISO-8859-1" ?> instanciation

<XMI xmi.version="1.2">
<XMI.header>
<XMI.documentation>
<XMI.exporter>ModFact</XMI.exporter>
<XMI.exporterVersion>1.0</XMI.exporterVersion>
</XMI.documentation>
</XMI.header>
<XMI.content>
<Catalogue xmi.id="0" nom="BiblioAcsi">
<Catalogue.livre>
<Livre xmi.id="1" titre="Tout sur UML" />
<Livre xmi.id="2" titre="Tout sur MOF" />
</Catalogue.livre>
</Catalogue>
</XMI.content>
</XMI>

EMF : Eclipse Modelling Framework

• Framework opensource basé sur
Eclipse
• Le métamétamodèle Ecore repose sur
le MOF 2.0 (EMOF sans meta-
association)
• Un métamodèle est composé de
Eclass contenant des EAttribute et des
EReference
• EObject :
– représente n’importe quel élément
d’un modèle ou à un métamodèle.
– eClass() renvoit l’EClass de
l’élément.
– eGet() et eSet() lire et écrire les
valeurs des différentes propriétés
de l’élément (attributs et
références).
 EMF : Eclipse Modelling Framework
• EClass:
– représente une métaclasse d’un
métamodèle.
– getEAttributes() et getEReferences()
renvoie la liste de tous les attributs et
références contenus dans la
métaclasse.
– getEStructuralFeature() permet
d’obtenir une propriété (attribut ou
référence) d’une EClass à partir de son
nom.

• EPackage
– moyen d’accès à toutes les EClass
définies dans un package.
– getEClassifier(String qname) récupérer
la référence d’une EClass d’un
métamodèle à partir de son nom.

• EFactory
– permet de créer des instances des
EClass définies dans un package.
– create() :créer une instance d’une
EClass.

EMF : Génération d’interfaces taylored

• Génération à partir d’un métamodèle Ecore
• Règles de génération
– Métaclasse (EClass)
• Création d’une interface
– Hérite de EObject
– Nom : nom_EClass
– Opérations de lecture et d’écriture pour chaque EAttribute
– Opérations de lecture et d’écriture pour chaque EReference
– Métapaquetage (EPackage)
• Création de deux interfaces
– Factory : création des instances
» Nom : nom_packageFactory
» Opérations de création pour chaque EClass de l’EPackage
» Hérite de EFactory
– Package : navigation entre les EClass de l’EPackage
» Nom : nom_packagePackage
» Opérations de navigation pour chaque EClass de l’EPackage
» Hérite de EPackage
 EMF : exemple de génération
• Les interfaces taylored (avec Eclipse)
1. Sauvegarde du métamodèle en .mdl (Rose)
2. Import du modèle dans Eclipse
3. Génération automatique des interfaces (TP) :

Interface de la métaclasse Catalogue

Interface de la métaclasse Livre

Interface Factory du métapaquetage Model

Interface Package du métapaquetage Model

EMF : Création d’un modèle

• Création d’un modèle à partir d’un métamodèle Ecore
1. Ecrire un programme Java utilisant les interfaces Taylored

instanciation

ModelFactory m1Fact = ModelFactory.eINSTANCE;

Catalogue cat = m1Fact.createCatalogue();

cat.setNom("BiblioAcsi");

Livre l1 = m1Fact.createLivre();
l1.setTitre("Tout sur UML");

Livre l2 = m1Fact.createLivre();
l2.setTitre("Tout sur MOF");

cat.getLivre().add(l1);
cat.getLivre().add(l1);
 Le Framework EMF

• Objectif : Faciliter la manipulation de modèle

• Génération à partir d’un méta-modèle d’un éditeur
graphique de modèle
– Un nœud représente une instance d’une métaclasse

<?xml version="1.0" encoding="UTF-8"?>

<model:Catalogue xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:model="http:///model.ecore" nom="BiblioAcsi">
<Livre titre="Tout sur UML"/>
<Livre titre="Tout sur MOF"/>
</model:Catalogue>

Les modèles en XML

• Standard XMI (XML Metadata Interchange)

• Standard DI (Diagram Interchange)
• Assure le stockage et l’échange de modèle
• Standard XML du W3C (World Wide Web Consortium)
• XML utilisable pour la transformation de modèle avec
XSLT (eXtensible Stylesheet Language Transformations)
• XML les notions à connaître
– Document bien formé, Document valide (DTD, Schema),
Namespace, XSLT, SVG
 XML : Document bien formé
• Document textuel structuré par un ensemble de paires de balises
(ouverte et fermée)
– Une balise ouvrante a la forme : <nom>
– Une balise fermante a la forme : </nom>
• Une balise ouvrante peut avoir des attributs
• Une paire de balise peut contenir :
– D’autres paires de balises
– Du texte
• L’ordre de fermeture des balises doit respecter l’ordre d’ouverture
• Exemple :

<Catalogue nom="BiblioAcsi">
<Livre titre="Tout sur UML"> </Livre>
<Livre titre="Tout sur MOF"> </Livre>
</Catalogue>

XML : document valide

• Un document XML valide doit être • DTD, Exemple
bien formé et respecter une <!ELEMENT Catalogue (Livre)* >
structuration bien définie <!ATTLIST Catalogue nom CDATA #REQUIRED>
<!ELEMENT Livre (#PCDATA) >
• Deux formes de structuration <!ATTLIST Livre titre CDATA #REQUIRED>
existent :
– DTD (Document Type Definition) • XML Schema, exemple
• Un document textuel à balises <schema …>
non XML <element name='Catalogue'>
<complexType>
• Simple à mettre en œuvre <sequence>
• Pas de typage, pas de <element name='Livre' minOccurs="0"
réutilisation de structure maxOccurs="unbounded">
– XML Schema <complexType>
• Document XML <attribute name='titre' type='string'/>
</complexType>
• Définition de type de structure </element>
• Utilisation d’un système de typage </sequence>
<attribute name='nom' type='string'/>
</complexType>
</element>
</schema>
 XML : Namespace

• Identifier un ensemble de balises à utiliser et lui associer

un nom
• Utilise l’attribut xmlns qui peut être associée à toute
balise ouvrante
• L’espace des noms est défini par une uri qui localise une
DTD ou un schema
– Exemple
<shema xmlns:xsd=http://www.w3.org/2001/XMLSchema
>
• Les balises doivent commencer par « xsd: »

XML : XSLT

• XSLT : eXensible Stylesheet Language Transformations

• Définition d’une feuille de style
• Transformation de documents XML en un autre format
(XML, HTML)
• Transformation décrite par des templates
• template :
– Un motif à rechercher dans le documents XML
– Un ensemble de règles de transformation
 XSLT, exemple
<?xml version="1.0" encoding="ISO-8859-1"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/
1999/XSL/Transform">
<xsl:output method="html"
version="1.0" encoding="ISO-8859-1"
<Catalogue nom="BiblioAcsi">
indent="yes"/>
<Livre titre="Tout sur UML"> </Livre>
<xsl:template match="/">
<Livre titre="Tout sur MOF"> </Livre>
<Catalogue>
<html>
<head><title>Catalogue</title></head>
<body>
<xsl:apply-templates select="Catalogue"/>
</body>
</html>

</xsl:template> Catalogue : BiblioAcsi

<xsl:template match="Catalogue">
<b> Catalogue : <xsl:value-of select="@nom"/></b> titre
<table border="1">
<tr><th>titre</th></tr>
<xsl:apply-templates select="Livre"/>
Tout sur
</table> UML
</xsl:template>
Tout sur
<xsl:template match="Livre">
<tr><td><xsl:value-of select="@titre"/></td></tr> MOF
</xsl:template>

XML, SVG

• SVG : Scalable Vector Graphics

• Graphiques vectoriels 2D décrit en XML
• Utilisation d’un viewer Adobe : http://www.adobe.com/svg/
• Génération de graphiques à partir de documents XML
avec XSLT
• MDA : représentation graphique des modèles en XML
• Echanger des diagrammes
 SVG, exemple
<?xml version="1.0" encoding="ISO-8859-1" standalone="no"?>
<!DOCTYPE svg SYSTEM "../svg10.dtd" >
<svg width=« 410" height="260" >
<text x="5" y="20" style="font-size:10">SVG Demo: cercle et ellipse.</text>
<g stroke-width="4px" stroke="black">
<circle r="50" cx="100" cy="100" fill="cyan" fill-opacity="1"/>
<ellipse rx="150" ry="100" cx="250" cy="150" fill="yellow" fill-
opacity="0.5"/>
</g>
</svg>

XML Metadata Interchange : XMI

• Représentation de modèles sous forme XML

• La DTD ou le XML Schema décrit le métamodèle
• Le document XML contient le modèle
• Génération de la DTD ou XML schéma à partir du
métamodèle

DTD ou
Métamodèle XMI : génération
XML schema

Est structuré par Est structuré par

Document
Modèle XMI : sérialisation
XML
 XML Metadata Interchange : XMI

• Règles de génération de la DTD à partir du métamodèle :

1. Métaclasse -> balise de même nom + attribut id
2. Méta-attribut-> balise de même nom dans balise de la
métaclasse
3. Méta-référence-> balise de même nom dans la balise de la
métaclasse + id de la métaclasse référence
4. Méta-association -> balise de même nom avec id des
métaclasses participant aux associations. Si l’association est
navigable la balise doit être contenue dans la balise de la
métaclasse source

XMI, exemple
<!ELEMENT Catalogue (nom, CatalogueToLivre) >
<!ATTLIST Catalogue
id ID #REQUIRED>
<!ELEMENT nom (#PCDATA)>

<!ELEMENT CatalogueToLivre (Livre)*>

<!ELEMENT Livre (titre)>

<!ATTLIST Livre id ID #REQUIRED>
<!ELEMENT titre (#PCDATA)>

<Catalogue id="idvalue0">
<nom>BiblioACSI</nom>
<CatalogueToLivre>
<Livre id="l1">
<titre>Tout sur UML</titre>
</Livre>
<Livre id="l2">
<titre>Tout sur MOF</titre>
</Livre>
</CatalogueToLivre>
</Catalogue>
 XMI, échange de modèle
• Le métamodèle : UML
• DTD définit à partir d’UML

UML DTD
UML

<!-- =========== model.Catalogue [Class] ========== -->

<Model.Class xmi.id = 'a43E1EA1E0251' >
<Model.ModelElement.name>Catalogue</
Model.ModelElement.name>
<Model.ModelElement.annotation></
Model.ModelElement.annotation>
<Model.GeneralizableElement.isRoot xmi.value = "false"/>
<Model.GeneralizableElement.isLeaf xmi.value = "false"/>
<Model.GeneralizableElement.isAbstract xmi.value = "false"/>
<Model.GeneralizableElement.visibility xmi.value = "public_vis" />
<Model.Class.isSingleton xmi.value = "false"/>
<Model.Namespace.contents>
…..

XMI, Etat actuel

• XMI 1.0 : DTD à partir de MOF 1.3 (version de base)

• XMI 1.1 : DTD à partir de MOF 1.4 : utilisation des
namespace, sous partie de modèle
• Subissent les lacunes des DTD (typage)
• XMI 1.2 : corrigent les erreurs, stable en cours de
normalisation ISO
• Extension de XMI 1.2 pour intégrer des schéma XML
• XMi 2.0 : XML schema à partir de MOF 1.4
• XMi 2.1 : XML schema à partir de MOF 2.0
 XMI, échange de modèle entre outils

• Cinq ans après l’annonce d’XMI

– Toujours difficile d’échanger des modèles
– Multitude de version des standards :
• Quatre versions de XMI, quatre d’UML, trois de MOF !
• Chaque version de XMI liée à une version de MOF
• Seule les versions de XMI et d’UML conditionnent l’échange de
modèle UML

XMI 1.0 XMI 1.1 XMI 1.2 XMI 1.2 XMI 2.0 XMI 2.1
schema
UML 1.3

UML 1.4

UML 1.5

UML 2.0

DI, Diagramme interchange

• Représentation en XML des parties graphiques des modèles UML
• Définition d’un métamodèle définissant les éléments (métaclasse)
graphiques d’un diagramme UML
• Définition d’une transformation SVG
DTD ou
Métamodèle DTD ou
XMI : génération XML schema
Métamodèle UML XML schema
UML
Graphique Graphique
Est structuré par Est structuré par

Modèle XMI : sérialisation Document

Partie UML XML Document
graphique XML

G
SV
tion
orma
nsf
Tra
 Conclusion

• Modèles manipulables dans des programmes OO

– Deux approches
• JMI : présent dans plusieurs outils
– Netbean, Poséidon
• EMF : lié à Eclipse
– Présent dans RSA (Rational Software Architect)
– Intérêt : test, transformation, validation
• Modèles représentables en XML
– Intérêt : échanges et persistences des modèles
– XMI et DI, les standards
• Encore difficile à utiliser entre outils