setNorm(doc, field, Similarity.encodeNorm(value));  }  /** Returns an enumeration of all the terms in the index. The   * enumeration is ordered by Term.compareTo(). Each term is greater   * than all that precede it in the enumeration. Note that after   * calling terms(), {@link TermEnum#next()} must be called   * on the resulting enumeration before calling other methods such as   * {@link TermEnum#term()}.   * @throws IOException if there is a low-level IO error   */  public abstract TermEnum terms() throws IOException;  /** Returns an enumeration of all terms starting at a given term. If   * the given term does not exist, the enumeration is positioned at the   * first term greater than the supplied term. The enumeration is   * ordered by Term.compareTo(). Each term is greater than all that   * precede it in the enumeration.   * @throws IOException if there is a low-level IO error   */  public abstract TermEnum terms(Term t) throws IOException;  /** Returns the number of documents containing the term <code>t</code>.   * @throws IOException if there is a low-level IO error   */  public abstract int docFreq(Term t) throws IOException;  /** Returns an enumeration of all the documents which contain   * <code>term</code>. For each document, the document number, the frequency of   * the term in that document is also provided, for use in search scoring.   * Thus, this method implements the mapping:   * <p><ul>   * Term &nbsp;&nbsp; =&gt; &nbsp;&nbsp; &lt;docNum, freq&gt;<sup>*</sup>   * </ul>   * <p>The enumeration is ordered by document number.  Each document number   * is greater than all that precede it in the enumeration.   * @throws IOException if there is a low-level IO error   */  public TermDocs termDocs(Term term) throws IOException {    ensureOpen();    TermDocs termDocs = termDocs();    termDocs.seek(term);    return termDocs;  }  /** Returns an unpositioned {@link TermDocs} enumerator.   * @throws IOException if there is a low-level IO error   */  public abstract TermDocs termDocs() throws IOException;  /** Returns an enumeration of all the documents which contain   * <code>term</code>.  For each document, in addition to the document number   * and frequency of the term in that document, a list of all of the ordinal   * positions of the term in the document is available.  Thus, this method   * implements the mapping:   *   * <p><ul>   * Term &nbsp;&nbsp; =&gt; &nbsp;&nbsp; &lt;docNum, freq,   * &lt;pos<sub>1</sub>, pos<sub>2</sub>, ...   * pos<sub>freq-1</sub>&gt;   * &gt;<sup>*</sup>   * </ul>   * <p> This positional information facilitates phrase and proximity searching.   * <p>The enumeration is ordered by document number.  Each document number is   * greater than all that precede it in the enumeration.   * @throws IOException if there is a low-level IO error   */  public TermPositions termPositions(Term term) throws IOException {    ensureOpen();    TermPositions termPositions = termPositions();    termPositions.seek(term);    return termPositions;  }  /** Returns an unpositioned {@link TermPositions} enumerator.   * @throws IOException if there is a low-level IO error   */  public abstract TermPositions termPositions() throws IOException;  /** Deletes the document numbered <code>docNum</code>.  Once a document is   * deleted it will not appear in TermDocs or TermPostitions enumerations.   * Attempts to read its field with the {@link #document}   * method will result in an error.  The presence of this document may still be   * reflected in the {@link #docFreq} statistic, though   * this will be corrected eventually as the index is further modified.   *   * @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 deleteDocument(int docNum) throws StaleReaderException, CorruptIndexException, LockObtainFailedException, IOException {    ensureOpen();    acquireWriteLock();    hasChanges = true;    doDelete(docNum);  }  /** Implements deletion of the document numbered <code>docNum</code>.   * Applications should call {@link #deleteDocument(int)} or {@link #deleteDocuments(Term)}.   */  protected abstract void doDelete(int docNum) throws CorruptIndexException, IOException;  /** Deletes all documents that have a given <code>term</code> indexed.   * This is useful if one uses a document field to hold a unique ID string for   * the document.  Then to delete such a document, one merely constructs a   * term with the appropriate field and the unique ID string as its text and   * passes it to this method.   * See {@link #deleteDocument(int)} for information about when this deletion will    * become effective.   *   * @return the number of documents deleted   * @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 int deleteDocuments(Term term) throws StaleReaderException, CorruptIndexException, LockObtainFailedException, IOException {    ensureOpen();    TermDocs docs = termDocs(term);    if (docs == null) return 0;    int n = 0;    try {      while (docs.next()) {        deleteDocument(docs.doc());        n++;      }    } finally {      docs.close();    }    return n;  }  /** Undeletes all documents currently marked as deleted in this index.   *   * @throws StaleReaderException if the index has changed   *  since this reader was opened   * @throws LockObtainFailedException if another writer   *  has this index open (<code>write.lock</code> could not   *  be obtained)   * @throws CorruptIndexException if the index is corrupt   * @throws IOException if there is a low-level IO error   */  public synchronized void undeleteAll() throws StaleReaderException, CorruptIndexException, LockObtainFailedException, IOException {    ensureOpen();    acquireWriteLock();    hasChanges = true;    doUndeleteAll();  }  /** Implements actual undeleteAll() in subclass. */  protected abstract void doUndeleteAll() throws CorruptIndexException, IOException;  /** Does nothing by default. Subclasses that require a write lock for   *  index modifications must implement this method. */  protected synchronized void acquireWriteLock() throws IOException {    /* NOOP */  }    /**   *    * @throws IOException   */  public final synchronized void flush() throws IOException {    ensureOpen();    commit();  }  /**   * Commit changes resulting from delete, undeleteAll, or   * setNorm operations   *   * If an exception is hit, then either no changes or all   * changes will have been committed to the index   * (transactional semantics).   * @throws IOException if there is a low-level IO error   */  protected final synchronized void commit() throws IOException {    if(hasChanges){      doCommit();    }    hasChanges = false;  }  /** Implements commit. */  protected abstract void doCommit() throws IOException;  /**   * Closes files associated with this index.   * Also saves any new deletions to disk.   * No other methods should be called after this has been called.   * @throws IOException if there is a low-level IO error   */  public final synchronized void close() throws IOException {    if (!closed) {      decRef();      closed = true;    }  }    /** Implements close. */  protected abstract void doClose() throws IOException;  /**   * Get a list of unique field names that exist in this index and have the specified   * field option information.   * @param fldOption specifies which field option should be available for the returned fields   * @return Collection of Strings indicating the names of the fields.   * @see IndexReader.FieldOption   */  public abstract Collection getFieldNames(FieldOption fldOption);  /**   * Returns <code>true</code> iff the index in the named directory is   * currently locked.   * @param directory the directory to check for a lock   * @throws IOException if there is a low-level IO error   * @deprecated Please use {@link IndexWriter#isLocked(Directory)} instead   */  public static boolean isLocked(Directory directory) throws IOException {    return      directory.makeLock(IndexWriter.WRITE_LOCK_NAME).isLocked();  }  /**   * Returns <code>true</code> iff the index in the named directory is   * currently locked.   * @param directory the directory to check for a lock   * @throws IOException if there is a low-level IO error   * @deprecated Please use {@link IndexWriter#isLocked(String)} instead   */  public static boolean isLocked(String directory) throws IOException {    Directory dir = FSDirectory.getDirectory(directory);    boolean result = isLocked(dir);    dir.close();    return result;  }  /**   * Forcibly unlocks the index in the named directory.   * <P>   * Caution: this should only be used by failure recovery code,   * when it is known that no other process nor thread is in fact   * currently accessing this index.   * @deprecated Please use {@link IndexWriter#unlock(Directory)} instead   */  public static void unlock(Directory directory) throws IOException {    directory.makeLock(IndexWriter.WRITE_LOCK_NAME).release();  }  /**   * Expert: return the IndexCommit that this reader has   * opened.  This method is only implemented by those   * readers that correspond to a Directory with its own   * segments_N file.   *   * <p><b>WARNING</b>: this API is new and experimental and   * may suddenly change.</p>   */  public IndexCommit getIndexCommit() throws IOException {    throw new UnsupportedOperationException("This reader does not support this method.");  }    /**   * Prints the filename and size of each file within a given compound file.   * Add the -extract flag to extract files to the current working directory.   * In order to make the extracted version of the index work, you have to copy   * the segments file from the compound index into the directory where the extracted files are stored.   * @param args Usage: org.apache.lucene.index.IndexReader [-extract] &lt;cfsfile&gt;   */  public static void main(String [] args) {    String filename = null;    boolean extract = false;    for (int i = 0; i < args.length; ++i) {      if (args[i].equals("-extract")) {        extract = true;      } else if (filename == null) {        filename = args[i];      }    }    if (filename == null) {      System.out.println("Usage: org.apache.lucene.index.IndexReader [-extract] <cfsfile>");      return;    }    Directory dir = null;    CompoundFileReader cfr = null;    try {      File file = new File(filename);      String dirname = file.getAbsoluteFile().getParent();      filename = file.getName();      dir = FSDirectory.getDirectory(dirname);      cfr = new CompoundFileReader(dir, filename);      String [] files = cfr.list();      Arrays.sort(files);   // sort the array of filename so that the output is more readable      for (int i = 0; i < files.length; ++i) {        long len = cfr.fileLength(files[i]);        if (extract) {          System.out.println("extract " + files[i] + " with " + len + " bytes to local directory...");          IndexInput ii = cfr.openInput(files[i]);          FileOutputStream f = new FileOutputStream(files[i]);          // read and write with a small buffer, which is more effectiv than reading byte by byte          byte[] buffer = new byte[1024];          int chunk = buffer.length;          while(len > 0) {            final int bufLen = (int) Math.min(chunk, len);            ii.readBytes(buffer, 0, bufLen);            f.write(buffer, 0, bufLen);            len -= bufLen;          }          f.close();          ii.close();        }        else          System.out.println(files[i] + ": " + len + " bytes");      }    } catch (IOException ioe) {      ioe.printStackTrace();    }    finally {      try {        if (dir != null)          dir.close();        if (cfr != null)          cfr.close();      }      catch (IOException ioe) {        ioe.printStackTrace();      }    }  }  /** Returns all commit points that exist in the Directory.   *  Normally, because the default is {@link   *  KeepOnlyLastCommitDeletionPolicy}, there would be only   *  one commit point.  But if you're using a custom {@link   *  IndexDeletionPolicy} then there could be many commits.   *  Once you have a given commit, you can open a reader on   *  it by calling {@link IndexReader#open(IndexCommit)}   *  There must be at least one commit in   *  the Directory, else this method throws {@link   *  java.io.IOException}.  Note that if a commit is in   *  progress while this method is running, that commit   *  may or may not be returned array.  */  public static Collection listCommits(Directory dir) throws IOException {    return DirectoryIndexReader.listCommits(dir);  }}