LinearNode.java
001 /*
002  * LinearNode.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 software,
007  * licenced under the GNU Library General Public License, Version 2, June1991.
008  
009  * A copy of this licence is included in the distribution in the file
010  * licence.html, and is also available at http://gate.ac.uk/gate/licence.html.
011  
012  * borislav popov 02/2002
013  */
014 package gate.creole.gazetteer;
015 
016 import gate.creole.ANNIEConstants;
017 
018 /**
019  * Linear node specifies an entry of the type : list:major:minor:language:annotationType
020  */
021 public class LinearNode {
022   /** the gazetteer list from the node */
023   private String list;
024 
025   /** the minor type from the node */
026   private String minor;
027 
028   /** the major type from the node */
029   private String major;
030 
031   /** the languages member from the node */
032   private String language;
033 
034   /** the annotationType member from the node **/
035   private String annotationType;
036 
037   /**
038    * Constructor
039    
040    @param list
041    *          name of the list
042    @param minor
043    *          minor type
044    @param major
045    *          major type
046    @param language
047    *          language feature
048    @param annotationType
049    *          the annotation type that should be used for annotating mentions of
050    *          entries from the list
051    */
052   public LinearNode(String list, String minor, String major, String language,
053       String annotationType) {
054     this.list = list;
055     this.minor = minor;
056     this.major = major;
057     this.language = language;
058     this.annotationType = annotationType;
059   }
060 
061   /**
062    * Constructs a linear node given its elements
063    
064    @param aList
065    *          the gazetteer list file name
066    @param aMajor
067    *          the major type
068    @param aMinor
069    *          the minor type
070    @param aLanguage
071    *          the language(s)
072    */
073   public LinearNode(String aList, String aMajor, String aMinor, String aLanguage) {
074     this(aList, aMajor, aMinor, aLanguage, null);
075   // LinearNode construct
076 
077   /**
078    * Parses and create a linear node from a string
079    
080    @param node
081    *          the linear node to be parsed
082    @throws InvalidFormatException
083    */
084   public LinearNode(String nodethrows InvalidFormatException {
085     int firstColon = node.indexOf(':');
086     int secondColon = node.indexOf(':', firstColon + 1);
087     int thirdColon = node.indexOf(':', secondColon + 1);
088     int fourthColon = node.indexOf(':', thirdColon + 1);
089     annotationType = ANNIEConstants.LOOKUP_ANNOTATION_TYPE; // default value
090                                                             // must be lookup
091                                                             // for backword
092                                                             // compatibility
093     if(firstColon == -1) { throw new InvalidFormatException("""Line: " + node)}
094     list = node.substring(0, firstColon);
095     if(secondColon == -1) {
096       major = node.substring(firstColon + 1);
097       minor = null;
098       language = null;
099     else {
100       major = node.substring(firstColon + 1, secondColon);
101       if(thirdColon == -1) {
102         minor = node.substring(secondColon + 1);
103         language = null;
104       else {
105         minor = node.substring(secondColon + 1, thirdColon);
106         if(fourthColon == -1) {
107           language = node.substring(thirdColon + 1);
108           annotationType = ANNIEConstants.LOOKUP_ANNOTATION_TYPE;
109         else {
110           language = node.substring(thirdColon + 1, fourthColon);
111           annotationType = node.substring(fourthColon + 1);
112         }
113       }
114     // else
115   // LinearNode concstruct
116 
117   /**
118    * Get the gazetteer list filename from the node
119    
120    @return the gazetteer list filename
121    */
122   public String getList() {
123     return list;
124   }
125 
126   /**
127    * Sets the gazetteer list filename for the node
128    
129    @param aList
130    *          the gazetteer list filename
131    */
132   public void setList(String aList) {
133     list = aList;
134   }
135 
136   /**
137    * Gets the language of the node (the language is optional)
138    
139    @return the language of the node
140    */
141   public String getLanguage() {
142     return language;
143   }
144 
145   /**
146    * Sets the language of the node
147    
148    @param aLanguage
149    *          the language of the node
150    */
151   public void setLanguage(String aLanguage) {
152     language = aLanguage;
153   }
154 
155   /**
156    * Gets the minor type
157    
158    @return the minor type
159    */
160   public String getMinorType() {
161     return minor;
162   }
163 
164   /**
165    * Sets the minor type
166    */
167   public void setMinorType(String minorType) {
168     minor = minorType;
169   }
170 
171   /**
172    * Gets the major type
173    
174    @return the major type
175    */
176   public String getMajorType() {
177     return major;
178   }
179 
180   /**
181    * Sets the major type
182    
183    @param majorType
184    *          the major type
185    */
186   public void setMajorType(String majorType) {
187     major = majorType;
188   }
189 
190   /**
191    * Gets the annotationType
192    
193    @return the annotationType
194    */
195   public String getAnnotationType() {
196     return annotationType;
197   }
198 
199   /**
200    * Sets the annotaionType
201    
202    @param annotationType
203    */
204   public void setAnnotationType(String annotationType) {
205     this.annotationType = annotationType;
206   }
207 
208   /**
209    * Gets the string representation of this node
210    
211    @return the string representation of this node
212    */
213   @Override
214   public String toString() {
215     String result = list + ':' + major;
216     if((null != minor&& (!= minor.length())) result += ':' + minor;
217     if((null != language&& (!= language.length())) {
218       if((null == minor|| (== minor.length())) result += ':';
219       result += ':' + language;
220     }
221     // if the annotation type is Lookup we don't really need to add
222     // it to the definition file
223     if((null != annotationType&& (!= annotationType.length())
224         && !annotationType.equals(ANNIEConstants.LOOKUP_ANNOTATION_TYPE)) {
225       if((null == minor|| (== minor.length())) result += ':';
226       if(language == null || (== language.length())) result += ':';
227       result += ':' + annotationType;
228     }
229     return result;
230   }
231 
232   @Override
233   public int hashCode() {
234     final int prime = 31;
235     int result = 1;
236     result =
237         prime * result
238             ((annotationType == null: annotationType.hashCode());
239     result = prime * result + ((language == null: language.hashCode());
240     result = prime * result + ((list == null: list.hashCode());
241     result = prime * result + ((major == null: major.hashCode());
242     result = prime * result + ((minor == null: minor.hashCode());
243     return result;
244   }
245 
246   @Override
247   public boolean equals(Object obj) {
248     if(this == objreturn true;
249     if(obj == nullreturn false;
250     if(getClass() != obj.getClass()) return false;
251     LinearNode other = (LinearNode)obj;
252     if(annotationType == null) {
253       if(other.annotationType != nullreturn false;
254     else if(!annotationType.equals(other.annotationType)) return false;
255     if(language == null) {
256       if(other.language != nullreturn false;
257     else if(!language.equals(other.language)) return false;
258     if(list == null) {
259       if(other.list != nullreturn false;
260     else if(!list.equals(other.list)) return false;
261     if(major == null) {
262       if(other.major != nullreturn false;
263     else if(!major.equals(other.major)) return false;
264     if(minor == null) {
265       if(other.minor != nullreturn false;
266     else if(!minor.equals(other.minor)) return false;
267     return true;
268   }
269 // class LinearNode