throw new UnsupportedOperationException("This reader does not support this method.");      }  }  /**   * Returns the time the index in the named directory was last modified.   * Do not use this to check whether the reader is still up-to-date, use   * {@link #isCurrent()} instead.    * @throws CorruptIndexException if the index is corrupt   * @throws IOException if there is a low-level IO error   */  public static long lastModified(String directory) throws CorruptIndexException, IOException {    return lastModified(new File(directory));  }  /**   * Returns the time the index in the named directory was last modified.    * Do not use this to check whether the reader is still up-to-date, use   * {@link #isCurrent()} instead.    * @throws CorruptIndexException if the index is corrupt   * @throws IOException if there is a low-level IO error   */  public static long lastModified(File fileDirectory) throws CorruptIndexException, IOException {    return ((Long) new SegmentInfos.FindSegmentsFile(fileDirectory) {        public Object doBody(String segmentFileName) {          return new Long(FSDirectory.fileModified(fileDirectory, segmentFileName));        }      }.run()).longValue();  }  /**   * Returns the time the index in the named directory was last modified.    * Do not use this to check whether the reader is still up-to-date, use   * {@link #isCurrent()} instead.    * @throws CorruptIndexException if the index is corrupt   * @throws IOException if there is a low-level IO error   */  public static long lastModified(final Directory directory2) throws CorruptIndexException, IOException {    return ((Long) new SegmentInfos.FindSegmentsFile(directory2) {        public Object doBody(String segmentFileName) throws IOException {          return new Long(directory2.fileModified(segmentFileName));        }      }.run()).longValue();  }  /**   * Reads version number from segments files. The version number is   * initialized with a timestamp and then increased by one for each change of   * the index.   *    * @param directory where the index resides.   * @return version number.   * @throws CorruptIndexException if the index is corrupt   * @throws IOException if there is a low-level IO error   */  public static long getCurrentVersion(String directory) throws CorruptIndexException, IOException {    return getCurrentVersion(new File(directory));  }  /**   * Reads version number from segments files. The version number is   * initialized with a timestamp and then increased by one for each change of   * the index.   *    * @param directory where the index resides.   * @return version number.   * @throws CorruptIndexException if the index is corrupt   * @throws IOException if there is a low-level IO error   */  public static long getCurrentVersion(File directory) throws CorruptIndexException, IOException {    Directory dir = FSDirectory.getDirectory(directory);    long version = getCurrentVersion(dir);    dir.close();    return version;  }  /**   * Reads version number from segments files. The version number is   * initialized with a timestamp and then increased by one for each change of   * the index.   *    * @param directory where the index resides.   * @return version number.   * @throws CorruptIndexException if the index is corrupt   * @throws IOException if there is a low-level IO error   */  public static long getCurrentVersion(Directory directory) throws CorruptIndexException, IOException {    return SegmentInfos.readCurrentVersion(directory);  }  /**   * Version number when this IndexReader was opened. Not implemented in the IndexReader base class.   * @throws UnsupportedOperationException unless overridden in subclass   */  public long getVersion() {    throw new UnsupportedOperationException("This reader does not support this method.");  }  /**<p>For IndexReader implementations that use   * TermInfosReader to read terms, this sets the   * indexDivisor to subsample the number of indexed terms   * loaded into memory.  This has the same effect as {@link   * IndexWriter#setTermIndexInterval} except that setting   * must be done at indexing time while this setting can be   * set per reader.  When set to N, then one in every   * N*termIndexInterval terms in the index is loaded into   * memory.  By setting this to a value > 1 you can reduce   * memory usage, at the expense of higher latency when   * loading a TermInfo.  The default value is 1.</p>   *   * <b>NOTE:</b> you must call this before the term   * index is loaded.  If the index is already loaded,    * an IllegalStateException is thrown.   * @throws IllegalStateException if the term index has already been loaded into memory   */  public void setTermInfosIndexDivisor(int indexDivisor) throws IllegalStateException {    throw new UnsupportedOperationException("This reader does not support this method.");  }  /** <p>For IndexReader implementations that use   *  TermInfosReader to read terms, this returns the   *  current indexDivisor.   *  @see #setTermInfosIndexDivisor */  public int getTermInfosIndexDivisor() {    throw new UnsupportedOperationException("This reader does not support this method.");  }  /**   * Check whether this IndexReader is still using the   * current (i.e., most recently committed) version of the   * index.  If a writer has committed any changes to the   * index since this reader was opened, this will return   * <code>false</code>, in which case you must open a new   * IndexReader in order to see the changes.  See the   * description of the <a href="IndexWriter.html#autoCommit"><code>autoCommit</code></a>   * flag which controls when the {@link IndexWriter}   * actually commits changes to the index.   *    * <p>   * Not implemented in the IndexReader base class.   * </p>   * @throws CorruptIndexException if the index is corrupt   * @throws IOException if there is a low-level IO error   * @throws UnsupportedOperationException unless overridden in subclass   */  public boolean isCurrent() throws CorruptIndexException, IOException {    throw new UnsupportedOperationException("This reader does not support this method.");  }  /**   * Checks is the index is optimized (if it has a single segment and    * no deletions).  Not implemented in the IndexReader base class.   * @return <code>true</code> if the index is optimized; <code>false</code> otherwise   * @throws UnsupportedOperationException unless overridden in subclass   */  public boolean isOptimized() {    throw new UnsupportedOperationException("This reader does not support this method.");  }    /**   *  Return an array of term frequency vectors for the specified document.   *  The array contains a vector for each vectorized field in the document.   *  Each vector contains terms and frequencies for all terms in a given vectorized field.   *  If no such fields existed, the method returns null. The term vectors that are   * returned my either be of type TermFreqVector or of type TermPositionsVector if   * positions or offsets have been stored.   *    * @param docNumber document for which term frequency vectors are returned   * @return array of term frequency vectors. May be null if no term vectors have been   *  stored for the specified document.   * @throws IOException if index cannot be accessed   * @see org.apache.lucene.document.Field.TermVector   */  abstract public TermFreqVector[] getTermFreqVectors(int docNumber)          throws IOException;  /**   *  Return a term frequency vector for the specified document and field. The   *  returned vector contains terms and frequencies for the terms in   *  the specified field of this document, if the field had the storeTermVector   *  flag set. If termvectors had been stored with positions or offsets, a    *  TermPositionsVector is returned.   *    * @param docNumber document for which the term frequency vector is returned   * @param field field for which the term frequency vector is returned.   * @return term frequency vector May be null if field does not exist in the specified   * document or term vector was not stored.   * @throws IOException if index cannot be accessed   * @see org.apache.lucene.document.Field.TermVector   */  abstract public TermFreqVector getTermFreqVector(int docNumber, String field)          throws IOException;  /**   * Load the Term Vector into a user-defined data structure instead of relying on the parallel arrays of   * the {@link TermFreqVector}.   * @param docNumber The number of the document to load the vector for   * @param field The name of the field to load   * @param mapper The {@link TermVectorMapper} to process the vector.  Must not be null   * @throws IOException if term vectors cannot be accessed or if they do not exist on the field and doc. specified.   *    */  abstract public void getTermFreqVector(int docNumber, String field, TermVectorMapper mapper) throws IOException;  /**   * Map all the term vectors for all fields in a Document   * @param docNumber The number of the document to load the vector for   * @param mapper The {@link TermVectorMapper} to process the vector.  Must not be null   * @throws IOException if term vectors cannot be accessed or if they do not exist on the field and doc. specified.   */  abstract public void getTermFreqVector(int docNumber, TermVectorMapper mapper) throws IOException;  /**   * Returns <code>true</code> if an index exists at the specified directory.   * If the directory does not exist or if there is no index in it.   * <code>false</code> is returned.   * @param  directory the directory to check for an index   * @return <code>true</code> if an index exists; <code>false</code> otherwise   */  public static boolean indexExists(String directory) {    return indexExists(new File(directory));  }  /**   * Returns <code>true</code> if an index exists at the specified directory.   * If the directory does not exist or if there is no index in it.   * @param  directory the directory to check for an index   * @return <code>true</code> if an index exists; <code>false</code> otherwise   */  public static boolean indexExists(File directory) {    return SegmentInfos.getCurrentSegmentGeneration(directory.list()) != -1;  }  /**   * Returns <code>true</code> if an index exists at the specified directory.   * If the directory does not exist or if there is no index in it.   * @param  directory the directory to check for an index   * @return <code>true</code> if an index exists; <code>false</code> otherwise   * @throws IOException if there is a problem with accessing the index   */  public static boolean indexExists(Directory directory) throws IOException {    return SegmentInfos.getCurrentSegmentGeneration(directory) != -1;  }  /** Returns the number of documents in this index. */  public abstract int numDocs();  /** Returns one greater than the largest possible document number.   * This may be used to, e.g., determine how big to allocate an array which   * will have an element for every document number in an index.   */  public abstract int maxDoc();  /** Returns the number of deleted documents. */  public int numDeletedDocs() {    return maxDoc() - numDocs();  }  /** Returns the stored fields of the <code>n</code><sup>th</sup>   <code>Document</code> in this index.   * @throws CorruptIndexException if the index is corrupt   * @throws IOException if there is a low-level IO error   */  public Document document(int n) throws CorruptIndexException, IOException {    ensureOpen();    return document(n, null);  }  /**   * Get the {@link org.apache.lucene.document.Document} at the <code>n</code><sup>th</sup> position. The {@link org.apache.lucene.document.FieldSelector}   * may be used to determine what {@link org.apache.lucene.document.Field}s to load and how they should be loaded.   *    * <b>NOTE:</b> If this Reader (more specifically, the underlying <code>FieldsReader</code>) is closed before the lazy {@link org.apache.lucene.document.Field} is   * loaded an exception may be thrown.  If you want the value of a lazy {@link org.apache.lucene.document.Field} to be available after closing you must   * explicitly load it or fetch the Document again with a new loader.   *    *     * @param n Get the document at the <code>n</code><sup>th</sup> position   * @param fieldSelector The {@link org.apache.lucene.document.FieldSelector} to use to determine what Fields should be loaded on the Document.  May be null, in which case all Fields will be loaded.   * @return The stored fields of the {@link org.apache.lucene.document.Document} at the nth position   * @throws CorruptIndexException if the index is corrupt   * @throws IOException if there is a low-level IO error   *    * @see org.apache.lucene.document.Fieldable   * @see org.apache.lucene.document.FieldSelector   * @see org.apache.lucene.document.SetBasedFieldSelector   * @see org.apache.lucene.document.LoadFirstFieldSelector   */  //When we convert to JDK 1.5 make this Set<String>  public abstract Document document(int n, FieldSelector fieldSelector) throws CorruptIndexException, IOException;      /** Returns true if document <i>n</i> has been deleted */  public abstract boolean isDeleted(int n);  /** Returns true if any documents have been deleted */  public abstract boolean hasDeletions();  /** Returns true if there are norms stored for this field. */  public boolean hasNorms(String field) throws IOException {    // backward compatible implementation.    // SegmentReader has an efficient implementation.    ensureOpen();    return norms(field) != null;  }  /** Returns the byte-encoded normalization factor for the named field of   * every document.  This is used by the search code to score documents.   *   * @see org.apache.lucene.document.Field#setBoost(float)   */  public abstract byte[] norms(String field) throws IOException;  /** Reads the byte-encoded normalization factor for the named field of every   *  document.  This is used by the search code to score documents.   *   * @see org.apache.lucene.document.Field#setBoost(float)   */  public abstract void norms(String field, byte[] bytes, int offset)    throws IOException;  /** Expert: Resets the normalization factor for the named field of the named   * document.  The norm represents the product of the field's {@link   * org.apache.lucene.document.Fieldable#setBoost(float) boost} and its {@link Similarity#lengthNorm(String,   * int) length normalization}.  Thus, to preserve the length normalization   * values when resetting this, one should base the new value upon the old.   *   * @see #norms(String)   * @see Similarity#decodeNorm(byte)   * @throws StaleReaderException if the index has changed   *  since this reader was opened   * @throws CorruptIndexException if the index is corrupt   * @throws LockObtainFailedException if another writer   *  has this index open (<code>write.lock</code> could not   *  be obtained)   * @throws IOException if there is a low-level IO error   */  public synchronized  void setNorm(int doc, String field, byte value)          throws StaleReaderException, CorruptIndexException, LockObtainFailedException, IOException {    ensureOpen();    acquireWriteLock();    hasChanges = true;    doSetNorm(doc, field, value);  }  /** Implements setNorm in subclass.*/  protected abstract void doSetNorm(int doc, String field, byte value)          throws CorruptIndexException, IOException;  /** Expert: Resets the normalization factor for the named field of the named   * document.   *   * @see #norms(String)   * @see Similarity#decodeNorm(byte)   *    * @throws StaleReaderException if the index has changed   *  since this reader was opened   * @throws CorruptIndexException if the index is corrupt   * @throws LockObtainFailedException if another writer   *  has this index open (<code>write.lock</code> could not   *  be obtained)   * @throws IOException if there is a low-level IO error   */  public void setNorm(int doc, String field, float value)          throws StaleReaderException, CorruptIndexException, LockObtainFailedException, IOException {    ensureOpen();