|
AbstractProcessingResource |
|
1 /* 2 * AbstractProcessingResource.java 3 * 4 * Copyright (c) 1998-2001, The University of Sheffield. 5 * 6 * This file is part of GATE (see http://gate.ac.uk/), and is free 7 * software, licenced under the GNU Library General Public License, 8 * Version 2, June 1991 (in the distribution as file licence.html, 9 * and also available at http://gate.ac.uk/gate/licence.html). 10 * 11 * Hamish Cunningham, 10/Nov/2000 12 * 13 * $Id: AbstractProcessingResource.java,v 1.15 2001/09/28 15:45:20 valyt Exp $ 14 */ 15 16 package gate.creole; 17 18 import java.util.*; 19 20 import gate.*; 21 import gate.util.*; 22 import gate.event.*; 23 24 /** A convenience implementation of ProcessingResource with some default 25 * code. 26 */ 27 abstract public class AbstractProcessingResource 28 extends AbstractResource implements ProcessingResource 29 { 30 /** Initialise this resource, and return it. */ 31 public Resource init() throws ResourceInstantiationException { 32 return this; 33 } // init() 34 35 /** Run the resource. It doesn't make sense not to override 36 * this in subclasses so the default implementation signals an 37 * exception. 38 */ 39 public void execute() throws ExecutionException{ 40 throw new ExecutionException( 41 "Resource " + getClass() + " hasn't overriden the execute() method" 42 ); 43 } // execute() 44 45 /** 46 * Reinitialises the processing resource. After calling this method the 47 * resource should be in the state it is after calling init. 48 * If the resource depends on external resources (such as rules files) then 49 * the resource will re-read those resources. If the data used to create 50 * the resource has changed since the resource has been created then the 51 * resource will change too after calling reInit(). 52 * The implementation in this class simply calls {@link #init()}. This 53 * functionality must be overriden by derived classes as necessary. 54 */ 55 public void reInit() throws ResourceInstantiationException{ 56 init(); 57 } // reInit() 58 59 /** should clear all internal data of the resource. Does nothing now */ 60 public void cleanup() { 61 } 62 63 /** 64 * Checks whether this PR has been interrupted since the lsat time its 65 * {@link execute()} method was called. 66 */ 67 public synchronized boolean isInterrupted(){ 68 return interrupted; 69 } 70 71 /** 72 * Notifies this PR that it should stop its execution as soon as possible. 73 */ 74 public synchronized void interrupt(){ 75 interrupted = true; 76 } 77 78 79 /** 80 * Removes a {@link gate.event.StatusListener} from the list of listeners for 81 * this processing resource 82 */ 83 public synchronized void removeStatusListener(StatusListener l) { 84 if (statusListeners != null && statusListeners.contains(l)) { 85 Vector v = (Vector) statusListeners.clone(); 86 v.removeElement(l); 87 statusListeners = v; 88 } 89 } 90 91 /** 92 * Adds a {@link gate.event.StatusListener} to the list of listeners for 93 * this processing resource 94 */ 95 public synchronized void addStatusListener(StatusListener l) { 96 Vector v = statusListeners == null ? new Vector(2) : (Vector) statusListeners.clone(); 97 if (!v.contains(l)) { 98 v.addElement(l); 99 statusListeners = v; 100 } 101 } 102 103 /** 104 * Notifies all the {@link gate.event.StatusListener}s of a change of status. 105 * @param e the message describing the status change 106 */ 107 protected void fireStatusChanged(String e) { 108 if (statusListeners != null) { 109 Vector listeners = statusListeners; 110 int count = listeners.size(); 111 for (int i = 0; i < count; i++) { 112 ((StatusListener) listeners.elementAt(i)).statusChanged(e); 113 } 114 } 115 } 116 117 /** 118 * Adds a {@link gate.event.ProgressListener} to the list of listeners for 119 * this processing resource. 120 */ 121 public synchronized void addProgressListener(ProgressListener l) { 122 Vector v = progressListeners == null ? new Vector(2) : (Vector) progressListeners.clone(); 123 if (!v.contains(l)) { 124 v.addElement(l); 125 progressListeners = v; 126 } 127 } 128 129 /** 130 * Removes a {@link gate.event.ProgressListener} from the list of listeners 131 * for this processing resource. 132 */ 133 public synchronized void removeProgressListener(ProgressListener l) { 134 if (progressListeners != null && progressListeners.contains(l)) { 135 Vector v = (Vector) progressListeners.clone(); 136 v.removeElement(l); 137 progressListeners = v; 138 } 139 } 140 141 /** 142 * Notifies all the {@link gate.event.ProgressListener}s of a progress change 143 * event. 144 * @param e the new value of execution completion 145 */ 146 protected void fireProgressChanged(int e) { 147 if (progressListeners != null) { 148 Vector listeners = progressListeners; 149 int count = listeners.size(); 150 for (int i = 0; i < count; i++) { 151 ((ProgressListener) listeners.elementAt(i)).progressChanged(e); 152 } 153 } 154 } 155 156 /** 157 * Notifies all the {@link gate.event.ProgressListener}s of a progress 158 * finished. 159 */ 160 protected void fireProcessFinished() { 161 if (progressListeners != null) { 162 Vector listeners = progressListeners; 163 int count = listeners.size(); 164 for (int i = 0; i < count; i++) { 165 ((ProgressListener) listeners.elementAt(i)).processFinished(); 166 } 167 } 168 } 169 170 /** 171 * A progress listener used to convert a 0..100 interval into a smaller one 172 */ 173 protected class IntervalProgressListener implements ProgressListener{ 174 public IntervalProgressListener(int start, int end){ 175 this.start = start; 176 this.end = end; 177 } 178 public void progressChanged(int i){ 179 fireProgressChanged(start + (end - start) * i / 100); 180 } 181 182 public void processFinished(){ 183 fireProgressChanged(end); 184 } 185 186 int start; 187 int end; 188 }//IntervalProgressListener 189 190 /** 191 * A simple status listener used to forward the events upstream. 192 */ 193 protected class InternalStatusListener implements StatusListener{ 194 public void statusChanged(String message){ 195 fireStatusChanged(message); 196 } 197 }//InternalStatusListener 198 199 /** 200 * The list of {@link gate.event.StatusListener}s registered with this 201 * resource 202 */ 203 private transient Vector statusListeners; 204 205 /** 206 * The list of {@link gate.event.ProgressListener}s registered with this 207 * resource 208 */ 209 private transient Vector progressListeners; 210 211 protected boolean interrupted = false; 212 } // class AbstractProcessingResource 213
|
AbstractProcessingResource |
|