DataStoreRegister.java
001 /*
002  *  DataStoreRegister.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  *  Hamish Cunningham, 23/Jan/2001
013  *
014  *  $Id: DataStoreRegister.java 17662 2014-03-14 16:19:05Z markagreenwood $
015  */
016 
017 package gate;
018 
019 import gate.event.CreoleEvent;
020 import gate.event.CreoleListener;
021 
022 import java.util.HashMap;
023 import java.util.HashSet;
024 import java.util.Iterator;
025 import java.util.Map;
026 import java.util.Set;
027 import java.util.Vector;
028 
029 /**
030  * Records all the open DataStores.
031  */
032 public class DataStoreRegister extends HashSet<DataStore> {
033   private static final long serialVersionUID = 1L;
034 
035   /**
036    * All the DataStore classes available. This is a map of class name to
037    * descriptive text.
038    */
039   public static Map<String,String> getDataStoreClassNames() {
040     Map<String,String> names = new HashMap<String,String>();
041 
042     // TODO: no plugability here at present.... at some future point there should
043     // be a capability to add new data store classes via creole.xml metadata
044     // and resource jars
045 
046     // filesystem
047     names.put("gate.persist.SerialDataStore""SerialDataStore: file-based storage using Java serialisation");
048 
049     names.put("gate.persist.LuceneDataStoreImpl""Lucene Based Searchable DataStore");
050     
051     // docservice
052     try {
053       if (Class.forName("gleam.docservice.gate.DocServiceDataStore", true, Gate.getClassLoader()) != null) {
054         names.put("gleam.docservice.gate.DocServiceDataStore",
055             "SAFE DocService DataStore");
056       }
057     catch (ClassNotFoundException e) {
058     }
059     
060     return names;
061   // getDataStoreClassNames()
062 
063   /**
064    * Adds the specified element to this set if it is not already present.
065    * Overriden here for event registration code.
066    */
067   @Override
068   public boolean add(DataStore o) {
069     return super.add(o);
070   // add
071 
072   /**
073    * Removes the given element from this set if it is present. Overriden here
074    * for event registration code.
075    */
076   @Override
077   public boolean remove(Object o) {
078     boolean res = super.remove(o);
079     if (res) {
080       fireDatastoreClosed(new CreoleEvent((DataStoreo, CreoleEvent.DATASTORE_CLOSED));
081     }
082     return res;
083   // remove
084 
085   /**
086    * Removes all of the elements from this set. Overriden here for event
087    * registration code.
088    */
089   @Override
090   public void clear() {
091     Set<DataStore> datastores = new HashSet<DataStore>(this);
092     super.clear();
093 
094     Iterator<DataStore> iter = datastores.iterator();
095     while (iter.hasNext()) {
096       fireDatastoreClosed(new CreoleEvent(iter.next(), CreoleEvent.DATASTORE_CLOSED));
097     // while
098   // clear()
099   
100   /**
101    * Removes a previously registered {@link gate.event.CreoleListener} from the
102    * list of listeners for this DataStoreRegister. Normally the only listener
103    * that is registered with the DataStoreRegister is the {@link CreoleRegister}
104    * which can be obtained through {@link Gate#getCreoleRegister()}
105    */
106   public synchronized void removeCreoleListener(CreoleListener l) {
107     if (creoleListeners != null && creoleListeners.contains(l)) {
108       @SuppressWarnings("unchecked")
109       Vector<CreoleListener> v = (Vector<CreoleListener>creoleListeners.clone();
110       v.removeElement(l);
111       creoleListeners = v;
112     }
113   // removeCreoleListener(CreoleListener l)
114 
115   /**
116    * Registers a new {@link gate.event.CreoleListener} with this
117    * DataStoreRegister. Normally the only listener that is registered with the
118    * DataStoreRegister is the {@link CreoleRegister} which can be obtained
119    * through {@link Gate#getCreoleRegister()}
120    */
121   public synchronized void addCreoleListener(CreoleListener l) {
122     @SuppressWarnings("unchecked")
123     Vector<CreoleListener> v = creoleListeners == null new Vector<CreoleListener>(2(Vector<CreoleListener>)creoleListeners.clone();
124     if (!v.contains(l)) {
125       v.addElement(l);
126       creoleListeners = v;
127     }// if
128   }// addCreoleListener(CreoleListener l)
129 
130   /**
131    * Notifies all registered {@link gate.event.CreoleListener}s that a
132    {@link DataStore} has been opened. Normally the only listener that is
133    * registered with the DataStoreRegister is the {@link CreoleRegister} which
134    * can be obtained through {@link Gate#getCreoleRegister()}
135    */
136   protected void fireDatastoreOpened(CreoleEvent e) {
137     if (creoleListeners != null) {
138       Vector<CreoleListener> listeners = creoleListeners;
139       int count = listeners.size();
140       for (int i = 0; i < count; i++) {
141         listeners.elementAt(i).datastoreOpened(e);
142       // for
143     // if
144   // fireDatastoreOpened(CreoleEvent e)
145 
146   /**
147    * Notifies all registered {@link gate.event.CreoleListener}s that a new
148    {@link DataStore} has been created. Normally the only listener that is
149    * registered with the DataStoreRegister is the {@link CreoleRegister} which
150    * can be obtained through {@link Gate#getCreoleRegister()}
151    */
152   protected void fireDatastoreCreated(CreoleEvent e) {
153     if (creoleListeners != null) {
154       Vector<CreoleListener> listeners = creoleListeners;
155       int count = listeners.size();
156       for (int i = 0; i < count; i++) {
157         listeners.elementAt(i).datastoreCreated(e);
158       // for
159     // if
160   // fireDatastoreCreated(CreoleEvent e)
161 
162   /**
163    * Notifies all registered {@link gate.event.CreoleListener}s that a
164    {@link DataStore} has been closed. Normally the only listener that is
165    * registered with the DataStoreRegister is the {@link CreoleRegister} which
166    * can be obtained through {@link Gate#getCreoleRegister()}
167    */
168   protected void fireDatastoreClosed(CreoleEvent e) {
169     if (creoleListeners != null) {
170       Vector<CreoleListener> listeners = creoleListeners;
171       int count = listeners.size();
172       for (int i = 0; i < count; i++) {
173         listeners.elementAt(i).datastoreClosed(e);
174       // for
175     // if
176   // fireDatastoreClosed(CreoleEvent e)
177 
178   /** */
179   private transient Vector<CreoleListener> creoleListeners;
180 
181 // class DataStoreRegister