Lookup.java
001 /*
002  * Lookup.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 software,
008  * licenced under the GNU Library General Public License, Version 2, June 1991
009  * (in the distribution as file licence.html, and also available at
010  * http://gate.ac.uk/gate/licence.html).
011  
012  * Valentin Tablan, 11/07/2000 borislav popov, 05/02/2002
013  
014  * $Id: Lookup.java 17593 2014-03-08 10:03:19Z markagreenwood $
015  */
016 package gate.creole.gazetteer;
017 
018 import gate.creole.ANNIEConstants;
019 
020 import java.io.Serializable;
021 import java.util.ArrayList;
022 import java.util.Collections;
023 import java.util.Iterator;
024 import java.util.List;
025 import java.util.Map;
026 
027 /**
028  * Used to describe a type of lookup annotations. A lookup is described by a
029  * major type a minor type and a list of languages. Added members are :
030  * ontologyClass and list. All these values are strings (the list of languages
031  * is a string and it is intended to represesnt a comma separated list). An
032  * optional features field stores arbitary features as part of the lookup
033  * annotation. This can be used to set meta-data for a gazetteer entry.
034  */
035 public class Lookup implements Serializable {
036 
037   private static final long serialVersionUID = 4107354748136747541L;
038 
039   /** a map of arbitary features */
040   public Map<String,Object> features = null;
041 
042   /**
043    * Creates a new Lookup value with the given major and minor types and
044    * languages.
045    
046    @param major
047    *          major type
048    @param minor
049    *          minor type
050    @param theLanguages
051    *          the languages
052    @param annotationType
053    *          the annotation type to use for annotating this particular lookup.
054    */
055   public Lookup(String theList, String major, String minor,
056       String theLanguages, String annotationType) {
057     majorType = major;
058     minorType = minor;
059     languages = theLanguages;
060     list = theList;
061     this.annotationType = annotationType;
062   }
063 
064   /**
065    * Creates a new Lookup value with the given major and minor types and
066    * languages.
067    
068    @param major
069    *          major type
070    @param minor
071    *          minor type
072    @param theLanguages
073    *          the languages
074    */
075   public Lookup(String theList, String major, String minor, String theLanguages) {
076     this(theList, major, minor, theLanguages,
077         ANNIEConstants.LOOKUP_ANNOTATION_TYPE);
078   }
079 
080   /** Tha major type for this lookup, e.g. "Organisation" */
081   public String majorType;
082 
083   /** The minor type for this lookup, e.g. "Company" */
084   public String minorType;
085 
086   /** The languages for this lookup, e.g. "English, French" */
087   public String languages;
088 
089   /**
090    * the ontology class of this lookup according to the mapping between list and
091    * ontology
092    */
093   public String oClass;
094 
095   /** the ontology ID */
096   public String ontology;
097 
098   /** the list represented by this lookup */
099   public String list;
100 
101   /** annotation type that should be used to create a lookup */
102   public String annotationType;
103 
104   /**
105    * Returns a string representation of this lookup in the format This method is
106    * used in equals() that caused this method to implement dualistic behaviour :
107    * i.e. whenever class and ontology are filled then use the long version,incl.
108    * list, ontology and class; else return just majorType.minorType
109    */
110   @Override
111   public String toString() {
112     StringBuffer b = new StringBuffer();
113     boolean longVersion = false;
114     boolean hasArbitaryFeatures = false;
115     if(null != ontology && null != oClass) {
116       longVersion = true;
117     }
118     if(null != features) {
119       hasArbitaryFeatures = true;
120     }
121     if(longVersion) {
122       b.append(list);
123       b.append(".");
124     }
125     b.append(majorType);
126     b.append(".");
127     if(null != minorType) {
128       b.append(minorType);
129       if(null != languages) {
130         b.append(".");
131         b.append(languages);
132       }// if
133     }// if
134     if(longVersion) {
135       b.append("|");
136       b.append(ontology);
137       b.append(":");
138       b.append(oClass);
139     }
140     if(hasArbitaryFeatures) {
141       // as the ordering of the featureMap is undefined, create a new list of
142       // keys and sort it to ensure the string returned is always the same
143       List<String> sortedKeys = new ArrayList<String>(features.keySet());
144       Collections.sort(sortedKeys);
145       for(Iterator<String> it = sortedKeys.iterator(); it.hasNext();) {
146         String key = it.next();
147         b.append("|");
148         b.append(key);
149         b.append(":");
150         b.append(features.get(key));
151       }
152     }
153     return b.toString();
154   }
155 
156   /**
157    * Two lookups are equal if they have the same string representation (major
158    * type and minor type).
159    
160    @param obj
161    */
162   @Override
163   public boolean equals(Object obj) {
164     if(obj instanceof Lookup)
165       return obj.toString().equals(toString());
166     else return false;
167   // equals
168 
169   /**
170    * *
171    */
172   @Override
173   public int hashCode() {
174     return toString().hashCode();
175   }
176 // Lookup