Transducer.java
001 /*
002  *  Transducer.java - transducer class
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  *  Hamish Cunningham, 24/07/98
013  *
014  *  $Id: Transducer.java 17616 2014-03-10 16:09:07Z markagreenwood $
015  */
016 
017 
018 package gate.jape;
019 
020 import gate.AnnotationSet;
021 import gate.Controller;
022 import gate.Document;
023 import gate.creole.ExecutionException;
024 import gate.creole.ontology.Ontology;
025 import gate.event.ProgressListener;
026 import gate.event.StatusListener;
027 import gate.util.Benchmarkable;
028 import gate.util.GateClassLoader;
029 
030 import java.io.Serializable;
031 import java.net.URL;
032 import java.util.HashMap;
033 import java.util.Map;
034 import java.util.Vector;
035 
036 
037 /**
038   * Represents a single or multiphase transducer.
039   */
040 public abstract class Transducer implements Serializable, Benchmarkable
041 {
042   private static final long serialVersionUID = -5607520609825899179L;
043 
044   /** Name of this transducer. */
045   protected String name;
046 
047   protected Ontology ontology = null;
048   
049   /**
050    * Shared featureMap
051    */
052   protected Map<Object,Object> benchmarkFeatures = new HashMap<Object,Object>();
053 
054   /**
055    * Benchmark ID of this transducer.
056    */
057   protected String benchmarkID;
058 
059   /** Get the phase name of this transducer */
060   public String getName() { return name; }
061 
062   /**
063    * Gets the benchmark ID of this transducer.
064    */
065   @Override
066   public String getBenchmarkId() {
067     if(benchmarkID == null) {
068       return getName();
069     }
070     else {
071       return benchmarkID;
072     }
073   }
074 
075   /**
076    * Set the benchmark ID for this transducer.
077    */
078   @Override
079   public void setBenchmarkId(String benchmarkId) {
080     this.benchmarkID = benchmarkId;
081   }
082 
083   /** Transduce a document.  */
084   public abstract void transduce(Document doc, AnnotationSet inputAS,
085                                  AnnotationSet outputAS)
086                                  throws JapeException, ExecutionException;
087 
088   /**
089    * Finish: parsing is complete so now we need to do some small amount of final
090    * processing before loading the grammars into the specified classloader.
091    */
092   public abstract void finish(GateClassLoader classLoader);
093   
094   /** Clean up (delete action class files, for e.g.). */
095   public abstract void cleanUp();
096 
097   /** Create a string representation of the object with padding. */
098   public abstract String toString(String pad);
099 
100 
101   /**
102    * Checks whether this PR has been interrupted since the last time its
103    {@link #transduce(Document, AnnotationSet, AnnotationSet)} method was called.
104    */
105   public synchronized boolean isInterrupted(){
106     return interrupted;
107   }
108 
109   /**
110    * Notifies this PR that it should stop its execution as soon as possible.
111    */
112   public synchronized void interrupt(){
113     interrupted = true;
114   }
115 
116   protected boolean interrupted = false;
117 
118 
119   public void setBaseURL(java.net.URL newBaseURL) {
120     baseURL = newBaseURL;
121   }
122   public java.net.URL getBaseURL() {
123     return baseURL;
124   }
125   public synchronized void removeProgressListener(ProgressListener l) {
126     if (progressListeners != null && progressListeners.contains(l)) {
127       @SuppressWarnings("unchecked")
128       Vector<ProgressListener> v = (Vector<ProgressListener>progressListeners.clone();
129       v.removeElement(l);
130       progressListeners = v;
131     }
132   }
133   public synchronized void addProgressListener(ProgressListener l) {
134     @SuppressWarnings("unchecked")
135     Vector<ProgressListener> v = progressListeners == null new Vector<ProgressListener>(2(Vector<ProgressListener>)progressListeners.clone();
136     if (!v.contains(l)) {
137       v.addElement(l);
138       progressListeners = v;
139     }
140   }
141 
142   public void setDebugMode(boolean debugMode) {
143     this.debugMode = debugMode;
144   }
145   public boolean isDebugMode() {
146     return debugMode;
147   }
148 
149   /**
150    * Switch used to enable printing debug messages
151    */
152   private boolean debugMode = false;
153 
154   public void setMatchGroupMode(boolean mode) {
155     matchGroupMode = mode;
156   }
157   
158   public boolean isMatchGroupMode() {
159     return matchGroupMode;
160   }
161 
162   /** Switch used to enable multiple LHS matching  in case of pattern coverage
163    * over one and same span with different annotation groups */
164   private boolean matchGroupMode = false;
165 
166   /**
167    * Switch used to use pre 7.0 style negation, where multiple negative 
168    * predicates are not grouped into a conjunction.
169    */
170   private boolean negationCompatMode;
171   
172   
173   private URL baseURL;
174 
175   private transient Vector<ProgressListener> progressListeners;
176   private transient Vector<StatusListener> statusListeners;
177 
178   /**
179    * Switch used to activate the JAPE debugger
180    */
181   protected boolean enableDebugging;
182 
183   /**
184    * This property affects the Appelt style of rules application.
185    * If true then the longest match will be fired otherwise the shortest will
186    * be used. By default it is true.
187    */
188   protected void fireProgressChanged(int e) {
189     if (progressListeners != null  && !progressListeners.isEmpty()) {
190       Vector<ProgressListener> listeners = progressListeners;
191       int count = listeners.size();
192       for (int i = 0; i < count; i++) {
193         listeners.elementAt(i).progressChanged(e);
194       }
195     }
196   }
197   protected void fireProcessFinished() {
198     if (progressListeners != null) {
199       Vector<ProgressListener> listeners = progressListeners;
200       int count = listeners.size();
201       for (int i = 0; i < count; i++) {
202         listeners.elementAt(i).processFinished();
203       }
204     }
205   }
206   public synchronized void removeStatusListener(StatusListener l) {
207     if (statusListeners != null && statusListeners.contains(l)) {
208       @SuppressWarnings("unchecked")
209       Vector<StatusListener> v = (Vector<StatusListener>)statusListeners.clone();
210       v.removeElement(l);
211       statusListeners = v;
212     }
213   }
214   public synchronized void addStatusListener(StatusListener l) {
215     @SuppressWarnings("unchecked")
216     Vector<StatusListener> v = statusListeners == null new Vector<StatusListener>(2(Vector<StatusListener>statusListeners.clone();
217     if (!v.contains(l)) {
218       v.addElement(l);
219       statusListeners = v;
220     }
221   }
222   protected void fireStatusChanged(String e) {
223     if (statusListeners != null) {
224       Vector<StatusListener> listeners = statusListeners;
225       int count = listeners.size();
226       for (int i = 0; i < count; i++) {
227         listeners.elementAt(i).statusChanged(e);
228       }
229     }
230   }
231 
232   /**
233    * Gets the ontology used by this transducer;
234    @return an {@link gate.creole.ontology.Ontology} value;
235    */
236   public Ontology getOntology() {
237     return ontology;
238   }
239 
240   /**
241    * Sets the ontology used by this transducer;
242    @param ontology an {@link gate.creole.ontology.Ontology} value;
243    */
244   public void setOntology(Ontology ontology) {
245     this.ontology = ontology;
246   }
247 
248   public boolean isEnableDebugging() {
249     return enableDebugging;
250   }
251 
252   public void setEnableDebugging(boolean enableDebugging) {
253     this.enableDebugging = enableDebugging;
254   }
255 
256   
257   
258   //ProcessProgressReporter implementation ends here
259   
260   public boolean isNegationCompatMode() {
261     return negationCompatMode;
262   }
263 
264   public void setNegationCompatMode(boolean negationCompatMode) {
265     this.negationCompatMode = negationCompatMode;
266   }
267 
268   protected ActionContext actionContext;
269   public void setActionContext(ActionContext ac) {
270     actionContext = ac;
271   }
272 
273   void runControllerExecutionStartedBlock(ActionContext ac, Controller c, Ontology othrows ExecutionException { }
274   void runControllerExecutionFinishedBlock(ActionContext ac, Controller c, Ontology othrows ExecutionException { }
275   void runControllerExecutionAbortedBlock(ActionContext ac, Controller c, Throwable t, Ontology othrows ExecutionException { }
276  
277 
278 
279 // class Transducer
280 
281