src/edu/berkeley/sbp/ResultNode.java

   1 // Copyright 2006-2007 all rights reserved; see LICENSE file for BSD-style license
   2
   3 package edu.berkeley.sbp;
   4 import edu.berkeley.sbp.util.*;
   5 import edu.berkeley.sbp.Sequence.Pos;
   6 import edu.berkeley.sbp.Sequence.Pos;
   7 import java.util.*;
   8
   9 final class ResultNode
  10     extends Node<StateNode> {
  11
  12     private Forest.Many f = new Forest.Many();
  13     private boolean destroyed = false;
  14     private boolean primordeal;
  15     private int usedByNonDoomedNode = 0;
  16     private Pos reduction;
  17     private GSS.Phase predPhase;
  18
  19     public boolean predecessorsContains(StateNode n) {
  20         return predecessors.contains(n);
  21     }
  22     public Pos reduction() { return reduction; }
  23     public void merge(Forest newf) {
  24         this.f.merge(newf);
  25         /*
  26         if (predecessors.contains(pred)) return;
  27         addPred(pred);
  28         if (fromEmptyReduction) return;
  29         n.state().invokeReductions(n.phase().getToken(), n, this);
  30         */
  31     }
  32
  33     public boolean noSuccessors() { return successors.size()==0; }
  34
  35     public GSS.Phase phase() { return predPhase; }
  36     public Forest getForest() { return f; }
  37     public Iterable<StateNode> getPreds() { return predecessors; }
  38     public void addSucc(StateNode succ) {
  39         if (successors.contains(succ)) return;
  40         successors.add(succ);
  41         usedByNonDoomedNode += succ.state().doomed ? 0 : 1;
  42         if (predecessors.size() > 1) throw new Error();
  43     }
  44     public void removeSucc(StateNode succ) {
  45         if (!successors.contains(succ)) return;
  46         successors.remove(succ);
  47         usedByNonDoomedNode -= succ.state().doomed ? 0 : 1;
  48         check();
  49     }
  50
  51     public boolean usedByAnyNode() { return successors.size() > 0; }
  52     public boolean usedByNonDoomedNode() { return usedByNonDoomedNode > 0; }
  53
  54     public String toString() { return super.toString()+"->"+predPhase; }
  55
  56     public void check() {
  57         if (successors.size()==0) destroy();
  58         else if (predecessors.size()==0) destroy();
  59     }
  60     public void destroy() {
  61         if (destroyed) return;
  62         if (primordeal) return;  // never destroy the "primordeal" result
  63         destroyed = true;
  64         while(predecessors.size() > 0)
  65             for(StateNode pred : predecessors) {
  66                 removePred(pred);
  67                 pred.removeSucc(this);
  68                 break;
  69             }
  70         predecessors = null;
  71         while(successors.size() > 0)
  72             for(StateNode succ : successors) {
  73                 removeSucc(succ);
  74                 succ.removeResult(this);
  75                 break;
  76             }
  77         successors = null;
  78     }
  79
  80     public void removePred(StateNode pred) {
  81         if (!predecessors.contains(pred)) return;
  82         predecessors.remove(pred);
  83         check();
  84     }
  85
  86     public void addPred(StateNode pred) {
  87         if (predPhase==null) predPhase = pred.phase();
  88         if (predPhase != pred.phase()) throw new Error();
  89         predecessors.add(pred);
  90         pred.addSucc(this);
  91         if (predecessors.size() > 1) throw new Error();
  92     }
  93
  94     public ResultNode() {
  95         this(null, null, null);
  96         this.primordeal = true;
  97     }
  98     public ResultNode(Forest f, Pos reduction, StateNode pred) {
  99         this.f.merge(f);
 100         this.reduction = reduction;
 101         if (pred != null) addPred(pred);
 102     }
 103
 104
 105 }