Concrete subclasses of IndexReader are usually constructed with a call to
- one of the static open() methods, e.g. {@link
- #open(Directory, boolean)}.
-
-
For efficiency, in this API documents are often referred to via - document numbers, non-negative integers which each name a unique - document in the index. These document numbers are ephemeral--they may change - as documents are added to and deleted from an index. Clients should thus not - rely on a given document having the same number between sessions. - -
An IndexReader can be opened on a directory for which an IndexWriter is - opened already, but it cannot be used to delete documents from the index then. - -
- NOTE: for backwards API compatibility, several methods are not listed - as abstract, but have no useful implementations in this base class and - instead always throw UnsupportedOperationException. Subclasses are - strongly encouraged to override these methods, but in many cases may not - need to. -
- -- - NOTE: as of 2.4, it's possible to open a read-only - IndexReader using the static open methods that accept the - boolean readOnly parameter. Such a reader has better - concurrency as it's not necessary to synchronize on the - isDeleted method. You must specify false if you want to - make changes with the resulting IndexReader. -
- -NOTE: {@link
- IndexReader} instances are completely thread
- safe, meaning multiple threads can call any of its methods,
- concurrently. If your application requires external
- synchronization, you should not synchronize on the
- IndexReader instance; use your own
- (non-Lucene) objects instead.
-*/
-public abstract class IndexReader implements Cloneable,Closeable {
-
- /**
- * A custom listener that's invoked when the IndexReader
- * is finished.
- *
- *
For a SegmentReader, this listener is called only - * once all SegmentReaders sharing the same core are - * closed. At this point it is safe for apps to evict - * this reader from any caches keyed on {@link - * #getCoreCacheKey}. This is the same interface that - * {@link FieldCache} uses, internally, to evict - * entries.
- * - *For other readers, this listener is called when they - * are closed.
- * - * @lucene.experimental - */ - public static interface ReaderFinishedListener { - public void finished(IndexReader reader); - } - - // Impls must set this if they may call add/removeReaderFinishedListener: - protected volatile Collection- * Opening an IndexReader is an expensive operation. This method can be used - * to refresh an existing IndexReader to reduce these costs. This method - * tries to only load segments that have changed or were created after the - * IndexReader was (re)opened. - *
- * If the index has not changed since this instance was (re)opened, then this
- * call is a NOOP and returns this instance. Otherwise, a new instance is
- * returned. The old instance is not closed and remains usable.
- *
- * If the reader is reopened, even though they share - * resources internally, it's safe to make changes - * (deletions, norms) with the new reader. All shared - * mutable state obeys "copy on write" semantics to ensure - * the changes are not seen by other readers. - *
- * You can determine whether a reader was actually reopened by comparing the - * old instance with the instance returned by this method: - *
- * IndexReader reader = ...
- * ...
- * IndexReader newReader = r.reopen();
- * if (newReader != reader) {
- * ... // reader was reopened
- * reader.close();
- * }
- * reader = newReader;
- * ...
- *
- *
- * Be sure to synchronize that code so that other threads,
- * if present, can never use reader after it has been
- * closed and before it's switched to newReader.
- *
- * NOTE: If this reader is a near real-time - * reader (obtained from {@link IndexWriter#getReader()}, - * reopen() will simply call writer.getReader() again for - * you, though this may change in the future. - * - * @throws CorruptIndexException if the index is corrupt - * @throws IOException if there is a low-level IO error - */ - public synchronized IndexReader reopen() throws CorruptIndexException, IOException { - throw new UnsupportedOperationException("This reader does not support reopen()."); - } - - - /** Just like {@link #reopen()}, except you can change the - * readOnly of the original reader. If the index is - * unchanged but readOnly is different then a new reader - * will be returned. */ - public synchronized IndexReader reopen(boolean openReadOnly) throws CorruptIndexException, IOException { - throw new UnsupportedOperationException("This reader does not support reopen()."); - } - - /** Expert: reopen this reader on a specific commit point. - * This always returns a readOnly reader. If the - * specified commit point matches what this reader is - * already on, and this reader is already readOnly, then - * this same instance is returned; if it is not already - * readOnly, a readOnly clone is returned. */ - public synchronized IndexReader reopen(final IndexCommit commit) throws CorruptIndexException, IOException { - throw new UnsupportedOperationException("This reader does not support reopen(IndexCommit)."); - } - - /** - * Expert: returns a readonly reader, covering all - * committed as well as un-committed changes to the index. - * This provides "near real-time" searching, in that - * changes made during an IndexWriter session can be - * quickly made available for searching without closing - * the writer nor calling {@link #commit}. - * - *
Note that this is functionally equivalent to calling - * {#flush} (an internal IndexWriter operation) and then using {@link IndexReader#open} to - * open a new reader. But the turnaround time of this - * method should be faster since it avoids the potentially - * costly {@link #commit}.
- * - *You must close the {@link IndexReader} returned by - * this method once you are done using it.
- * - *It's near real-time because there is no hard - * guarantee on how quickly you can get a new reader after - * making changes with IndexWriter. You'll have to - * experiment in your situation to determine if it's - * fast enough. As this is a new and experimental - * feature, please report back on your findings so we can - * learn, improve and iterate.
- * - *The resulting reader supports {@link - * IndexReader#reopen}, but that call will simply forward - * back to this method (though this may change in the - * future).
- * - *The very first time this method is called, this - * writer instance will make every effort to pool the - * readers that it opens for doing merges, applying - * deletes, etc. This means additional resources (RAM, - * file descriptors, CPU time) will be consumed.
- * - *For lower latency on reopening a reader, you should - * call {@link IndexWriterConfig#setMergedSegmentWarmer} to - * pre-warm a newly merged segment before it's committed - * to the index. This is important for minimizing - * index-to-search delay after a large merge.
- * - *If an addIndexes* call is running in another thread, - * then this reader will only search those segments from - * the foreign index that have been successfully copied - * over, so far
. - * - *NOTE: Once the writer is closed, any - * outstanding readers may continue to be used. However, - * if you attempt to reopen any of those readers, you'll - * hit an {@link AlreadyClosedException}.
- * - * @return IndexReader that covers entire index plus all - * changes made so far by this IndexWriter instance - * - * @param writer The IndexWriter to open from - * @param applyAllDeletes If true, all buffered deletes will - * be applied (made visible) in the returned reader. If - * false, the deletes are not applied but remain buffered - * (in IndexWriter) so that they will be applied in the - * future. Applying deletes can be costly, so if your app - * can tolerate deleted documents being returned you might - * gain some performance by passing false. - * - * @throws IOException - * - * @lucene.experimental - */ - public IndexReader reopen(IndexWriter writer, boolean applyAllDeletes) throws CorruptIndexException, IOException { - return writer.getReader(applyAllDeletes); - } - - /** - * Efficiently clones the IndexReader (sharing most - * internal state). - *- * On cloning a reader with pending changes (deletions, - * norms), the original reader transfers its write lock to - * the cloned reader. This means only the cloned reader - * may make further changes to the index, and commit the - * changes to the index on close, but the old reader still - * reflects all changes made up until it was cloned. - *
- * Like {@link #reopen()}, it's safe to make changes to - * either the original or the cloned reader: all shared - * mutable state obeys "copy on write" semantics to ensure - * the changes are not seen by other readers. - *
- */
- @Override
- public synchronized Object clone() {
- throw new UnsupportedOperationException("This reader does not implement clone()");
- }
-
- /**
- * Clones the IndexReader and optionally changes readOnly. A readOnly
- * reader cannot open a writeable reader.
- * @throws CorruptIndexException if the index is corrupt
- * @throws IOException if there is a low-level IO error
- */
- public synchronized IndexReader clone(boolean openReadOnly) throws CorruptIndexException, IOException {
- throw new UnsupportedOperationException("This reader does not implement clone()");
- }
-
- /**
- * Returns the directory associated with this index. The Default
- * implementation returns the directory specified by subclasses when
- * delegating to the IndexReader(Directory) constructor, or throws an
- * UnsupportedOperationException if one was not specified.
- * @throws UnsupportedOperationException if no directory
- */
- public Directory directory() {
- ensureOpen();
- 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(final Directory directory2) throws CorruptIndexException, IOException {
- return ((Long) new SegmentInfos.FindSegmentsFile(directory2) {
- @Override
- public Object doBody(String segmentFileName) throws IOException {
- return Long.valueOf(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(Directory directory) throws CorruptIndexException, IOException {
- return SegmentInfos.readCurrentVersion(directory);
- }
-
- /**
- * Reads commitUserData, previously passed to {@link
- * IndexWriter#commit(Map)}, from current index
- * segments file. This will return null if {@link
- * IndexWriter#commit(Map)} has never been called for
- * this index.
- *
- * @param directory where the index resides.
- * @return commit userData.
- * @throws CorruptIndexException if the index is corrupt
- * @throws IOException if there is a low-level IO error
- *
- * @see #getCommitUserData()
- */
- public static Map If this reader is based on a Directory (ie, was
- * created by calling {@link #open}, or {@link #reopen} on
- * a reader based on a Directory), then this method
- * returns the version recorded in the commit that the
- * reader opened. This version is advanced every time
- * {@link IndexWriter#commit} is called. If instead this reader is a near real-time reader
- * (ie, obtained by a call to {@link
- * IndexWriter#getReader}, or by calling {@link #reopen}
- * on a near real-time reader), then this method returns
- * the version of the last commit done by the writer.
- * Note that even as further changes are made with the
- * writer, the version will not changed until a commit is
- * completed. Thus, you should not rely on this method to
- * determine when a near real-time reader should be
- * opened. Use {@link #isCurrent} instead. If this reader is based on a Directory (ie, was
- * created by calling {@link #open}, or {@link #reopen} on
- * a reader based on a Directory), then this method checks
- * if any further commits (see {@link IndexWriter#commit}
- * have occurred in that directory). If instead this reader is a near real-time reader
- * (ie, obtained by a call to {@link
- * IndexWriter#getReader}, or by calling {@link #reopen}
- * on a near real-time reader), then this method checks if
- * either a new commmit has occurred, or any new
- * uncommitted changes have taken place via the writer.
- * Note that even if the writer has only performed
- * merging, this method will still return false. In any event, if this returns false, you should call
- * {@link #reopen} to get a new reader that sees the
- * changes.
- * NOTE: for performance reasons, this method does not check if the
- * requested document is deleted, and therefore asking for a deleted document
- * may yield unspecified results. Usually this is not required, however you
- * can call {@link #isDeleted(int)} with the requested document ID to verify
- * the document is not deleted.
- *
- * @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();
- if (n < 0 || n >= maxDoc()) {
- throw new IllegalArgumentException("docID must be >= 0 and < maxDoc=" + maxDoc() + " (got docID=" + n + ")");
- }
- return document(n, null);
- }
-
- /**
- * Get the {@link org.apache.lucene.document.Document} at the
- * NOTE: for performance reasons, this method does not check if the
- * requested document is deleted, and therefore asking for a deleted document
- * may yield unspecified results. Usually this is not required, however you
- * can call {@link #isDeleted(int)} with the requested document ID to verify
- * the document is not deleted.
- *
- * @param n Get the document at the 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.
- *
- * Note: the TermDocs returned is unpositioned. Before using it, ensure
- * that you first position it with {@link TermDocs#seek(Term)} or
- * {@link TermDocs#seek(TermEnum)}.
- *
- * @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
- * This positional information facilitates phrase and proximity searching.
- * 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 NOTE: this method can only recover documents marked
- * for deletion but not yet removed from the index; when
- * and how Lucene removes deleted documents is an
- * implementation detail, subject to change from release
- * to release. However, you can use {@link
- * #numDeletedDocs} on the current IndexReader instance to
- * see how many documents will be un-deleted.
- *
- * @throws StaleReaderException if the index has changed
- * since this reader was opened
- * @throws LockObtainFailedException if another writer
- * has this index open (
- * NOTE: You should not try using sub-readers returned by
- * this method to make any changes (setNorm, deleteDocument,
- * etc.). While this might succeed for one composite reader
- * (like MultiReader), it will most likely lead to index
- * corruption for other readers (like DirectoryReader obtained
- * through {@link #open}. Use the parent reader directly. */
- public IndexReader[] getSequentialSubReaders() {
- return null;
- }
-
- /** Expert */
- public Object getCoreCacheKey() {
- return this;
- }
-
- /** Expert. Warning: this returns null if the reader has
- * no deletions */
- public Object getDeletesCacheKey() {
- return this;
- }
-
- /** Returns the number of unique terms (across all fields)
- * in this reader.
- *
- * This method returns long, even though internally
- * Lucene cannot handle more than 2^31 unique terms, for
- * a possible future when this limitation is removed.
- *
- * @throws UnsupportedOperationException if this count
- * cannot be easily determined (eg Multi*Readers).
- * Instead, you should call {@link
- * #getSequentialSubReaders} and ask each sub reader for
- * its unique term count. */
- public long getUniqueTermCount() throws IOException {
- throw new UnsupportedOperationException("this reader does not implement getUniqueTermCount()");
- }
-
- /** For IndexReader implementations that use
- * TermInfosReader to read terms, this returns the
- * current indexDivisor as specified when the reader was
- * opened.
- */
- public int getTermInfosIndexDivisor() {
- throw new UnsupportedOperationException("This reader does not support this method.");
- }
-}
true if the index is optimized; false 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 may either be of type {@link TermFreqVector}
- * or of type {@link TermPositionVector} 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
- * {@link TermPositionVector} 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 true if an index exists at the specified directory.
- * @param directory the directory to check for an index
- * @return true if an index exists; false otherwise
- * @throws IOException if there is a problem with accessing the index
- */
- public static boolean indexExists(Directory directory) throws IOException {
- try {
- new SegmentInfos().read(directory);
- return true;
- } catch (IOException ioe) {
- return false;
- }
- }
-
- /** 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 nth
- * Document in this index.
- * n
- * th position. The {@link FieldSelector} may be used to determine
- * what {@link org.apache.lucene.document.Field}s to load and how they should
- * be loaded. NOTE: If this Reader (more specifically, the underlying
- * FieldsReader) 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.
- * nth position
- * @param fieldSelector The {@link 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
- */
- // TODO (1.5): When we convert to JDK 1.5 make this Setwrite.lock could not
- * be obtained)
- * @throws IOException if there is a low-level IO error
- * @throws IllegalStateException if the field does not index norms
- */
- 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#decodeNormValue(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 (write.lock could not
- * be obtained)
- * @throws IOException if there is a low-level IO error
- * @deprecated Use {@link #setNorm(int, String, byte)} instead, encoding the
- * float to byte with your Similarity's {@link Similarity#encodeNormValue(float)}.
- * This method will be removed in Lucene 4.0
- */
- @Deprecated
- public void setNorm(int doc, String field, float value)
- throws StaleReaderException, CorruptIndexException, LockObtainFailedException, IOException {
- ensureOpen();
- setNorm(doc, field, Similarity.getDefault().encodeNormValue(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 t.
- * @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
- * term. For each document, the document number, the frequency of
- * the term in that document is also provided, for use in
- * search scoring. If term is null, then all non-deleted
- * docs are returned with freq=1.
- * Thus, this method implements the mapping:
- *
- * Term => <docNum, freq>*
- *
- * term. 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:
- *
- *
- * Term => <docNum, freq,
- * <pos1, pos2, ...
- * posfreq-1>
- * >*
- *
- * docNum. 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 (write.lock 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 docNum.
- * 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 term 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 (write.lock 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.
- *
- * write.lock 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();
- }
-
- /**
- * @param commitUserData Opaque Map (String -> String)
- * that's recorded into the segments file in the index,
- * and retrievable by {@link
- * IndexReader#getCommitUserData}.
- * @throws IOException
- */
- public final synchronized void flush(Map