Term.java
001 package gate.creole.annic.apache.lucene.index;
002 
003 /**
004   A Term represents a word from text.  This is the unit of search.  It is
005   composed of two elements, the text of the word, as a string, and the name of
006   the field that the text occured in, an interned string.
007 
008   Note that terms may represent more than words from text fields, but also
009   things like dates, email addresses, urls, etc.  */
010 @SuppressWarnings({"rawtypes","unused","serial"})
011 public final class Term implements Comparable, java.io.Serializable {
012   String field;
013   String text;
014   //Niraj
015   String type;
016   // End
017 
018 
019   /** Constructs a Term with the given field and text. */
020   public Term(String fld, String txt) {
021     this(fld, txt, true);
022   }
023 
024   // Niraj
025   public Term(String fld, String txt, String type/*, int pos*/) {
026     this(fld, txt, type, /*pos,*/ true);
027   }
028 
029 
030   Term(String fld, String txt, String type, /*int pos,*/ boolean intern) {
031     field = intern ? fld.intern() : fld;
032     text = txt;
033     this.type = type;
034   }
035 
036   // End
037 
038   Term(String fld, String txt, boolean intern) {
039     field = intern ? fld.intern() : fld;    // field names are interned
040     text = txt;            // unless already known to be
041   }
042 
043 
044   /** Returns the field of this term, an interned string.   The field indicates
045     the part of a document which this term came from. */
046   public final String field() { return field; }
047 
048   //Niraj
049   public final String type() { return type; }
050 /*  public final int position() { return position; }*/
051   //End
052 
053   /** Returns the text of this term.  In the case of words, this is simply the
054     text of the word.  In the case of dates and other types, this is an
055     encoding of the object as a string.  */
056   public final String text() { return text; }
057 
058   /** Compares two terms, returning true iff they have the same
059       field and text. */
060   @Override
061   public final boolean equals(Object o) {
062     if (o == null)
063       return false;
064     Term other = (Term)o;
065     if (type != null) {
066       // Niraj
067       //return field == other.field && text.equals(other.text);
068       boolean ret = (field.equals(other.field)) &&
069           (text.equals(other.text)/* || text.equals("*") || other.text.equals("*")*/&&
070           (type.equals(other.type)/* || type.equals("*") || other.type.equals("*")*/);/* &&
071           position == other.position;*/
072       return ret;
073       // End
074     }
075     else {
076       boolean ret = (field.equals(other.field)) &&
077           (text.equals(other.text)/* || text.equals("*") || other.text.equals("*")*/);
078       return ret;
079     }
080   }
081 
082   /** Combines the hashCode() of the field and the text. */
083   @Override
084   public final int hashCode() {
085     if(type != null) {
086     //Niraj
087     //return field.hashCode() + text.hashCode();
088     return field.hashCode() + text.hashCode() + type.hashCode();
089     //End
090     else {
091       return field.hashCode() + text.hashCode();
092     }
093 
094   }
095 
096   @Override
097   public int compareTo(Object other) {
098     return compareTo((Term)other);
099   }
100 
101   /** Compares two terms, returning an integer which is less than zero iff this
102     term belongs after the argument, equal zero iff this term is equal to the
103     argument, and greater than zero iff this term belongs after the argument.
104 
105     The ordering of terms is first by field, then by text.*/
106   public final int compareTo(Term other) {
107     if (field == other.field) {        // fields are interned
108       int rank = text.compareTo(other.text);
109       if (rank == 0) {
110         rank = type.compareTo(other.type);
111         /*if(rank == 0) {
112           if(position > other.position)
113             return 1;
114           else if(position == other.position)
115             return 0;
116           else
117             return -1;
118         }*/
119         return rank;
120       }
121       else {
122         return rank;
123       }
124     else {
125       return field.compareTo(other.field);
126     }
127   }
128 
129 
130   public final int indexCompareTo(Term other) {
131     if (field.equals(other.field)) {        // fields are interned
132       int rank = text.compareTo(other.text);
133       // we need to check for the star wild card characters
134       if (rank == && type != null && other.type != null) {
135         rank = type.compareTo(other.type);
136         if(rank == /*|| type.equals("*") || other.type.equals("*")*/) {
137           return 0;
138           //System.out.println("position "+position+" : "+other.position);
139           //return new Integer(position).compareTo(new Integer(other.position));
140         }
141         return rank;
142       }
143       else {
144         return rank;
145       }
146     else {
147       int rank = field.compareTo(other.field);
148       return rank;
149     }
150   }
151 
152   private boolean isWildcharMatches(String text, String other) {
153     /*if(text.endsWith("*")) {
154       String text1 = text.substring(0, text.length()-1);
155       if(other.startsWith(text1))
156         return true;
157       else
158         return false;
159     }
160     return false;*/
161      java.util.regex.Pattern p = java.util.regex.Pattern.compile(text);
162      java.util.regex.Matcher m = p.matcher(other);
163      return m.matches();
164   }
165 
166   /** Resets the field and text of a Term. */
167   final void set(String fld, String txt) {
168     field = fld;
169     text = txt;
170   }
171 
172   // Niraj
173   final void set(String fld, String text, String type/*, int pos*/) {
174     field = fld;
175     this.text = text;
176     this.type = type;
177     /*position = pos;*/
178   }
179   // End
180 
181   @Override
182   public final String toString() {
183     if(type == null)
184       return field + ":" + text;
185     //Niraj
186     return field + ":" + text + ":" + type;/* + ":" + position;*/
187     //End
188   }
189 
190   private void readObject(java.io.ObjectInputStream in)
191     throws java.io.IOException, ClassNotFoundException
192   {
193       in.defaultReadObject();
194       field = field.intern();
195   }
196 }