Token.java
001 package gate.creole.annic.apache.lucene.analysis;
002 
003 /**
004  * Copyright 2004 The Apache Software Foundation
005  *
006  * Licensed under the Apache License, Version 2.0 (the "License");
007  * you may not use this file except in compliance with the License.
008  * You may obtain a copy of the License at
009  *
010  *     http://www.apache.org/licenses/LICENSE-2.0
011  *
012  * Unless required by applicable law or agreed to in writing, software
013  * distributed under the License is distributed on an "AS IS" BASIS,
014  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
015  * See the License for the specific language governing permissions and
016  * limitations under the License.
017  */
018 
019 
020 
021 /** A Token is an occurence of a term from the text of a field.  It consists of
022   a term's text, the start and end offset of the term in the text of the field,
023   and a type string.
024 
025   The start and end offsets permit applications to re-associate a token with
026   its source text, e.g., to display highlighted query terms in a document
027   browser, or to show matching text fragments in a KWIC (KeyWord In Context)
028   display, etc.
029 
030   The type is an interned string, assigned by a lexical analyzer
031   (a.k.a. tokenizer), naming the lexical or syntactic class that the token
032   belongs to.  For example an end of sentence marker token might be implemented
033   with type "eos".  The default token type is "word".  */
034 
035 import java.io.Serializable;
036 
037 @SuppressWarnings("serial")
038 public final class Token implements Serializable {
039   String termText;          // the text of the term
040   int startOffset;          // start in source text
041   int endOffset;          // end in source text
042   String type = "word";          // lexical type
043   int position;
044 
045   private int positionIncrement = 1;
046 
047   /** Constructs a Token with the given term text, and start & end offsets.
048       The type defaults to "word." */
049   public Token(String text, int start, int end) {
050     termText = text;
051     startOffset = start;
052     endOffset = end;
053   }
054 
055   /** Constructs a Token with the given text, start and end offsets, & type. */
056   public Token(String text, int start, int end, String typ) {
057     termText = text;
058     startOffset = start;
059     endOffset = end;
060     type = typ;
061   }
062 
063   /** Set the position increment.  This determines the position of this token
064    * relative to the previous Token in a {@link TokenStream}, used in phrase
065    * searching.
066    *
067    <p>The default value is one.
068    *
069    <p>Some common uses for this are:<ul>
070    *
071    <li>Set it to zero to put multiple terms in the same position.  This is
072    * useful if, e.g., a word has multiple stems.  Searches for phrases
073    * including either stem will match.  In this case, all but the first stem's
074    * increment should be set to zero: the increment of the first instance
075    * should be one.  Repeating a token with an increment of zero can also be
076    * used to boost the scores of matches on that token.
077    *
078    <li>Set it to values greater than one to inhibit exact phrase matches.
079    * If, for example, one does not want phrases to match across removed stop
080    * words, then one could build a stop word filter that removes stop words and
081    * also sets the increment to the number of stop words removed before each
082    * non-stop word.  Then exact phrase queries will only match when the terms
083    * occur with no intervening stop words.
084    *
085    </ul>
086    @see gate.creole.annic.apache.lucene.index.TermPositions
087    */
088   public void setPositionIncrement(int positionIncrement) {
089     if (positionIncrement < 0)
090       throw new IllegalArgumentException
091         ("Increment must be zero or greater: " + positionIncrement);
092     this.positionIncrement = positionIncrement;
093   }
094 
095   public void setPosition(int pos) {
096     this.position = pos;
097   }
098 
099   public int getPosition() {
100     return position;
101   }
102 
103   /** Returns the position increment of this Token.
104    @see #setPositionIncrement
105    */
106   public int getPositionIncrement() { return positionIncrement; }
107 
108   /** Returns the Token's term text. */
109   public final String termText() { return termText; }
110 
111   /** Returns this Token's starting offset, the position of the first character
112     corresponding to this token in the source text.
113 
114     Note that the difference between endOffset() and startOffset() may not be
115     equal to termText.length(), as the term text may have been altered by a
116     stemmer or some other filter. */
117   public final int startOffset() { return startOffset; }
118 
119   /** Returns this Token's ending offset, one greater than the position of the
120     last character corresponding to this token in the source text. */
121   public final int endOffset() { return endOffset; }
122 
123   /** Returns this Token's lexical type.  Defaults to "word". */
124   public final String type() { return type; }
125 
126 }