Transférer les fichiers vers 'src/fr/sae/JSonInspector/Storage'

src/fr/sae/JSonInspector/Storage/Tree.java

@@ -1,17 +1,28 @@
-package fr.sae.JSonInspector.Storage;
+package JsonInspector;
-
-import fr.sae.JSonInspector.Exception.JsonSyntaxException;
-import fr.sae.JSonInspector.Settings.Parameters;
 
 import java.util.ArrayList;
+import java.util.List;
 
 public class Tree {
-    private Node firstNode;
+    private final Node firstNode;
 
+
+    /**
+     * Construit un objet de type 'Tree'
+     * @param file le fichier complet sur une ligne
+     * @throws JsonSyntaxException exception lever en cas d'erreur de syntaxe
+     */
     public Tree(String file) throws JsonSyntaxException {
         firstNode = parseElement(file);
     }
 
+
+    /**
+     * Détermine le type de l'élément passer en argument et le transforme en noeud
+     * @param element
+     * @return le noeud correspondant à "element"
+     * @throws JsonSyntaxException exception lever en cas d'erreur de syntaxe
+     */
     private Node whichType(String element) throws JsonSyntaxException {
         String[] keyValue = splitKeyValue(element);
 
@@ -34,7 +45,7 @@ public class Tree {
 
         } else if (keyValue[0].equals("")) {
 
-            if (keyValue[0].charAt(0) == '{' && keyValue[0].charAt(keyValue[0].length() - 1) == '}') {
+            if (keyValue[0].charAt(0) == '{' && keyValue[0].charAt(keyValue[0].length()-1) == '}') {
                 return parseElement(keyValue[0]);
             } else {
                 throw new JsonSyntaxException();
@@ -45,9 +56,17 @@ public class Tree {
         }
     }
 
+
+    /**
+     * Créer un noeud de type tableau
+     * @param name le nom du tableau
+     * @param rawValues l'ensemble des caractères contenu entre les crochets
+     * @return le noeud correspondant couple clé/valeur fournie
+     * @throws JsonSyntaxException exception lever en cas d'erreur de syntaxe
+     */
     private Node parseArray(String name, String rawValues) throws JsonSyntaxException {
         Node array = new Node(cleanOpeningExpression(name), Type.ARRAY);
-        ArrayList<String> elements = splitList(rawValues);
+        List<String> elements = splitList(rawValues);
 
         for (String value : elements) {
             if (0 < value.length()) {
@@ -67,9 +86,17 @@ public class Tree {
         return array;
     }
 
+
+    /**
+     * Créer un noeud de type objet
+     * @param name nom de l'objet
+     * @param rawValues l'ensemble des éléments contenu entre les accolades
+     * @return le noeud correspondant couple clé/valeur fournie
+     * @throws JsonSyntaxException exception lever en cas d'erreur de syntaxe
+     */
     private Node parseObject(String name, String rawValues) throws JsonSyntaxException {
         Node object = new Node(cleanOpeningExpression(name), Type.OBJECT);
-        ArrayList<String> elements = splitList(rawValues);
+        List<String> elements = splitList(rawValues);
 
         for (String value : elements) {
             object.add(whichType(value));
@@ -78,6 +105,13 @@ public class Tree {
         return object;
     }
 
+
+    /**
+     * Créer un noeud de type pair
+     * @param name nom du couple
+     * @param value valeur
+     * @return le noeud correspondant couple clé/valeur fournie
+     */
     private Node parsePair(String name, String value) {
         Node pair = new Node(cleanOpeningExpression(name), Type.PAIR);
         pair.add(value);
@@ -85,9 +119,16 @@ public class Tree {
         return pair;
     }
 
+
+    /**
+     * Créer un noeud de type element (meme chose que le type object mais sans nom)
+     * @param rawValues l'ensemble des éléments contenu entre les accolades
+     * @return le noeud correspondant couple clé/valeur fournie
+     * @throws JsonSyntaxException exception lever en cas d'erreur de syntaxe
+     */
     private Node parseElement(String rawValues) throws JsonSyntaxException {
         Node element = new Node("", Type.ELEMENT);
-        ArrayList<String> elements = splitList(rawValues);
+        List<String> elements = splitList(rawValues);
 
         for (String value : elements) {
             element.add(whichType(value));
@@ -96,17 +137,29 @@ public class Tree {
         return element;
     }
 
+
+    /**
+     * Enlève les caractères ouvrant et fermant
+     * @param strToClean chaîne de caractères à nettoyer
+     * @return chaîne de caractères nettoyée
+     */
     public static String cleanOpeningExpression(String strToClean) {
         StringBuilder cleanedString = new StringBuilder(strToClean);
         cleanedString.deleteCharAt(0);
-        cleanedString.deleteCharAt(cleanedString.length() - 1);
+        cleanedString.deleteCharAt(cleanedString.length()-1);
         return cleanedString.toString();
     }
 
-    private ArrayList<String> splitList(String listToSplit) {
+
+    /**
+     * Sépare l'ensemble des éléments contenu dans la chaîne de caractères
+     * @param listToSplit la liste à trier
+     * @return l'ensemble des éléments séparé
+     */
+    private List<String> splitList(String listToSplit) {
         char[] chars = cleanOpeningExpression(listToSplit).toCharArray();
         int depth = 0;
-        ArrayList<String> elements = new ArrayList<>();
+        List<String> elements = new ArrayList<>();
         String buffer = "";
 
         for (char currentChar : chars) {
@@ -127,6 +180,12 @@ public class Tree {
         return elements;
     }
 
+
+    /**
+     * Sépare la clé de sa valeur
+     * @param expressionToSplit l'expression à diviser
+     * @return le couple clé/valeur créé
+     */
     private String[] splitKeyValue(String expressionToSplit) {
         boolean inKey = true;
         char[] chars = expressionToSplit.toCharArray();
@@ -150,14 +209,21 @@ public class Tree {
         }
         value = buffer;
 
-        return new String[] { key, value };
+        return new String[] {key, value};
     }
 
+
+    /**
+     * Affiche l'arbre de manière récursive
+     * @param node le noeud a afficher
+     * @param depth la profondeur dans l'arbre
+     * @return le noeud convertit en chaîne de caractères
+     */
     public static String printTree(Node node, int depth) {
         String line = "", indentation = "";
 
-        // créé l'indentation de la bonne taille en fonction de la
+        //créé l'indentation de la bonne taille en fonction de la
-        // profondeur dans l'arbre
+        //profondeur dans l'arbre
         for (int i = 0; i < depth; i++) {
             indentation += Parameters.CONSOLE_INDENTATION;
         }
@@ -168,19 +234,27 @@ public class Tree {
             line += indentation + node.getName();
         }
 
+
         if (node.isObject() || node.isElement()) {
             line += printObjectElement(node, depth, indentation);
 
-        } else if (node.isPair()) {
+        } else if (node.isPair()){
             line += printPair(node);
 
-        } else if (node.isArray()) {
+        } else if (node.isArray()){
             line += printArray(node, depth, indentation);
         }
 
         return line;
     }
 
+
+    /**
+     * Appel les fils suivants d'un noeud père
+     * @param node le noeud père
+     * @param depth la profondeur dans l'arbre
+     * @return l'ensemble des noeuds fils convertit en chaîne de caractères
+     */
     private static String callNextNodes(Node node, int depth) {
         String line = "";
 
@@ -197,6 +271,12 @@ public class Tree {
         return line;
     }
 
+
+    /**
+     * Convertit en chaîne de caractères un noeud de type 'PAIR'
+     * @param node le noeud a afficher
+     * @return le noeud convertit en chaîne de caractères
+     */
     private static String printPair(Node node) {
         String line = "";
 
@@ -214,6 +294,14 @@ public class Tree {
         return line;
     }
 
+
+    /**
+     * Convertit en chaîne de caractères un noeud de type 'OBJECT' ou 'ELEMENT'
+     * @param node le noeud à afficher
+     * @param depth la profondeur dans l'arbre
+     * @param indentation l'indentation du noeud père
+     * @return le noeud convertit en chaîne de caractères
+     */
     private static String printObjectElement(Node node, int depth, String indentation) {
         String line = "";
 
@@ -233,6 +321,14 @@ public class Tree {
         return line;
     }
 
+
+    /**
+     * Convertit en chaîne de caractères un noeud de type 'ARRAY'
+     * @param node le noeud à afficher
+     * @param depth la profondeur dans l'arbre
+     * @param indentation l'indentation du noeud père
+     * @return le noeud convertit en chaîne de caractères
+     */
     private static String printArray(Node node, int depth, String indentation) {
         String line = "";
         line += ": [";
@@ -249,11 +345,11 @@ public class Tree {
                     line += "\n" + printTree((Node) node.get(i).getValue(), depth + 1);
                 } else {
                     line += "\n" + indentation + Parameters.CONSOLE_INDENTATION;
-                    if (node.get(i).isString()) {
+                     if (node.get(i).isString()) {
-                        line += "\"" + node.get(i).getValue() + "\"";
+                         line += "\"" + node.get(i).getValue() + "\"";
-                    } else {
+                     } else {
-                        line += node.get(i).getValue();
+                         line += node.get(i).getValue();
-                    }
+                     }
                 }
 
                 // si la valeur n'est pas la dernière alors on lui ajoute une virgule
@@ -268,11 +364,17 @@ public class Tree {
         return line;
     }
 
+
     @Override
     public String toString() {
         return printTree(firstNode, 0);
     }
 
+
+    /**
+     * retourne le noeud d'entrer dans l'arbre
+     * @return le premier noeud de l'arbre
+     */
     public Node getFirstNode() {
         return firstNode;
     }