Parser#parse(String) (not finished)

rapport/rapport.tex

@@ -48,9 +48,8 @@ Ce nombre indique le nombre de fois que les règles peuvent être appliquées.
 Voici, expliqué en détail, les composants de notre L-système. 
 \paragraph{L'alphabet}\label{alpha} étant propre à chaque L-system, nous avons du créer le notre.
 Il est constitué de 6 lettres , 10 chiffres et 6 caractères.
-Les lettres comprennent 3 majuscules $(X,Y,Z)$ et 3 minuscules $(x,y,z)$.
-Les trois majuscules servent à représenter un mouvement d'une unité dans le sens positif de leur axe.
-Ainsi $X = $ mouvement d'une unité dans le sens positif sur l'axe $X$.
+Les lettres comprennent 3 majuscules $(X,Y)$ et 3 minuscules $(x,y,z)$.
+Les X représente un mouvement d'une unité et Y ne dessine pas et permet de controller.
 Les trois minuscules quant à elles, permettent d'effectuer une rotation de +25° sur leurs axes respectifs.
 Ainsi, $x = $ rotation de 25° par rapport à l'axe des $X$.
 Les chiffres permettent, avec les symboles $(.,+,-)$ de faire varier les valeurs de base des lettres de l'alphabet.

src/lsystem/engine/Element.java

@@ -0,0 +1,22 @@
+package lsystem.engine;
+
+import java.util.LinkedList;
+
+public class Element {
+
+    public final ElementProperties properties;
+    public final LinkedList<Element> children = new LinkedList<>();
+    public final Element parent;
+    public final float value;
+
+    public Element(ElementProperties properties, Element parent) {
+        this(properties, 0, parent);
+    }
+
+    public Element(ElementProperties properties, float value, Element parent) {
+        this.properties = properties;
+        this.parent = parent;
+        this.value = value;
+    }
+
+}

src/lsystem/engine/ElementProperties.java

@@ -0,0 +1,20 @@
+package lsystem.engine;
+
+public enum ElementProperties {
+
+    DRAW('X'),
+    NOTHING('Y'),
+    ROTATION_X('x'),
+    ROTATION_Y('y'),
+    ROTATION_Z('z');
+
+    private final char c;
+
+    ElementProperties(char c) {
+        this.c = c;
+    }
+
+    public char getChar() {
+        return c;
+    }
+}

src/lsystem/engine/Parser.java

@@ -4,6 +4,7 @@ import lsystem.Type;
 import lsystem.utils.Pair;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 
 public class Parser {
@@ -11,7 +12,7 @@ public class Parser {
     private final String axiom;
     private final List<String> rules;
     private final int nbIterations;
-    private char[] validChars = {'=',']','[','.','+','-','X','Y','Z','x','y','z','0','1','2','3','4','5','6','7','8','9',' '};
+    private final char[] validChars = {'=',']','[','.','+','-','X','Y','Z','x','y','z','0','1','2','3','4','5','6','7','8','9',' '};
 
     public Parser(String axiom, List<String> rules,int nbIterations) {
         this.axiom = axiom;
@@ -41,12 +42,19 @@ public class Parser {
     	char old = ' ';
         int bracket = 0;
         boolean equalsSymbolFound = false;
-        for (int i = 0; i > stringToCheck.length(); i++){
+        for (int i = 0; i < stringToCheck.length(); i++) {
         	char temp = stringToCheck.charAt(i);
-            if (temp == '[')
+            if (temp == '[') {
                 bracket++;
-            if(temp == ']')
+                if(stringToCheck.charAt(i - 1) == '[')
+                    return false;
+            }
+            if(temp == ']') {
                 bracket--;
+                if(stringToCheck.charAt(i - 1) == '[')
+                    return false;
+            }
+
             if(temp == '=') {
             	if(!equalsSymbolFound)
             		equalsSymbolFound = true;
@@ -72,16 +80,53 @@ public class Parser {
 	}
     
     /**
-     * Used by {@link Rewrite}
+     * Used by {@link Rewrite#rewrite()}
      * @return a list of rules with the left and right sides separated by a {@link lsystem.utils.Pair Pair}
      */
     public List<Pair<String, String>> parseRules() {
     	List<Pair<String, String>> rules = new ArrayList<>();
     	this.rules.forEach(rule -> {
     		String[] str = rule.split("=");
-    		rules.add(new Pair<String, String>(str[0], str[1]));
+    		rules.add(new Pair<>(str[0], str[1]));
     	});
     	return rules;
     }
 
+
+    // TODO: 02/03/2021 to finish 
+    public Element parse(String rewritten) {
+        String toParse = rewritten;
+        Element root = null;
+        Element workingElement = null;
+        float number = 0;
+        boolean bracket = false;
+        int i = 0;
+        while (!toParse.isEmpty()) {
+            char c = toParse.charAt(i);
+            toParse = toParse.substring(i);
+            ElementProperties pro = Arrays.stream(ElementProperties.values()).filter(p -> p.getChar() == c).findFirst().orElse(null);
+            if(pro != null) {
+                if(workingElement == null) {
+                    workingElement = new Element(pro, null);
+                    root = workingElement;
+                } else {
+                    Element element = new Element(pro, number, workingElement);
+                    workingElement.children.add(element);
+                    if(bracket) {
+                        workingElement = element;
+                        bracket = false;
+                    }
+                }
+            } else {
+                if(c == '[')
+                    bracket = true;
+                if(c == ']') {
+                    workingElement = workingElement.parent;
+                }
+            }
+            i++;
+        }
+        return root;
+    }
+    
 }