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 Pos reduction() { return reduction; }
  20     public void merge(Forest newf) {
  21         this.f.merge(newf);
  22         /*
  23         if (predecessors.contains(pred)) return;
  24         addPred(pred);
  25         if (fromEmptyReduction) return;
  26         n.state().invokeReductions(n.phase().getToken(), n, this);
  27         */
  28     }
  29
  30     public GSS.Phase phase() { return predPhase; }
  31     public Forest getForest() { return f; }
  32     public void addSucc(StateNode succ) {
  33         if (successors.contains(succ)) return;
  34         successors.add(succ);
  35         usedByNonDoomedNode += succ.state().doomed ? 0 : 1;
  36         if (predecessors.size() > 1) throw new Error();
  37     }
  38     public void removeSucc(StateNode succ) {
  39         if (!successors.contains(succ)) return;
  40         successors.remove(succ);
  41         usedByNonDoomedNode -= succ.state().doomed ? 0 : 1;
  42         check();
  43     }
  44
  45     public boolean usedByAnyNode() { return successors.size() > 0; }
  46     public boolean usedByNonDoomedNode() { return usedByNonDoomedNode > 0; }
  47
  48     public String toString() { return super.toString()+"->"+predPhase; }
  49
  50     public void check() {
  51         if (successors.size()==0) destroy();
  52         else if (predecessors.size()==0) destroy();
  53     }
  54     public void destroy() {
  55         if (destroyed) return;
  56         if (primordeal) return;  // never destroy the "primordeal" result
  57         destroyed = true;
  58         while(predecessors.size() > 0)
  59             for(StateNode pred : predecessors) {
  60                 removePred(pred);
  61                 pred.removeSucc(this);
  62                 break;
  63             }
  64         predecessors = null;
  65         while(successors.size() > 0)
  66             for(StateNode succ : successors) {
  67                 removeSucc(succ);
  68                 succ.removeResult(this);
  69                 break;
  70             }
  71         successors = null;
  72     }
  73
  74     public void removePred(StateNode pred) {
  75         if (!predecessors.contains(pred)) return;
  76         predecessors.remove(pred);
  77         check();
  78     }
  79
  80     public void addPred(StateNode pred) {
  81         if (predPhase==null) predPhase = pred.phase();
  82         if (predPhase != pred.phase()) throw new Error();
  83         predecessors.add(pred);
  84         pred.addSucc(this);
  85         if (predecessors.size() > 1) throw new Error();
  86     }
  87
  88     public ResultNode() {
  89         this(null, null, null);
  90         this.primordeal = true;
  91     }
  92     public ResultNode(Forest f, Pos reduction, StateNode pred) {
  93         this.f.merge(f);
  94         this.reduction = reduction;
  95         if (pred != null) addPred(pred);
  96     }
  97
  98
  99 }