Ce laboratoire est fait en deux parties, la première en Nit, pour jouer avec le raffinement de classes, et la seconde en Java pour essayer de reproduire dans un langage à objets habituel.
Le thème est de faire un petit convertisseur Logo vers SVG en séparant les préoccupations.
Afin de ne pas tout écrire, on vous donne à disposition un code incomplet qu'il faudra étendre.
Le langage Logo permet de faire de la programmation graphique amusante.
Dans ce laboratoire, on considère des programmes Logos très simples composé seulement des 3 instructions forward, turn right et repeat.
La structure d'un programme Logo est donnée dans le fichier logo.nit.
Pour simplifier la création d'un objet programme logo, on fournit une API fluide via la classe LogoWriter et la fonction logo.
to_s de LogoProg et LogoRepeatlogo$ nit logo.nit
REPEAT 5 [FD 50 RT 144]
REPEAT 4 [FD 50 RT 90] FD 50 RT -135 FD 35 RT -90 FD 35 RT 225
Aide 1: for item in coll do ... pour itérer sur une collection
Aide 2: for i in [0..len[ do ... pour itérer len fois.
Aide 3: "A {b} C {d}" est équivalent à "A " + b.to_s + " C " + d.to_s.
Aide 4: [a,b,c].join("x") est équivalent à "{a}x{b}x{c}".
Nous avons des programmes Logo, mais nous pouvons rien en faire pour l'instant.
Il suffit d'ajouter une tortue et d'implémenter les services qui déplacent la tortue. Comme en Nit il est possible de raffiner des classes existantes, il suffit d'implémenter les services qui vont bien, directement dans les raffinements des classes.
Dans le module turtle.nit, on vous fournit une classe Turtle et on raffine la classe Logo.
apply des sous-classes de Logoturtle$ nit turtle.nit
(50.0,0.0;0.0)
(10.0,20.0;90.0)
(55.0,55.0;180.0)
Le patron de conception Visiteur permet de séparer un algorithme d'une structure de données.
Il est intéressant dans les langages à objets classiques car il permet de définir de nouveaux traitements sur une structure de données existante complexe que l'on ne veut/peut pas modifier.
Dans ce laboratoire, la structure de données considérée est la classe Logo et ses sous-classes.
Elle est complexe car elle est hétérogène (plusieurs catégories d'instructions) et récursive (à cause de l'instruction repeat).
Comme en Nit il est possible de raffiner les classes existantes dans un module différent, le visiteur est moins utile. La preuve: c'est exactement ce que l'on a fait à l'étape précédente où on a ajouté le comportement apply aux classes existantes.
Toutefois, le visiteur a un autre avantage, il permet de factoriser le code de parcours de la structure de données. En effet, si on regarde les classes LogoProg et LogoRepeat on se rend compte que le comportement sera très semblable d'un algorithme à l'autre: il suffit pour s'en convaincre de regarder le code de apply.
Également, lorsque qu'un algorithme doit visiter les éléments, il faut généralement maintenir un état spécifique à l'algorithme. En programmation à objets, il est raisonnable de maintenir cet état dans un objet spécifique qui est passé en paramètre dans les méthodes des éléments. Cet objet est un bon candidat pour devenir un visiteur.
Le module visitor.nit introduit la structure abstraire d'un visiteur.
Notez que grâce au raffinement on peut introduire l'instrumentation du visiteur dans un sous-module sans toucher aux classes originales.
Notez aussi que visitor.nit ne dépend pas de turtle.nit.
Dans cette étape nous allons implémenter le calcul d'une boite englobante un programme Logo. Pour ce faire il faut visiter les instructions d'un programme en mettant à jour la position de la tortue et en grossissant la boite englobante. Une bonne conception indiquerait de créer un visiteur qui agrège ces deux informations.
BoundVisitor.bound$ nit bound.nit
(0.0,0.0)--(10.0,0.0)
(0.0,-18.164)--(50.0,29.389)
(0.0,-24.749)--(50.0,50.0)
Aide 1: Dans visitor.nit, inspirez-vous de apply pour implémenter visit_all.
Aide 2: Dans bound.nit, vous pouvez raffiner la classe Logo et ses sous-classes pour ajouter du service.
Maintenant que nous maîtrisons les visiteurs, il ne reste qu'à générer le SVG.
Le module canvas.nit indépendant fournit un moyen simpliste de générer du SVG.
trace.nit.trace$ nit trace.nit
Aide: initialisez la tortue en (250.0,100.0) pour quelle soit au milieu du canevas SVG.
On imagine que les modules précédents sont fournis par un tiers, on ne peut pas les modifier. Toutefois on veut pouvoir les faire évoluer pour les adapter à de nouveaux besoins.
On va donc créer un nouveau module pen.nit qui va importer tous les modules précédents (en fait seul trace suffit) et spécialiser ou raffiner les classes existantes.
L'objectif est de créer deux nouvelles instructions «pen up» (PU) et «pen down» (PD) qui permettent de lever ou poser le crayon afin de pouvoir déplacer la tortue sans tracer sur le canevas lorsque le crayon est levé.
pen$ nit pen.nit
PU FD -200 PD REPEAT 7 [REPEAT 4 [FD 50 RT 90] FD 50 RT -135 FD 35 RT -90 FD 35 RT 225 PU FD 60 PD]
Indice: pour commencer, raffinez la classe Turtle pour rajouter un état indiquant si le crayon est levé ou posé.
Réimplémentez ce programme en Java (ou en C#) en essayant de séparer au mieux les préoccupations.
Visitor.
Edit