From 936e74f10bb20114f5139c8b4e8f6e70a226794e Mon Sep 17 00:00:00 2001 From: besson Date: Mon, 16 Jan 2023 00:10:15 +0100 Subject: [PATCH] =?UTF-8?q?Transf=C3=A9rer=20les=20fichiers=20vers=20'src/?= =?UTF-8?q?fr/sae/JSonInspector/Storage'?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/fr/sae/JSonInspector/Storage/Node.java | 248 ++++--- src/fr/sae/JSonInspector/Storage/Other.java | 33 +- src/fr/sae/JSonInspector/Storage/Tree.java | 768 ++++++++++---------- src/fr/sae/JSonInspector/Storage/Type.java | 14 +- src/fr/sae/JSonInspector/Storage/Value.java | 86 ++- 5 files changed, 608 insertions(+), 541 deletions(-) diff --git a/src/fr/sae/JSonInspector/Storage/Node.java b/src/fr/sae/JSonInspector/Storage/Node.java index d583846..cdd7dab 100644 --- a/src/fr/sae/JSonInspector/Storage/Node.java +++ b/src/fr/sae/JSonInspector/Storage/Node.java @@ -1,100 +1,148 @@ -package fr.sae.JSonInspector.Storage; - -import java.util.ArrayList; - -public class Node { - private final ArrayList values = new ArrayList<>(); - private final String name; - private final Type type; - - public Node(String name, Type type) { - this.type = type; - if (type == Type.ELEMENT) { - this.name = ""; - } else { - this.name = name; - } - } - - private void findType(String value) { - if (value.charAt(0) == '"' && value.charAt(value.length() - 1) == '"') { - values.add(new Value(Tree.cleanOpeningExpression(value))); - return; - } - - try { - values.add(new Value(Integer.parseInt(value))); - } catch (NumberFormatException nfeInt) { - try { - values.add(new Value(Double.parseDouble(value))); - } catch (NumberFormatException nfeDouble) { - values.add(new Value(new Other(value))); - } - } - } - - public void add(T value) { - if (value != null) { - if (value.getClass().equals(Node.class)) { - values.add(new Value(value)); - } else { - findType((String) value); - } - } - } - - public Type getType() { - return type; - } - - public String getName() { - return name; - } - - public Value get(int index) { - return values.get(index); - } - - public int getSize() { - return values.size(); - } - - public boolean isObject() { - return type == Type.OBJECT; - } - - public boolean isArray() { - return type == Type.ARRAY; - } - - public boolean isElement() { - return type == Type.ELEMENT; - } - - public boolean isPair() { - return type == Type.PAIR; - } - - public boolean isArrayObjectElement() { - boolean array = type == Type.ARRAY; - boolean object = type == Type.OBJECT; - boolean element = type == Type.ELEMENT; - - if (array || object || element) { - return true; - } - - return false; - } - - @Override - public String toString() { - String string = name + " : "; - - for (int i = 0; i < values.size(); i++) { - string += values.get(i) + ", "; - } - - return string; - } -} +package JsonInspector.Storage; + +import java.util.ArrayList; +import java.util.List; + + +public class Node { + private final List values = new ArrayList<>(); + private final String name; + private final Type type; + + + /** + * + * @param name le nom du noeud + * @param type le type du noeud + */ + public Node(String name, Type type) { + this.type = type; + if (type == Type.ELEMENT) { + this.name = ""; + } else { + this.name = name; + } + } + + + /** + * Détermine le type de la chaîne de caractère passé en argument + * @param value la valeur à classifier + */ + private void findType(String value) { + if (value.charAt(0) == '"' && value.charAt(value.length()-1) == '"') { + values.add(new Value(Tree.cleanOpeningExpression(value))); + return; + } + + try { + values.add(new Value(Integer.parseInt(value))); + } catch (NumberFormatException nfeInt) { + try { + values.add(new Value(Double.parseDouble(value))); + } catch (NumberFormatException nfeDouble) { + values.add(new Value(new Other(value))); + } + } + } + + + /** + * Ajoute une valeur au noeud + * @param value la valeur à ajouter + * @param le type de la valeur à ajouter + */ + public void add(T value) { + if (value != null) { + if (value.getClass().equals(Node.class)) { + values.add(new Value(value)); + } else { + findType((String) value); + } + } + } + + + /** + * + * @return le type du noeud + */ + public Type getType() { + return type; + } + + + /** + * + * @return le nom du noeud + */ + public String getName() { + return name; + } + + + /** + * Retourne la valeur contenue à l'index spécifié + * @param index l'index de la valeur + * @return la valeur trouvée + */ + public Value get(int index) { + return values.get(index); + } + + + /** + * retourne le nombre de valeurs du noeud + * @return + */ + public int getSize() { + return values.size(); + } + public boolean isObject() { + return type == Type.OBJECT; + } + + + public boolean isArray() { + return type == Type.ARRAY; + } + + + public boolean isElement() { + return type == Type.ELEMENT; + } + + + public boolean isPair() { + return type == Type.PAIR; + } + + + /** + * Test si l'objet est du type 'ELEMENT' ou 'OBJECT' + * @return + */ + public boolean isArrayObjectElement() { + boolean array = type == Type.ARRAY; + boolean object = type == Type.OBJECT; + boolean element = type == Type.ELEMENT; + + if (array || object || element) { + return true; + } + + return false; + } + + + @Override + public String toString() { + String string = name + " : "; + + for (int i = 0; i < values.size(); i++) { + string += values.get(i) + ", "; + } + + return string; + } +} diff --git a/src/fr/sae/JSonInspector/Storage/Other.java b/src/fr/sae/JSonInspector/Storage/Other.java index 3a6bcca..6bed103 100644 --- a/src/fr/sae/JSonInspector/Storage/Other.java +++ b/src/fr/sae/JSonInspector/Storage/Other.java @@ -1,14 +1,19 @@ -package fr.sae.JSonInspector.Storage; - -public class Other { - String value; - - public Other(String value) { - this.value = value; - } - - @Override - public String toString() { - return value; - } -} +package JsonInspector.Storage; + + +/** + * Un type créé pour les valeurs qui ne sont pas de type String, Double ou Integer (e type est un String dans les faits). + */ +public class Other { + String value; + + public Other(String value) { + this.value = value; + } + + + @Override + public String toString() { + return value; + } +} diff --git a/src/fr/sae/JSonInspector/Storage/Tree.java b/src/fr/sae/JSonInspector/Storage/Tree.java index 3c56805..21d966c 100644 --- a/src/fr/sae/JSonInspector/Storage/Tree.java +++ b/src/fr/sae/JSonInspector/Storage/Tree.java @@ -1,384 +1,384 @@ -package fr.sae.JSonInspector.Storage; - -import fr.sae.JSonInspector.Exception.JsonSyntaxException; -import fr.sae.JSonInspector.Settings.Parameters; - -import java.util.ArrayList; -import java.util.List; - -public class Tree { - 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); - - if (keyValue.length == 2) { - String key = keyValue[0], value = keyValue[1]; - - if (0 < value.length()) { - if (value.charAt(0) == '[' && value.charAt(value.length() - 1) == ']') { - return parseArray(key, value); - - } else if (value.charAt(0) == '{' && value.charAt(value.length() - 1) == '}') { - return parseObject(key, value); - - } else { - return parsePair(key, value); - } - } else { - return null; - } - - } else if (keyValue[0].equals("")) { - - if (keyValue[0].charAt(0) == '{' && keyValue[0].charAt(keyValue[0].length()-1) == '}') { - return parseElement(keyValue[0]); - } else { - throw new JsonSyntaxException(); - } - - } else { - throw new JsonSyntaxException(); - } - } - - - /** - * 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); - List elements = splitList(rawValues); - - for (String value : elements) { - if (0 < value.length()) { - if (value.charAt(0) == '{') { - if (value.charAt(value.length() - 1) == '}') { - array.add(parseElement(value)); - } else { - throw new JsonSyntaxException(); - } - - } else { - array.add(value); - } - } - } - - 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); - List elements = splitList(rawValues); - - for (String value : elements) { - object.add(whichType(value)); - } - - 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); - - 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); - List elements = splitList(rawValues); - - for (String value : elements) { - element.add(whichType(value)); - } - - 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); - return cleanedString.toString(); - } - - - /** - * 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 splitList(String listToSplit) { - char[] chars = cleanOpeningExpression(listToSplit).toCharArray(); - int depth = 0; - List elements = new ArrayList<>(); - String buffer = ""; - - for (char currentChar : chars) { - if (currentChar == ',' && depth == 0) { - elements.add(buffer); - buffer = ""; - } else if (currentChar == '{' || currentChar == '[') { - depth += 1; - buffer += currentChar; - } else if (currentChar == '}' || currentChar == ']') { - depth -= 1; - buffer += currentChar; - } else { - buffer += currentChar; - } - } - elements.add(buffer); - 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(); - String key = "", value, buffer = ""; - - for (char currentChar : chars) { - if (inKey) { - if (currentChar == '{' || currentChar == ':') { - key = buffer; - buffer = ""; - if (currentChar == '{') { - buffer += currentChar; - } - inKey = false; - } else { - buffer += currentChar; - } - } else { - buffer += currentChar; - } - } - value = buffer; - - 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 - //profondeur dans l'arbre - for (int i = 0; i < depth; i++) { - indentation += Parameters.CONSOLE_INDENTATION; - } - - if (!node.isElement()) { - line += indentation + "\"" + node.getName() + "\""; - } else { - line += indentation + node.getName(); - } - - - if (node.isObject() || node.isElement()) { - line += printObjectElement(node, depth, indentation); - - } else if (node.isPair()){ - line += printPair(node); - - } 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 = ""; - - for (int i = 0; i < node.getSize(); i++) { - if (node.get(i).isNode()) { - line += "\n" + printTree((Node) node.get(i).getValue(), depth + 1); - } - - if (i != node.getSize() - 1) { - line += ","; - } - } - - 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 = ""; - - if (node.getSize() != 0) { - if (node.get(0).isString()) { - line += ": \"" + node.get(0).getValue() + "\""; - } else { - line += ": " + node.get(0).getValue(); - } - - } else { - line += ": null"; - } - - 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 = ""; - - if (node.getType() == Type.ELEMENT) { - line += "{"; - } else { - line += ": {"; - } - - if (node.getSize() == 0) { - line += "}"; - } else { - line += callNextNodes(node, depth); - line += "\n" + indentation + "}"; - } - - 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 += ": ["; - - if (node.getSize() == 0) { - line += "]"; - - } else { - // Cette boucle parcours les valeurs du tableau - for (int i = 0; i < node.getSize(); i++) { - // si la valeur a l'indice i n'est pas une valeur brute alors - // on appelle de manière récursive la fonction d'affichage de l'arbre - if (node.get(i).isNode()) { - line += "\n" + printTree((Node) node.get(i).getValue(), depth + 1); - } else { - line += "\n" + indentation + Parameters.CONSOLE_INDENTATION; - if (node.get(i).isString()) { - line += "\"" + node.get(i).getValue() + "\""; - } else { - line += node.get(i).getValue(); - } - } - - // si la valeur n'est pas la dernière alors on lui ajoute une virgule - if (i != node.getSize() - 1) { - line += ","; - } - } - - line += "\n" + indentation + "]"; - } - - 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; - } -} +package JsonInspector.Storage; + +import JsonInspector.Exception.JsonSyntaxException; +import JsonInspector.Settings.Parameters; + +import java.util.ArrayList; +import java.util.List; + +public class Tree { + 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); + + if (keyValue.length == 2) { + String key = keyValue[0], value = keyValue[1]; + + if (0 < value.length()) { + if (value.charAt(0) == '[' && value.charAt(value.length() - 1) == ']') { + return parseArray(key, value); + + } else if (value.charAt(0) == '{' && value.charAt(value.length() - 1) == '}') { + return parseObject(key, value); + + } else { + return parsePair(key, value); + } + } else { + return null; + } + + } else if (keyValue[0].equals("")) { + + if (keyValue[0].charAt(0) == '{' && keyValue[0].charAt(keyValue[0].length()-1) == '}') { + return parseElement(keyValue[0]); + } else { + throw new JsonSyntaxException(); + } + + } else { + throw new JsonSyntaxException(); + } + } + + + /** + * 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); + List elements = splitList(rawValues); + + for (String value : elements) { + if (0 < value.length()) { + if (value.charAt(0) == '{') { + if (value.charAt(value.length() - 1) == '}') { + array.add(parseElement(value)); + } else { + throw new JsonSyntaxException(); + } + + } else { + array.add(value); + } + } + } + + 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); + List elements = splitList(rawValues); + + for (String value : elements) { + object.add(whichType(value)); + } + + 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); + + 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); + List elements = splitList(rawValues); + + for (String value : elements) { + element.add(whichType(value)); + } + + 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); + return cleanedString.toString(); + } + + + /** + * 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 splitList(String listToSplit) { + char[] chars = cleanOpeningExpression(listToSplit).toCharArray(); + int depth = 0; + List elements = new ArrayList<>(); + String buffer = ""; + + for (char currentChar : chars) { + if (currentChar == ',' && depth == 0) { + elements.add(buffer); + buffer = ""; + } else if (currentChar == '{' || currentChar == '[') { + depth += 1; + buffer += currentChar; + } else if (currentChar == '}' || currentChar == ']') { + depth -= 1; + buffer += currentChar; + } else { + buffer += currentChar; + } + } + elements.add(buffer); + 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(); + String key = "", value, buffer = ""; + + for (char currentChar : chars) { + if (inKey) { + if (currentChar == '{' || currentChar == ':') { + key = buffer; + buffer = ""; + if (currentChar == '{') { + buffer += currentChar; + } + inKey = false; + } else { + buffer += currentChar; + } + } else { + buffer += currentChar; + } + } + value = buffer; + + 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 + //profondeur dans l'arbre + for (int i = 0; i < depth; i++) { + indentation += Parameters.CONSOLE_INDENTATION; + } + + if (!node.isElement()) { + line += indentation + "\"" + node.getName() + "\""; + } else { + line += indentation + node.getName(); + } + + + if (node.isObject() || node.isElement()) { + line += printObjectElement(node, depth, indentation); + + } else if (node.isPair()){ + line += printPair(node); + + } 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 = ""; + + for (int i = 0; i < node.getSize(); i++) { + if (node.get(i).isNode()) { + line += "\n" + printTree((Node) node.get(i).getValue(), depth + 1); + } + + if (i != node.getSize() - 1) { + line += ","; + } + } + + 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 = ""; + + if (node.getSize() != 0) { + if (node.get(0).isString()) { + line += ": \"" + node.get(0).getValue() + "\""; + } else { + line += ": " + node.get(0).getValue(); + } + + } else { + line += ": null"; + } + + 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 = ""; + + if (node.getType() == Type.ELEMENT) { + line += "{"; + } else { + line += ": {"; + } + + if (node.getSize() == 0) { + line += "}"; + } else { + line += callNextNodes(node, depth); + line += "\n" + indentation + "}"; + } + + 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 += ": ["; + + if (node.getSize() == 0) { + line += "]"; + + } else { + // Cette boucle parcours les valeurs du tableau + for (int i = 0; i < node.getSize(); i++) { + // si la valeur a l'indice i n'est pas une valeur brute alors + // on appelle de manière récursive la fonction d'affichage de l'arbre + if (node.get(i).isNode()) { + line += "\n" + printTree((Node) node.get(i).getValue(), depth + 1); + } else { + line += "\n" + indentation + Parameters.CONSOLE_INDENTATION; + if (node.get(i).isString()) { + line += "\"" + node.get(i).getValue() + "\""; + } else { + line += node.get(i).getValue(); + } + } + + // si la valeur n'est pas la dernière alors on lui ajoute une virgule + if (i != node.getSize() - 1) { + line += ","; + } + } + + line += "\n" + indentation + "]"; + } + + 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; + } +} diff --git a/src/fr/sae/JSonInspector/Storage/Type.java b/src/fr/sae/JSonInspector/Storage/Type.java index a6f87a3..691c3b3 100644 --- a/src/fr/sae/JSonInspector/Storage/Type.java +++ b/src/fr/sae/JSonInspector/Storage/Type.java @@ -1,5 +1,9 @@ -package fr.sae.JSonInspector.Storage; - -public enum Type { - OBJECT, ELEMENT, ARRAY, PAIR, NULL -} +package JsonInspector.Storage; + + +/** + * Un type énuméré contenant tous les types possibles de noeud + */ +public enum Type { + OBJECT, ELEMENT, ARRAY, PAIR, NULL +} diff --git a/src/fr/sae/JSonInspector/Storage/Value.java b/src/fr/sae/JSonInspector/Storage/Value.java index 304670e..3e8bf99 100644 --- a/src/fr/sae/JSonInspector/Storage/Value.java +++ b/src/fr/sae/JSonInspector/Storage/Value.java @@ -1,38 +1,48 @@ -package fr.sae.JSonInspector.Storage; - -public class Value { - private T value; - - public Value(T value) { - this.value = value; - } - - public T getValue() { - return value; - } - - public boolean isObjectOrArray() { - if (value.getClass().equals(Node.class)) { - Node node = (Node) value; - if (node.getType() == Type.OBJECT || node.getType() == Type.ARRAY) { - return true; - } else { - return false; - } - } else { - return false; - } - } - - public boolean isNode() { - return value.getClass().equals(Node.class); - } - - public boolean isString() { - return value.getClass().equals(String.class); - } - - public boolean isNumber() { - return value.getClass().equals(Integer.class) || value.getClass().equals(Double.class); - } -} +package JsonInspector.Storage; + +/** + * Représente une valeur + * @param le type de la valeur + */ +public class Value { + private T value; + + + public Value(T value) { + this.value = value; + } + + + public T getValue() { + return value; + } + + + public boolean isObjectOrArray() { + if (value.getClass().equals(Node.class)) { + Node node = (Node) value; + if (node.getType() == Type.OBJECT || node.getType() == Type.ARRAY) { + return true; + } else { + return false; + } + } else { + return false; + } + } + + + public boolean isNode() { + return value.getClass().equals(Node.class); + } + + + public boolean isString () { + return value.getClass().equals(String.class); + } + + + public boolean isNumber() { + return value.getClass().equals(Integer.class) || value.getClass().equals(Double.class); + } +}