Added support for dot file output

Changed Evaluable<T> from an Interface to Abstract Class.

Added toString functions and support for breath first construction of
dot file.

Author: Gabriel-T-Harris

structure/Base_Node.java

@@ -1,5 +1,7 @@
 package structure;
 
+import java.util.Collection;
+
 /**
 <b>
 Purpose: To be the base node which others will extend.<br>
@@ -8,31 +10,40 @@
 </b>
 */
 
-//TODO: add toString() methods with some reference to outputting as dot file format.
-public abstract class Base_Node<T> implements Evaluable<T>
+public abstract class Base_Node<T> extends Evaluable<T>
 {
-    /**
-     * Unique identifier for this node.
-     */
-    public final int UNIQUE_IDENTIFIER;
-
     /**
      * The name of this node.
      */
     public final String NAME;
 
-    /**
-     * Used to set {@link #UNIQUE_IDENTIFIER}
-     */
-    private static int CREATED_NODES_COUNT = 0;
-
     /**
      * Constructor of {@link #Base_Node}.
      * @param NAME the name to be given to this {@link #Base_Node}
      */
     public Base_Node(final String NAME)
     {
         this.NAME = NAME;
-        this.UNIQUE_IDENTIFIER = ++CREATED_NODES_COUNT;
+    }
+
+    /**
+     * for dot format
+     */
+    public String toString()
+    {
+        StringBuilder output = new StringBuilder(64);
+
+        output.append(this.UNIQUE_IDENTIFIER);
+        output.append("[label=\"");
+        output.append(this.NAME.replace(">", "\\>").replace("<", "\\<").replace("\"", "\\\""));//escape certain characters
+        output.append("\"];\n");
+
+        return output.toString();
+    }
+
+    @Override
+    protected Collection<? extends Evaluable<T>> continue_breath_search()
+    {
+        return null;
     }
 }

structure/Binary_Operator_Node.java

@@ -1,5 +1,8 @@
 package structure;
 
+import java.util.ArrayList;
+import java.util.Collection;
+
 /**
 <b>
 Purpose: Base of the binary operators.<br>
@@ -33,4 +36,37 @@ public Binary_Operator_Node(String NAME, final Evaluable<T> LEFT_CHILD, final Ev
         this.LEFT_CHILD = LEFT_CHILD;
         this.RIGHT_CHILD = RIGHT_CHILD;
     }
+
+    /**
+     * for dot format
+     */
+    public String toString()
+    {
+        StringBuilder output = new StringBuilder(128);
+
+        output.append(super.toString()); //call standard part
+
+        //left child
+        output.append(this.UNIQUE_IDENTIFIER);
+        output.append("->");
+        output.append(this.LEFT_CHILD.UNIQUE_IDENTIFIER);
+        output.append(";\n");
+
+        //right child
+        output.append(this.UNIQUE_IDENTIFIER);
+        output.append("->");
+        output.append(this.RIGHT_CHILD.UNIQUE_IDENTIFIER);
+        output.append(";\n");
+
+        return output.toString();
+    }
+
+    @Override
+    protected Collection<? extends Evaluable<T>> continue_breath_search()
+    {
+        Collection<Evaluable<T>> to_return = new ArrayList<Evaluable<T>>();
+        to_return.add(this.LEFT_CHILD);
+        to_return.add(this.RIGHT_CHILD);
+        return to_return;
+    }
 }

structure/Evaluable.java

@@ -1,5 +1,6 @@
 package structure;
 
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
@@ -12,10 +13,9 @@
 </b>
 */
 
-public interface Evaluable<T>
+public abstract class Evaluable<T>
 {
-    boolean debugMode = false;
-
+    //TODO: add javadoc
     enum TestResult {
         /**
          * The evaluation succeeded
@@ -31,10 +31,31 @@ enum TestResult {
         Rollback
     }
 
+    /**
+     * Lambda for {@link Evaluable#evaluate(Collection, RollbackCallback)}.
+     */
     interface RollbackCallback {
         TestResult call();
     }
 
+    //TODO: add javadoc
+    static boolean debugMode = false;
+
+    /**
+     * Unique identifier for this node.
+     */
+    public final int UNIQUE_IDENTIFIER;
+
+    /**
+     * Used to set {@link #UNIQUE_IDENTIFIER}
+     */
+    private static int CREATED_NODES_COUNT = 0;
+
+    public Evaluable()
+    {
+        this.UNIQUE_IDENTIFIER = ++CREATED_NODES_COUNT;
+    }
+
     /**
      * Function used to evaluate a node's condition using a rollback evaluation implementation.
      * Allows for hand to be in an arbitrary order
@@ -43,7 +64,7 @@ interface RollbackCallback {
      * @param next function to call when a leaf node takes a card from the hand
      * @return a {@link TestResult} used as a signal on what action to preform next
      */
-    <E extends Reservable> TestResult evaluate(final Collection<E> hand, final RollbackCallback next);
+    abstract <E extends Reservable> TestResult evaluate(final Collection<E> hand, final RollbackCallback next);
 
     /**
      * Function used to deprecated_evaluate a node's condition using a rollback evaluation implementation.
@@ -54,18 +75,59 @@ interface RollbackCallback {
      * @param hand to be checked {@link Collection}
      * @return If the hand meets a condition
      */
-    default <E extends Reservable> boolean evaluate(final Collection<E> hand)
+    public <E extends Reservable> boolean evaluate(final Collection<E> hand)
     {
         TestResult result = evaluate(hand, () -> TestResult.Success);
         return result == TestResult.Success;
     }
 
+    /**
+     * Output whole tree in dot file format.
+     * 
+     * @param START of breath first search
+     */
+    public static String print_whole_subtree(final Evaluable<?> START)
+    {
+        StringBuilder output = new StringBuilder();
+        Evaluable<?> placeholder;
+        Collection<? extends Evaluable<?>> children;
+        ArrayList<Evaluable<?>> traverse_nodes = new ArrayList<Evaluable<?>>();
+        traverse_nodes.add(START);
+
+        output.append("digraph {\nnode [shape=record];\nnode [fontname=Sans];charset=\"UTF-8\" splines=true splines=spline rankdir =LR\n");
+
+        //children
+        do
+        {
+            placeholder = traverse_nodes.get(0);
+            output.append(placeholder.toString()); // print out top node
+
+            children = placeholder.continue_breath_search();
+            if (children != null)
+                traverse_nodes.addAll(children); // add children
+
+            traverse_nodes.remove(0); // remove first
+        } while (!traverse_nodes.isEmpty());
+
+        output.append('}');
+
+        return output.toString();
+    }
+
+    /**
+     * Expected to be defined to pass along children for {@link #print_whole_subtree}.
+     * 
+     * @return null or children
+     */
+    abstract protected Collection<? extends Evaluable<T>> continue_breath_search();
+
     /**
      * If debugMode is set, print current debug details about the currently executing node
      *
      * @param hand to be checked {@link Collection}
      */
-    default <E extends Reservable> void printDebugStep(final Collection<E> hand) {
+    <E extends Reservable> void printDebugStep(final Collection<E> hand)
+    {
         if (debugMode) {
             System.out.printf("%s ", this);
             Map<Boolean, List<E>> hand_partition = hand.stream().collect(Collectors.partitioningBy(Reservable::isReserved));

structure/Not_Operator_Node.java

@@ -1,5 +1,6 @@
 package structure;
 
+import java.util.ArrayList;
 import java.util.Collection;
 
 /**
@@ -32,4 +33,30 @@ public <E extends Reservable> TestResult evaluate(Collection<E> hand, RollbackCa
         // result should only ever be TestResult.Rollback here
         return next.call();
     }
+
+    /**
+     * for dot format
+     */
+    public String toString()
+    {
+        StringBuilder output = new StringBuilder(128);
+
+        output.append(super.toString()); //call standard part
+
+        //child
+        output.append(this.UNIQUE_IDENTIFIER);
+        output.append("->");
+        output.append(this.CHILD.UNIQUE_IDENTIFIER);
+        output.append(";\n");
+
+        return output.toString();
+    }
+
+    @Override
+    protected Collection<? extends Evaluable<T>> continue_breath_search()
+    {
+        Collection<Evaluable<T>> to_return = new ArrayList<Evaluable<T>>();
+        to_return.add(this.CHILD);
+        return to_return;
+    }
 }

structure/Scenario.java

@@ -9,7 +9,7 @@
 </b>
 */
 
-public class Scenario<T> implements Evaluable<T>
+public class Scenario<T> extends Evaluable<T>
 {
     /**
      * Controls whether this should be displayed in final results.
@@ -53,4 +53,31 @@ public <E extends Reservable> TestResult evaluate(Collection<E> hand, RollbackCa
         printDebugStep(hand);
         return TREE_CONDITION.evaluate(hand, next);
     }
+
+    /**
+     * for dot format
+     */
+    public String toString()
+    {
+        StringBuilder output = new StringBuilder(128);
+
+        output.append(this.UNIQUE_IDENTIFIER);
+        output.append("[label=\"");
+        output.append(this.NAME.replace(">", "\\>").replace("<", "\\<").replace("\"", "\\\""));//escape certain characters
+        output.append("\"];\n");
+
+        //child
+        output.append(this.UNIQUE_IDENTIFIER);
+        output.append("->");
+        output.append(this.TREE_CONDITION.UNIQUE_IDENTIFIER);
+        output.append(";\n");
+
+        return output.toString();
+    }
+
+    @Override
+    protected Collection<? extends Evaluable<T>> continue_breath_search()
+    {
+        return null;//TODO: consider changing to adding TREE_CONDITION.
+    }
 }