refactoring of Node class and more stringent checks

[sbp.git] / src / edu / berkeley / sbp / Node.java

diff --git a/src/edu/berkeley/sbp/Node.java b/src/edu/berkeley/sbp/Node.java
index 1168c78..4feac2b 100644 (file)
--- a/src/edu/berkeley/sbp/Node.java
+++ b/src/edu/berkeley/sbp/Node.java
@@ -10,11 +10,78 @@ import java.io.*;
 import java.util.*;
 import java.lang.reflect.*;
 
-class Node<OtherNode extends Node>
+abstract class Node<OtherNode extends Node>
     implements IntegerMappable,
                GraphViz.ToGraphViz,
                Iterable<OtherNode> {
 
+    /**
+     *  Every Node has a phase; StateNodes belong to the phase in
+     *  which they were shifted, ResultNodes belong to the phase of
+     *  their predecessors.  All of the predecessors of a given node
+     *  must belong to the same phase
+     */
+    public Node(GSS.Phase phase, GSS.Phase predecessorPhase) {
+        this.phase = phase;
+        this.predecessorPhase = predecessorPhase;
+    }
+
+    private final GSS.Phase phase;
+    private final GSS.Phase predecessorPhase;
+    public GSS.Phase phase() { return phase; }
+    public GSS.Phase predecessorPhase() { return predecessorPhase; }
+    protected boolean destroyed = false;
+    private int numNonDoomedSuccessors = 0;
+    public boolean hasSuccessors() { return successors.size() > 0; }
+    public boolean hasNonDoomedSuccessors() { return numNonDoomedSuccessors > 0; }
+
+    /** only to be invoked (or overridden as public) by the subclass */
+    protected void addPred(OtherNode pred) {
+        if (predecessors.contains(pred)) throw new Error("a predecessor was added twice");
+        if (pred.phase() != predecessorPhase()) throw new Error();
+        predecessors.add(pred);
+        pred.addSucc(this);
+    }
+    public void addSucc(OtherNode succ) {
+        if (successors.contains(succ)) throw new Error("a predecessor was added twice");
+        successors.add(succ);
+        numNonDoomedSuccessors += succ.isDoomedState() ? 0 : 1;
+        if (predecessors.size() > 1 && (((Object)this) instanceof ResultNode)) throw new Error();
+    }
+    public void removeSucc(OtherNode succ) {
+        if (!successors.contains(succ)) return;
+        successors.remove(succ);
+        numNonDoomedSuccessors -= succ.isDoomedState() ? 0 : 1;
+        check();
+    }
+
+    protected void destroy() {
+        destroyed = true;
+        while(predecessors.size() > 0)
+            for(OtherNode pred : predecessors) {
+                removePred(pred);
+                pred.removeSucc(this);
+                break;
+            }
+        predecessors = null;
+        while(successors.size() > 0)
+            for(OtherNode succ : successors) {
+                removeSucc(succ);
+                succ.removePred(this);
+                break;
+            }
+        successors = null;
+    }
+
+    public abstract boolean isDoomedState();
+    protected abstract void check();
+
+    public void removePred(OtherNode pred) {
+        if (!predecessors.contains(pred)) return;
+        predecessors.remove(pred);
+        check();
+    }
+
     protected       FastSet<OtherNode> predecessors = new FastSet<OtherNode>();
     protected       FastSet<OtherNode> successors = new FastSet<OtherNode>();
     //private       HashSet<OtherNode> predecessors = new HashSet<OtherNode>();