GraphViz.ToGraphViz,
Iterable<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
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);
+ if (pred.hasPathToRoot()) hasPathToRoot = true;
}
public void addSucc(OtherNode succ) {
if (successors.contains(succ)) throw new Error("a predecessor was added twice");
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;
- }
+ while(predecessors.size() > 0) {
+ OtherNode pred = predecessors.first();
+ removePred(pred);
+ pred.removeSucc(this);
+ }
predecessors = null;
- while(successors.size() > 0)
- for(OtherNode succ : successors) {
- removeSucc(succ);
- succ.removePred(this);
- break;
- }
+ while(successors.size() > 0) {
+ OtherNode succ = successors.first();
+ removeSucc(succ);
+ succ.removePred(this);
+ }
successors = null;
}
-
- public abstract boolean isDoomedState();
- protected abstract void check();
-
+ 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();
}
- 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>();
+
+ 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) {