/** * If the IndexCommit differs from what the * provided reader is searching, open and return a new * reader; else, return null. * * @see #openIfChanged(DirectoryReader) */ public static DirectoryReader openIfChanged(DirectoryReader oldReader, IndexCommit commit) throws IOException { final DirectoryReader newReader = oldReader.doOpenIfChanged(commit); assert newReader != oldReader; return newReader; }
/** * Expert: Opens a new reader, if there are any changes, controlling whether past deletions should be applied. * * @see #openIfChanged(DirectoryReader,IndexWriter) * * @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 if there is a low-level IO error * * @lucene.experimental */ public static DirectoryReader openIfChanged(DirectoryReader oldReader, IndexWriter writer, boolean applyAllDeletes) throws IOException { final DirectoryReader newReader = oldReader.doOpenIfChanged(writer, applyAllDeletes); assert newReader != oldReader; return newReader; }
/** * If the index has changed since the provided reader was * opened, open and return a new reader; else, return * null. The new reader, if not null, will be the same * type of reader as the previous one, ie an NRT reader * will open a new NRT reader, a MultiReader will open a * new MultiReader, etc. * * <p>This method is typically far less costly than opening a * fully new <code>DirectoryReader</code> as it shares * resources (for example sub-readers) with the provided * <code>DirectoryReader</code>, when possible. * * <p>The provided reader is not closed (you are responsible * for doing so); if a new reader is returned you also * must eventually close it. Be sure to never close a * reader while other threads are still using it; see * {@link SearcherManager} to simplify managing this. * * @throws CorruptIndexException if the index is corrupt * @throws IOException if there is a low-level IO error * @return null if there are no changes; else, a new * DirectoryReader instance which you must eventually close */ public static DirectoryReader openIfChanged(DirectoryReader oldReader) throws IOException { final DirectoryReader newReader = oldReader.doOpenIfChanged(); assert newReader != oldReader; return newReader; }
@Override protected final DirectoryReader doOpenIfChanged() throws IOException { return wrapDirectoryReader(in.doOpenIfChanged()); }
@Override protected final DirectoryReader doOpenIfChanged(IndexWriter writer, boolean applyAllDeletes) throws IOException { return wrapDirectoryReader(in.doOpenIfChanged(writer, applyAllDeletes)); }
@Override protected final DirectoryReader doOpenIfChanged(IndexCommit commit) throws IOException { return wrapDirectoryReader(in.doOpenIfChanged(commit)); }
/** * If the IndexCommit differs from what the * provided reader is searching, open and return a new * reader; else, return null. * * @see #openIfChanged(DirectoryReader) */ public static DirectoryReader openIfChanged(DirectoryReader oldReader, IndexCommit commit) throws IOException { final DirectoryReader newReader = oldReader.doOpenIfChanged(commit); assert newReader != oldReader; return newReader; }
/** * If the IndexCommit differs from what the * provided reader is searching, open and return a new * reader; else, return null. * * @see #openIfChanged(DirectoryReader) */ public static DirectoryReader openIfChanged(DirectoryReader oldReader, IndexCommit commit) throws IOException { final DirectoryReader newReader = oldReader.doOpenIfChanged(commit); assert newReader != oldReader; return newReader; }
/** * If the IndexCommit differs from what the * provided reader is searching, open and return a new * reader; else, return null. * * @see #openIfChanged(DirectoryReader) */ public static DirectoryReader openIfChanged(DirectoryReader oldReader, IndexCommit commit) throws IOException { final DirectoryReader newReader = oldReader.doOpenIfChanged(commit); assert newReader != oldReader; return newReader; }
/** * Expert: Opens a new reader, if there are any changes, controlling whether past deletions should be applied. * * @see #openIfChanged(DirectoryReader,IndexWriter) * * @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 if there is a low-level IO error * * @lucene.experimental */ public static DirectoryReader openIfChanged(DirectoryReader oldReader, IndexWriter writer, boolean applyAllDeletes) throws IOException { final DirectoryReader newReader = oldReader.doOpenIfChanged(writer, applyAllDeletes); assert newReader != oldReader; return newReader; }
/** * Expert: Opens a new reader, if there are any changes, controlling whether past deletions should be applied. * * @see #openIfChanged(DirectoryReader,IndexWriter) * * @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 if there is a low-level IO error * * @lucene.experimental */ public static DirectoryReader openIfChanged(DirectoryReader oldReader, IndexWriter writer, boolean applyAllDeletes) throws IOException { final DirectoryReader newReader = oldReader.doOpenIfChanged(writer, applyAllDeletes); assert newReader != oldReader; return newReader; }
@Override protected final DirectoryReader doOpenIfChanged(IndexWriter writer, boolean applyAllDeletes) throws IOException { return wrapDirectoryReader(in.doOpenIfChanged(writer, applyAllDeletes)); }
@Override protected final DirectoryReader doOpenIfChanged() throws IOException { return wrapDirectoryReader(in.doOpenIfChanged()); }
@Override protected final DirectoryReader doOpenIfChanged(IndexCommit commit) throws IOException { return wrapDirectoryReader(in.doOpenIfChanged(commit)); }
@Override protected final DirectoryReader doOpenIfChanged() throws IOException { return wrapDirectoryReader(in.doOpenIfChanged()); }
@Override protected final DirectoryReader doOpenIfChanged(IndexCommit commit) throws IOException { return wrapDirectoryReader(in.doOpenIfChanged(commit)); }
@Override protected final DirectoryReader doOpenIfChanged() throws IOException { return wrapDirectoryReader(in.doOpenIfChanged()); }
@Override protected final DirectoryReader doOpenIfChanged(IndexWriter writer, boolean applyAllDeletes) throws IOException { return wrapDirectoryReader(in.doOpenIfChanged(writer, applyAllDeletes)); }
@Override protected final DirectoryReader doOpenIfChanged(IndexWriter writer, boolean applyAllDeletes) throws IOException { return wrapDirectoryReader(in.doOpenIfChanged(writer, applyAllDeletes)); }
@Override protected final DirectoryReader doOpenIfChanged(IndexCommit commit) throws IOException { return wrapDirectoryReader(in.doOpenIfChanged(commit)); }