FilterIndexReader.java
001 package gate.creole.annic.apache.lucene.index;
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 import java.io.IOException;
020 import java.util.Collection;
021 
022 import gate.creole.annic.apache.lucene.document.Document;
023 
024 /**  A <code>FilterIndexReader</code> contains another IndexReader, which it
025  * uses as its basic source of data, possibly transforming the data along the
026  * way or providing additional functionality. The class
027  <code>FilterIndexReader</code> itself simply implements all abstract methods
028  * of <code>IndexReader</code> with versions that pass all requests to the
029  * contained index reader. Subclasses of <code>FilterIndexReader</code> may
030  * further override some of these methods and may also provide additional
031  * methods and fields.
032  */
033 @SuppressWarnings("rawtypes")
034 public class FilterIndexReader extends IndexReader {
035 
036   /** Base class for filtering {@link TermDocs} implementations. */
037   public static class FilterTermDocs implements TermDocs {
038     protected TermDocs in;
039 
040     public FilterTermDocs(TermDocs in) { this.in = in; }
041 
042     @Override
043     public void seek(Term termthrows IOException in.seek(term)}
044     @Override
045     public void seek(TermEnum termEnumthrows IOException in.seek(termEnum)}
046     @Override
047     public int doc() { return in.doc()}
048     @Override
049     public int freq() { return in.freq()}
050     @Override
051     public boolean next() throws IOException return in.next()}
052     @Override
053     public int read(int[] docs, int[] freqsthrows IOException {
054       return in.read(docs, freqs);
055     }
056     @Override
057     public boolean skipTo(int ithrows IOException return in.skipTo(i)}
058     @Override
059     public void close() throws IOException in.close()}
060   }
061 
062   /** Base class for filtering {@link TermPositions} implementations. */
063   public static class FilterTermPositions
064           extends FilterTermDocs implements TermPositions {
065 
066     public FilterTermPositions(TermPositions in) { super(in)}
067 
068     @Override
069     public int nextPosition() throws IOException {
070       return ((TermPositionsthis.in).nextPosition();
071     }
072   }
073 
074   /** Base class for filtering {@link TermEnum} implementations. */
075   public static class FilterTermEnum extends TermEnum {
076     protected TermEnum in;
077 
078     public FilterTermEnum(TermEnum in) { this.in = in; }
079 
080     @Override
081     public boolean next() throws IOException return in.next()}
082     @Override
083     public Term term() { return in.term()}
084     @Override
085     public int docFreq() { return in.docFreq()}
086     @Override
087     public void close() throws IOException in.close()}
088   }
089 
090   protected IndexReader in;
091 
092   /**
093    <p>Construct a FilterIndexReader based on the specified base reader.
094    * Directory locking for delete, undeleteAll, and setNorm operations is
095    * left to the base reader.</p>
096    <p>Note that base reader is closed if this FilterIndexReader is closed.</p>
097    @param in specified base reader.
098    */
099   public FilterIndexReader(IndexReader in) {
100     super(in.directory());
101     this.in = in;
102   }
103 
104   @Override
105   public TermFreqVector[] getTermFreqVectors(int docNumber)
106           throws IOException {
107     return in.getTermFreqVectors(docNumber);
108   }
109 
110   @Override
111   public TermFreqVector getTermFreqVector(int docNumber, String field)
112           throws IOException {
113     return in.getTermFreqVector(docNumber, field);
114   }
115 
116   @Override
117   public int numDocs() { return in.numDocs()}
118   @Override
119   public int maxDoc() { return in.maxDoc()}
120 
121   @Override
122   public Document document(int nthrows IOException return in.document(n)}
123 
124   @Override
125   public boolean isDeleted(int n) { return in.isDeleted(n)}
126   @Override
127   public boolean hasDeletions() { return in.hasDeletions()}
128   @Override
129   protected void doUndeleteAll() throws IOException in.undeleteAll()}
130 
131   @Override
132   public byte[] norms(String fthrows IOException return in.norms(f)}
133   @Override
134   public void norms(String f, byte[] bytes, int offsetthrows IOException {
135     in.norms(f, bytes, offset);
136   }
137   @Override
138   protected void doSetNorm(int d, String f, byte bthrows IOException {
139     in.setNorm(d, f, b);
140   }
141 
142   @Override
143   public TermEnum terms() throws IOException return in.terms()}
144   @Override
145   public TermEnum terms(Term tthrows IOException return in.terms(t)}
146 
147   @Override
148   public int docFreq(Term tthrows IOException return in.docFreq(t)}
149 
150   @Override
151   public TermDocs termDocs() throws IOException return in.termDocs()}
152 
153   @Override
154   public TermPositions termPositions() throws IOException {
155     return in.termPositions();
156   }
157 
158   @Override
159   protected void doDelete(int nthrows IOException in.delete(n)}
160   @Override
161   protected void doCommit() throws IOException in.commit()}
162   @Override
163   protected void doClose() throws IOException in.close()}
164 
165   @Override
166   public Collection getFieldNames() throws IOException {
167     return in.getFieldNames();
168   }
169 
170   @Override
171   public Collection getFieldNames(boolean indexedthrows IOException {
172     return in.getFieldNames(indexed);
173   }
174 
175   /**
176    *
177    @param storedTermVector if true, returns only Indexed fields that have term vector info,
178    *                        else only indexed fields without term vector info
179    @return Collection of Strings indicating the names of the fields
180    */
181   @Override
182   public Collection getIndexedFieldNames(boolean storedTermVector) {
183     return in.getIndexedFieldNames(storedTermVector);
184   }
185 }