fix javadoc generation

[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..6aecefa 100644 (file)
--- a/src/edu/berkeley/sbp/Node.java
+++ b/src/edu/berkeley/sbp/Node.java
@@ -10,17 +10,99 @@ 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> {
 
-    protected       FastSet<OtherNode> predecessors = new FastSet<OtherNode>();
-    protected       FastSet<OtherNode> successors = new FastSet<OtherNode>();
-    //private       HashSet<OtherNode> predecessors = new HashSet<OtherNode>();
-    //private       HashSet<OtherNode> successors = new HashSet<OtherNode>();
+    private final GSS.Phase phase;
+    private final GSS.Phase predecessorPhase;
+    protected boolean destroyed        = false;
+    private int numNonDoomedSuccessors = 0;
+    private boolean hasPathToRoot      = false;
+
+    private       FastSet<OtherNode> predecessors = new FastSet<OtherNode>();
+    private       FastSet<OtherNode> successors = new FastSet<OtherNode>();
+    //protected       HashSet<OtherNode> predecessors = new HashSet<OtherNode>();
+    //protected       HashSet<OtherNode> successors = new HashSet<OtherNode>();
+
+    public GSS.Phase phase() { return phase; }
+    public GSS.Phase predecessorPhase() { return predecessorPhase; }
+    public boolean hasPredecessors() { return predecessors.size() > 0; }
+    public boolean hasSuccessors() { return successors.size() > 0; }
+    public boolean hasNonDoomedSuccessors() { return numNonDoomedSuccessors > 0; }
+
+    public boolean hasPathToRoot() { return hasPathToRoot; }
+    public void updatePathsToRootAfterRemoval() {
+        if (!hasPathToRoot()) return;
+        for(OtherNode on : predecessors)
+            if (on.hasPathToRoot())
+                return;
+        hasPathToRoot = false;
+        for(OtherNode on : successors)
+            on.updatePathsToRootAfterRemoval();
+    }
+
+    /**
+     *  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;
+    }
+
+    /** 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);
+        if (pred.hasPathToRoot()) hasPathToRoot = true;
+    }
+    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();
+    }
+
+    protected void destroy() {
+        destroyed = true;
+        while(predecessors.size() > 0) {
+            OtherNode pred = predecessors.first();
+            removePred(pred);
+            pred.removeSucc(this);
+        }
+        predecessors = null;
+        while(successors.size() > 0) {
+            OtherNode succ = successors.first();
+            removeSucc(succ);
+            succ.removePred(this);
+        }
+        successors = null;
+    }
+    public void removeSucc(OtherNode succ) {
+        if (!successors.contains(succ)) return;
+        successors.remove(succ);
+        numNonDoomedSuccessors -= succ.isDoomedState() ? 0 : 1;
+        check();
+    }
+    public void removePred(OtherNode pred) {
+        if (!predecessors.contains(pred)) return;
+        predecessors.remove(pred);
+        updatePathsToRootAfterRemoval();
+        check();
+    }
+
+
+    public abstract boolean isDoomedState();
+    protected abstract void check();
 
     public Iterator<OtherNode> iterator() { return predecessors.iterator(); }
+    public Iterable<OtherNode> successors() { return successors; }
 
     public boolean noSuccessors() { return successors.size()==0; }
     public boolean predecessorsContains(OtherNode n) {