First Draft of Rollback Implementation (#1)

* first draft of rollback implementation

* clean up Leaf Node

* minor fix

* review based fixes

* move comments out of function body

* deal with intelliJ warnings

* Working Tests

* Working Tests

Author: AlexOxorn

.gitignore

@@ -3,5 +3,10 @@
 .project
 .classpath
 
+#JetBrains
+.idea/
+*.iml
+out/
+
 #Java
-*.class
+*.class

structure/And_Operator_Node.java

@@ -5,30 +5,28 @@
 /**
 <b>
 Purpose: And operator<br>
-Programmer: Gabriel Toban Harris <br>
+Programmer: Gabriel Toban Harris, Alexander Herman Oxorn <br>
 Date: 2021-07-24
 </b>
 */
 
 public class And_Operator_Node<T> extends Binary_Operator_Node<T>
 {
     /**
-     * Constructor, refer to {@link Binary_Operator_Node#Binary_Operator_Node(String, Evaluatable, Evaluatable)}.
+     * Constructor, refer to {@link Binary_Operator_Node#Binary_Operator_Node(String, Evaluable, Evaluable)}.
      */
-    public And_Operator_Node(final Evaluatable<T> LEFT_CHILD, final Evaluatable<T> RIGHT_CHILD)
+    public And_Operator_Node(final Evaluable<T> LEFT_CHILD, final Evaluable<T> RIGHT_CHILD)
     {
         super("AND", LEFT_CHILD, RIGHT_CHILD);
     }
 
+    // If LEFT_CHILD can take card(s), then make sure the RIGHT CHILD can also take card(s)
     @Override
-    public <E extends Collection<T>> boolean evaluate(E hand)
-    {
-        if (!super.evaluated)
-        {
-            super.result = super.LEFT_CHILD.evaluate(hand) && super.RIGHT_CHILD.evaluate(hand);
-            super.evaluated = true;
-        }
-
-        return super.result;
+    public <E extends Reservable> TestResult evaluate(Collection<E> hand, RollbackCallback next) {
+        printDebugStep(hand);
+        return LEFT_CHILD.evaluate(
+                hand,
+                () -> RIGHT_CHILD.evaluate(hand, next)
+        );
     }
 }

structure/Base_Card.java

@@ -22,6 +22,8 @@ public class Base_Card
      */
     protected final int HASH_CODE;
 
+    protected boolean reserved;
+
     /**
      * Constructor.
      * 
@@ -42,20 +44,21 @@ public Base_Card(final Base_Card CARD)
     {
         this.NAME = CARD.NAME;
         this.HASH_CODE = CARD.HASH_CODE;
+        this.reserved = false;
     }
 
     @Override
     public boolean equals(final Object INPUT)
     {
         if (INPUT instanceof Base_Card)
-            return this.equals(INPUT);
+            return this.equals((Base_Card) INPUT);
         else
             return false;
     }
 
     /**
      * Function to check card equality.
-     * 
+     *
      * @param <T> anything which either is or extends, {@link Base_Card}.
      * @param CARD to be compared
      * @return true for equivalent, otherwise false

structure/Base_Node.java

@@ -10,30 +10,20 @@
 
 //TODO: add toString() methods with some reference to outputting as dot file format.
 //TODO: figure out edge cases in evaluation for both duplication (maybe paint) and overlap (maybe attempt condition evaluation in different combinations).
-public abstract class Base_Node<T> implements Evaluatable<T>
+public abstract class Base_Node<T> implements Evaluable<T>
 {
     /**
      * Unique identifier for this node.
      */
-    public final int UNIQUE_IDENTIFER;
+    public final int UNIQUE_IDENTIFIER;
 
     /**
      * The name of this node.
      */
     public final String NAME;
 
     /**
-     * Used to prevent repeated evaluations.
-     */
-    protected boolean evaluated = false;
-
-    /**
-     * Used to store result.
-     */
-    protected boolean result;
-
-    /**
-     * Used to set {@link #UNIQUE_IDENTIFER}
+     * Used to set {@link #UNIQUE_IDENTIFIER}
      */
     private static int CREATED_NODES_COUNT = 0;
 
@@ -44,12 +34,6 @@ public abstract class Base_Node<T> implements Evaluatable<T>
     public Base_Node(final String NAME)
     {
         this.NAME = NAME;
-        this.UNIQUE_IDENTIFER = ++CREATED_NODES_COUNT;
-    }
-
-    @Override
-    public void reset()
-    {
-        this.evaluated = false;
+        this.UNIQUE_IDENTIFIER = ++CREATED_NODES_COUNT;
     }
 }

structure/Binary_Operator_Node.java

@@ -14,12 +14,12 @@ public abstract class Binary_Operator_Node<T> extends Base_Node<T>
     /**
      * Left operand.
      */
-    public final Evaluatable<T> LEFT_CHILD;
+    public final Evaluable<T> LEFT_CHILD;
 
     /**
      * Right operand.
      */
-    public final Evaluatable<T> RIGHT_CHILD;
+    public final Evaluable<T> RIGHT_CHILD;
 
     /**
      * Constructor.
@@ -28,21 +28,10 @@ public abstract class Binary_Operator_Node<T> extends Base_Node<T>
      * @param LEFT_CHILD is the left operand of the operator
      * @param RIGHT_CHILD is the right operand of the operator
      */
-    public Binary_Operator_Node(String NAME, final Evaluatable<T> LEFT_CHILD, final Evaluatable<T> RIGHT_CHILD)
+    public Binary_Operator_Node(String NAME, final Evaluable<T> LEFT_CHILD, final Evaluable<T> RIGHT_CHILD)
     {
         super(NAME);
         this.LEFT_CHILD = LEFT_CHILD;
         this.RIGHT_CHILD = RIGHT_CHILD;
     }
-
-    /**
-     * Resets self and children for next hand.
-     */
-    @Override
-    public void reset()
-    {
-        super.reset();
-        this.LEFT_CHILD.reset();
-        this.RIGHT_CHILD.reset();
-    }
 }

structure/Deck_Card.java

@@ -3,18 +3,13 @@
 /**
 <b>
 Purpose: To be used as the representation of cards in a deck.<br>
-Programmer: Gabriel Toban Harris <br>
+Programmer: Gabriel Toban Harris, Alexander Herman Oxorn <br>
 Date: 2021-07-25
 </b>
 */
 
-public class Deck_Card extends Base_Card
+public class Deck_Card extends Base_Card implements Reservable
 {
-    /**
-     * For classes in {@link structure} to use to know that a card has already been allocated.
-     */
-    public boolean used;
-
     /**
      * See {@link Base_Card#Base_Card(String)}
      */
@@ -31,13 +26,29 @@ public Deck_Card(final String NAME)
     public Deck_Card(final Deck_Card INPUT)
     {
         super(INPUT);
+        this.reserved = false;
+    }
+
+    @Override
+    public boolean isReserved() {
+        return reserved;
     }
 
     /**
-     * Calls {@link #equals(Base_Card)} and then sets {@link #used} to that value. Meant to be convenience method for {@link structure}.
+     * Calls {@link #equals(Base_Card)} and then sets {@link #reserved} to that value. Meant to be convenience method for {@link structure}.
      */
     public <T extends Base_Card> boolean convenience_comparison(final T CARD)
     {
-        return this.used = this.equals(CARD);
+        return this.reserved = this.equals(CARD);
+    }
+
+    @Override
+    public void reserve() {
+        reserved = true;
+    }
+
+    @Override
+    public void release() {
+        reserved = false;
     }
 }

structure/Evaluable.java

@@ -0,0 +1,77 @@
+package structure;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+<b>
+Purpose: Requirement to be a node for evaluation purposes.<br>
+Programmer: Gabriel Toban Harris, Alexander Herman Oxorn <br>
+Date: 2021-07-24
+</b>
+*/
+
+public interface Evaluable<T>
+{
+    boolean debugMode = false;
+
+    enum TestResult {
+        /**
+         * The evaluation succeeded
+         */
+        Success,
+        /**
+         * The evaluation of the child of NOT succeeded
+         */
+        NotSuccess,
+        /**
+         * Evaluation failed given reserved cards
+         */
+        Rollback
+    }
+
+    interface RollbackCallback {
+        TestResult call();
+    }
+
+    /**
+     * Function used to evaluate a node's condition using a rollback evaluation implementation.
+     * Allows for hand to be in an arbitrary order
+     *
+     * @param hand to be checked {@link Collection}
+     * @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);
+
+    /**
+     * Function used to deprecated_evaluate a node's condition using a rollback evaluation implementation.
+     * Allows for hand to be in an arbitrary order
+     *
+     * Default entry point where the success callback returns true and the failure callback returns false
+     *
+     * @param hand to be checked {@link Collection}
+     * @return If the hand meets a condition
+     */
+    default <E extends Reservable> boolean evaluate(final Collection<E> hand)
+    {
+        TestResult result = evaluate(hand, () -> TestResult.Success);
+        return result == TestResult.Success;
+    }
+
+    /**
+     * 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) {
+        if (debugMode) {
+            System.out.printf("%s ", this);
+            Map<Boolean, List<E>> hand_partition = hand.stream().collect(Collectors.partitioningBy(Reservable::isReserved));
+            System.out.printf("Used Cards: [%s] ", hand_partition.get(true).stream().map(Object::toString).collect(Collectors.joining(",")));
+            System.out.printf("Unused Cards: [%s]\n", hand_partition.get(false).stream().map(Object::toString).collect(Collectors.joining(",")));
+        }
+    }
+}