Correction des Codes Canoniques

src/fr/iutfbleau/sae/mhuffman/CanonicalCode.java

@@ -2,33 +2,51 @@ package fr.iutfbleau.sae.mhuffman;
 import java.util.*;
 
 public class CanonicalCode{
-	private Map<Integer, Integer> codeLengths = new HashMap<>(); //  Changer ici car la premiere version est incorecte
+	private Map<Integer, String> codeLengths = new HashMap<>();
 	private Map<Integer, String> canonicalCodes = new HashMap<>();
 
 
 	public Map<Integer,String> generateCodes(){
 		// 1 ere chose à faire : on regarde uniquement la longueur des codes initiaux(Huffman)
 		// 2eme chose à faire : remettre dans l'ordre des longueurs : si meme taille ==> regarder valeur 
-		// 3eme chose à faire : ecriture des codes canoniques : 
+		// 3eme chose à faire : ecriture des codes canoniques 
 
 		// on recupere les entrées des codes Huffman pour pouvoir les triés
-		List<Map.Entry<Integer, Integer>> liste  = new ArrayList<>(codeLengths.entrySet());
+		List<Map.Entry<Integer, String>> liste  = new ArrayList<>(codeLengths.entrySet());
 
 		// ici on comparer par longueur de la valeur ou sinon par la clé
-		// type générique pour éviter les erreurs de compilation !!!
-		// referencement de méthode : passer une méthode déja existante
-        liste.sort(Comparator.<Map.Entry<Integer,Integer>>comparingInt(Map.Entry::getValue)
-                            .thenComparing(Map.Entry::getKey));
+        	
+        Collections.sort(liste, new Comparator<Map.Entry<Integer, String>>() {
+            @Override
+            public int compare(Map.Entry<Integer, String> arg1 ,Map.Entry<Integer, String> arg2) {
 
-        int code = 0; // code canonique à attribuer 
+                int length1 = arg1.getValue().length();
+                int length2 = arg2.getValue().length();
+
+                if (length1 != length2) {
+                    return length1 - length2; 
+                }
+                return arg1.getKey() - arg2.getKey();
+            }
+        });
+
+
+		int code = 0; // code canonique à attribuer 
         int temp = 0; //garde la longueur du code précedent , pour gérer le décalage 
 
-        for (Map.Entry<Integer, Integer> entree : liste ) {
+        for (Map.Entry<Integer, String> entree : liste ) {
             int valeur = entree.getKey(); // symbole actuel 
-            int longueur = entree.getValue(); // longueur du code actuel 
+            int longueur = entree.getValue().length(); // longueur du code actuel 
 
-            code <<= (longueur - temp); // permet de décaler le code actuel si la longueur augmente 
-            canonicalCodes.put(valeur,code); // ajout dans le dictionnaire 
+            code <<= (longueur - temp); // permet de décaler le code actuel si la longueur augmente
+            String codeBinaire = Integer.toBinaryString(code);
+
+            // permet d'ajouter des zeros si nécessaire !!!
+			while (codeBinaire.length() < longueur) {
+    		codeBinaire = "0" + codeBinaire;
+			} 
+
+            canonicalCodes.put(valeur,codeBinaire); // ajout dans le dictionnaire 
             code++; // incrémentation pour la valeur qui suit 
             temp = longueur; // mise à jour de la longueur précedente
         }
@@ -37,12 +55,12 @@ public class CanonicalCode{
 	}
 	
 
-	public int getCode(int value){
-		return 0;
+	public String getCode(int value){
+		return this.canonicalCodes.get(value);
 	}
 
 	public int getLength(int value){
-		return 0;
+		return this.codeLengths.get(value).length();
 	}