X-Git-Url: http://git.megacz.com/?p=sbp.git;a=blobdiff_plain;f=src%2Fedu%2Fberkeley%2Fsbp%2FStateNode.java;h=af1a3e9c20f60139e71c856cdfc2a022150eaace;hp=321334d5822b8237f64efd677886c8dde5a7e668;hb=d96df56ee69e62c4d4d6dfe3786ea4853e5120eb;hpb=c53fc2952c7885d727500ce404887d552c5dec5f

diff --git a/src/edu/berkeley/sbp/StateNode.java b/src/edu/berkeley/sbp/StateNode.java
index 321334d..af1a3e9 100644
--- a/src/edu/berkeley/sbp/StateNode.java
+++ b/src/edu/berkeley/sbp/StateNode.java
@@ -12,19 +12,16 @@ import java.lang.reflect.*;
 
 /** a node in the GSS */
 final class StateNode
-    implements Invokable<Pos, ResultNode, Object>,
-               IntegerMappable,
-               GraphViz.ToGraphViz,
-               Iterable<ResultNode> {
+    extends Node<ResultNode>
+    implements Invokable<Pos, ResultNode, Object> {
+
+    private final Parser.Table.State state;
+    private  boolean fromEmptyReduction;
 
     /** which GSS.Phase this StateNode belongs to */
-    public GSS.Phase phase() { return phase; }
-    public Iterator<ResultNode> iterator() { return results.iterator(); }
+    public Iterator<ResultNode> iterator() { return predecessors.iterator(); }
     public Parser.Table.State state() { return state; }
-
-    public int toInt() { return idx; }
-
-    boolean destroyed = false;
+    public boolean isDoomedState() { return state.doomed; }
 
     public void check() {
         if (destroyed) return;
@@ -33,45 +30,17 @@ final class StateNode
         // - non-doomed nodes must either:
         //      - be on the frontier or
         //      - have a non-doomed node closer to the frontier than themself
-        if (phase.isFrontier()) dead = false;
+        if (phase().isFrontier()) dead = false;
         else for(ResultNode r : successors)
-                 if (state.doomed) { if (r.usedByAnyNode()) { dead = false; break; } }
-                 else              { if (r.usedByNonDoomedNode()) { dead = false; break; } }
-        dead |= results.size()==0;
+                 if (state.doomed) { if (r.hasSuccessors()) { dead = false; break; } }
+                 else              { if (r.hasNonDoomedSuccessors()) { dead = false; break; } }
+        dead |= predecessors.size()==0;
         if (!dead) return;
-        destroyed = true;
         if (phase() != null && phase().hash != null)
-            phase().hash.remove(state, predPhase);
-        while(successors.size()>0)
-            for(ResultNode r : successors) {
-                successors.remove(r);
-                r.removePred(this);
-                break;
-            }
-        while(results.size()>0)
-            for(ResultNode r : results) {
-                results.remove(r);
-                r.removeSucc(this);
-                break;
-            }
-        results = null;
-        successors = null;
+            phase().hash.remove(state, predecessorPhase());
+        destroy();
     }
 
-    //////////////////////////////////////////////////////////////////////
-
-    private static int node_idx = 0;
-    private final int idx = node_idx++;
-
-    private final GSS.Phase phase;
-    private final GSS.Phase predPhase;
-    private final Parser.Table.State state;
-    private  boolean fromEmptyReduction;
-    private       FastSet<ResultNode> results = new FastSet<ResultNode>();
-    private       FastSet<ResultNode> successors = new FastSet<ResultNode>();
-    //private       HashSet<ResultNode> results = new HashSet<ResultNode>();
-    //private       HashSet<ResultNode> successors = new HashSet<ResultNode>();
-
     public final void invoke(Pos r, ResultNode only, Object o) {
         boolean emptyProductions = only==null;
         if (emptyProductions != (r.numPops()==0)) return;
@@ -83,9 +52,9 @@ final class StateNode
     }
 
     private void reduce(Pos r, int pos, GSS.Phase target, ResultNode only) {
-        for(ResultNode res : results)
+        for(ResultNode res : predecessors)
             if (only == null || res == only)
-                for(StateNode pred : res.getPreds())
+                for(StateNode pred : res)
                     reduce2(r, pos, target, pred, res.getForest());
     }
 
@@ -105,61 +74,28 @@ final class StateNode
         this(phase, new ResultNode(f, reduction, pred), state, fromEmptyReduction);
     }
     StateNode(GSS.Phase phase, ResultNode pred, State state, boolean fromEmptyReduction) {
-        this.phase = phase;
+        super(phase, pred.phase());
         this.state = state;
         this.fromEmptyReduction = fromEmptyReduction;
         if (phase.hash.get(state, pred.phase()) != null) throw new Error("severe problem!");
-        this.predPhase = pred.phase();
         phase.hash.put(state, pred.phase(), this);
-
-        results.add(pred);
-        pred.addSucc(this);
-        if (!fromEmptyReduction)
-            state.invokeReductions(phase().getToken(), this, pred);
-
+        addPred(pred);
         state.invokeEpsilonReductions(phase().token, this);
     }
 
-    // Add/Remove Successors/Results //////////////////////////////////////////////////////////////////////////////
+    // Add/Remove Successors/Predecessors //////////////////////////////////////////////////////////////////////////////
 
-    public void removeSucc(ResultNode succ)   {
-        successors.remove(succ);
-        check();
-    }
-    public void removeResult(ResultNode result) {
-        results.remove(result);
-        check();
-    }
-    public void addSucc(ResultNode succ)      {
-        successors.add(succ);
-    }
-    public void addResult(Forest f, Pos reduction, StateNode pred) {
-        for(ResultNode r : results)
+    public void addPred(Forest f, Pos reduction, StateNode pred) {
+        for(ResultNode r : predecessors)
             if (r.predecessorsContains(pred)) {
                 r.merge(f);
                 return;
             }
-        ResultNode result = new ResultNode(f, reduction, pred);
-        results.add(result);
-        result.addSucc(this);
-        if (!this.fromEmptyReduction) state.invokeReductions(phase().getToken(), this, result);
+        addPred(new ResultNode(f, reduction, pred));
     }
-
-    // GraphViz //////////////////////////////////////////////////////////////////////////////
-
-    public GraphViz.StateNode toGraphViz(GraphViz gv) {
-        if (results.size()==0) return null;
-        if (gv.hasNode(this)) return gv.createNode(this);
-        GraphViz.StateNode n = gv.createNode(this);
-        n.label = "state["+state.toInt()+"]";
-        n.shape = "rectangle";
-        boolean haspreds = false;
-        for(ResultNode r : results) n.edge(r, "");
-        n.color = state.doomed ? "red" : "green";
-        ((GraphViz.Group)phase().toGraphViz(gv)).add(n);
-        return n;
+    protected void addPred(ResultNode result) {
+        super.addPred(result);
+        if (!this.fromEmptyReduction)
+            state.invokeReductions(phase().getToken(), this, result);
     }
-    public boolean isTransparent() { return false; }
-    public boolean isHidden() { return false; }
-
 }