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

Packages that use CorruptIndexException
org.apache.lucene.codecs Codecs API: API for customization of the encoding and structure of the index. 
org.apache.lucene.codecs.lucene40 Lucene 4.0 file format. 
org.apache.lucene.codecs.simpletext Simpletext Codec: writes human readable postings. 
org.apache.lucene.index Code to maintain and access indices. 
org.apache.lucene.search Code to search indices. 
 

Uses of CorruptIndexException in org.apache.lucene.codecs
 

Methods in org.apache.lucene.codecs that throw CorruptIndexException
abstract  void StoredFieldsReader.visitDocument(int n, StoredFieldVisitor visitor)
          Visit the stored fields for document n
 

Uses of CorruptIndexException in org.apache.lucene.codecs.lucene40
 

Methods in org.apache.lucene.codecs.lucene40 that throw CorruptIndexException
 void Lucene40StoredFieldsReader.visitDocument(int n, StoredFieldVisitor visitor)
           
 

Constructors in org.apache.lucene.codecs.lucene40 that throw CorruptIndexException
Lucene40TermVectorsReader(Directory d, SegmentInfo si, FieldInfos fieldInfos, IOContext context)
           
 

Uses of CorruptIndexException in org.apache.lucene.codecs.simpletext
 

Methods in org.apache.lucene.codecs.simpletext that throw CorruptIndexException
 void SimpleTextStoredFieldsReader.visitDocument(int n, StoredFieldVisitor visitor)
           
 

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(Iterable<? extends IndexableField> doc)
          Adds a document to this index.
 void IndexWriter.addDocument(Iterable<? extends IndexableField> doc, Analyzer analyzer)
          Adds a document to this index, using the provided analyzer instead of the value of IndexWriter.getAnalyzer().
 void IndexWriter.addDocuments(Iterable<? extends Iterable<? extends IndexableField>> 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(Iterable<? extends Iterable<? extends IndexableField>> 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.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 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.
protected abstract  Object SegmentInfos.FindSegmentsFile.doBody(String segmentFileName)
          Subclass must implement this.
 Document IndexReader.document(int docID)
          Returns the stored fields of the nth Document in this index.
 Document IndexReader.document(int docID, Set<String> fieldsToLoad)
          Like IndexReader.document(int) but only loads the specified fields.
abstract  void IndexReader.document(int docID, StoredFieldVisitor visitor)
          Expert: visits the fields of a stored document, for custom processing/loading of each field.
 void SegmentReader.document(int docID, StoredFieldVisitor visitor)
           
 void BaseCompositeReader.document(int docID, StoredFieldVisitor visitor)
           
 void FilterAtomicReader.document(int docID, StoredFieldVisitor visitor)
           
 void ParallelAtomicReader.document(int docID, StoredFieldVisitor visitor)
           
 void SlowCompositeReaderWrapper.document(int docID, StoredFieldVisitor visitor)
           
protected abstract  DirectoryReader DirectoryReader.doOpenIfChanged()
          Implement this method to support DirectoryReader.openIfChanged(DirectoryReader).
protected abstract  DirectoryReader DirectoryReader.doOpenIfChanged(IndexCommit commit)
          Implement this method to support DirectoryReader.openIfChanged(DirectoryReader,IndexCommit).
protected abstract  DirectoryReader DirectoryReader.doOpenIfChanged(IndexWriter writer, boolean applyAllDeletes)
          Implement this method to support DirectoryReader.openIfChanged(DirectoryReader,IndexWriter,boolean).
 MergePolicy.MergeSpecification TieredMergePolicy.findForcedDeletesMerges(SegmentInfos infos)
           
 MergePolicy.MergeSpecification LogMergePolicy.findForcedDeletesMerges(SegmentInfos segmentInfos)
          Finds merges necessary to force-merge all deletes from the index.
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 UpgradeIndexMergePolicy.findForcedDeletesMerges(SegmentInfos segmentInfos)
           
 MergePolicy.MergeSpecification NoMergePolicy.findForcedDeletesMerges(SegmentInfos segmentInfos)
           
abstract  MergePolicy.MergeSpecification MergePolicy.findForcedMerges(SegmentInfos segmentInfos, int maxSegmentCount, Map<SegmentInfoPerCommit,Boolean> segmentsToMerge)
          Determine what set of merge operations is necessary in order to merge to <= the specified segment count.
 MergePolicy.MergeSpecification UpgradeIndexMergePolicy.findForcedMerges(SegmentInfos segmentInfos, int maxSegmentCount, Map<SegmentInfoPerCommit,Boolean> segmentsToMerge)
           
 MergePolicy.MergeSpecification NoMergePolicy.findForcedMerges(SegmentInfos segmentInfos, int maxSegmentCount, Map<SegmentInfoPerCommit,Boolean> segmentsToMerge)
           
abstract  MergePolicy.MergeSpecification MergePolicy.findMerges(SegmentInfos segmentInfos)
          Determine what set of merge operations are now necessary on the index.
 MergePolicy.MergeSpecification UpgradeIndexMergePolicy.findMerges(SegmentInfos segmentInfos)
           
 MergePolicy.MergeSpecification NoMergePolicy.findMerges(SegmentInfos segmentInfos)
           
protected  void IndexWriter.flush(boolean triggerMerge, boolean applyAllDeletes)
          Flush all in-memory buffered updates (adds and deletes) to the Directory.
 void IndexWriter.forceMerge(int maxNumSegments)
          Forces merge policy to merge segments until there are <= 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.
abstract  IndexCommit DirectoryReader.getIndexCommit()
          Expert: return the IndexCommit that this reader has opened.
abstract  boolean DirectoryReader.isCurrent()
          Check whether any new changes have occurred to the index since this reader was opened.
 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)
           
abstract  void MergeScheduler.merge(IndexWriter writer)
          Run the merges provided by IndexWriter.getNextMerge().
 void SerialMergeScheduler.merge(IndexWriter writer)
          Just do the merges in sequence.
 void IndexWriter.merge(MergePolicy.OneMerge merge)
          Merges the indicated segments, replacing them in the stack with a single segment.
static DirectoryReader IndexReader.open(Directory directory)
          Deprecated. Use DirectoryReader.open(Directory)
static DirectoryReader DirectoryReader.open(Directory directory)
          Returns a IndexReader reading the index in the given Directory
static DirectoryReader IndexReader.open(Directory directory, int termInfosIndexDivisor)
          Deprecated. Use DirectoryReader.open(Directory,int)
static DirectoryReader DirectoryReader.open(Directory directory, int termInfosIndexDivisor)
          Expert: Returns a IndexReader reading the index in the given Directory with the given termInfosIndexDivisor.
static DirectoryReader IndexReader.open(IndexCommit commit)
          Deprecated. Use DirectoryReader.open(IndexCommit)
static DirectoryReader DirectoryReader.open(IndexCommit commit)
          Expert: returns an IndexReader reading the index in the given IndexCommit.
static DirectoryReader IndexReader.open(IndexCommit commit, int termInfosIndexDivisor)
          Deprecated. Use DirectoryReader.open(IndexCommit,int)
static DirectoryReader DirectoryReader.open(IndexCommit commit, int termInfosIndexDivisor)
          Expert: returns an IndexReader reading the index in the given IndexCommit and termInfosIndexDivisor.
static DirectoryReader IndexReader.open(IndexWriter writer, boolean applyAllDeletes)
          Deprecated. Use DirectoryReader.open(IndexWriter,boolean)
static DirectoryReader DirectoryReader.open(IndexWriter writer, boolean applyAllDeletes)
          Open a near real time IndexReader from the IndexWriter.
 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)
           
 void SegmentInfos.read(Directory directory, String segmentFileName)
          Read a particular segmentFileName.
 Object SegmentInfos.FindSegmentsFile.run()
           
 Object SegmentInfos.FindSegmentsFile.run(IndexCommit commit)
           
 void IndexWriter.updateDocument(Term term, Iterable<? extends IndexableField> doc)
          Updates a document by first deleting the document(s) containing term and then adding the new document.
 void IndexWriter.updateDocument(Term term, Iterable<? extends IndexableField> 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, Iterable<? extends Iterable<? extends IndexableField>> 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, Iterable<? extends Iterable<? extends IndexableField>> 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
DirectoryReader(Directory directory, AtomicReader[] segmentReaders)
          Expert: Constructs a DirectoryReader on the given subReaders.
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.TrackingIndexWriter.addIndexes(Directory... dirs)
           
 long NRTManager.TrackingIndexWriter.addIndexes(IndexReader... readers)
           
 Document IndexSearcher.doc(int docID)
          Sugar for .getIndexReader().document(docID)
 void IndexSearcher.doc(int docID, StoredFieldVisitor fieldVisitor)
          Sugar for .getIndexReader().document(docID, fieldVisitor)
 Document IndexSearcher.document(int docID, Set<String> fieldsToLoad)
          Sugar for .getIndexReader().document(docID, fieldsToLoad)
 



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