1   package debugger.resources.pr;
2   
3   import debugger.ClassRipper;
4   import debugger.resources.ResourcesFactory;
5   import gate.fsm.FSM;
6   import gate.jape.RightHandSide;
7   import gate.jape.SinglePhaseTransducer;
8   
9   import java.util.*;
10  
11  /**
12   * Copyright (c) Ontos AG (http://www.ontosearch.com).
13   * This class is part of JAPE Debugger component for
14   * GATE (Copyright (c) "The University of Sheffield" see http://gate.ac.uk/) <br>
15   * @author Andrey Shafirin
16   */
17  
18  public class PhaseModel //extends DefaultMutableTreeNode
19  {
20      final SinglePhaseTransducer transducer;
21      private final SPTName transducerName;
22  
23      public ArrayList getRules() {
24          return rules;
25      }
26  
27      ArrayList rules = new ArrayList();
28  
29      public PhaseModel(SinglePhaseTransducer transducer) {
30          this.transducer = transducer;
31          this.transducerName = new SPTName(this.transducer);
32          //setUserObject(transducerName);
33          //    for (Iterator rulesItr = getPhaseRules(this.transducer).iterator(); rulesItr.hasNext();) {
34          rules = getPhaseRules(transducer);
35          //this.add((RuleModel) rulesItr.next());
36          //    }
37          this.transducer.setPhaseController(ResourcesFactory.getPhaseController());
38      }
39  
40      public String getName() {
41          return this.transducerName.toString();
42      }
43  
44      ArrayList getPhaseRules(SinglePhaseTransducer spt) {
45          ArrayList phaseRules = new ArrayList();
46          FSM fsm = spt.getFSM();
47          try {
48              Collection allStates = (Collection) ClassRipper.getFieldValue(fsm, "allStates");
49              synchronized (phaseRules) {
50                  for (Iterator allStatesItr = allStates.iterator(); allStatesItr.hasNext();) {
51                      gate.fsm.State st = (gate.fsm.State) allStatesItr.next();
52                      if (!st.isFinal()) {
53                          continue; // processing just final states
54                      }
55                      RightHandSide rhs = st.getAction();
56                      RuleModel newRule = new RuleModel(rhs);
57                      HashMap hm = new HashMap();
58                      hm.put(fsm.ruleHash.get(newRule.getName()), null);
59                      newRule.setBindings(hm);
60                      if (!phaseRules.contains(newRule)) {
61                          phaseRules.add(newRule);
62                      }
63                  }
64                  Collections.sort(phaseRules, new Comparator() {
65                      public int compare(Object o1, Object o2) {
66                          String name1 = ((RuleModel) o1).getName();
67                          String name2 = ((RuleModel) o2).getName();
68                          return name1.compareToIgnoreCase(name2);
69                      }
70                  });
71              }
72          } catch (SecurityException e) {
73              e.printStackTrace();
74          } catch (IllegalArgumentException e) {
75              e.printStackTrace();
76          } catch (IllegalAccessException e) {
77              e.printStackTrace();
78          }
79          return phaseRules;
80      }
81  
82      public boolean equals(Object obj) {
83          if (obj instanceof PhaseModel) {
84              return this.transducer.equals(((PhaseModel) obj).transducer);
85          }
86          return super.equals(obj);
87      }
88  
89      class SPTName {
90          private SinglePhaseTransducer tr;
91  
92          public SPTName(SinglePhaseTransducer transducer) {
93              if (null == transducer) {
94                  throw new RuntimeException("SinglePhaseTransducer is null!");
95              }
96              this.tr = transducer;
97          }
98  
99          public String toString() {
100             if (null == this.tr.getName() || this.tr.getName().length() == 0) {
101                 return "Unnamed Transducer";
102             } else {
103                 return this.tr.getName();
104             }
105         }
106 
107         public boolean equals(Object obj) {
108             if (null == obj || null == tr || null == tr.getName()) {
109                 return false;
110             }
111             if (obj instanceof String) {
112                 return tr.getName().equals(obj);
113             }
114             if (obj instanceof SPTName) {
115                 return tr.getName().equals(((SPTName) obj).tr.getName());
116             }
117             return false;
118         }
119     }
120 
121     public RuleModel getRule(String name) {
122         for (int i = 0; i < rules.size(); i++) {
123             RuleModel ruleModel = (RuleModel) rules.get(i);
124             if (ruleModel.getName().equals(name)) {
125                 return ruleModel;
126             }
127 
128         }
129 //        Enumeration ruleEnum = this.children();
130 //        while (ruleEnum.hasMoreElements()) {
131 //            RuleModel rule = (RuleModel) ruleEnum.nextElement();
132 //            if (rule.getName().equals(name)) {
133 //                return rule;
134 //            }
135 //        }
136         return null;
137     }
138 
139     public RuleModel getRule(RightHandSide rhs) {
140         for (int i = 0; i < rules.size(); i++) {
141             RuleModel ruleModel = (RuleModel) rules.get(i);
142             if (ruleModel.getRHS().equals(rhs)) {
143                 return ruleModel;
144             }
145         }
146 //        Enumeration ruleEnum = this.children();
147 //        while (ruleEnum.hasMoreElements()) {
148 //            RuleModel rule = (RuleModel) ruleEnum.nextElement();
149 //            if (rule.getRHS().equals(rhs)) {
150 //                return rule;
151 //            }
152 //        }
153         return null;
154     }
155 
156     public boolean containsSPT(SinglePhaseTransducer spt) {
157         return this.transducer.equals(spt);
158     }
159 
160     public SinglePhaseTransducer getSPT() {
161         return this.transducer;
162     }
163 
164     public String getControl() {
165         return this.transducer.getOption("control");
166     }
167 
168     public Set getInput() {
169         return getSPT().input;
170     }
171 
172 }
173