Implémentation du dictionnaire 

TileConfiguration

TileConfiguration configure le jeu de caractère utilisé dans le dictionnaire, en plus des spécificités liées au scrabble. 

Voici un lien vers un Json qui vous permet de configurer un jeu en français. Ce Json ou autre structure doit être transformée dans TilesConfiguration qui est ensuite passé dans TilesIUtils. Le TilesUtils est quant à lui injecté dans le compilateur de dictionnaire.

TilesConfiguration

Cette classe est utilisée pour mapper un caractère vers sa valeur en byte, et inversément pour mapper sa valeur en, byte vers son caractère correspondant. Voici un extrait de code permettant de créer cette configuration.

        public static TilesConfiguration ReadLetterConfig(ILetterConfigModel letterData)
        {
            var config = new TilesConfiguration();

            config.Name = letterData.Name;
            foreach (var letter in letterData.Letters)
            {
                config.LettersByByte.Add(letter.Letter, letter);
                config.LettersByChar.Add(letter.Char[0], letter);
            }
            return config;
        }

TilesUtils

TilesUtils contient les fonctions nécessaires pour convertir des tuiles en mots, ou des mots en tuiles. Dans le cas qui nous occupe, la création du dictionnaire, seul ConvertWordToBytes.

La sérialisation du dictionnaire est customisée. On ne peut en effet pas sérialiser le dictionnaire en utilisant la sérialisation binaire standard de .NET. La sérialisation .NET ne tient pas compte des noeuds identiques, chaque noeud sera resérialiser autant de fois qu'il est utilisé 'logiquement', et nous mènerait à un fichier énormissime, et qui serait évidemment aussi long à recharger en mémoire et à recalculer tous les noeuds. Pour cela nous avons deux options : SaveToFile ou WriteToStream

4.1 Déterminer l'ordre d'écriture des noeuds.

Le dictionnaire est à ce stade compressé. Il faut maintenant s'assurer que l'on puisse écrire cette structure aussi d'une façon minimale. Pour cela avant la sérialisation dans le stream nous allons définir l'ordre d'écriture des noeuds et attribuer à chaque noeud un ID => Dictionary<ILetterNode, int> nodeToId  associant à chaque noeud un Id et List<ILetterNode> writeOrder = new List<ILetterNode>() contenant les noeuds à sérialiser.

4. 2 Sérialisation des noeuds

Pour la sérialisation, nous allons écrire chaque noeud de writeOrder dans le stream. Chaque noeud est composé de : 

1. Le bit de contrôle (byte)

2. Le nombre d'enfants (int)

3. Pour chaque enfant :

   1. La lettre correspondant au noeud (byte)

   2. Le NodeId qui ramène au point 1.. (int)

  4.3 Compression finale

Pour gagner encore un peu de stockage, le stream est décoré d'un GZipStream qui permet de gagner encore un gros pourcentage d'espace et ainsi optimiser le transfert du dictionnaire à travers le net

La désérialisation, tout comme la sérialisation n,'est pas celle standard au .NET. Il faut relire noeud par noeud et recréer le dictionnaire, une fois le stream dézippé, on peut désérialiser le dictionnaire :

1. On lit le nombre de noeuds présents dans le dictionnaire

2. On crée une Array de LetterNode de la taille du dictionnaire.

3. Ensuite pour chaque noeud nous allons relire séquentiellement le contenu avec ReadNodeWithId(nodeList[i], reader, nodeList);

   1. On lit le bit de Control

   2. Le nombre d'enfants

      1. Pour chaque enfant : 

         1. on lit sa lettre.

         2. on lit son Id, on récupère l'enfant dans nodeList 

         3. et on ajoute à LetterNode.Children le noeud récupéré.

Une fois que tous les noeuds ont été lus, on retrouve l'état du dictionnaire juste après sa compilation, en ayant recrée les références vers les noeuds identiques.

Voici une liste des améliorations à apporter :

• Dans LetterNode, utiliser un Array pour les lettres enfants au lieu d'une liste

• Remplacer les fonctions LINQ ou les foreach en travaillant sur les enfants avec des fonctions customisées : Cela a très peu d'impact sur le module de recherche, mais cela pourrait améliorer les performances dans la résolution d'une partie de scrabble où chaque coup génère des millions de possibilités et de traversée de noeuds

Au final, nous avons 2 représentations du dictionnaire :

• En mémoire, le dictionnaire est représenté sous forme de trie compressé (DAWG), où les nœuds sont reliés par des références objet partagées.

• Lors de la sérialisation, cette structure est transformée en un graphe indexé linéarisé, où chaque nœud est identifié par un identifiant entier stable et les relations sont représentées par des indices.

Les voilà, les dictionnaires prêts à l'emploi, nous allons commencer par la recherche de mots dans un dictionnaire. Ceci sera dans le prochain chapitre.