Lucene.Net  3.0.3
Lucene.Net is a .NET port of the Java Lucene Indexing Library
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Properties
Namespaces | Classes | Enumerations
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

The type of parser for the value of the term.

Enumerator
String 
Numeric 

Definition at line 31 of file FieldEnumerator.cs.