MappingDefinition.java
001 /*
002  * MappingDefinition.java
003  *
004  * Copyright (c) 2002, The University of Sheffield.
005  *
006  * This file is part of GATE (see http://gate.ac.uk/), and is free
007  * software, licenced under the GNU Library General Public License,
008  * Version 2, June1991.
009  *
010  * A copy of this licence is included in the distribution in the file
011  * licence.html, and is also available at http://gate.ac.uk/gate/licence.html.
012  *
013  * borislav popov 02/2002
014  *
015  */
016 package gate.creole.gazetteer;
017 
018 
019 import gate.creole.ResourceInstantiationException;
020 import gate.util.BomStrippingInputStreamReader;
021 import gate.util.Files;
022 
023 import java.io.BufferedReader;
024 import java.io.BufferedWriter;
025 import java.io.File;
026 import java.io.FileWriter;
027 import java.io.IOException;
028 import java.net.URL;
029 import java.util.ArrayList;
030 import java.util.Collection;
031 import java.util.HashMap;
032 import java.util.HashSet;
033 import java.util.Iterator;
034 import java.util.List;
035 import java.util.ListIterator;
036 import java.util.Map;
037 import java.util.Set;
038 
039 /** Represents a mapping definition which maps gazetteer lists to ontology classes */
040 public class MappingDefinition extends gate.creole.AbstractLanguageResource
041                               implements List<MappingNode> {
042 
043   private static final long serialVersionUID = 3617291212063848503L;
044 
045   /** the default encoding of the mapping */
046   private final static String ENCODING = "UTF-8";
047 
048   /** the list of nodes */
049   private List<MappingNode> nodes = new ArrayList<MappingNode>();
050 
051   /** the url of the mapping definition */
052   private URL url;
053 
054   /** set of gaz lists */
055   private Set<String> lists = new HashSet<String>();
056 
057   /** mapping between a list and a node */
058   private Map<String, MappingNode> nodesByList = new HashMap<String, MappingNode>();
059 
060 
061   /** Creates a new mapping definition */
062   public MappingDefinition() {
063   }
064 
065   /**Gets the urls from this definition
066    @return a list of all the ontology urls present in this mapping def   */
067   public List<String> getUrls() {
068     Set<String> result = new HashSet<String>();
069     for int i = ; i < nodes.size() ; i++ ) {
070       result.add(nodes.get(i).getOntologyID());
071     // for
072     return new ArrayList<String>(result);
073   }  // getUrls()
074 
075   /** Gets the url of this definition
076    *  @return the url of the definition */
077   public URL getURL() {
078     return url;
079   }
080 
081   /** Sets the url of this definition
082    *  @param aUrl the url of the definition*/
083   public void setURL(URL aUrl) {
084     url = aUrl;
085   }
086 
087   /**Loads the mapping definition
088    @throws ResourceInstantiationException if load fails.
089    */
090   public void load() throws ResourceInstantiationException,InvalidFormatException {
091     if (null == url) {
092       throw new ResourceInstantiationException("URL not set (null).");
093     }
094     try {
095       BufferedReader mapReader =
096       new BomStrippingInputStreamReader((url).openStream(), ENCODING);
097 
098       String line;
099       MappingNode node;
100       while (null != (line = mapReader.readLine())) {
101         if (!= line.trim().length()) {
102           node = new MappingNode(line);
103           this.add(node);
104         // if
105       //while
106 
107       mapReader.close();
108 
109     catch (InvalidFormatException ife){
110       throw new InvalidFormatException(url,"on load");
111     catch (IOException ioe) {
112       throw new ResourceInstantiationException(ioe);
113     }
114 
115 
116   // load();
117 
118   /**
119    * Stores the mapping definition
120    @throws ResourceInstantiationException if store fails.
121    */
122   public void store()throws ResourceInstantiationException{
123     if (null == url) {
124       throw new ResourceInstantiationException("URL not set (null).");
125     }
126     try {
127     File fileo = Files.fileFromURL(url);
128     fileo.delete();
129     BufferedWriter mapWriter = new BufferedWriter(new FileWriter(fileo));
130     for (int index = ; index < nodes.size() ; index++) {
131       mapWriter.write(nodes.get(index).toString());
132       mapWriter.newLine();
133     }
134     mapWriter.close();
135     catch (IOException ioe) {
136       throw new ResourceInstantiationException(ioe);
137     }
138   //store();
139 
140   /**
141    * Gets the gaz lists.
142    @return set of the gazetteer lists
143    */
144   public Set<String> getLists() {
145     return new HashSet<String>(lists);
146   }
147 
148   /**
149    * Gets node by list
150    @param list a gazetteer list filename
151    @return the mapping node that matches the list
152    */
153   public MappingNode getNodeByList(String list) {
154     return nodesByList.get(list);
155   }
156 
157   /*---implementation of interface java.util.List---*/
158 
159   @Override
160   public int size() {
161     return nodes.size();
162   }
163 
164   @Override
165   public boolean isEmpty() {
166     return nodes.isEmpty();
167   }
168 
169   @Override
170   public boolean contains(Object o) {
171     return nodes.contains(o);
172   }
173 
174   @Override
175   public Iterator<MappingNode> iterator() {
176     return new SafeIterator();
177   }
178 
179   @Override
180   public Object[] toArray() {
181     return nodes.toArray();
182   }
183 
184   @Override
185   public <T> T[] toArray(T[] a) {
186     return nodes.toArray(a);
187   }
188 
189   /**
190    * adds a new node, only if its list is new and uniquely mapped to this node.
191    @param o a node
192    @return true if the list of node is not already mapped with another node.
193    */
194   @Override
195   public boolean add(MappingNode o) {
196     boolean result = false;
197 
198     String list = o.getList();
199     if(!nodesByList.containsKey(list)) {
200       result = nodes.add(o);
201       nodesByList.put(list, o);
202       lists.add(list);
203     // if unique
204 
205     return result;
206   // add()
207 
208   /**
209    * adds a new node at the specified position, only if its list is new and uniquely mapped to this node.
210    @param o a node
211    @param index position in the list
212    */
213   @Override
214   public void add(int index, MappingNode o) {
215     String list = o.getList();
216     if(!nodesByList.containsKey(list)) {
217       nodes.add(index, o);
218       nodesByList.put(list, o);
219       lists.add(list);
220     // if unique
221   // add()
222 
223   @Override
224   public MappingNode set(int index, MappingNode o) {
225     throw new UnsupportedOperationException("this method has not been implemented");
226   }
227 
228   @Override
229   public MappingNode get(int index){
230     return nodes.get(index);
231   }
232 
233   @Override
234   public boolean remove(Object o) {
235     boolean result = false;
236     if (instanceof MappingNode) {
237       result = nodes.remove(o);
238       String list = ((MappingNode)o).getList();
239       lists.remove(list);
240       nodesByList.remove(list);
241     // if linear node
242     return result;
243   }// remove
244 
245   @Override
246   public MappingNode remove(int index) {
247     MappingNode result = null;
248     result = nodes.remove(index);
249     if (null!=result) {
250       String list = result.getList();
251       lists.remove(list);
252       nodesByList.remove(list);
253     }
254     return result;
255   }
256 
257   @Override
258   public boolean containsAll(Collection<?> c) {
259     return nodes.containsAll(c);
260   }
261 
262   @Override
263   public boolean addAll(Collection<? extends MappingNode> c) {
264     boolean result = false;
265     Iterator<? extends MappingNode> iter = c.iterator();
266     MappingNode o;
267     while(iter.hasNext()) {
268       o = iter.next();
269       result |= add(o);
270     // while
271     return result;
272   // addAll(Collection)
273 
274   @Override
275   public boolean addAll(int index, Collection<? extends MappingNode> c) {
276     int size = nodes.size();
277     Iterator<? extends MappingNode> iter = c.iterator();
278     MappingNode o;
279     while(iter.hasNext()) {
280       o = iter.next();
281       add(index++, o);
282     // while
283     return (size != nodes.size());
284   }// addAll(int,Collection)
285 
286   @Override
287   public boolean removeAll(Collection<?> c) {
288     boolean result = false;
289     Iterator<?> iter = c.iterator();
290     Object o;
291     while (iter.hasNext()) {
292       o = iter.next();
293       result |= remove(o);
294     }
295     return result;
296   }// removeAll()
297 
298 
299   @Override
300   public boolean retainAll(Collection<?> c) {
301     int aprioriSize = nodes.size();
302     List<MappingNode> scrap = new ArrayList<MappingNode>();
303 
304     MappingNode node;
305     for (int index = 0; index < nodes.size(); index++) {
306       node = nodes.get(index);
307       if (c.contains(node)) {
308         scrap.add(node);
309       }
310     //for
311 
312     removeAll(scrap);
313 
314     return (aprioriSize != nodes.size());
315   }
316 
317 
318   @Override
319   public void clear() {
320     nodes.clear();
321     lists.clear();
322     nodesByList.clear();
323   }
324 
325   @Override
326   public int hashCode() {
327     final int prime = 31;
328     int result = 1;
329     result = prime * result + ((lists == null: lists.hashCode());
330     result = prime * result + ((nodes == null: nodes.hashCode());
331     result =
332             prime * result
333                     ((nodesByList == null: nodesByList.hashCode());
334     return result;
335   }
336 
337   @Override
338   public boolean equals(Object obj) {
339     if(this == objreturn true;
340     if(obj == nullreturn false;
341     if(getClass() != obj.getClass()) return false;
342     MappingDefinition other = (MappingDefinition)obj;
343     if(lists == null) {
344       if(other.lists != nullreturn false;
345     else if(!lists.equals(other.lists)) return false;
346     if(nodes == null) {
347       if(other.nodes != nullreturn false;
348     else if(!nodes.equals(other.nodes)) return false;
349     if(nodesByList == null) {
350       if(other.nodesByList != nullreturn false;
351     else if(!nodesByList.equals(other.nodesByList)) return false;
352     return true;
353   }
354   
355   @Override
356   public List<MappingNode> subList(int i1, int i2) {
357     return nodes.subList(i1,i2);
358   }
359 
360   @Override
361   public ListIterator<MappingNode> listIterator(int index) {
362     throw new UnsupportedOperationException("this method is not implemented");
363   }
364   @Override
365   public ListIterator<MappingNode> listIterator() {
366     throw new UnsupportedOperationException("this method is not implemented");
367   }
368 
369   @Override
370   public int lastIndexOf(Object o) {
371     return nodes.lastIndexOf(o);
372   }
373 
374   @Override
375   public int indexOf(Object o) {
376     return nodes.indexOf(o);
377   }
378 
379  /*---end of implementation of interface java.util.List---*/
380 
381  /*-----------internal classes -------------*/
382 
383   /**Provides means for safe iteration over
384    * the entries of the Mapping Definition  */
385   private class SafeIterator implements Iterator<MappingNode> {
386     private int index = 0;
387     private boolean removeCalled = false;
388 
389     @Override
390     public boolean hasNext() {
391       return (index < nodes.size());
392     }
393 
394     @Override
395     public MappingNode next() {
396       removeCalled = false;
397       return nodes.get(index++);
398     }
399 
400     @Override
401     public void remove() {
402       if (!removeCalled && index > 0  ) {
403         index--;
404         MappingDefinition.this.remove(nodes.get(index));
405       }// if possible remove
406       removeCalled = true;
407     // remove
408 
409 
410   // class SafeIterator
411 
412 // class MappingDefinition