Merge pull request #20 from agupta231/R2

R2 finished

Author: goobta

.gitignore

@@ -1,2 +1,6 @@
 # Fucking Akash and Bryson
 /.idea
+.DS_Store
+/out
+*.iml
+*.swp

src/AbstractCompoundExpression.java

@@ -1,8 +1,16 @@
+import javafx.scene.Node;
+import javafx.scene.layout.HBox;
 import java.util.LinkedList;
 
-public abstract class AbstractCompoundExpression implements CompoundExpression{
+/**
+ * Child function of CompoundExpression. Meant to abstract a lot of the code in
+ * Multiplicative and Additive Expression classes
+ */
+public abstract class AbstractCompoundExpression implements CompoundExpression, CopyAble {
     private CompoundExpression parent = null;
     private LinkedList<Expression> children = new LinkedList<Expression>();
+    protected boolean focused;
+    protected Node node;
 
     /**
      * Flatten's the expression's children.
@@ -51,38 +59,188 @@ public void setChildren(LinkedList<Expression> children){
      * @param child An expression
      */
     public void addSubexpression(Expression child){
+        child.setParent(this);
+
         this.children.add(child);
     }
 
     /**
-     * Will generate a String representation for the the addition
+     * Will generate a String representation for the current
      * operator, with the appropiate number of tabs to properly
      * represent it's position in the expression.
      * @param indentLevel the indentation level
-     * @param name the name of the expression
+     * @param name what the current operator is
      * @return a String containing this expression and all its children in hierarchic format.
      */
 
-    public String convertToString(int indentLevel, String name){
+    public String convertToString(int indentLevel, String name) {
         StringBuffer sb = new StringBuffer();
         Expression.indent(sb,indentLevel);
         sb.append(name + "\n");
+
         for(Expression e: this.getChildren()){
             sb.append(e.convertToString(indentLevel+1));
         }
+
         return sb.toString();
     }
 
+    /**
+     * Will generate a String representation for the operator, with no
+     * space though.
+     * @param delimiter the operator
+     * @return a String containing this expresison.
+     */
+    public String convertToStringFlat(String delimiter) {
+        String outputString = "";
+
+        for(int i = 0; i < this.getChildren().size() - 1; i++) {
+            outputString += ((CopyAble) this.getChildren().get(i)).convertToStringFlat();
+            outputString += delimiter;
+        }
+
+        outputString += ((CopyAble) this.getChildren().get(this.getChildren().size() - 1)).convertToStringFlat();
+
+        return outputString;
+    }
+
     /**
      * Creates a deep copy of the expression
      * @param copy, an empty Compound expression that will be returned.
      * @return a deep copy of the expression
      */
     public AbstractCompoundExpression deepCopy(AbstractCompoundExpression copy){
-        for(Expression c: this.getChildren()){
-            copy.addSubexpression(c.deepCopy());
+        for(Expression c: this.getChildren()) {
+            copy.addSubexpression(c);
+        }
+        for(Expression c: copy.getChildren()) {
+            c.setParent(copy);
         }
+
+        copy.node = node;
         return copy;
     }
 
+    /**
+     * Abstracted function for getNode() for Multiplicative and Additive Expressions
+     * @param delimiter the operator
+     * @return a Node represeneting the current Expression
+     */
+    public Node getNode(String delimiter) {
+        if(node == null) {
+            final HBox hbox = new HBox();
+            hbox.getChildren().add(this.getChildren().get(0).getNode());
+            for (int i = 1; i < this.getChildren().size(); i++) {
+                hbox.getChildren().add(ExpressionEditor.newLabel(delimiter));
+                hbox.getChildren().add(this.getChildren().get(i).getNode());
+            }
+            if (this.getFocused()) {
+                hbox.setBorder(RED_BORDER);
+            }
+            node = hbox;
+            return hbox;
+        }
+
+        return node;
+    }
+
+    /**
+     * Getter for if the current expression is focused.
+     * @return true if the expression is focused, false
+     *         otherwise
+     */
+    public boolean getFocused() {
+        return focused;
+    }
+
+    /**
+     * Setter for if the current expression is focused.
+     * @param s A boolean representing if the current
+     *          expression is focused or not
+     */
+    public void setFocused(boolean s) {
+        focused = s;
+    }
+
+    /**
+     * Will create a copy of the current expression, and transfer
+     * the Node pointers as well
+     * @return a copy of Expression with old Node pointers
+     */
+    @Override
+    public Expression trueCopy() {
+        if(this.getParent() == null) {
+            return this.deepCopy();
+        }
+
+        AbstractCompoundExpression parent =  ((AbstractCompoundExpression) this.getParent());
+        AbstractCompoundExpression copy = (AbstractCompoundExpression) parent.trueCopy();
+
+        for(Expression e:copy.getChildren()) {
+            if(e.convertToString(0).equals(this.convertToString(0))) {
+                return e;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Will generate all possible trees that an expression can take
+     * @param parent Parent of the focused expression
+     * @param selected the focused expression, represented by the .convertToString(0) method
+     * @return a LinkedList of Expressions of all of the permutations of the Expression
+     */
+    public static LinkedList<Expression> generateAllPossibleTrees(Expression parent, String selected) {
+        Expression focused = null;
+
+        for(Expression child : ((AbstractCompoundExpression) parent).getChildren()) {
+            if (child.convertToString(0).equals(selected)) {
+                focused = child;
+                break;
+            }
+        }
+
+        final LinkedList<Expression> children = ((AbstractCompoundExpression) parent).getChildren();
+        final int childrenSize = children.size();
+
+        int nodeIndex = -1;
+
+        for(int i = 0; i < childrenSize; i++) {
+            if (children.get(i) == focused) {
+                nodeIndex = i;
+                break;
+            }
+        }
+
+        if (nodeIndex == -1) {
+            return new LinkedList<>();
+        }
+
+        children.remove(nodeIndex);
+
+        LinkedList<Expression> possibleTrees = new LinkedList<>();
+
+        for (int i = 0; i < childrenSize; i++) {
+            AbstractCompoundExpression tempParent = (AbstractCompoundExpression) ((AbstractCompoundExpression) parent).trueCopy();
+            LinkedList<Expression> orderedChildren = new LinkedList<>();
+
+            for (int j = 0; j < children.size(); j++) {
+                if (j == i) {
+                    orderedChildren.add(focused);
+                }
+
+                orderedChildren.add(children.get(j));
+            }
+
+            if(i == childrenSize - 1) {
+                orderedChildren.add(focused);
+            }
+
+            tempParent.setChildren(orderedChildren);
+            possibleTrees.add(tempParent);
+        }
+
+        return possibleTrees;
+    }
 }

src/AdditiveExpression.java

@@ -1,16 +1,27 @@
+import javafx.scene.Node;
+
+
 /**
  * Child of expression that represents an addition operator.
  */
-public class AdditiveExpression extends CollapsibleExpression{
+public class AdditiveExpression extends CollapsibleExpression {
+
 	/**
 	 * Will return a copy of the Additive expression to use
 	 * for the GUI.
-	 * @return an copy of the {@link AdditiveExpression}
+	 * @return a copy of the {@link AdditiveExpression}
+	 */
+	public Expression deepCopy() {
+		return super.deepCopy(new AdditiveExpression());
+	}
+
+	/**
+	 * Gives the Node representation of the current Additive Expression
+	 * @return a Node representing the current AdditiveExpression
 	 */
-    public Expression deepCopy() {
-        AdditiveExpression copy = new AdditiveExpression();
-        return super.deepCopy(copy);
-    }
+	public Node getNode() {
+		return super.getNode("+");
+	}
 
 	/**
 	 * Will generate a String representation for the the addition
@@ -19,8 +30,17 @@ public Expression deepCopy() {
 	 * @param indentLevel how many "levels" down the operator is
 	 * @return a String representing the addition operator.
 	 */
-    public String convertToString(int indentLevel){
-        return super.convertToString(indentLevel,"+");
-    }
+	public String convertToString(int indentLevel) {
+		return super.convertToString(indentLevel,"+");
+	}
 
-}
+	/**
+	 * Will generate a String representation for the the addition,
+	 * with no whitespace.
+	 * @return a flattened String representing the addition operator.
+	 */
+	@Override
+	public String convertToStringFlat() {
+		return super.convertToStringFlat("+");
+	}
+}

src/CollapsibleExpression.java

@@ -1,28 +1,28 @@
-import java.util.LinkedList;
-
-public abstract class CollapsibleExpression extends AbstractCompoundExpression {
+import javafx.scene.Node;
+import javafx.scene.layout.HBox;
 
+import java.util.LinkedList;
 
+public abstract class CollapsibleExpression extends AbstractCompoundExpression implements Focusable {
     /**
      * Flattens the expression in order to make it easier for the GUI to parse.
      */
     public void flatten() {
         flattenChildren();
-        LinkedList<Expression> children = new LinkedList<Expression>();
-        for(Expression e: this.getChildren())
-        {
+        LinkedList<Expression> children = new LinkedList<>();
+
+        for(Expression e: this.getChildren()) {
             if(e.getClass() == this.getClass()){
                 CollapsibleExpression tempExp = (CollapsibleExpression)e;
-                for(Expression exp: tempExp.getChildren())
-                {
+
+                for(Expression exp: tempExp.getChildren()) {
                     children.add(exp);
                 }
             }
-            else{
+            else {
                 children.add(e);
             }
         }
         this.setChildren(children);
     }
-
 }

src/CopyAble.java

@@ -0,0 +1,15 @@
+public interface CopyAble {
+    /**
+     * Will create a copy of the current expression, and transfer
+     * the Node pointers as well
+     * @return a copy of Expression with old Node pointers
+     */
+    Expression trueCopy();
+
+    /**
+     * Will generate a String representation for the operator, with no
+     * space though.
+     * @return a String containing this expresison.
+     */
+    String convertToStringFlat();
+}

src/Expression.java

@@ -1,24 +1,52 @@
+import javafx.scene.layout.*;
+import javafx.scene.paint.Color;
+import javafx.scene.Node;
+
 interface Expression {
+	/**
+	 * Border for showing a focused expression
+	 */
+	Border RED_BORDER = new Border(
+	  new BorderStroke(Color.RED, BorderStrokeStyle.SOLID, CornerRadii.EMPTY, BorderWidths.DEFAULT)
+	);
+
+	/**
+	 * Border for showing a non-focused expression
+	 */
+	Border NO_BORDER = null;
+
+	/**
+	 * Color used for a "ghosted" expression
+	 */
+	Color GHOST_COLOR = Color.LIGHTGREY;
+
 	/**
 	 * Returns the expression's parent.
 	 * @return the expression's parent
 	 */
 	CompoundExpression getParent ();
-
+        
 	/**
-	 * Sets the parent be the specified expression.
-	 * @param parent the CompoundExpression that should be the parent of the target object
-	 */
+         * Sets the parent be the specified expression.
+         * @param parent the CompoundExpression that should be the parent of the target object
+         */
 	void setParent (CompoundExpression parent);
 
 	/**
 	 * Creates and returns a deep copy of the expression.
 	 * The entire tree rooted at the target node is copied, i.e.,
 	 * the copied Expression is as deep as possible.
-	 * @return the deep copy
+	  * @return the deep copy
 	 */
 	Expression deepCopy ();
 
+
+	/**
+	 * Returns the JavaFX node associated with this expression.
+	 * @return the JavaFX node associated with this expression.
+	 */
+	Node getNode ();
+
 	/**
 	 * Recursively flattens the expression as much as possible
 	 * throughout the entire tree. Specifically, in every multiplicative