IFT3913
Qualité du logiciel et métriques
TP1
Conception et implantation d’un parseur
présenté à M. Sahraoui Houari
par
Nicola Grenon
GREN30077303 (grenonni)
le jeudi 15 février 2007
Introduction
Dans le cadre d'un apprentissage sur les mesures et processus, nous avions, dans un premier temps, à créer un parseur pour des données fournies via un fichier texte de syntaxe data warehouse. Les données ainsi traitées devaient avoir une représentation interne aisément manipulable pour usage ultérieur (prochains travaux).
Nous avions également à produire une interface graphique de base afin de faciliter la visualisation de ces dites données.
Dans ce document se trouvent une description de la méthodologie de conception, de la manière d'utiliser le programme de même qu'une schématisation du format interne des données.
Utilisation
Fichiers fournis: parseur.java [ Le fichier exécutable (main) + outils de parsing ]
Syntaxe.Java [ Les classes associées à la syntaxe à traiter ]
Fenetre.java [ Les détails de l'interface visuelle ]
Compilation: make
Exécution: java parseur
Discussion
Comme structure pour représenter les données en mémoire, le choix simple était de rester collé le plus fidèlement possible à la syntaxe fournie sous forme de grammaire BNF. En effet, cette méthode de travail permettrait, entre autre, de facilement mettre la structure à jour s'il était nécessaire d'ajuster la syntaxe. En outre, cela simplifie également la mise en place en conservant une grande cohérence (facilement compréhensible) entre la structure et les données à stocker.
Les classes utilisées sont en fait simple et petites, directement liées au Schéma, Star, Fact table et Dimension table présentés. À ceci s'ajoute une classe Clef, afin de permettre une représentation objet de celles-ci, nous laissant ainsi la possibilité de conserver dans l'objet clef un lien vers sa classe dimension, ce qui pourrait nous donner la latitude de parcourir plus aisément notre base de données dans plusieurs sens.
Le parsing comme tel du texte a été laissé au soin de chaque classe. C'est-à-dire que chacune des classes structurelles reçoit grosso modo le texte au niveau du constructeur et s'organise pour le traiter, refilant possiblement à d'autres classes encore les sous parties nécessaires. Ceci permet de conserver dans un même secteur les références aux données de même type tout en rendant, encore une fois, plus faciles d'éventuelles modifications à la syntaxe.
Le principal point ayant demandé une attention plus pointue lors de la réalisation du programme fut de penser à traiter en premier lieu les Dimensions tables, soit avant la Fact table, lors de la création d'un Star. Le but de cette façon de faire est qu'ainsi nous pouvons directement référencer les clés primaires déjà créées sans devoir faire un retraitement dans une seconde passe, économisant ainsi des ressources.
(Évidemment cela sera plus pertinent dans le cas d'un exemple beaucoup plus lourd.) Un souci qui est resté présent lors du codage fut d'arriver à imaginer, avec le peu d'information disponible, des scénarios d'utilisation de la structure de données développée. C'est ainsi que s'est imposée l'idée de conserver des listes statiques dans les classes de même qu'un lien vers la classe mère dans l'objet clé primaire. De cette façon nous obtenons quelque chose qui sera d'avantage versatile.
D'un point de vue technique, il est apparu simple de générer dans l'ensemble des classes susmentionnées une méthode générique d'id, quitte à ce qu'elle délègue la question à une sous-classe dans le cas du Star. Dans le même esprit, les classes génèrent à l'interne les array qui sont directement utilisés par l'interface graphique, simplifiant grandement l'implémentation de celle-ci.
Finalement, notons qu'il aurait certes été possible de traiter indépendamment les données puis de créer les mêmes objets à partir de l'extérieur en passant les données compilées en paramètres. En fait c'eut été une autre approche intéressante, mais dans ce cas-ci, il me semble que la flexibilité et la solidité que confère l'idée d'intégrer le traitement des données aux classes elles-mêmes motive bien ce choix. Si nous voulions rendre plus robuste le traitement des données, il serait facile d'ajouter des tests un par un pour chaque cas, sans risque de "briser" le traitement global.
Diagramme
Voici un diagramme des classes associées aux éléments de la structure de données. À l'exception de ces classes qui représentent le cœur du programme, il suffit de mentionner les outils statiques inclus dans la classe parseur et l'interface graphique pour faire le tour de toutes les classes définies.
S c h e m a id e n t if ie r :S t r in g
+ id ( )
+ g e t A r r a y S t a r ( )
S t a r
+ id ( ) + g e t F a c t + g e t V e c t D im ( ) + g e t A r r a y D im ( )
F a c t id e n t if ie r :S t r in g
+ id ( )
+ g e t A r r a y C le f ( )
D im e n s io n a l id e n t if ie r :S t r in g
+ id ( )
+ g e t A r r a y C le f ( )
C le f id e n t if ie r :S t r in g
+ id ( ) + s e t P r im a r y ( ) + g e t P r im a r y ( )
1 1 . . n 1 1
1 . . n
1 . . n
1
0 . . n
1 . . n 1
Conclusion
En définitive, le traitement des données comme telles n'est pas un très grand problème: ce n'est pas très difficile à coder. Ce qui peut engendrer des problèmes, c'est d'un côté le niveau de robustesse désiré (ce qui ne s'applique pas vraiment ici, mais la forme employée laisse la porte ouverte à des ajouts) et de l'autre la nécessité de planifier les relations qui devront rester dynamiques entre certaines parties des données lors de la représentation interne de l'information (en prenant le temps d'imaginer les divers cas de figures possibles pour l'appel des informations à partir de telle ou telle autre donnée, on peut élaborer une bien meilleure représentation et ajouter des possibilités (par exemple le lien clef/table)).
Il est toutefois difficile d'aller plus loin dans l'analyse de ce travail, car nous n'en connaissons pas vraiment les objectifs à moyen terme. Le tout est quelque peu abstrait pour le moment. Ceci dit, des améliorations, qui n'étaient pas requises ici, pourraient bien entendu être faites au niveau de la robustesse de la syntaxe pour, par exemple, détecter les problèmes de pairage d'accolades ou autres.
