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;
-
-import fr.sae.JSonInspector.Exception.JsonSyntaxException;
-import fr.sae.JSonInspector.Settings.Parameters;
+package JsonInspector;
 
 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);
 
@@ -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,6 +137,12 @@ 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);
@@ -103,10 +150,16 @@ public class Tree {
         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();
@@ -153,6 +212,13 @@ public class Tree {
         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 = "";
 
@@ -168,6 +234,7 @@ public class Tree {
             line += indentation + node.getName();
         }
 
+
         if (node.isObject() || node.isElement()) {
             line += printObjectElement(node, depth, indentation);
 
@@ -181,6 +248,13 @@ public class Tree {
         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 += ": [";
@@ -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;
     }