Package Lucene.Net.Index

Namespaces
package	Memory

Classes
class	FieldEnumerator< T >
	More...
class	TermDocEnumerator
	Class to handle creating a TermDocs and allowing for seeking and enumeration. Used when you have a set of one or moreterms for which you want to enumerate over the documents that contain those terms. More...
class	StringFieldEnumerator
	Implementation for enumerating over terms with a string value. More...
class	NumericFieldEnum< T >
	Base for enumerating over numeric fields. More...
class	IntFieldEnumerator
	Implementation for enumerating over all of the terms in an int numeric field. More...
class	FloatFieldEnumerator
	Implementation for enumerating over all of the terms in a float numeric field. More...
class	DoubleFieldEnumerator
	Implementation for enumerating over all of the terms in a double numeric field. More...
class	LongFieldEnumerator
	Implementation for enumerating over all of the terms in a long numeric field. More...
class	SegmentsGenCommit
	Class that will force an index writer to open an index based on the generation in the segments.gen file as opposed to the highest generation found in a directory listing. More...
class	TermVectorEnumerator
	Class to allow for enumerating over the documents in the index to retrieve the term vector for each one. More...
class	EmptyVector
	A simple TermFreqVector implementation for an empty vector for use with a deleted document or a document that does not have the field that is being enumerated. More...
class	AbstractAllTermDocs
	Base class for enumerating all but deleted docs. More...
class	AllTermDocs
class	BufferedDeletes
	Holds buffered deletes, by docID, term or query. We hold two instances of this class: one for the deletes prior to the last flush, the other for deletes after the last flush. This is so if we need to abort (discard all buffered docs) we can also discard the buffered deletes yet keep the deletes done during previously flushed segments. More...
class	ByteBlockPool
class	ByteSliceReader
class	ByteSliceWriter
	Class to write byte streams into slices of shared byte[]. This is used by DocumentsWriter to hold the posting list for many terms in RAM. More...
class	CharBlockPool
class	CheckIndex
	Basic tool and API to check the health of an index and write a new segments file that removes reference to problematic segments. More...
class	CompoundFileReader
	Class for accessing a compound stream. This class implements a directory, but is limited to only read operations. Directory methods that would normally modify data throw an exception. More...
class	CompoundFileWriter
	Combines multiple files into a single compound file. The file format: VInt fileCount {Directory} fileCount entries with the following structure: long dataOffset String fileName {File Data} fileCount entries with the raw data of the corresponding file More...
class	ConcurrentMergeScheduler
	A MergeScheduler that runs each merge using a separate thread, up until a maximum number of threads (MaxThreadCount) at which when a merge is needed, the thread(s) that are updating the index will pause until one or more merges completes. This is a simple way to use concurrency in the indexing process without having to create and manage application level threads. More...
class	CorruptIndexException
	This exception is thrown when Lucene detects an inconsistency in the index. More...
class	DefaultSkipListReader
	Implements the skip list reader for the default posting list format that stores positions and payloads. More...
class	DefaultSkipListWriter
	Implements the skip list writer for the default posting list format that stores positions and payloads. More...
class	DirectoryReader
	An IndexReader which reads indexes with multiple segments. More...
class	DocConsumer
class	DocConsumerPerThread
class	DocFieldConsumer
class	DocFieldConsumerPerField
class	DocFieldConsumerPerThread
class	DocFieldConsumers
	This is just a "splitter" class: it lets you wrap two DocFieldConsumer instances as a single consumer. More...
class	DocFieldConsumersPerField
class	DocFieldConsumersPerThread
class	DocFieldProcessor
	This is a DocConsumer that gathers all fields under the same name, and calls per-field consumers to process field by field. This class doesn't doesn't do any "real" work of its own: it just forwards the fields to a DocFieldConsumer. More...
class	DocFieldProcessorPerField
	Holds all per thread, per field state. More...
class	DocFieldProcessorPerThread
	Gathers all Fieldables for a document under the same name, updates FieldInfos, and calls per-field consumers to process field by field. More...
class	DocInverter
	This is a DocFieldConsumer that inverts each field, separately, from a Document, and accepts a InvertedTermsConsumer to process those terms. More...
class	DocInverterPerField
	Holds state for inverting all occurrences of a single field in the document. This class doesn't do anything itself; instead, it forwards the tokens produced by analysis to its own consumer (InvertedDocConsumerPerField). It also interacts with an endConsumer (InvertedDocEndConsumerPerField). More...
class	DocInverterPerThread
	This is a DocFieldConsumer that inverts each field, separately, from a Document, and accepts a InvertedTermsConsumer to process those terms. More...
class	DocumentsWriter
	This class accepts multiple added documents and directly writes a single segment file. It does this more efficiently than creating a single segment per document (with DocumentWriter) and doing standard merges on those segments. More...
class	DocumentsWriterThreadState
	Used by DocumentsWriter to maintain per-thread state. We keep a separate Posting hash and other state for each thread and then merge postings hashes from all threads when writing the segment. More...
class	FieldInfo
class	FieldInfos
	Access to the Fieldable Info file that describes document fields and whether or not they are indexed. Each segment has a separate Fieldable Info file. Objects of this class are thread-safe for multiple readers, but only one thread can be adding documents at a time, with no other reader or writer threads accessing this object. More...
class	FieldInvertState
	This class tracks the number and position / offset parameters of terms being added to the index. The information collected in this class is also used to calculate the normalization factor for a field. More...
class	FieldReaderException
	More...
class	FieldSortedTermVectorMapper
	For each Field, store a sorted collection of TermVectorEntrys This is not thread-safe. More...
class	FieldsReader
	Class responsible for access to stored document fields. It uses <segment>.fdt and <segment>.fdx; files. More...
class	FieldsWriter
class	FilterIndexReader
	A FilterIndexReader contains another IndexReader, which it uses as its basic source of data, possibly transforming the data along the way or providing additional functionality. The class FilterIndexReader itself simply implements all abstract methods of IndexReader with versions that pass all requests to the contained index reader. Subclasses of FilterIndexReader may further override some of these methods and may also provide additional methods and fields. More...
class	FormatPostingsDocsConsumer
	NOTE: this API is experimental and will likely change More...
class	FormatPostingsDocsWriter
	Consumes doc and freq, writing them using the current index file format More...
class	FormatPostingsFieldsConsumer
	Abstract API that consumes terms, doc, freq, prox and payloads postings. Concrete implementations of this actually do "something" with the postings (write it into the index in a specific format). More...
class	FormatPostingsFieldsWriter
class	FormatPostingsPositionsConsumer
class	FormatPostingsPositionsWriter
class	FormatPostingsTermsConsumer
	NOTE: this API is experimental and will likely change More...
class	FormatPostingsTermsWriter
class	FreqProxFieldMergeState
	Used by DocumentsWriter to merge the postings from multiple ThreadStates when creating a segment More...
class	FreqProxTermsWriter
class	FreqProxTermsWriterPerField
class	FreqProxTermsWriterPerThread
class	IndexCommit
	Expert: represents a single commit into an index as seen by the IndexDeletionPolicy or IndexReader. More...
interface	IndexDeletionPolicy
	Expert: policy for deletion of stale index commits. More...
class	IndexFileDeleter
	More...
class	IndexFileNameFilter
	Filename filter that accept filenames and extensions only created by Lucene. More...
class	IndexFileNames
	Useful constants representing filenames and extensions used by lucene More...
class	IndexReader
	IndexReader is an abstract class, providing an interface for accessing an index. Search of an index is done entirely through this abstract interface, so that any subclass which implements it is searchable. Concrete subclasses of IndexReader are usually constructed with a call to one of the static open() methods, e.g. Open(Lucene.Net.Store.Directory, bool) 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 accepts the boolean readOnly parameter. Such a reader has better better concurrency as it's not necessary to synchronize on the isDeleted method. You must explicitly specify false if you want to make changes with the resulting IndexReader. NOTE: 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. More...
class	IndexWriter
	An IndexWriter creates and maintains an index. The create argument to the constructor determines whether a new index is created, or whether an existing index is opened. Note that you can open an index with create=true even while readers are using the index. The old readers will continue to search the "point in time" snapshot they had opened, and won't see the newly created index until they re-open. There are also constructors with no create argument which will create a new index if there is not already an index at the provided path and otherwise open the existing index.In either case, documents are added with AddDocument(Document) and removed with DeleteDocuments(Term) or DeleteDocuments(Query). A document can be updated with UpdateDocument(Term, Document) (which just deletes and then adds the entire document). When finished adding, deleting and updating documents, Close() should be called. These changes are buffered in memory and periodically flushed to the Directory (during the above method calls). A flush is triggered when there are enough buffered deletes (see SetMaxBufferedDeleteTerms) or enough added documents since the last flush, whichever is sooner. For the added documents, flushing is triggered either by RAM usage of the documents (see SetRAMBufferSizeMB) or the number of added documents. The default is to flush when RAM usage hits 16 MB. For best indexing speed you should flush by RAM usage with a large RAM buffer. Note that flushing just moves the internal buffered state in IndexWriter into the index, but these changes are not visible to IndexReader until either Commit() or Close() is called. A flush may also trigger one or more segment merges which by default run with a background thread so as not to block the addDocument calls (see below for changing the MergeScheduler). If an index will not have more documents added for a while and optimal search performance is desired, then either the full Optimize() method or partial Optimize(int) method should be called before the index is closed. Opening an IndexWriter creates a lock file for the directory in use. Trying to open another IndexWriter on the same directory will lead to a LockObtainFailedException. The LockObtainFailedException is also thrown if an IndexReader on the same directory is used to delete documents from the index. More...
class	IntBlockPool
class	InvertedDocConsumer
class	InvertedDocConsumerPerField
class	InvertedDocConsumerPerThread
class	InvertedDocEndConsumer
class	InvertedDocEndConsumerPerField
class	InvertedDocEndConsumerPerThread
class	KeepOnlyLastCommitDeletionPolicy
	This IndexDeletionPolicy implementation that keeps only the most recent commit and immediately removes all prior commits after a new commit is done. This is the default deletion policy. More...
class	LogByteSizeMergePolicy
	This is a LogMergePolicy that measures size of a segment as the total byte size of the segment's files. More...
class	LogDocMergePolicy
	This is a LogMergePolicy that measures size of a segment as the number of documents (not taking deletions into account). More...
class	LogMergePolicy
	This class implements a MergePolicy that tries to merge segments into levels of exponentially increasing size, where each level has fewer segments than the value of the merge factor. Whenever extra segments (beyond the merge factor upper bound) are encountered, all segments within the level are merged. You can get or set the merge factor using MergeFactor and MergeFactor respectively. More...
class	MergeDocIDRemapper
	Remaps docIDs after a merge has completed, where the merged segments had at least one deletion. This is used to renumber the buffered deletes in IndexWriter when a merge of segments with deletions commits. More...
class	MergePolicy
	Expert: a MergePolicy determines the sequence of primitive merge operations to be used for overall merge and optimize operations. More...
class	MergeScheduler
	Expert: IndexWriter uses an instance implementing this interface to execute the merges selected by a MergePolicy. The default MergeScheduler is ConcurrentMergeScheduler. More...
class	MultiLevelSkipListReader
	This abstract class reads skip lists with multiple levels. More...
class	MultiLevelSkipListWriter
	This abstract class writes skip lists with multiple levels. More...
class	MultipleTermPositions
	Allows you to iterate over the TermPositions for multiple Terms as a single TermPositions. More...
class	MultiReader
	An IndexReader which reads multiple indexes, appending their content. More...
class	NormsWriter
	Writes norms. Each thread X field accumulates the norms for the doc/fields it saw, then the flush method below merges all of these together into a single _X.nrm file. More...
class	NormsWriterPerField
	Taps into DocInverter, as an InvertedDocEndConsumer, which is called at the end of inverting each field. We just look at the length for the field (docState.length) and record the norm. More...
class	NormsWriterPerThread
class	ParallelReader
	An IndexReader which reads multiple, parallel indexes. Each index added must have the same number of documents, but typically each contains different fields. Each document contains the union of the fields of all documents with the same document number. When searching, matches for a query term are from the first index added that has the field. More...
class	Payload
	A Payload is metadata that can be stored together with each occurrence of a term. This metadata is stored inline in the posting list of the specific term. To store payloads in the index a TokenStream has to be used that produces payload data. Use TermPositions.PayloadLength and TermPositions.GetPayload(byte[], int) to retrieve the payloads from the index. More...
class	PositionBasedTermVectorMapper
	For each Field, store position by position information. It ignores frequency information This is not thread-safe. More...
class	RawPostingList
	This is the base class for an in-memory posting list, keyed by a Token. TermsHash maintains a hash table holding one instance of this per unique Token. Consumers of TermsHash (TermsHashConsumer) must subclass this class with its own concrete class. FreqProxTermsWriter.PostingList is a private inner class used for the freq/prox postings, and TermVectorsTermsWriter.PostingList is a private inner class used to hold TermVectors postings. More...
class	ReadOnlyDirectoryReader
class	ReadOnlySegmentReader
class	ReusableStringReader
	Used by DocumentsWriter to implemented a StringReader that can be reset to a new string; we use this when tokenizing the string value from a Field. More...
class	SegmentInfo
	Information about a segment such as it's name, directory, and files related to the segment. More...
class	SegmentInfos
	A collection of segmentInfo objects with methods for operating on those segments in relation to the file system. More...
class	SegmentMergeInfo
class	SegmentMergeQueue
class	SegmentMerger
	The SegmentMerger class combines two or more Segments, represented by an IndexReader (Add, into a single Segment. After adding the appropriate readers, call the merge method to combine the segments. If the compoundFile flag is set, then the segments will be merged into a compound file. More...
class	SegmentReader
	NOTE: This API is new and still experimental (subject to change suddenly in the next release) More...
class	SegmentTermDocs
class	SegmentTermEnum
class	SegmentTermPositions
class	SegmentTermPositionVector
class	SegmentTermVector
class	SegmentWriteState
class	SerialMergeScheduler
	A MergeScheduler that simply does each merge sequentially, using the current thread. More...
class	SnapshotDeletionPolicy
	A IndexDeletionPolicy that wraps around any other IndexDeletionPolicy and adds the ability to hold and later release a single "snapshot" of an index. While the snapshot is held, the IndexWriter will not remove any files associated with it even if the index is otherwise being actively, arbitrarily changed. Because we wrap another arbitrary IndexDeletionPolicy, this gives you the freedom to continue using whatever IndexDeletionPolicy you would normally want to use with your index. Note that you can re-use a single instance of SnapshotDeletionPolicy across multiple writers as long as they are against the same index Directory. Any snapshot held when a writer is closed will "survive" when the next writer is opened. More...
class	SortedTermVectorMapper
	Store a sorted collection of Lucene.Net.Index.TermVectorEntrys. Collects all term information into a single, SortedSet. NOTE: This Mapper ignores all Field information for the Document. This means that if you are using offset/positions you will not know what Fields they correlate with. This is not thread-safe More...
class	StaleReaderException
	This exception is thrown when an IndexReader tries to make changes to the index (via IndexReader.DeleteDocument , IndexReader.UndeleteAll or IndexReader.SetNorm(int,string,float)) but changes have already been committed to the index since this reader was instantiated. When this happens you must open a new reader on the current index to make the changes. More...
class	StoredFieldsWriter
	This is a DocFieldConsumer that writes stored fields. More...
class	StoredFieldsWriterPerThread
class	Term
	A Term represents a word from text. This is the unit of search. It is composed of two elements, the text of the word, as a string, and the name of the field that the text occured in, an interned string. Note that terms may represent more than words from text fields, but also things like dates, email addresses, urls, etc. More...
class	TermBuffer
interface	TermDocs
	TermDocs provides an interface for enumerating <document, frequency> pairs for a term. The document portion names each document containing the term. Documents are indicated by number. The frequency portion gives the number of times the term occurred in each document. The pairs are ordered by document number. More...
class	TermEnum
	Abstract class for enumerating terms. Term enumerations are always ordered by Term.compareTo(). Each term in the enumeration is greater than all that precede it. More...
interface	ITermFreqVector
	Provides access to stored term vector of a document field. The vector consists of the name of the field, an array of the terms tha occur in the field of the Lucene.Net.Documents.Document and a parallel array of frequencies. Thus, getTermFrequencies()[5] corresponds with the frequency of getTerms()[5], assuming there are at least 5 terms in the Document. More...
class	TermInfo
	A TermInfo is the record of information stored for a term. More...
class	TermInfosReader
	This stores a monotonically increasing set of <Term, TermInfo> pairs in a Directory. Pairs are accessed either by Term or by ordinal position the set. More...
class	TermInfosWriter
	This stores a monotonically increasing set of <Term, TermInfo> pairs in a Directory. A TermInfos can be written once, in order. More...
interface	TermPositions
	TermPositions provides an interface for enumerating the <document, frequency, <position>* > tuples for a term. The document and frequency are the same as for a TermDocs. The positions portion lists the ordinal positions of each occurrence of a term in a document. More...
interface	TermPositionVector
	Extends TermFreqVector to provide additional information about positions in which each of the terms is found. A TermPositionVector not necessarily contains both positions and offsets, but at least one of these arrays exists. More...
class	TermsHash
	This class implements InvertedDocConsumer, which is passed each token produced by the analyzer on each field. It stores these tokens in a hash table, and allocates separate byte streams per token. Consumers of this class, eg FreqProxTermsWriter and TermVectorsTermsWriter , write their own byte streams under each term. More...
class	TermsHashConsumer
class	TermsHashConsumerPerField
	Implement this class to plug into the TermsHash processor, which inverts and stores Tokens into a hash table and provides an API for writing bytes into multiple streams for each unique Token. More...
class	TermsHashConsumerPerThread
class	TermsHashPerField
class	TermsHashPerThread
class	TermVectorEntry
	Convenience class for holding TermVector information. More...
class	TermVectorEntryFreqSortedComparator
	Compares Lucene.Net.Index.TermVectorEntrys first by frequency and then by the term (case-sensitive) More...
class	TermVectorMapper
	The TermVectorMapper can be used to map Term Vectors into your own structure instead of the parallel array structure used by Lucene.Net.Index.IndexReader.GetTermFreqVector(int,String). It is up to the implementation to make sure it is thread-safe. More...
struct	TermVectorOffsetInfo
	The TermVectorOffsetInfo class holds information pertaining to a Term in a Lucene.Net.Index.TermPositionVector's offset information. This offset information is the character offset as set during the Analysis phase (and thus may not be the actual offset in the original content). More...
class	TermVectorsReader
class	ParallelArrayTermVectorMapper
	Models the existing parallel array structure More...
class	TermVectorsTermsWriter
class	TermVectorsTermsWriterPerField
class	TermVectorsTermsWriterPerThread
class	TermVectorsWriter

Enumerations
enum	FieldParser { String, Numeric }
	The type of parser for the value of the term. More...

Enumeration Type Documentation

enum Lucene.Net.Index.FieldParser

The type of parser for the value of the term.

Enumerator
String
Numeric

Definition at line 31 of file FieldEnumerator.cs.