Transition.java
001 /*
002  *  Transition.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/Apr/2000
013  *
014  *  $Id: Transition.java 17595 2014-03-08 13:05:32Z markagreenwood $
015  */
016 
017 package gate.fsm;
018 
019 import gate.Annotation;
020 import gate.jape.BasicPatternElement;
021 import gate.jape.Constraint;
022 
023 import java.io.Serializable;
024 import java.util.LinkedList;
025 import java.util.List;
026 
027 /**
028   * This class implements a Finite State Machine transition.
029   * A transition is owned by a gate.fsm.State object and contains set of
030   * restrictions and a reference to the next state that will be accessed after
031   * consuming a set of input symbols according to the restrictions.
032   * A transition can also hold information about the label that should be bound
033   * to the symbols (annotations) consumed during the state transition.
034   */
035 // >>> DAM
036 /*
037 public class Transition implements Serializable {
038 */
039 // >>> DAM, TransArray optimzation, now implements the Comparable interface
040 public class Transition implements Serializable, Comparable<Transition> {
041 
042   private static final long serialVersionUID = 5970884178025357306L;
043 
044 // >>> DAM, end
045 
046   /**
047     * Default constructor. Creates a new transition with a new unique index.
048     * This constructor should be called by all other constructors.
049     */
050   public Transition() {
051     myIndex = Transition.index++;
052   }
053 
054   /**
055     * Creates a new transition using the given set of constraints and target
056     * state.
057     @param constraints the set on constraints associated to this transition
058     @param state the target state of this transition
059     */
060   public Transition(BasicPatternElement constraints, State state) {
061     this(constraints, state, new LinkedList<String>());
062   }
063 
064   /**
065     * Creates a new transition from a set of constraints, a target state and a
066     * list of labels to be bound with the recognized input symbols
067     * (aka annotations).
068     */
069   public Transition(BasicPatternElement constraints, State state,
070                     List<String> bindings) {
071     this();
072     this.constraints = constraints;
073     target = state;
074     this.bindings = bindings;
075   }
076 
077   /**
078     * Creates a new transition to the given State with the same
079     * bindings as this one.
080     */
081   public Transition spawn(State s)
082   {
083       return new Transition(constraints, s, bindings);
084   }
085 
086   /**
087     * Gets the target state of this transition
088     @return an object of type gate.fsm.State
089     */
090   public State getTarget(){ return target; }
091 
092   /**
093     * Gets the constraints associated to this transition
094     */
095   public BasicPatternElement getConstraints(){ return constraints; }
096 
097   /**
098     * Returns a boolean value indicating whether this Transition
099     * has any constraints on it.
100     */
101   public boolean hasConstraints()
102   {
103       return constraints != null;
104   }
105 
106   /**
107     * Returns true if all the constraints on this transition are satisfied
108     * by the given Annotations, false otherwise.  The given Annotations
109     * should be the set of Annotations beginning at a single point in the
110     * document.
111     */
112   public boolean satisfiedBy(Annotation[] coIncidentAnnos) {
113       Constraint[] allConstraints = getConstraints().getConstraints();
114 
115       processAllConstraints:
116       for (int i = 0; i < allConstraints.length; i++)
117       {
118           Constraint c = allConstraints[i];
119           boolean negated = c.isNegated();
120 
121           for (int j = 0; j < coIncidentAnnos.length; j++)
122           {
123               if (c.matches(coIncidentAnnos[j]null))
124               {
125                   // One of these puppies being satisfied invalidates the whole transition
126                   if (negatedreturn false;
127 
128                   // This constraint is satisfied, go on to the next one
129                   continue processAllConstraints;
130               }
131           }
132 
133           // No matching annotations found for this constraint
134           if (!negatedreturn false;
135       }
136 
137       // All constraints satisfied
138       return true;
139   }
140 
141   /**
142     * Returns a boolean value indicating whether this Transition
143     * deals with multiple types of annotations.
144     */
145   public boolean isMultiType() {
146       return constraints != null && constraints.isMultiType();
147   }
148 
149   /**
150     * Returns a textual desciption of this transition.
151     @return a String
152     */
153   @Override
154   public String toString(){
155     return toString(true);
156   }
157 
158   public String toString(boolean includeTarget){
159     StringBuffer toReturn = new StringBuffer();
160     if (includeTargettoReturn.append("If: ");
161     toReturn.append(constraints);
162     if (includeTargettoReturn.append(" then ->: " + target.getIndex());
163     return toReturn.toString();
164   }
165 
166   /**
167     * Returns a shorter description that toSting().
168     * Actually, it returns the unique index in String form.
169     */
170   public String shortDesc(){
171     String res = "" + myIndex;
172     return res;
173   }
174 
175   /**
176     *  Returns the list of bindings associated to this transition
177     */
178   public List<String> getBindings(){ return bindings; }
179 
180   /**
181     * The constraints on this transition.
182     */
183   private BasicPatternElement constraints;
184 
185   /**
186     * The state this transition leads to
187     */
188   private State target;
189 
190   /**
191     * A list with all the labels associated to the annotations recognized by
192     * this transition.
193     */
194   private List<String> bindings;
195 
196   /** The unique index of this transition. This value is not used by any of
197     * the algorithms. It is only provided as a convenient method of identifying
198     * the transitions in textual representations (toString() and GML related
199     * methods)
200     */
201   private int myIndex;
202 
203   /** Static member used for generating unique IDs for the objects of type
204     * Transition*/
205   private static int index = 0;
206 
207 // >>> DAM, TransArray optimzation, now implements the Comparable interface
208   @Override
209   public int compareTo(Transition t)
210   throws ClassCastException
211   {
212     return myIndex - t.myIndex;
213   }
214 // >>> DAM, end
215 // Transition