Visualisation de la structure du logiciel CATIAsous-forme de graphes

Sonia Jamal

Formation DESS CCI - UFR IMAUniversité Joseph Fourier

Année 1999-2000

Stage réalisé dans le laboratoire

Logiciels Systèmes et Réseaux (LSR)

Equipe ADELE

Responsables :

Jean-Marie Favre - Jorge Villalobos

2/25 03/07/00

1. Introduction………………………………………………………… 3

1.1. Contexte du stage…………………………………………… 3

1.2. Objectifs du stage……………………………………………. 3

1.3. Démarche…………………………………………………….. 4

1.4. Plan du document……………………………………………. 4

2. Exploration des logiciels………………………………………… 5

2.1. Environnements de Rétro – ingénierie………………….… 5

2.2. Outils de visualisation de graphe……………….………….. 6

2.2.1.Dotty……………………………………………………….. 6

2.2.2.Grappa…………………………………………………….. 8

3. Application au langage java et à l’Object Modeler …………. 13

3.1. Visualisation de hiérarchies de classes java……………… 13

3.1.1.Modèle de données……………………………………… 13

3.1.2.Vue…………………………………………………………. 13

3.1.3.Architecture…………..…………………………………… 14

3.1.4.Réalisation………………………………………………… 15

3.2. Visualisation de composants "Object Modeler"…………... 16

3.2.1.Modèle de données……………………………………… 16

3.2.2.Vues……………………………………………………….. 16

3.2.3.Architecture ………………………………………………. 19

3.2.4.Réalisation………………………………………………… 20

4. Conclusion……………………………………………………….… 25

5. Références bibliographiques…………………………………… 25

3/25 03/07/00

1. Introduction

1.1. Contexte du stage

Maîtriser le développement et l'évolution des logiciels de grande taille est unetâche extrêmement difficile. En effet de tels logiciels sont très complexes et leurstructure n'est pas apparente. Il est entre autre très difficile d'avoir une vision globalede l'architecture de ces logiciels.

Dassault Système (DS) est une entreprise spécialisée dans le développementde logiciels pour la conception et la fabrication assisté par ordinateur. Le logicielphare de DS est CATIA v5. Ce logiciel, avec plus de quatre millions de lignes decode, est difficile à maintenir et à faire évoluer. En outre, avoir une visionarchitecturale de ce logiciel est une tâche complexe.

Le laboratoire Logiciels Systèmes et Réseaux (LSR) est un des septlaboratoires de la fédération de recherche en informatique et MathématiquesAppliquées de Grenoble (IMAG).

Dans le cadre d'une collaboration avec la société Dassault Système (DS), lelaboratoire LSR effectue des travaux sur les architectures logicielles et leur évolutiondans un contexte industriel. Dans ce contexte, une plateforme a été mise au pointpar le laboratoire LSR pour définir, analyser et visualiser l'architecture du logicielCATIA.

1.2. Objectifs du stage

L'objectif de ce stage était d'intégrer à la plateforme existante un outil devisualisation de graphe facilement paramétrable afin de pouvoir générer "à lademande" différentes vues graphiques. Différents outils ont déjà été proposés etréalisés au dessus de la plateforme, mais ces outils sont spécifiques à certains typesd'informations et ne sont pas paramétrables. Chacun de ces outils se concentreessentiellement sur la représentation graphique d'un type d'entité et bien queparticulièrement adaptés à une visualisation spécifique, ils ne permettent pas d'avoirune vision d'ensemble. Dans le cadre de ce stage on souhaite au contraire, intégrer àla plateforme un outil générique de visualisation de graphe afin de visualisern'importe quel type de graphes en indiquant simplement les relations et les entités àvisualiser ainsi que la manière de les visualiser.

4/25 03/07/00

1.3. Démarche

Dans le cadre de ce stage, nous nous intéressons à la visualisation de lastructure des logiciels sous forme de graphe. Plus particulièrement à réaliser un outilde visualisation pour l’Object Modeler de Dassault Systèmes. Pour cela, nous avonsétudié deux outils de visualisation de graphe: Dotty, un outil de visualisation basé surun format de fichier représentant un graphe, et Grappa, une interface deprogrammation écrite en java.

Dans un premier temps, pour nous concentrer sur l’aspect visualisation nousavons réalisé un outil de visualisation permettant de visualiser des structures javagrâce au mécanisme d’introspection. Ceci nous a permis de valider nosconnaissances sur Grappa et Dotty. Puis, en deuxième étape, nous avons réalisé unoutil de visualisation pour l’Object Modeler de Dassault Systèmes.

Le logiciel est écrit en langage Java. Il est spécifié et documenté en UML enutilisant l'environnement de génie logiciel ROSE-J.

1.4. Plan du document

Dans le chapitre 2 de ce document, nous présentons les conceptsnécessaires à la compréhension de ce stage ainsi que les outils utilisés. Nousmontrons tout d'abord l'architecture des environnement de rétro-ingéniérie et la placedes outils de visualisation dans une telle architecture. Ensuite nous présentons l'outilDotty et l'outil Grappa.

Le chapitre 3 décrit l'application des concepts et outils présentés, d'une partpour la visualisation de hiérarchies de classes java, et d'autre part pour lavisualisation de composants de l'Object Modeler dans le logiciel CATIA de DassaultSystèmes.

Finalement ce document se termine par une conclusion et une descriptionbrève des perspectives à ce travail.

5/25 03/07/00

2. Exploration des logiciels

La première partie de ce chapitre explique brièvement le principe defonctionnement commun aux différents outils de rétro–ingénierie, en détaillant Plusparticulièrement l’étape "Visualisation". La deuxième partie présente des outils devisualisation étudiés dans le cadre de ce stage: Dotty et Grappa.

2.1. Environnements de Rétro–ingénierie

La rétro–ingénierie est le processus d’analyse d’un système afin d’identifierses composants et d’en créer une représentation sous une autre forme. Le principede fonctionnement des outils de rétro–ingénierie consiste à extraire les objetsconceptuels du code source du logiciel. Ces objets sont stockés dans une base afinde pouvoir y accéder par la suite sans avoir à parcourir à nouveau le code. Ladernière étape (la "visualisation"), consiste a construire de nouvelles représentationsde certaines informations. Les représentations construites, appelées "vues", peuventêtre graphiques ou textuelle. Nous nous intéressons plus particulièrement aux vuessous forme de graphe (ensemble de nœud reliés par des arcs).

Figure 1 : environnement de rétro – ingénierie

Dans le cadre de ce stage, on s’intéresse a la visualisation graphique desinformations. Cette visualisation graphique s’effectue à l’aide des "outils devisualisation" qui facilitent la construction des graphes.

L’étape de visualisation peut elle même se décomposer en deux étapes:1. La sélection des informations à visualiser à partir de la base d’objets.2. Le choix du "rendu", c’est a dire la représentation graphique associée aux

éléments du modèle (mapping). Il s’agit d’associer une forme graphique à chaqueentité et relation visualisée.

Base d’objets

Vues

Visualisation

Extraction

Source

6/25 03/07/00

2.2. Outils de visualisation de graphe

Il existe de nombreux outils de visualisation de graphe. Nous nous sommesconcentrés sur deux de ces outils développés dans le cadre du projet Grapviz parATT: Dotty et Grappa. Ces deux outils utilisent l’analyseur "dot", qui possède desalgorithmes de placement permettant d’arranger les éléments du graphe.

L’intérêt de ces outils réside dans leur ouverture, leur performance et dansleur capacité d’afficher des graphes complexes. Ces outils sont disponiblesgratuitement.

Ces outils sont complètement indépendant du domaine d’application etpeuvent donc être utilisés pour afficher n’importe quel type de graphe. L’une destaches importante de notre stage était d’étudier ces outils et de montrer la manièrede les utiliser.

La documentation de Dotty était bien construite . Néanmoins un certainnombre de contrainte n’était pas précisée. Nous les présentons ci dessous .

Quant a Grappa, on ne dispose que d’une documentation des classes sousforme de javadoc, et il nous fallait comprendre comment utiliser ce paquetage.

La section ci dessous est l’aboutissement de ce travail.

2.2.1. Dotty

L’outil Dotty permet de visualiser des graphes, en chargeant un fichier textuelde syntaxe assez simple (un fichier de format dot) voir la Figure 2. Le langage utilisépour construire ces fichiers textuels est basé sur trois sortes d’éléments : lesgraphes, les nœuds et les arcs.

• Description des éléments

Chaque nœud est défini par un nom spécifique et unique pour un graphedonné. Un nœud est créé dés que son nom apparaît dans le fichier pour la premièrefois. L’arc est créé lorsque deux noms de nœud sont reliés par l’opérateur « -> ».

Le graphe principal (mot clé "digraphe" dans l’exemple ci dessous), estl’élément qui contient les nœuds, les arcs, et les sous graphes. Un sous graphe estun graphe encadré par un rectangle. Il contient ses propres nœuds et arcs, et n’estdessiné que lorsque son nom est préfixé par le mot : cluster.

Remarquons qu’un sous graphe n’est affiché que lorsque il contient desnœuds, un sous graphe vide ne peut donc pas être affiché.

Un sous graphe peut contenir aussi d’autres sous graphes, dans ce cas là, lesous graphe extérieur doit être préfixé par le mot : cluster_outer.

Le nom d’un nœud peut être répété plusieurs fois dans le fichier, ainsi que lenom d’un sous graphe. Le placement du nœud dans le graphe principal dépend del’endroit ou son nom apparaît dans le fichier :• Si le nom du nœud apparaît dans deux sous graphes différents (non imbriqués),

le nœud sera placé a l’intérieur du premier sous graphe ou le nom apparaît.• Si le nom du nœud apparaît dans deux sous graphes imbriqués, le nœud sera

placé a l’intérieur du plus profond.• Si le nom n’apparaît dans aucun sous graphe il sera placé a l’extérieur de tous les

sous graphes du graphe principal.

7/25 03/07/00

La Figure 2 illustre un exemple de visualisation de graphes à l’aide de Dotty,et permet de voir l’application de quelques unes ces règles. Dans cet exemple, onvoit à gauche un fichier de format dot, à droite on voit le résultat graphique qu’affichel’outil Dotty après avoir chargé ce fichier.

1. digraph G {2. Ex2 -> B;3. subgraph cluster_outer {4. A -> E;5. A -> C;6. subgraph cluster_inner {7. B -> D;8. B -> E;9. }10. }11. Ex1 -> D;12.}

Figure 2 : exemple de fichier de format dot

Dans l’exemple précédent, on remarque les deux sous graphes imbriqués:cluster_outer qui est le sous graphe extérieur, et a l’intérieur de celui là on a lesous graphe cluster_inner. La deuxième ligne du fichier se traduit par la créationde deux nœuds: Ex2 et B, et d’un arc qui les relie. Par défaut l’étiquette du nœud estla même que le nom de ce nœud.

On peut remarquer la répétition du nom de nœud B dans le fichier. Ce nœudest créé lors de l’analyse de la ligne 2, et placé a l’intérieur du sous graphecluster_inner, suite a l’analyse de la ligne 7. Les deux nœuds: Ex1 et Ex2n’apparaissent dans aucun des deux sous graphe de notre graphe, c’est pour celaqu’ils sont placé a l’extérieur.

• Rendu des éléments

Dans le chapitre précédent nous avons vu les deux aspects de lavisualisation. L’aspect "rendu" qui est la représentation graphique associée auxéléments du modèle, s’effectue dans Dotty par l’association d’attributs aux éléments.

Les éléments du graphe ont des caractéristiques par défaut fournis par Dotty.On peut en remarquer quelque uns dans la Figure 2: les ovales pour lareprésentation des nœuds, les flèches pour les arcs, la couleur noire, la police"Times-Roman",… Ces caractéristiques peuvent être changés en utilisant une clausede la forme suivante.

[ <nom_de_l’attribut> = <valeur> ]

Une telle clause peut être associée soit a un élément spécifique (dans la ligne 2 de laFigure 3 on associe la forme carrée au nœud B), soit à un type d’éléments, nœud(node), arc (edge), ou graphe (graph), dans le graphe principal ou dans lesous_graphe, ce qui permet d’attribuer cette valeur à tous les éléments de ce typecontenus dans le graphe. Par exemple, dans la ligne 5 de la Figure 3 on associe lapolice "Impact" et la taille "16" de la police a tout les éléments du type nœud.

8/25 03/07/00

Les sous-graphes non préfixé par le mot : cluster regroupe des élémentssans dessiner un rectangle autour d’eux. Ce type de sous-graphes sert a associerdes attributs communs a plusieurs éléments, en regroupant ces éléments dans unsous-graphe non préfixé par le mot : cluster, et associer ces attributs communsaux types d’éléments dans ce sous-graphe.

Les attributs les plus utilisés sont les formes de nœuds « shape » et lesétiquettes des éléments « label ».

Pour changer l’étiquette de l’élément il suffit d’associer à l’attribut « label » decet élément la chaîne souhaitée. Celle-ci peut contenir des caractères spéciauxpermettant de passer à la ligne en précisant le mode d’alignement. Par exemple «\n»

passe à la ligne et centre la ligne précédente alors que «\l» et «\r» correspondentrespectivement à un alignement à gauche et a droite. Le caractère «|» est utiliséquand le nœud est de la forme enregistrement « record » pour tracer des ligneshorizontales. Dans ce cas là, la chaîne qui représente l’étiquette du "record" doitêtre entre deux accolades: "{","}", (ligne 6 de la Figure 3). Remarquons que cescaractères ("{","}", et "|") ne sont pas interprétés lorsque l’attribut « shape » n’apas la valeur « record ».

Au cours de nos expérimentations, il est apparu que l’étiquette du nœud de laforme « record » doit contenir au plus 511 caractère entre deux caractère «|». L’outilDotty ne peut pas afficher les graphes qui contiennent des étiquettes ne vérifiant pascette contrainte.

1. digraph G {2. B [shape=box];3. B -> D[style=bold];

4. subgraph cluster_outer {5. node[fontname="Impact",fontsize="16"];

6. A [shape=record , label ="{A1|un\n deux|trois}"];

7. C [shape=doublecircle,style=filled];

8. A -> C;9. subgraph cluster_inner {10. C;11. }12. }13. B -> C[dir=none,label="100"];14.}

Figure 3 : modification d’attributs dans les fichier de format dot

2.2.2. Grappa

Grappa est un paquetage de classes écrites en Java, facilitant l’affichage et lamanipulation de graphes par des applications écrites en langage Java. Il offre lesmême fonctionnalités que Dotty, seule la réalisation change. L’expérience acquiseavec Dotty a donc été très utile pour utiliser Grappa. On retrouve les même conceptsmais le logiciel n’est que peu documenté. La première étape du travail a doncconsisté à retrouver dans la bibliothèque de classes quelles étaient cellesnécessaires à la création d’un graphe. La seconde étape a consisté à voir dans quelordre faut il appeler les différentes méthodes.

9/25 03/07/00

• Classes nécessaires pour la visualisation d’un graphe

Grappa est un paquetage assez étendu, il possède 73 classes. La Figure 4illustre les classes nécessaires à la création d’un graphe. Ce schéma est issu d’unprocessus de rétro–ingénierie effectué à partir du logiciel « Rose ».

Les éléments (nœuds, arcs, et sous-graphes), dans les applications utilisant lepaquetage Grappa, sont des instances des classes Node, Edge, et Subgraph,représentés dans la Figure 4. Ces classes possèdent un nombre important deméthodes (la classe "Subgraph" possède 51 méthodes, la classe "Element" enpossède 40..). Ces méthodes permettent de gérer les éléments de l’application avecplus de souplesse qu’avec Dotty.

Les classes Node, Edge, et Subgraph, nous sert a construire les éléments dugraphe. Ces éléments ne sont affiché qu’après avoir dessiné le graphe dans unpanneau de dessins " DrawPane ".

A cause du grand nombre de méthodes que possèdent les classesreprésentés dans la Figure 4, nous n’avons affiché que les méthodes utilisées dansle cadre de ce stage.

Chaque élément du type nœud ou sous graphe doit avoir un nom qui lespécifie. Ce nom ne peut pas être répété pour plusieurs éléments. A partir de cenom, on peut chercher cet élément dans le graphe (ou dans le sous graphe), a l’aidedes méthodes de la classe Subgraph :

findNodeByName(String) , findSubgraphByName(String)

voir Figure 4.

En comparant avec Dotty, on s’aperçoit de quelques différences. Dans Dotty,comme dans Grappa, chaque nœud a son nom spécifique. Cependant, si le nom dunœud est répété dans le fichier "dot", l’interpréteur comprend qu’il s’agit toujours dumême nœud. Ceci facilite l’utilisation du nœud dans plusieurs commandes du fichier(simplement en utilisant son nom). Par contre, avec Grappa, la réutilisation d’unnœud devient plus compliqué puisqu’il faut le chercher dans le graphe à l’aide desméthodes dont on vient de parler.

Comme Dotty, Grappa utilise l’analyseur "dot", qui possède des algorithmesde placement permettant de positionner les éléments du graphe.

La différence la plus importante entre Grappa et Dotty est que Dotty affiche ungraphe défini dans un fichier textuel de format dot, qui utilise une syntaxe assezsimple. Une fois que ce graphe est affiché, il ne peut pas être modifié. Par contreGrappa permet de manipuler le graphe après la création de ses éléments, à l’aidedes différentes méthodes des classes de ce paquetage. Il est donc plus puissant queDotty.

10/25 03/07/00

Figure 4 : Classes du paquetage Grappautilisées dans le cadre de ce stage

• Protocole pour la visualisation d’un graphe

Dans ce qui suit, nous allons expliquer les étapes nécessaires pour construireun graphe a l’aide de Grappa.

Pour construire un graphe donné à l’aide de Grappa, il faut d’abord créer unnouveau Graphe en faisant une instance de la classe "Graph", et lui associer un nomspécifique.

Graph graph = new Graph("graph");Initialement le graphe est vide. On peut ensuite créer dans ce graphe les éléments(nœuds, arcs, sous graphes).

Pour créer un sous-graphe, il suffit de créer une instance de la classe"Subgraph", et de lui associer un nom spécifique, en précisant le graphe ou le sousgraphe qui le contient.

Edge

Edge(Subgraph, Node, Node)

Subgraph

Subgraph(Subgraph, String)addEdge(Edge)addNode(Node)addSubgraph(Subgraph)drawGraph()findEdgeByName(String)findNodeByName(String)findSubgraphByName(String)redrawGraph()setAttribute(String, String)setEdgeAttribute(String, String)setNodeAttribute(String, String)

Graph

reset()setEditable()setErrorWriter()setMenuable()Graph(String)

Element

setAttribute(String, String)

Node

Node(Subgraph)Node(Subgraph, String)

Container

Component(from awt)

ScrollPane

Object

DrawPane

DrawPane(Graph, boolean,int)DrawPane(Graph, boolean, int, Backgrounder)DrawPane(Graph, boolean, int, Dimension)DrawPane(Graph, boolean, int, Dimension, Backgrounder)clearGraph(Graph)clearGraph(Subgraph)drawGraph(Graph)drawGraph(Subgraph)getGraph()redrawGraph(Graph)redrawGraph(Subgraph)refreshGraph(Graph)refreshGraph(Subgraph)

11/25 03/07/00

Le sous-graphe regroupe plusieurs éléments. Comme dans Dotty, il existedans Grappa deux sortes de sous-graphe, différant par la manière de les nommer.Les sous-graphe ou le nom n’est pas préfixé par le mot cluster, ne sont pasreprésentés par des rectangles entourant les éléments qu’ils regroupent. Ce type desous-graphes sert juste a associer des attributs communs a ces éléments.

Le deuxième type de sous-graphes est affiché dans le panneau de dessinsous forme de rectangle encadrant les éléments qu’il regroupe. Le nom d’un sous-graphe de ce type doit être préfixé par le mot cluster, ou, pour les sous-graphes imbriqués, par le mot cluster_outer si c’est un sous graphe extérieur quicontient d’autres sous graphes.

Subgraph sub1=new Subgraph(graph,"cluster_outer_1");Subgraph sub2=new Subgraph(sub1 ,"cluster_2");

Dans les deux lignes précédentes, on a créé dans le graphe principal graph un sousgraphe extérieur sub1 auquel on a associé le nom "cluster_outer_1". Puis, dans cesous graphe sub1, on a créé un sous graphe sub2, auquel on a associé le nom"cluster_2". Les sous graphes sont représentés par des rectangles (voir Figure 5).

Les éléments créés dans le graphe ont des caractéristiques par défaut. Lescaractéristiques d’un élément peuvent être changé en utilisant la méthode :

setAttribute("<nom_de_l’attribut>" , <"valeur"> )

qui permet d’associer des attributs à un élément (existant).

Dans l’exemple ci-dessous on associe à l’élément sub1, créé précédemment,l’étiquette "cluster 1", en associant cette étiquette a l’attribut "label" de l’élémentsub1. De la même façon, on associe a l’élément sub2 l’étiquette "cluster 2".L’étiquette du sous graphe est affichée au dessus du rectangle représentant le sousgraphe,voir Figure 5.

sub1.setAttribute("label","cluster 1");sub2.setAttribute("label","cluster 2");

On peut également associer une valeur d’attribut par défaut à tous les nœudsou à tous les arcs d’un sous-graphe en utilisant les méthodes suivantes :

sub1.setNodeAttribute("shape" , "record");sub1.setEdgeAttribute("dir" , "back");

Dans la première ligne, la forme de nœuds "record" est associée à tous les nœudsdu sous-graphe sub1. Dans la deuxième ligne, la direction de toutes les flèches de cesous graphe est inversée.

La chaîne de caractère qui spécifie le nom de l’élément peut contenir descaractère spéciaux (retour à la ligne «\\n », ligne horizontale «|» pour les nœud dela forme « record » …)

Node n1=new Node(graph,"Node 1");Node n2=new Node(sub1,"{ Classe | Attributs | operations }");Node n3=new Node(sub2,"Node \\n 2");Node n4=new Node(sub2,"Node 4");

Edge e1=new Edge(graph,n1,n2);Edge e2=new Edge(graph,n1,n3);

12/25 03/07/00

Dans ce qui précède, quatre nœuds sont créés. Le premier nœud n1 est créédans le graphe principal graph, il prend alors la forme ovale par défaut (voir Figure 5).Le deuxième nœud n2 est créé dans le sous graphe sub1, il hérite donc la forme"record" associée a tous les nœuds de ce sous graphe. Le nom du nœuds n2

contient le caractère «|» qui dessine des lignes horizontales dans les nœuds de laforme "record" (voir Figure 5). Les deux derniers nœuds n3 et n4 sont créé dans lesous graphe sub2. Le nom du nœuds n3 contient le caractère «\\n», qui permetd’écrire le nom de ce nœud en deux lignes (voir Figure 5).On remarque aussi les deux arcs qu’on a créé e1 et e2, qui relient le nœud n1 auxdeux nœuds n2 et n3 respectivement (voir Figure 5).

Après avoir créé les éléments du graphe, il ne reste plus qu’a les construire.graph.buildObjects();

La dernière étape consiste à dessiner le graphe à l’aide d’un "DrawPane" .DrawPane pane = new DrawPane(graph,false,ScrollPane.SCROLLBARS_AS_NEEDED,

new Dimension(650,650));

Pour cela il faut préciser le graphe à dessiner (premier paramètre). Il faut aussiindiquer si le graphe doit être réduit pour l’afficher complètement dans la zoneprécise, en passant une valeur booléenne (deuxième paramètre). Le graphe réduitest en général moins lisible, surtout quand il contient de nombreux éléments. Pourcette raison dans l’outil réalisé nous avons préféré de passer la valeur false endeuxième paramètre, pour afficher le graphe sans le réduire.Le troisième paramètre de cette méthode indique la manière d’utiliser les ascenseursdans le panneau de dessin "DrawPane". Ce paramètre prend une des valeurssuivantes:

ScrollPane.SCROLLBARS_ALWAYS utiliser des ascenseursScrollPane.SCROLLBARS_AS_NEEDED utiliser des ascenseurs quand il y en a besoinScrollPane.SCROLLBARS_NEVER ne pas utiliser d’ascenseurs

Le quatrième paramètre précise la taille de la zone de dessin.Après avoir dessiné le graphe, on peut alors l’afficher dans une fenêtre "Frame".

Figure 5 : exemple de graphe construit a l’aide de Grappa

13/25 03/07/00

3. Application au langage java et à l’Object Modeler

Dans la partie précédente, nous avons vus que les outils Grappa et Dottypermettaient d’afficher n’importe quel type d’information sous forme de graphe. Dansle contexte de ce stage, nous nous intéressons à la visualisation de la structure deslogiciels. L’objectif était de réaliser un outil de visualisation pour l’Object Modeler deDassault Systèmes. Ceci impliquait la connaissance d’un modèle de donnéescomplexe ainsi que l’utilisation d’une base de données.

Dans un premier temps, pour nous concentrer sur l’aspect visualisation nousavons réalisé un outil de visualisation permettant de visualiser des structures javagrâce au mécanisme d’introspection. Ceci nous a permis de valider nosconnaissances sur Grappa et Dotty. Ce chapitre présente successivement l’outil devisualisation de structures Java, puis l’outil de visualisation de l’Object Modeler.

Pour chaque outil nous présentons tout d'abord le modèle de données surlequel il est basé (en UML) Nous présentons ensuite le(s) vue(s) proposée(s) parl'outil, puis l'architecture de l'environnement. Nous concluons par des informationssur la réalisation de l'outil.

3.1. Visualisation de hiérarchies de classes java

3.1.1.Modèle de données

Pour la visualisation de structures java, nous avons réalisé deux outils qui,pour un logiciel quelconque écrit en java, affichent le graphe d'héritage entre classesainsi que les relations de composition entre paquetages et classes. L’un de ces deuxoutils utilise Dotty, l’autre utilise Grappa. L’objectif était tout d’abord de se familiariseravec les concepts de graphe. Cela a été beaucoup plus simple avec Dotty car ondispose d’une documentation et que le format de fichier est relativement simple.Nous avons ensuite pu étudier Grappa, qui lui n’est pas documenté. La Figure 6représente les relations affichées par les deux outils réalisés.

Figure 6 : les relations de la structure javavisualisés par les outils réalisés

3.1.2.Vue

Nous avons choisi un même rendu d’éléments dans chaque outils. Chaqueclasse est représentée par un nœud. Nous avons choisi d’afficher le nom de sesméthodes (Method) et attributs (Field) dans ce nœud. On a choisi également dereprésenter les paquetages et la relation d’imbrication entre eux par des boitesimbriquées (des sous graphes). La relation d’imbrication entre classe et paquetage

Package0..1

0..*

0..1

0..*

Method Field

Class

0..1

0..*

0..1

0..*0..1 0..*0..1 0..*

0..*

1

0..*

1

0..*

1

0..*

1

14/25 03/07/00

est représenté par l’imbrication du nœud dans le sous graphe. Finalement, la relationd’héritage entre les classes est représentée par une flèche, de la classe vers sasuper classe.

3.1.3.Architecture

Dans ces deux outils, la sélection des informations à visualiser s’effectue al’aide des deux classes: java.lang, et java.reflect fournies par java (voir Figure 7).Cependant, la représentation graphique des éléments du modèle, s’effectue à l’aidede l’outil de visualisation utilisé.

L’outil réalisé génère un fichier de format dot pour visualiser le graphe à l'aidede Dotty.

Figure 7 : Architecture

java.lang java.reflect

appelle

Compilateur

Fichiers du type ".class"

DottyDot

LeGraph

verification()enregistrerUneClasse()enregistrerLArbre()main()

génère

Vue

fichier de format dot

flot de données

appelle

Grappa Dot

Vue

Demo

Fichiers du type ".java"

appelle

Les outils réalisésdans le cadre

du stage

Source

Extraction

Base d’objets

Visualisation

Vues

15/25 03/07/00

3.1.4.Réalisation

La réalisation de chaque un de ces deux outils est effectuée en deux étapes.La première étape consiste à sélectionner les informations à visualiser, et construireune structure d’arbre dans lequel les nœuds sont du type "classe", afin d’y stockerles informations sélectionnées. Cet arbre représente la hiérarchie de classes Javadont les feuilles sont données en paramètres.

La deuxième étape consiste à interpréter les informations stockées dansl’arbre. Cette interprétation diffère entre les deux outils. Dans l’outil utilisant Grappa,l’interprétation se traduit par la construction et l’affichage du graphe. Au contraire,dans l’outil utilisant Dotty, l’interprétation est effectuée par la création d’un fichier deformat dot et l’enregistrement des informations dans ce fichier.

La Figure 8 représente la hiérarchie de classes d’un de ces deux outils, l’outilutilisant Dotty. Cette structure est affichée par Dotty après avoir généré le fichier "dot"à l’aide de l’outil même. L’outil réalisé avec Grappa produit un résultat analogue.

Figure 8 : Hiérarchie de classes correspondant à l’outil réaliséet visualisé par l’outil lui même

16/25 03/07/00

3.2. Visualisation de composants "Object Modeler"

3.2.1.Modèle de données

A cause des limites du langage C++, Dassault Systèmes a développél’ "Object Modeler" (OM) qui est une sur-couche de C++.

Les entités introduites par l’Object Modeler manipulés dans ce stage sontessentiellement les Composants. Chaque composant est composé d’une Base quipeut être étendue par plusieurs Extensions et peut hériter d’une autre base. Lesbases et les extensions peuvent implémenter plusieurs interfaces, et chaqueinterface peut hériter d’une autre interface.

Un composant C1 hérite d’un composant C2, si la base de C1 hérite de labase de C2.

Le schéma simplifié décrivant ces entités est le suivant :

Figure 9 : modélisation simplifiée de l’Object Modeler

3.2.2.Vues :

Pour visualiser les composant OM, nous avons réalisé un logiciel qui nouspermet d’afficher différentes vues à partir du nom d’un composant. Les vues diffèrespar les informations visualisées et par leur rendu.

Les figures suivantes nous présentent les quatre vues obtenues par lelogiciel.

1. Vue composant – interfaces2. Vue composant – extensions3. Vue composant - héritage interfaces4. Vue base extension - héritage interfaces

Interface

0..10..*

0..10..*

Extension

0..*

1..*

0..*

1..*

Base0..*

0..*0..*

0..*0..1

0..*

0..1

0..*

1..*

0..*

1..*

0..*

Component

0..*

1..*

0..*

1..*

1

1

1

1

0..1

0..*

0..1

0..*

inherits

inherits implementsimplements

extends

inherits

17/25 03/07/00

Ces vues nous visualisent différentes relations entre les entités de l’ObjectModeler. Pour chaque vue on donne le sous modèle de données utilisé décrit enUML ainsi qu’un exemple de visualisation.

1. Vue composant - interfaces

Figure 10 : héritage entre composantsimplémentation entre interface et composant

Dans la vue composant - interfaces représentée par la Figure 10, chaquecomposant est représenté par un rectangle de forme enregistrement. Les interfacesqu’il implémente sont marquées dans ce rectangle. La relation d’héritage entrecomposants est représentée par une flèche, du composant vers son supercomposant.

2. Vue composant - extensions

Figure 11 : extension entre base et extensionhéritage entre composants

La représentation de la vue composant - extensions (Figure 11), est similaire àcelle de la vue composant – interfaces (Figure 10). La seule différence est qu’au lieude marquer dans le rectangle représentant le composant les interfaces qu’ilimplémente, on y marque les extensions de ce composant.

InterfaceComponent

inherits

implements1..*

0..10..1

0..*0..*0..* 1..*0..*

ExtensionComponent

inherits

extends1..*

0..10..1

0..*0..*0..*1..* 0..*

18/25 03/07/00

3. Vue composant - héritage interfaces

Figure 12 : héritage entre composants, héritage entre interfacesimplémentation entre interface et composant

Dans la vue composant - héritage interfaces représentée par la Figure 12, ona choisi de représenter chaque composant par un rectangle, et chaque interface parun ovale. La relation d’héritage entre composants est représentée, comme dans lesvues précédentes, par une flèche du composant vers son super composant. Larelation d’héritage entre interfaces est représentée par un trait, entre l’interface et sasuper interface, ainsi que la relation d’ implémentation entre interface et composant.

4. Vue base extension - héritage interfaces

Figure 13 : extension entre base et extensionhéritage entre composants, héritage entre interfaces

implémentation entre interface et composant

Interface

ExtensionBase

Component

inherits

inheritsimplementsimplements

extends

inherits0..10..1

0..*0..*

1..*1..*

0..*0..*

1..*

0..*

0..*

0..*

0..*

0..*0..10..1

0..*0..* 0..*

1..*

0..*

1

1..*

0..*

1..*1

1

1

0..10..1

0..*0..*

InterfaceComponent

inherits

implements

0..10..1

0..*0..*1..*

0..10..1

0..*0..*0..* 1..*0..*

inherits

19/25 03/07/00

Dans la vue base extension - héritage interfaces représentée par la Figure13,on a choisi de représenter chaque Base par un rectangle à double trait, et chaqueExtension par un rectangle simple. Le composant est représenté par une boite, quicontient les rectangles représentant sa Base et ses Extensions. Les interfaces sontreprésentées par des ovale. La relation d’héritage entre composants est représentéepar une flèche, de la Base du composant vers la Base de son super composant. Larelation d’héritage entre interfaces est représentée par un trait, entre l’interface et sasuper interface, ainsi que la relation d’ implémentation entre interface et Base, ouentre interface et Extension.

3.2.3.Architecture

La sélection des informations à visualiser s’effectue à l’aide d’une seuleclasse: OMDatabase fournie pour accéder à la base de données de manièretransparente (voir Figure 14).

La représentation graphique des éléments du modèle, s’effectue à l’aide dulogiciel réalisé.

Figure 14 : Architecture

GrappaDot

appelle

Vues

Analyseur

Le logiciel réalisédans le cadre du stageLeGraph

OMDatabase

Object Store

Source

Extraction

Base d’objets

Visualisation

Vuesflot de données

appelle

Code source Dassault Systèmes

20/25 03/07/00

3.2.4.Réalisation :

Le programme est écrit en Java, et formé de trois classes:

• "BarreOutils". Cette classe crée une barre d’outils formée d’un champ de texte poury écrire le nom du composant à partir duquel on va construire le graphe, et deplusieurs boutons permettant de préciser le type de vue qu’on veut afficher dansle panneau de dessin.

• "LeGraph". Dans cette classe ou se trouvent les procédures de construction desdifférents types de vues. Cette classe crée un panneau de dessin dans lequel onaffiche le graphe correspondant a la vue choisie.

• "FenetreDessin". Il s’agit de la classe principale affichant la barre d’outils, et lepanneau de dessin contenant le graphe.

La Figure 16 illustre la modélisation de ces trois classes.

Figure 15 : Interface du logiciel réalisé

BarreOutils

LeGraph

FenetreDessin

21/25 03/07/00

Figure 16 : classes du logiciel réalisé

La construction des vues est effectuée dans la classe "LeGraph", à l’aide desix méthodes, basées sur les classes du paquetage Grappa. La Figure 17 illustre lesdépendances entre les procédures de la classe "LeGraph".

Figure 17 : dépendances entre les méthodes de construction des vues

dessinerComposantEtSesInterfaces

dessinerHeritageDInterface dessinerComposantBaseExtensions

dessinerBaseExtansionEtSesInterfaces

dessinerHeritageDeComposant

specifierUnComposant

appèle

22/25 03/07/00

La Figure 18 illustre une des vues qu’offre le logiciel réalisé (la vuecomposant-héritage interfaces), en indiquant pour chaque partie de ce graphe laméthode qui l’a construit.

Figure 18 : méthodes de construction de la vue composant - héritage interfaces

Les méthodes de construction des vues du logiciel réalisées sont les suivantes:

1) dessinerHeritageDeComposant (composant, vue): nœud {composant}

Cette méthode dessine de manière récursive l’héritage de composants en luipassant un paramètre qui lui indique le modèle de composants demandé. Pourdessiner les composants sous forme choisie, cette méthode fait appel à une des troisméthodes suivantes selon la vue sélectionnée:

• dessinerUnComposant• dessinerComposantEtSesInterfaces• dessinerBaseExtansionEtSesInterfaces

La relation d’héritage entre composants est représentée par une flèche, ducomposant vers son super composant.

dessinerComposantEtSesInterfaces

dessinerHeritageDeComposant

dessinerHeritageDInterfaces

23/25 03/07/00

2) dessinerUnComposant (composant, vue): nœud {composant}

Cette méthode nous permet de dessiner un composant en une des deuxformes illustrées dans les deux Figures ci dessous :

L’une de ces deux formes affiche la relation d’implémentation entre composants etinterfaces, l’autre affiche la relation d’extension entre base et extensions. La formechoisie pour dessiner le composant dépend du paramètre passé a cette méthode.

3) dessinerComposantEtSesInterfaces (composant): nœud {composant}

Cette méthode permet de dessiner un rectangle représentant le composant.Puis de chercher dans la base de données les interfaces implémentées par cecomposant. Pour chaque une de ces interfaces, cette méthode fait appel à laméthode dessinerHeritageDInterface, qui dessine depuis l’interface passée enparamètre, l’héritage d’interfaces.

La Figure 21 illustre le graphe affichée par cette méthode.

Figure 21 : héritage entre interfacesimplémentation entre interface et composant

Figure 19 :relation implémentation entre

Composant et Interfaces

Figure 20 :relation extension entre

Base et Extensions

24/25 03/07/00

4) dessinerBaseExtansionsEtSesInterfaces (composant): nœud { base }

Cette méthode fait appel à la méthode dessinerComposantBaseExtensionsdessinant le composant sous forme illustrée dans la Figure 23, et récupérant le nomde la Base et des extensions dans une liste. Puis, la méthode cherche dans la basede données les interfaces implémentée par chaque élément de cette liste. Pourchacune de ces interfaces, cette méthode fait appel a la méthode :dessinerHeritageDInterface, qui dessine depuis l’interface passée en paramètre,l’héritage d’interfaces.

La Figure 22 illustre la forme affichée par cette méthode.

Figure 22 : extension entre base et extension, héritage entre interfacesimplémentation entre interface et composant

5) dessinerHeritageDInterface (interface): nœud { interface }

Cette méthode dessine de manière récursive l’héritage d’interfaces à partir del’interface passée en paramètre. Les interfaces sont représentées par des ovales.L’héritage est représenté par des traits qui relient l’interface et sa super interface.

6) DessinerComposantBaseExtensions (composant): un vecteur de nœuds

Cette méthode dessine un rectangle a double trait pour représenter la Base ducomposant, et des rectangles simples pour représenter les Extensions. Lecomposant est représenté par une boite, qui contient les rectangles représentant saBase et ses Extensions.

25/25 03/07/00

La Figure 23 illustre la forme affichée par cette méthode.

Figure 23 : extension entre base et extension

4. Conclusion

L’objectif de ce stage était de réaliser un outil de visualisation pour l’ObjectModeler de Dassault Systèmes, capable de visualiser n'importe quel type de graphesen indiquant simplement les relations et les entités à visualiser ainsi que la manièrede les visualiser.

Dans les dix premières semaines de ce stage nous avons réalisé un logicielpermettant d’afficher plusieurs vues à partir du nom d’un composant. Ces vuesdiffères par les informations visualisées et par leur rendu.

Notre but, dans le temps qui nous reste, est d’améliorer le logiciel réalisé, enajoutant la possibilité de choisir les informations à visualiser, et la sélection de lamanière de visualiser ces informations. Plus particulièrement, de permettre despécifier quelles relations doivent êtres visualisées et sous quelle forme graphique(traits reliant deux nœuds, boites imbriquées, couleurs, etc.).

En réalité ce stage s'inscrit dans un projet à plus long terme, celui dedévelopper un environnement générique permettant de faciliter la description etl'évolution des architectures logicielles.

5. Références bibliographiques

(1) Software-Practice and Experience "An open graph visualization system andits applications to software engineering", Mai 1999

(2) R. Angles "Outils pour l’exploration et la définition de l’architecture deslogiciels". Rapport de stage, Avril 2000

(3) J. Cardon "l’exploration des logiciels de grande taille et de leur évaluation".Rapport de DEA, Juin 2000