gate.creole.gazetteer.MappingDefinition Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of annie Show documentation
Show all versions of annie Show documentation
ANNIE is a general purpose information extraction system that
provides the building blocks of many other GATE applications.
/*
* MappingDefinition.java
*
* Copyright (c) 2002, The University of Sheffield.
*
* This file is part of GATE (see http://gate.ac.uk/), and is free
* software, licenced under the GNU Library General Public License,
* Version 2, June1991.
*
* A copy of this licence is included in the distribution in the file
* licence.html, and is also available at http://gate.ac.uk/gate/licence.html.
*
* borislav popov 02/2002
*
*/
package gate.creole.gazetteer;
import gate.creole.ResourceInstantiationException;
import gate.util.BomStrippingInputStreamReader;
import gate.util.Files;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;
/** Represents a mapping definition which maps gazetteer lists to ontology classes */
public class MappingDefinition extends gate.creole.AbstractLanguageResource
implements List {
private static final long serialVersionUID = 3617291212063848503L;
/** the default encoding of the mapping */
private final static String ENCODING = "UTF-8";
/** the list of nodes */
private List nodes = new ArrayList();
/** the url of the mapping definition */
private URL url;
/** set of gaz lists */
private Set lists = new HashSet();
/** mapping between a list and a node */
private Map nodesByList = new HashMap();
/** Creates a new mapping definition */
public MappingDefinition() {
}
/**Gets the urls from this definition
* @return a list of all the ontology urls present in this mapping def */
public List getUrls() {
Set result = new HashSet();
for ( int i = 0 ; i < nodes.size() ; i++ ) {
result.add(nodes.get(i).getOntologyID());
} // for
return new ArrayList(result);
} // getUrls()
/** Gets the url of this definition
* @return the url of the definition */
public URL getURL() {
return url;
}
/** Sets the url of this definition
* @param aUrl the url of the definition*/
public void setURL(URL aUrl) {
url = aUrl;
}
/**Loads the mapping definition
* @throws ResourceInstantiationException if load fails.
*/
public void load() throws ResourceInstantiationException,InvalidFormatException {
if (null == url) {
throw new ResourceInstantiationException("URL not set (null).");
}
try {
BufferedReader mapReader =
new BomStrippingInputStreamReader((url).openStream(), ENCODING);
String line;
MappingNode node;
while (null != (line = mapReader.readLine())) {
if (0 != line.trim().length()) {
node = new MappingNode(line);
this.add(node);
} // if
} //while
mapReader.close();
} catch (InvalidFormatException ife){
throw new InvalidFormatException(url,"on load");
} catch (IOException ioe) {
throw new ResourceInstantiationException(ioe);
}
} // load();
/**
* Stores the mapping definition
* @throws ResourceInstantiationException if store fails.
*/
public void store()throws ResourceInstantiationException{
if (null == url) {
throw new ResourceInstantiationException("URL not set (null).");
}
try {
File fileo = Files.fileFromURL(url);
fileo.delete();
BufferedWriter mapWriter = new BufferedWriter(new FileWriter(fileo));
for (int index = 0 ; index < nodes.size() ; index++) {
mapWriter.write(nodes.get(index).toString());
mapWriter.newLine();
}
mapWriter.close();
} catch (IOException ioe) {
throw new ResourceInstantiationException(ioe);
}
} //store();
/**
* Gets the gaz lists.
* @return set of the gazetteer lists
*/
public Set getLists() {
return new HashSet(lists);
}
/**
* Gets node by list
* @param list a gazetteer list filename
* @return the mapping node that matches the list
*/
public MappingNode getNodeByList(String list) {
return nodesByList.get(list);
}
/*---implementation of interface java.util.List---*/
@Override
public int size() {
return nodes.size();
}
@Override
public boolean isEmpty() {
return nodes.isEmpty();
}
@Override
public boolean contains(Object o) {
return nodes.contains(o);
}
@Override
public Iterator iterator() {
return new SafeIterator();
}
@Override
public Object[] toArray() {
return nodes.toArray();
}
@Override
public T[] toArray(T[] a) {
return nodes.toArray(a);
}
/**
* adds a new node, only if its list is new and uniquely mapped to this node.
* @param o a node
* @return true if the list of node is not already mapped with another node.
*/
@Override
public boolean add(MappingNode o) {
boolean result = false;
String list = o.getList();
if(!nodesByList.containsKey(list)) {
result = nodes.add(o);
nodesByList.put(list, o);
lists.add(list);
} // if unique
return result;
} // add()
/**
* adds a new node at the specified position, only if its list is new and uniquely mapped to this node.
* @param o a node
* @param index position in the list
*/
@Override
public void add(int index, MappingNode o) {
String list = o.getList();
if(!nodesByList.containsKey(list)) {
nodes.add(index, o);
nodesByList.put(list, o);
lists.add(list);
} // if unique
} // add()
@Override
public MappingNode set(int index, MappingNode o) {
throw new UnsupportedOperationException("this method has not been implemented");
}
@Override
public MappingNode get(int index){
return nodes.get(index);
}
@Override
public boolean remove(Object o) {
boolean result = false;
if (o instanceof MappingNode) {
result = nodes.remove(o);
String list = ((MappingNode)o).getList();
lists.remove(list);
nodesByList.remove(list);
} // if linear node
return result;
}// remove
@Override
public MappingNode remove(int index) {
MappingNode result = null;
result = nodes.remove(index);
if (null!=result) {
String list = result.getList();
lists.remove(list);
nodesByList.remove(list);
}
return result;
}
@Override
public boolean containsAll(Collection c) {
return nodes.containsAll(c);
}
@Override
public boolean addAll(Collection c) {
boolean result = false;
Iterator iter = c.iterator();
MappingNode o;
while(iter.hasNext()) {
o = iter.next();
result |= add(o);
} // while
return result;
} // addAll(Collection)
@Override
public boolean addAll(int index, Collection c) {
int size = nodes.size();
Iterator iter = c.iterator();
MappingNode o;
while(iter.hasNext()) {
o = iter.next();
add(index++, o);
} // while
return (size != nodes.size());
}// addAll(int,Collection)
@Override
public boolean removeAll(Collection c) {
boolean result = false;
Iterator iter = c.iterator();
Object o;
while (iter.hasNext()) {
o = iter.next();
result |= remove(o);
}
return result;
}// removeAll()
@Override
public boolean retainAll(Collection c) {
int aprioriSize = nodes.size();
List scrap = new ArrayList();
MappingNode node;
for (int index = 0; index < nodes.size(); index++) {
node = nodes.get(index);
if (c.contains(node)) {
scrap.add(node);
}
} //for
removeAll(scrap);
return (aprioriSize != nodes.size());
}
@Override
public void clear() {
nodes.clear();
lists.clear();
nodesByList.clear();
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((lists == null) ? 0 : lists.hashCode());
result = prime * result + ((nodes == null) ? 0 : nodes.hashCode());
result =
prime * result
+ ((nodesByList == null) ? 0 : nodesByList.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(getClass() != obj.getClass()) return false;
MappingDefinition other = (MappingDefinition)obj;
if(lists == null) {
if(other.lists != null) return false;
} else if(!lists.equals(other.lists)) return false;
if(nodes == null) {
if(other.nodes != null) return false;
} else if(!nodes.equals(other.nodes)) return false;
if(nodesByList == null) {
if(other.nodesByList != null) return false;
} else if(!nodesByList.equals(other.nodesByList)) return false;
return true;
}
@Override
public List subList(int i1, int i2) {
return nodes.subList(i1,i2);
}
@Override
public ListIterator listIterator(int index) {
throw new UnsupportedOperationException("this method is not implemented");
}
@Override
public ListIterator listIterator() {
throw new UnsupportedOperationException("this method is not implemented");
}
@Override
public int lastIndexOf(Object o) {
return nodes.lastIndexOf(o);
}
@Override
public int indexOf(Object o) {
return nodes.indexOf(o);
}
/*---end of implementation of interface java.util.List---*/
/*-----------internal classes -------------*/
/**Provides means for safe iteration over
* the entries of the Mapping Definition */
private class SafeIterator implements Iterator {
private int index = 0;
private boolean removeCalled = false;
@Override
public boolean hasNext() {
return (index < nodes.size());
}
@Override
public MappingNode next() {
removeCalled = false;
return nodes.get(index++);
}
@Override
public void remove() {
if (!removeCalled && index > 0 ) {
index--;
MappingDefinition.this.remove(nodes.get(index));
}// if possible remove
removeCalled = true;
} // remove
} // class SafeIterator
} // class MappingDefinition