FSMState.java
001 /*
002  *  FSMState.java
003  *
004  *  Copyright (c) 1995-2012, The University of Sheffield. See the file
005  *  COPYRIGHT.txt in the software or at http://gate.ac.uk/gate/COPYRIGHT.txt
006  *
007  *  This file is part of GATE (see http://gate.ac.uk/), and is free
008  *  software, licenced under the GNU Library General Public License,
009  *  Version 2, June 1991 (in the distribution as file licence.html,
010  *  and also available at http://gate.ac.uk/gate/licence.html).
011  *
012  *  Valentin Tablan, 11/07/2000
013  *
014  *  $Id: FSMState.java 17593 2014-03-08 10:03:19Z markagreenwood $
015  */
016 
017 package gate.creole.gazetteer;
018 
019 import java.io.Serializable;
020 import java.util.HashSet;
021 import java.util.Set;
022 import gate.creole.gazetteer.DefaultGazetteer.CharMap;
023 
024 /** Implements a state of the deterministic finite state machine of the
025  * gazetter.
026  *
027  */
028 public class FSMState implements Serializable {
029 
030   private static final long serialVersionUID = -3339572027660481558L;
031 
032   /** Constructs a new FSMState object and adds it to the list of
033    * states of the {@link DefaultGazetteer} provided as owner.
034    *
035    @param owner a {@link DefaultGazetteer} object
036    */
037   public FSMState(DefaultGazetteer owner) {
038     myIndex = index++;
039     owner.fsmStates.add(this);
040   }
041 
042   /** Adds a new value to the transition function
043    */
044 // >>> DAM: was - to use CharMap
045 /*
046   void put(Character chr, FSMState state) {
047     transitionFunction.put(chr,state);
048   }
049 */
050 // >>> DAM: TransArray optimization
051   public void put(char chr, FSMState state) {
052     transitionFunction.put(chr,state);
053   }
054 // >>> DAM: end
055 
056   /** This method is used to access the transition function of this state.
057    */
058 // >>> DAM: was
059 /*
060   FSMState next(Character chr) {//UnicodeType type){
061     return (FSMState)transitionFunction.get(chr);
062   }
063   */
064 // >>> DAM: TransArray optimization
065   public FSMState next(char chr) {//UnicodeType type){
066     return (FSMState)transitionFunction.get(chr);
067   }
068 // >>> DAM: end
069 
070   /** Returns a GML (Graph Modelling Language) representation of the edges
071    * emerging from this state.
072    */
073 //<<< DAM: was - to use new char Iter returned by the CharMap iteratior
074 /*
075   String getEdgesGML() {
076     String res = "";
077     Iterator charsIter = transitionFunction.keySet().iterator();
078     Character currentChar;
079     FSMState nextState;
080 
081     while(charsIter.hasNext()){
082       currentChar = (Character)charsIter.next();
083       nextState = next(currentChar);
084       res += "edge [ source " + myIndex +
085       " target " + nextState.getIndex() +
086       " label \"'" + currentChar + "'\" ]\n";
087     }
088 */
089 // DAM, TransArray optimization
090   public String getEdgesGML() {
091     String res = "";
092     char currentChar;
093     FSMState nextState;
094 
095     for (int i = 0; i < transitionFunction.itemsKeys.length; i++)
096     {
097       currentChar = transitionFunction.itemsKeys[i];
098       nextState = next(currentChar);
099       res += "edge [ source " + myIndex +
100       " target " + nextState.getIndex() +
101       " label \"'" + currentChar + "'\" ]\n";
102     }
103 // >>> DAM, end
104     return res;
105   }
106 
107   /** Checks whether this state is a final one
108    */
109   public boolean isFinal() {
110 // >>> was
111 //    return !lookupSet.isEmpty();
112 // >>> BOBI, Lookup opitimization
113     if (lookupSet==null)
114         return false;
115     return !lookupSet.isEmpty();
116 // >>> end
117   }
118 
119   /** Returns a set of {@link Lookup} objects describing the types of lookups
120    * the phrase for which this state is the final one belongs to
121    */
122   public Set<Lookup> getLookupSet(){return lookupSet;}
123 
124   /** Adds a new looup description to this state's lookup descriptions set
125    */
126   public void addLookup(Lookup lookup) {
127 // >>> was nothing
128 // >>> BOBI, Lookup opitimization
129     if (lookupSet == null)
130         lookupSet = new HashSet<Lookup>(4);
131 // >>> end
132 
133     lookupSet.add(lookup);
134   // addLookup
135 
136   /** Removes a looup description from this state's lookup descriptions set
137    */
138   public void removeLookup(Lookup lookup) {
139     lookupSet.remove(lookup);
140   // removeLookup
141 
142   /** Returns the unique ID of this state.
143    */
144   public int getIndex(){ return myIndex; }
145 
146 
147   /** The transition function of this state.
148    */
149 // >>> was
150 //  Map transitionFunction = new HashMap();
151 // >>> NASO, hash4 optimization
152 //  Map transitionFunction = new HashMap(4);
153 // >>> DAM, TransArray
154   protected CharMap transitionFunction = new CharMap();
155 // >>> end
156 
157   /**    *
158    */
159 // >>> was
160 //  Set lookupSet = new HashSet();
161 // >>> NASO, hash4 optimization
162 //  Set lookupSet = new HashSet(4);
163 // >>> BOBI, Lookup opitimization
164   protected Set<Lookup> lookupSet;
165 // >>> end
166 
167   /**
168    * The unique id of this state. This value is never used by the algorithms but
169    * it can be useful for graphical representations.
170    */
171   protected int myIndex;
172 
173   /**
174    * Class member used to generate unique ids for the instances
175    *
176    */
177   private static int index;
178 
179   static{
180     index = 0;
181   }
182 
183 // class FSMState