Le problème des boîtes imbriquées (v. 0)

Vous devez développer un ensemble de classes permettant de construire des boîtes et de les imbriquer. Nous avons abordé en classe une solution à ce problème, développée de manière incrémentale de manière à aborder le problème de la refactorisation du code, mais cette fois, c'est à un problème de design que vous êtes conviés.

C'est un problème a priori facile à résoudre. Dans une acception C#, l'idée est que si le programme suivant :

using System;

Console.WriteLine("J'aime mon prof");

... devrait afficher cela :

J'aime mon prof

... alors le programme suivant :

using System;

Console.WriteLine(new Boite("J'aime mon prof"));

... devrait afficher cela :

+---------------+
|J'aime mon prof|
+---------------+

...et que si le programme suivant :

using System;

Console.WriteLine("J'aime\nmon \"prof\"");
Console.WriteLine(@"Moi
""aussi""");

... devrait afficher cela :

J'aime
mon "prof"
Moi
"aussi"

... alors le programme suivant :

using System;

Console.WriteLine(new Boite("J'aime\nmon \"prof\""));
Console.WriteLine(new Boite(@"Moi
""aussi"""));

... devrait afficher cela :

+----------+
|J'aime    |
|mon "prof"|
+----------+
+-------+
|Moi    |
|"aussi"|
+-------+

Facile non?

Le plaisir commence...

Évidemment, ça devient plus intéressant si on inclut les combos verticaux et horizontaux. Par exemple, ceci :

using System;

Console.WriteLine(
   new Boite(new ComboVertical(new Boite("J'aime"), new Boite("mon \"prof\"")))
);
Console.WriteLine(
   new Boite(new ComboHorizontal(new Boite ("Moi"), new Boite("\"aussi\"")))
);

... doit afficher cela :

+----------+
|J'aime    |
|----------|
|mon "prof"|
+----------+
+-----------+
|Moi|"aussi"|
+-----------+

Plus en détail :

• Il importe que la représentation retournée par ToString pour une Boite s'affiche avec un cadre où les coins sont des '+' et où les murs sont '-' pour les murs horizontaux et '|' pour les murs verticaux
• Le texte dans une Boite doit respecter les sauts de ligne. Vous pouvez présumer, pour alléger le travail à faire, que les programmes de test ne vous mèneront pas à faire des boîtes si grandes que l'affichage en deviendrait illisible
• Un ComboVertical des boîtes ba et bb placera ces deux boîtes une par-dessus l'autre et s'assurera que leur largeur soit celle de la plus large des deux
• Un ComboHorizontal des boîtes ba et bb placera ces deux boîtes une à gauche de l'autre et s'assurera que leur hauteur soit celle de la plus haute des deux
• Il sera possible de placer un combo, vertical ou horizontal, dans une Boite
• Seule une Boite implémentera ToString. Pour afficher un combo, vertical ou horizontal, il faudra le placer dans une Boite
• Portez attention à la gestion des boîtes vides, particulièrement dans les combos. Ça demande un peu de doigté
• Vous pouvez ajouter des classes et des interfaces à celles qui apparaissent dans le code de test

Il s'agit d'un problème un peu plus costaud qu'il n'y paraît, ce qui explique que je vous laisse du temps pour le faire. Profitez de ce temps, et cherchez à obtenir un design qui vous semble de qualité : concis, modifiable, esthétique, clair. Si votre design est complexe, ou si vous codez sans réfléchir, ceci peut être casse-gueule. Si vous y allez avec délicatesse, votre solution pourrait être fort élégante.

Notez que nous avons vu plusieurs techniques au cours de votre formation qui sont susceptibles de vous être utiles pour résoudre ce problème. Profitez-en pour expérimenter!

Exemples de programmes clients

Vous pouvez écrire ce programme en C# ou en Java, à votre convenance. Deux exemples de code client suivent, un par langage, puis l'affichage attendu sera présenté.

Code client en C#

Pour C#, le code client serait :

using System;
using Boites; // pas obligé; dans mon cas, c'était utile

Boite b = new ();
Console.WriteLine(b);
Console.WriteLine(new Boite("yo"));
string texte = @"Man! Hey!!!
ceci est un test
multiligne";
string autTexte = "Ceci\nitou, genre";
Boite b0 = new (texte);
Boite b1 = new (autTexte);
Console.WriteLine(b0);
Console.WriteLine(b1);
ComboVertical cv = new (b0, b1);
Console.WriteLine(new Boite(cv));
ComboHorizontal ch = new (b0, b1);
Console.WriteLine(new Boite(ch));
ComboVertical cvplus = new (new Boite(cv), new Boite(ch));
Console.WriteLine(new Boite(cvplus));
ComboHorizontal chplus = new (new Boite(cv), new Boite(ch));
Console.WriteLine(new Boite(chplus));
ComboVertical cvv = new (new Boite(chplus), new Boite("coucou"));
Console.WriteLine(new Boite(cvv));
Console.WriteLine(new Boite(
   new ComboHorizontal(
      new Boite("a\nb\nc\nd\ne"),
         new Boite(
            new ComboVertical(
               new Boite("allo"), new Boite("yo")
            )
         )
      )
   )
);
Console.WriteLine(
   new Boite(new ComboHorizontal(new Boite("Yo"), new Boite()))
);
Console.WriteLine(
   new Boite(new ComboHorizontal(new Boite(), new Boite("Ya")))
);
Console.WriteLine(
   new Boite(new ComboHorizontal(new Boite(), new Boite()))
);
Console.WriteLine(
   new Boite(new ComboVertical(new Boite(), new Boite()))
);
Console.WriteLine(
   new Boite(new ComboVertical(new Boite("Yip"), new Boite()))
);
Console.WriteLine(
   new Boite(new ComboVertical(new Boite(), new Boite("Yap")))
);

Code client en Java

Pour Java, le code client serait :

public class Program {
   public static void main(String[] args) {
      Boite b = new Boite();
      System.out.println(b);
      System.out.println(new Boite("yo"));
      String texte = "Man! Hey!!!\nceci est un test\nmultiligne";
      String autTexte = "Ceci\nitou, genre";
      Boite b0 = new Boite(texte);
      Boite b1 = new Boite(autTexte);
      System.out.println(b0);
      System.out.println(b1);
      ComboVertical cv = new ComboVertical(b0, b1);
      System.out.println(new Boite(cv));
      ComboHorizontal ch = new ComboHorizontal(b0, b1);
      System.out.println(new Boite(ch));
      ComboVertical cvplus = new ComboVertical( new Boite(cv), new Boite(ch));
      System.out.println(new Boite(cvplus));
      ComboHorizontal chplus = new ComboHorizontal(new Boite(cv), new Boite(ch));
      System.out.println(new Boite(chplus));
      ComboVertical cvv = new ComboVertical(new Boite(chplus), new Boite("coucou"));
      System.out.println(new Boite(cvv));
      System.out.println(new Boite(
         new ComboHorizontal(
            new Boite("a\nb\nc\nd\ne"),
               new Boite(
                  new ComboVertical(
                     new Boite("allo"), new Boite("yo")
                  )
               )
            )
         )
      );
      System.out.println(
         new Boite(new ComboHorizontal(new Boite("Yo"), new Boite()))
      );
      System.out.println(
         new Boite(new ComboHorizontal(new Boite(), new Boite("Ya")))
      );
      System.out.println(
         new Boite(new ComboHorizontal(new Boite(), new Boite()))
      );
      System.out.println(
         new Boite(new ComboVertical(new Boite(), new Boite()))
      );
      System.out.println(
         new Boite(new ComboVertical(new Boite("Yip"), new Boite()))
      );
      System.out.println(
         new Boite(new ComboVertical(new Boite(), new Boite("Yap")))
      );
   }
}

Affichage attendu

Que vous ayez choisi l'un ou l'autre de ces langages, l'affichage attendu pour le code de test proposé va comme suit :

++
++
+--+
|yo|
+--+
+----------------+
|Man! Hey!!!     |
|ceci est un test|
|multiligne      |
+----------------+
+-----------+
|Ceci       |
|itou, genre|
+-----------+
+----------------+
|Man! Hey!!!     |
|ceci est un test|
|multiligne      |
|----------------|
|Ceci            |
|itou, genre     |
+----------------+
+----------------------------+
|Man! Hey!!!     |Ceci       |
|ceci est un test|itou, genre|
|multiligne      |           |
+----------------------------+
+----------------------------+
|Man! Hey!!!                 |
|ceci est un test            |
|multiligne                  |
|----------------------------|
|Ceci                        |
|itou, genre                 |
|----------------------------|
|Man! Hey!!!     |Ceci       |
|ceci est un test|itou, genre|
|multiligne      |           |
+----------------------------+
+---------------------------------------------+
|Man! Hey!!!     |Man! Hey!!!     |Ceci       |
|ceci est un test|ceci est un test|itou, genre|
|multiligne      |multiligne      |           |
|----------------|                |           |
|Ceci            |                |           |
|itou, genre     |                |           |
+---------------------------------------------+
+---------------------------------------------+
|Man! Hey!!!     |Man! Hey!!!     |Ceci       |
|ceci est un test|ceci est un test|itou, genre|
|multiligne      |multiligne      |           |
|----------------|                |           |
|Ceci            |                |           |
|itou, genre     |                |           |
|---------------------------------------------|
|coucou                                       |
+---------------------------------------------+
+------+
|a|allo|
|b|----|
|c|yo  |
|d|    |
|e|    |
+------+
+---+
|Yo||
+---+
+---+
||Ya|
+---+
+-+
+-+
++
||
++
+---+
|Yip|
|---|
+---+
+---+
|---|
|Yap|
+---+

Que vous abordiez ce problème en Java ou en C#, faites attention au partage des ressources. Je vous invite à prendre soin de dupliquer les objets que vous manipulez pour éviter qu'une redimension fortuite n'endommage un objet manipulé indirectement.

Exemple de design possible

Votre chic prof, quand il a résolu le problème, en est arrivé au design suivant. Vous n'avez absolument pas à faire comme lui. Pris d'un point de vue aérien, le schéma de sa solution est :

Quelques remarques :

• J'ai décidé de faire de ComboVertical, ComboHorizontal et Mono (ce que j'utilise pour les boîtes qui contiennent du texte, monoligne ou multiligne, tout simplement) des dérivés d'une même classe parent. Pour moi, ça simplifie le portrait quand je les place dans une Boite. Cela dit, j'aime plus ou moins mon nom (IBoite) pour ce parent. Le nom est à repenser, mais le design est pas mal
• J'ai des énumérateurs (variante des itérateurs) pour parcourir les « lignes » des enfants d'IBoite. Ça m'a beaucoup aidé à alléger le code. Quand je prends n'importe quel IBoite (incluant les enfants), je lui demande un énumérateur et je m'en sers pour aller d'une ligne à l'autre
• Les instances de Cadre me servent encore pour présenter convenablement mon contenu

Plus en détail :

• Vous remarquerez que dans mon design, une Boite comprend un IBoite par composition. Puisque IBoite est une abstraction polymorphique, cela signifie que je dois réaliser la duplication du contenu par clonage
• Toutes mes classes dérivant d'IBoite exposent une méthode retournant un objet capable d'itérer sur le contenu d'une sorte de boîte. C'est ce qui m'a le plus aidé, sans doute, à résoudre le problème
• Mes énumérateurs dérivent tous d'IÉnumérateur<string>, appliqué au type de texte manipulé dans mes boîtes. J'ai fait de cette interface un dérivé de IEnumerator<string> ce qui me permet d'afficher mes boîtes avec un foreach. En plus des méthodes de IEnumerator<T>, mon IÉnumérateur<T> expose :
  • La propriété Filling, dont je me sers si j'ai besoin de lignes alors que le contenu dans la boîte a été épuisé, et
  • La propriété HasNext, qui s'avère seulement si l'énumérateur ne mène pas déjà au dernier élément de la séquence d'origine

À titre d'exemple, pour mes fins, la classe ComboVertical.Énumérateur implémente IÉnumérateur<string> et fait en sorte que j'itère d'abord sur la section du haut, puis (brièvement) sur la « section » du centre, puis sur la section du bas, ce qui cache à la Boite englobante les détails d'implémentation de ce qu'elle « contient ».

Si vous souhaitez un petit bonus

Étant donné que ce travail pratique a été proposé par le passé et a acquis, semble-t-il, une certaine... réputation, j'ai pris sur moi de propose une option vous permettant d'aller chercher un petit bonus si tel est votre souhait.

Ce bonus prend la forme d'un MonoCombo, représentant une boîte encadrée dans une Boite. Évidemment, un MonoCombo peut être placé dans n'importe quelle Boite, et peut contenir n'importe quelle Boite.

Un exemple de programme C# utilisant aussi des MonoCombo suit. Vous pouvez extrapoler à partir del'exemple Java plus haut pour en arriver au même résultat avec ce langage :

using System;
using Boites; // pas obligé; dans mon cas, c'était utile

Boite b = new ();
Console.WriteLine(b);
Console.WriteLine(new Boite("yo"));
string texte = @"Man! Hey!!!
ceci est un test
multiligne";
string autTexte = "Ceci\nitou, genre";
Boite b0 = new (texte);
Boite b1 = new (autTexte);
Console.WriteLine(b0);
Console.WriteLine(b1);
ComboVertical cv = new (b0, b1);
Console.WriteLine(new Boite(cv));
ComboHorizontal ch = new (b0, b1);
Console.WriteLine(new Boite(ch));
ComboVertical cvplus = new (new Boite(cv), new Boite(ch));
Console.WriteLine(new Boite(cvplus));
ComboHorizontal chplus = new (new Boite(cv), new Boite(ch));
Console.WriteLine(new Boite(chplus));
ComboVertical cvv = new (new Boite(chplus), new Boite("coucou"));
Console.WriteLine(new Boite(cvv));
Console.WriteLine(new Boite(
   new ComboHorizontal(
      new Boite("a\nb\nc\nd\ne"),
         new Boite(
            new ComboVertical(
               new Boite("allo"), new Boite("yo")
            )
         )
      )
   )
);
Console.WriteLine(
   new Boite(new ComboHorizontal(new Boite("Yo"), new Boite()))
);
Console.WriteLine(
   new Boite(new ComboHorizontal(new Boite(), new Boite("Ya")))
);
Console.WriteLine(
   new Boite(new ComboHorizontal(new Boite(), new Boite()))
);
Console.WriteLine(
   new Boite(new ComboVertical(new Boite(), new Boite()))
);
Console.WriteLine(
   new Boite(new ComboVertical(new Boite("Yip"), new Boite()))
);
Console.WriteLine(
   new Boite(new ComboVertical(new Boite(), new Boite("Yap")))
);
Console.WriteLine(
   new Boite(new ComboVertical(new Boite(), new Boite()))
);
Console.WriteLine(new Boite(new MonoCombo(new Boite("allo"))));
Console.WriteLine(new Boite(new MonoCombo(new Boite(new MonoCombo(new Boite("allo"))))));
Console.WriteLine(new Boite(
   new ComboVertical(
      new Boite (new MonoCombo(new Boite(new MonoCombo(new Boite("allo"))))),
      new Boite("Eh ben")
   )
));
Console.WriteLine(new Boite(
   new ComboHorizontal(new Boite("a\nb\nc\nd"),
                       new Boite(new MonoCombo(new Boite())))
));
Console.WriteLine(new Boite(
   new ComboHorizontal(
      new Boite(new MonoCombo(new Boite(new MonoCombo(new Boite("allo"))))),
      new Boite(new ComboVertical(
         new Boite("Eh ben"),
         new Boite(new MonoCombo(new Boite(
            new ComboHorizontal(new Boite("yo"), new Boite("hey"))
         )))
      ))
   )
));

L'affichage attendu serait alors :

++
++
+----------------+
|Man! Hey!!!     |
|ceci est un test|
|multiligne      |
+----------------+
+-----------+
|Ceci       |
|itou, genre|
+-----------+
+----------------+
|Man! Hey!!!     |
|ceci est un test|
|multiligne      |
|----------------|
|Ceci            |
|itou, genre     |
+----------------+
+----------------------------+
|Man! Hey!!!     |Ceci       |
|ceci est un test|itou, genre|
|multiligne      |           |
+----------------------------+
+----------------------------+
|Man! Hey!!!                 |
|ceci est un test            |
|multiligne                  |
|----------------------------|
|Ceci                        |
|itou, genre                 |
|----------------------------|
|Man! Hey!!!     |Ceci       |
|ceci est un test|itou, genre|
|multiligne      |           |
+----------------------------+
+---------------------------------------------+
|Man! Hey!!!     |Man! Hey!!!     |Ceci       |
|ceci est un test|ceci est un test|itou, genre|
|multiligne      |multiligne      |           |
|----------------|                |           |
|Ceci            |                |           |
|itou, genre     |                |           |
+---------------------------------------------+
+---------------------------------------------+
|Man! Hey!!!     |Man! Hey!!!     |Ceci       |
|ceci est un test|ceci est un test|itou, genre|
|multiligne      |multiligne      |           |
|----------------|                |           |
|Ceci            |                |           |
|itou, genre     |                |           |
|---------------------------------------------|
|coucou                                       |
+---------------------------------------------+
+------+
|a|allo|
|b|----|
|c|yo  |
|d|    |
|e|    |
+------+
+---+
|Yo||
+---+
+---+
||Ya|
+---+
+-+
+-+
+---+
|Yip|
|---|
+---+
+---+
|---|
|Yap|
+---+
++
||
++
+------+
|+----+|
||allo||
|+----+|
+------+
+--------+
|+------+|
||+----+||
|||allo|||
||+----+||
|+------+|
+--------+
+--------+
|+------+|
||+----+||
|||allo|||
||+----+||
|+------+|
|--------|
|Eh ben  |
+--------+
+----+
|a|++|
|b||||
|c||||
|d|++|
+----+
+-----------------+
|+------+|Eh ben  |
||+----+||--------|
|||allo|||+------+|
||+----+|||yo|hey||
|+------+|+------+|
+-----------------+

Vous constaterez que les avertissements d'usage s'appliquent encore ici : si votre design est propre, ce sera un ajout relativement simple. Si vous essayez d'y aller par force brute et de tricher, ce sera... douloureux.

Prenez le temps de réfléchir à votre design. C'est un travail pratique amusant, et instructif.