Uses of Class
org.apache.lucene.index.CorruptIndexException

Packages that use CorruptIndexException
org.apache.lucene.benchmark.byTask.tasks Extendable benchmark tasks. 
org.apache.lucene.facet.taxonomy.directory Taxonomy implemented using a Lucene-Index 
org.apache.lucene.index Code to maintain and access indices. 
org.apache.lucene.search Code to search indices. 
org.apache.lucene.store.instantiated InstantiatedIndex, alternative RAM store for small corpora. 
 

Uses of CorruptIndexException in org.apache.lucene.benchmark.byTask.tasks
 

Methods in org.apache.lucene.benchmark.byTask.tasks that throw CorruptIndexException
static IndexWriter CreateIndexTask.configureWriter(Config config, PerfRunData runData, IndexWriterConfig.OpenMode mode, IndexCommit commit)
           
 

Uses of CorruptIndexException in org.apache.lucene.facet.taxonomy.directory
 

Methods in org.apache.lucene.facet.taxonomy.directory that throw CorruptIndexException
protected  int DirectoryTaxonomyWriter.addCategoryDocument(CategoryPath categoryPath, int length, int parent)
           
 void DirectoryTaxonomyWriter.close()
          Frees used resources as well as closes the underlying IndexWriter, which commits whatever changes made to it to the underlying Directory.
 void DirectoryTaxonomyWriter.commit()
          Calling commit() ensures that all the categories written so far are visible to a reader that is opened (or reopened) after that call.
 void DirectoryTaxonomyWriter.commit(Map<String,String> commitUserData)
          Like commit(), but also store properties with the index.
 CategoryPath DirectoryTaxonomyReader.getPath(int ordinal)
           
 boolean DirectoryTaxonomyReader.getPath(int ordinal, CategoryPath result)
           
protected  IndexReader DirectoryTaxonomyReader.openIndexReader(Directory directory)
           
 void DirectoryTaxonomyWriter.prepareCommit()
          prepare most of the work needed for a two-phase commit.
 void DirectoryTaxonomyWriter.prepareCommit(Map<String,String> commitUserData)
          Like above, and also prepares to store user data with the index.
 

Constructors in org.apache.lucene.facet.taxonomy.directory that throw CorruptIndexException
DirectoryTaxonomyWriter(Directory d)
           
DirectoryTaxonomyWriter(Directory directory, IndexWriterConfig.OpenMode openMode)
          Creates a new instance with a default cached as defined by DirectoryTaxonomyWriter.defaultTaxonomyWriterCache().
DirectoryTaxonomyWriter(Directory directory, IndexWriterConfig.OpenMode openMode, TaxonomyWriterCache cache)
          Construct a Taxonomy writer.
 

Uses of CorruptIndexException in org.apache.lucene.index
 

Subclasses of CorruptIndexException in org.apache.lucene.index
 class IndexFormatTooNewException
          This exception is thrown when Lucene detects an index that is newer than this Lucene version.
 class IndexFormatTooOldException
          This exception is thrown when Lucene detects an index that is too old for this Lucene version
 

Methods in org.apache.lucene.index that throw CorruptIndexException
 void IndexWriter.addDocument(Document doc)
          Adds a document to this index.
 void IndexWriter.addDocument(Document doc, Analyzer analyzer)
          Adds a document to this index, using the provided analyzer instead of the value of IndexWriter.getAnalyzer().
 void IndexWriter.addDocuments(Collection<Document> docs)
          Atomically adds a block of documents with sequentially assigned document IDs, such that an external reader will see all or none of the documents.
 void IndexWriter.addDocuments(Collection<Document> docs, Analyzer analyzer)
          Atomically adds a block of documents, analyzed using the provided analyzer, with sequentially assigned document IDs, such that an external reader will see all or none of the documents.
 void IndexWriter.addIndexes(Directory... dirs)
          Adds all segments from an array of indexes into this index.
 void IndexWriter.addIndexes(IndexReader... readers)
          Merges the provided indexes into this index.
 void IndexWriter.addIndexesNoOptimize(Directory... dirs)
          Deprecated. use IndexWriter.addIndexes(Directory...) instead
 IndexReader SegmentReader.clone(boolean openReadOnly)
           
 IndexReader IndexReader.clone(boolean openReadOnly)
          Clones the IndexReader and optionally changes readOnly.
 void IndexWriter.close()
          Commits all changes to an index and closes all associated files.
abstract  void MergeScheduler.close()
          Close this MergeScheduler.
 void PersistentSnapshotDeletionPolicy.close()
          Closes the index which writes the snapshots to the directory.
 void IndexWriter.close(boolean waitForMerges)
          Closes the index with or without waiting for currently running merges to finish.
 void IndexWriter.commit()
          Commits all pending changes (added & deleted documents, segment merges, added indexes, etc.) to the index, and syncs all referenced index files, such that a reader will see the changes and the index updates will survive an OS or machine crash or power loss.
 void IndexWriter.commit(Map<String,String> commitUserData)
          Commits all changes to the index, specifying a commitUserData Map (String -> String).
 void IndexReader.deleteDocument(int docNum)
          Deletes the document numbered docNum.
 void IndexWriter.deleteDocuments(Query... queries)
          Deletes the document(s) matching any of the provided queries.
 void IndexWriter.deleteDocuments(Query query)
          Deletes the document(s) matching the provided query.
 void IndexWriter.deleteDocuments(Term... terms)
          Deletes the document(s) containing any of the terms.
 void IndexWriter.deleteDocuments(Term term)
          Deletes the document(s) containing term.
 int IndexReader.deleteDocuments(Term term)
          Deletes all documents that have a given term indexed.
protected abstract  Object SegmentInfos.FindSegmentsFile.doBody(String segmentFileName)
          Subclass must implement this.
 Document IndexReader.document(int n)
          Returns the stored fields of the nth Document in this index.
 Document SegmentReader.document(int n, FieldSelector fieldSelector)
           
 Document FilterIndexReader.document(int n, FieldSelector fieldSelector)
           
 Document MultiReader.document(int n, FieldSelector fieldSelector)
           
abstract  Document IndexReader.document(int n, FieldSelector fieldSelector)
          Get the Document at the n th position.
 Document ParallelReader.document(int n, FieldSelector fieldSelector)
           
protected  void MultiPassIndexSplitter.FakeDeleteIndexReader.doDelete(int n)
           
protected  void FilterIndexReader.doDelete(int n)
           
protected  void MultiReader.doDelete(int n)
           
protected abstract  void IndexReader.doDelete(int docNum)
          Implements deletion of the document numbered docNum.
protected  void ParallelReader.doDelete(int n)
           
protected  IndexReader SegmentReader.doOpenIfChanged()
           
protected  IndexReader MultiReader.doOpenIfChanged()
          Tries to reopen the subreaders.
protected  IndexReader IndexReader.doOpenIfChanged()
          If the index has changed since it was opened, open and return a new reader; else, return null.
protected  IndexReader ParallelReader.doOpenIfChanged()
          Tries to reopen the subreaders.
protected  IndexReader SegmentReader.doOpenIfChanged(boolean openReadOnly)
           
protected  IndexReader MultiReader.doOpenIfChanged(boolean doClone)
          If clone is true then we clone each of the subreaders
protected  IndexReader IndexReader.doOpenIfChanged(boolean openReadOnly)
          If the index has changed since it was opened, open and return a new reader; else, return null.
protected  IndexReader IndexReader.doOpenIfChanged(IndexCommit commit)
          If the index has changed since it was opened, open and return a new reader; else, return null.
protected  IndexReader IndexReader.doOpenIfChanged(IndexWriter writer, boolean applyAllDeletes)
          If the index has changed since it was opened, open and return a new reader; else, return null.
protected  IndexReader ParallelReader.doReopen(boolean doClone)
           
protected  void FilterIndexReader.doSetNorm(int d, String f, byte b)
           
protected  void MultiReader.doSetNorm(int n, String field, byte value)
           
protected abstract  void IndexReader.doSetNorm(int doc, String field, byte value)
          Implements setNorm in subclass.
protected  void ParallelReader.doSetNorm(int n, String field, byte value)
           
protected  void MultiPassIndexSplitter.FakeDeleteIndexReader.doUndeleteAll()
          Just removes our overlaid deletions - does not undelete the original deletions.
protected  void FilterIndexReader.doUndeleteAll()
           
protected  void MultiReader.doUndeleteAll()
           
protected abstract  void IndexReader.doUndeleteAll()
          Implements actual undeleteAll() in subclass.
protected  void ParallelReader.doUndeleteAll()
           
 void IndexWriter.expungeDeletes()
          Deprecated.  
 void IndexWriter.expungeDeletes(boolean doWait)
          Deprecated.  
 MergePolicy.MergeSpecification BalancedSegmentMergePolicy.findForcedDeletesMerges(SegmentInfos infos)
           
abstract  MergePolicy.MergeSpecification MergePolicy.findForcedDeletesMerges(SegmentInfos segmentInfos)
          Determine what set of merge operations is necessary in order to expunge all deletes from the index.
 MergePolicy.MergeSpecification TieredMergePolicy.findForcedDeletesMerges(SegmentInfos infos)
           
 MergePolicy.MergeSpecification LogMergePolicy.findForcedDeletesMerges(SegmentInfos segmentInfos)
          Finds merges necessary to force-merge all deletes from the index.
 MergePolicy.MergeSpecification NoMergePolicy.findForcedDeletesMerges(SegmentInfos segmentInfos)
           
 MergePolicy.MergeSpecification UpgradeIndexMergePolicy.findForcedDeletesMerges(SegmentInfos segmentInfos)
           
abstract  MergePolicy.MergeSpecification MergePolicy.findForcedMerges(SegmentInfos segmentInfos, int maxSegmentCount, Map<SegmentInfo,Boolean> segmentsToMerge)
          Determine what set of merge operations is necessary in order to merge to <= the specified segment count.
 MergePolicy.MergeSpecification NoMergePolicy.findForcedMerges(SegmentInfos segmentInfos, int maxSegmentCount, Map<SegmentInfo,Boolean> segmentsToMerge)
           
 MergePolicy.MergeSpecification UpgradeIndexMergePolicy.findForcedMerges(SegmentInfos segmentInfos, int maxSegmentCount, Map<SegmentInfo,Boolean> segmentsToMerge)
           
abstract  MergePolicy.MergeSpecification MergePolicy.findMerges(SegmentInfos segmentInfos)
          Determine what set of merge operations are now necessary on the index.
 MergePolicy.MergeSpecification NoMergePolicy.findMerges(SegmentInfos segmentInfos)
           
 MergePolicy.MergeSpecification UpgradeIndexMergePolicy.findMerges(SegmentInfos segmentInfos)
           
protected  void IndexWriter.flush(boolean triggerMerge, boolean applyAllDeletes)
          Flush all in-memory buffered updates (adds and deletes) to the Directory.
protected  void IndexWriter.flush(boolean triggerMerge, boolean flushDocStores, boolean flushDeletes)
          NOTE: flushDocStores is ignored now (hardwired to true); this method is only here for backwards compatibility
 void IndexWriter.forceMerge(int maxNumSegments)
          Forces merge policy to merge segments until there's <= maxNumSegments.
 void IndexWriter.forceMerge(int maxNumSegments, boolean doWait)
          Just like IndexWriter.forceMerge(int), except you can specify whether the call should block until all merging completes.
 void IndexWriter.forceMergeDeletes()
          Forces merging of all segments that have deleted documents.
 void IndexWriter.forceMergeDeletes(boolean doWait)
          Just like IndexWriter.forceMergeDeletes(), except you can specify whether the call should block until the operation completes.
static SegmentReader SegmentReader.get(boolean readOnly, Directory dir, SegmentInfo si, int readBufferSize, boolean doOpenStores, int termInfosIndexDivisor)
           
static SegmentReader SegmentReader.get(boolean readOnly, SegmentInfo si, int termInfosIndexDivisor)
           
static Map<String,String> IndexReader.getCommitUserData(Directory directory)
          Reads commitUserData, previously passed to IndexWriter.commit(Map), from current index segments file.
static long IndexReader.getCurrentVersion(Directory directory)
          Reads version number from segments files.
 boolean FilterIndexReader.isCurrent()
           
 boolean MultiReader.isCurrent()
          Checks recursively if all subreaders are up to date.
 boolean IndexReader.isCurrent()
          Check whether any new changes have occurred to the index since this reader was opened.
 boolean ParallelReader.isCurrent()
          Checks recursively if all subreaders are up to date.
static long IndexReader.lastModified(Directory directory2)
          Returns the time the index in the named directory was last modified.
 void IndexWriter.maybeMerge()
          Expert: asks the mergePolicy whether any merges are necessary now and if so, runs the requested merges and then iterate (test again if merges are needed) until no more merges are returned by the mergePolicy.
 void NoMergeScheduler.merge(IndexWriter writer)
           
 void SerialMergeScheduler.merge(IndexWriter writer)
          Just do the merges in sequence.
abstract  void MergeScheduler.merge(IndexWriter writer)
          Run the merges provided by IndexWriter.getNextMerge().
 void IndexWriter.merge(MergePolicy.OneMerge merge)
          Merges the indicated segments, replacing them in the stack with a single segment.
static IndexReader IndexReader.open(Directory directory)
          Returns a IndexReader reading the index in the given Directory, with readOnly=true.
static IndexReader IndexReader.open(Directory directory, boolean readOnly)
          Returns an IndexReader reading the index in the given Directory.
static IndexReader IndexReader.open(Directory directory, IndexDeletionPolicy deletionPolicy, boolean readOnly)
          Expert: returns an IndexReader reading the index in the given Directory, with a custom IndexDeletionPolicy.
static IndexReader IndexReader.open(Directory directory, IndexDeletionPolicy deletionPolicy, boolean readOnly, int termInfosIndexDivisor)
          Expert: returns an IndexReader reading the index in the given Directory, with a custom IndexDeletionPolicy.
static IndexReader IndexReader.open(IndexCommit commit, boolean readOnly)
          Expert: returns an IndexReader reading the index in the given IndexCommit.
static IndexReader IndexReader.open(IndexCommit commit, IndexDeletionPolicy deletionPolicy, boolean readOnly)
          Expert: returns an IndexReader reading the index in the given Directory, using a specific commit and with a custom IndexDeletionPolicy.
static IndexReader IndexReader.open(IndexCommit commit, IndexDeletionPolicy deletionPolicy, boolean readOnly, int termInfosIndexDivisor)
          Expert: returns an IndexReader reading the index in the given Directory, using a specific commit and with a custom IndexDeletionPolicy.
static IndexReader IndexReader.open(IndexWriter writer, boolean applyAllDeletes)
          Open a near real time IndexReader from the IndexWriter.
 void IndexWriter.optimize()
          Deprecated.  
 void IndexWriter.optimize(boolean doWait)
          Deprecated.  
 void IndexWriter.optimize(int maxNumSegments)
          Deprecated.  
 void IndexWriter.prepareCommit()
          Expert: prepare for commit.
 void IndexWriter.prepareCommit(Map<String,String> commitUserData)
          Expert: prepare for commit, specifying commitUserData Map (String -> String).
 void SegmentInfos.read(Directory directory)
          This version of read uses the retry logic (for lock-less commits) to find the right segments file to load.
 void SegmentInfos.read(Directory directory, String segmentFileName)
          Read a particular segmentFileName.
static Map<String,String> SegmentInfos.readCurrentUserData(Directory directory)
          Returns userData from latest segments file
static long SegmentInfos.readCurrentVersion(Directory directory)
          Current version number from segments file.
 IndexReader IndexReader.reopen()
          Deprecated. Use IndexReader#openIfChanged(IndexReader) instead
 IndexReader IndexReader.reopen(boolean openReadOnly)
          Deprecated. Use IndexReader#openIfChanged(IndexReader,boolean) instead
 IndexReader IndexReader.reopen(IndexCommit commit)
          Deprecated. Use IndexReader#openIfChanged(IndexReader,IndexCommit) instead
 IndexReader IndexReader.reopen(IndexWriter writer, boolean applyAllDeletes)
          Deprecated. Use IndexReader#openIfChanged(IndexReader,IndexReader,boolean) instead
 Object SegmentInfos.FindSegmentsFile.run()
           
 Object SegmentInfos.FindSegmentsFile.run(IndexCommit commit)
           
 void IndexWriter.setMergeScheduler(MergeScheduler mergeScheduler)
          Deprecated. use IndexWriterConfig.setMergeScheduler(MergeScheduler) instead
 void IndexReader.setNorm(int doc, String field, byte value)
          Expert: Resets the normalization factor for the named field of the named document.
 void IndexReader.setNorm(int doc, String field, float value)
          Deprecated. Use IndexReader.setNorm(int, String, byte) instead, encoding the float to byte with your Similarity's Similarity.encodeNormValue(float). This method will be removed in Lucene 4.0
 void IndexReader.undeleteAll()
          Undeletes all documents currently marked as deleted in this index.
 void IndexWriter.updateDocument(Term term, Document doc)
          Updates a document by first deleting the document(s) containing term and then adding the new document.
 void IndexWriter.updateDocument(Term term, Document doc, Analyzer analyzer)
          Updates a document by first deleting the document(s) containing term and then adding the new document.
 void IndexWriter.updateDocuments(Term delTerm, Collection<Document> docs)
          Atomically deletes documents matching the provided delTerm and adds a block of documents with sequentially assigned document IDs, such that an external reader will see all or none of the documents.
 void IndexWriter.updateDocuments(Term delTerm, Collection<Document> docs, Analyzer analyzer)
          Atomically deletes documents matching the provided delTerm and adds a block of documents, analyzed using the provided analyzer, with sequentially assigned document IDs, such that an external reader will see all or none of the documents.
 

Constructors in org.apache.lucene.index that throw CorruptIndexException
IndexWriter(Directory d, Analyzer a, boolean create, IndexDeletionPolicy deletionPolicy, IndexWriter.MaxFieldLength mfl)
          Deprecated. use IndexWriter.IndexWriter(Directory, IndexWriterConfig) instead
IndexWriter(Directory d, Analyzer a, boolean create, IndexWriter.MaxFieldLength mfl)
          Deprecated. use IndexWriter.IndexWriter(Directory, IndexWriterConfig) instead
IndexWriter(Directory d, Analyzer a, IndexDeletionPolicy deletionPolicy, IndexWriter.MaxFieldLength mfl)
          Deprecated. use IndexWriter.IndexWriter(Directory, IndexWriterConfig) instead
IndexWriter(Directory d, Analyzer a, IndexDeletionPolicy deletionPolicy, IndexWriter.MaxFieldLength mfl, IndexCommit commit)
          Deprecated. use IndexWriter.IndexWriter(Directory, IndexWriterConfig) instead
IndexWriter(Directory d, Analyzer a, IndexWriter.MaxFieldLength mfl)
          Deprecated. use IndexWriter.IndexWriter(Directory, IndexWriterConfig) instead
IndexWriter(Directory d, IndexWriterConfig conf)
          Constructs a new IndexWriter per the settings given in conf.
PersistentSnapshotDeletionPolicy(IndexDeletionPolicy primary, Directory dir, IndexWriterConfig.OpenMode mode, Version matchVersion)
          PersistentSnapshotDeletionPolicy wraps another IndexDeletionPolicy to enable flexible snapshotting.
 

Uses of CorruptIndexException in org.apache.lucene.search
 

Methods in org.apache.lucene.search that throw CorruptIndexException
 long NRTManager.addIndexes(Directory... dirs)
           
 long NRTManager.addIndexes(IndexReader... readers)
           
 Document RemoteSearchable.doc(int i)
          Deprecated.  
abstract  Document Searcher.doc(int i)
          Deprecated.  
 Document MultiSearcher.doc(int n)
          Deprecated.  
 Document IndexSearcher.doc(int docID)
           
 Document Searchable.doc(int i)
          Deprecated. Returns the stored fields of document i.
 Document RemoteSearchable.doc(int i, FieldSelector fieldSelector)
          Deprecated.  
abstract  Document Searcher.doc(int docid, FieldSelector fieldSelector)
          Deprecated.  
 Document MultiSearcher.doc(int n, FieldSelector fieldSelector)
          Deprecated.  
 Document IndexSearcher.doc(int docID, FieldSelector fieldSelector)
           
 Document Searchable.doc(int n, FieldSelector fieldSelector)
          Deprecated. Get the Document at the nth position.
 boolean SearcherManager.isSearcherCurrent()
          Returns true if no changes have occured since this searcher ie.
 

Constructors in org.apache.lucene.search that throw CorruptIndexException
IndexSearcher(Directory path)
          Deprecated. use IndexSearcher.IndexSearcher(IndexReader) instead.
IndexSearcher(Directory path, boolean readOnly)
          Deprecated. Use IndexSearcher.IndexSearcher(IndexReader) instead.
 

Uses of CorruptIndexException in org.apache.lucene.store.instantiated
 

Methods in org.apache.lucene.store.instantiated that throw CorruptIndexException
 Document InstantiatedIndexReader.document(int n, FieldSelector fieldSelector)
          Return the Document at the nth position.
 



Copyright © 2000-2011 Apache Software Foundation. All Rights Reserved.