Lucene++ - a full-featured, c++ search engine
API Documentation


LuceneTypes.h
Go to the documentation of this file.
1 // Copyright (c) 2009-2014 Alan Wright. All rights reserved.
3 // Distributable under the terms of either the Apache License (Version 2.0)
4 // or the GNU Lesser General Public License.
6 
7 #ifndef LUCENETYPES_H
8 #define LUCENETYPES_H
9 
10 #include "Lucene.h"
11 
12 #define DECLARE_SHARED_PTR(Type) \
13  class Type; \
14  typedef boost::shared_ptr<Type> Type##Ptr; \
15  typedef boost::weak_ptr<Type> Type##WeakPtr;
16 
17 namespace Lucene {
18 
19 // analysis
50 DECLARE_SHARED_PTR(StandardAnalyzerSavedStreams)
55 DECLARE_SHARED_PTR(StopAnalyzerSavedStreams)
68 
69 // document
83 
84 // index
100 DECLARE_SHARED_PTR(CoreReaders)
132 DECLARE_SHARED_PTR(FieldsReaderLocal)
135 DECLARE_SHARED_PTR(FindSegmentsModified)
136 DECLARE_SHARED_PTR(FindSegmentsOpen)
137 DECLARE_SHARED_PTR(FindSegmentsRead)
138 DECLARE_SHARED_PTR(FindSegmentsReopen)
177 DECLARE_SHARED_PTR(MergeThread)
185 DECLARE_SHARED_PTR(MyCommitPoint)
186 DECLARE_SHARED_PTR(MySegmentTermDocs)
195 DECLARE_SHARED_PTR(ParallelTermEnum)
196 DECLARE_SHARED_PTR(ParallelTermDocs)
197 DECLARE_SHARED_PTR(ParallelTermPositions)
216 DECLARE_SHARED_PTR(SegmentReaderRef)
244 DECLARE_SHARED_PTR(TermPositionsQueue)
266 
267 // query parser
275 
276 // search
283 DECLARE_SHARED_PTR(BooleanWeight)
291 DECLARE_SHARED_PTR(CachedDfSource)
299 DECLARE_SHARED_PTR(ConstantScoreAutoRewriteDefault)
300 DECLARE_SHARED_PTR(ConstantScoreBooleanQueryRewrite)
301 DECLARE_SHARED_PTR(ConstantScoreFilterRewrite)
303 DECLARE_SHARED_PTR(ConstantScorer)
304 DECLARE_SHARED_PTR(ConstantWeight)
311 DECLARE_SHARED_PTR(CustomWeight)
312 DECLARE_SHARED_PTR(CustomScorer)
313 DECLARE_SHARED_PTR(DefaultByteParser)
314 DECLARE_SHARED_PTR(DefaultCustomScoreProvider)
315 DECLARE_SHARED_PTR(DefaultDoubleParser)
316 DECLARE_SHARED_PTR(DefaultIntParser)
317 DECLARE_SHARED_PTR(DefaultLongParser)
321 DECLARE_SHARED_PTR(DisjunctionMaxWeight)
329 DECLARE_SHARED_PTR(EmptyDocIdSet)
330 DECLARE_SHARED_PTR(EmptyDocIdSetIterator)
335 DECLARE_SHARED_PTR(FieldCacheDocIdSet)
340 DECLARE_SHARED_PTR(FieldCacheRangeFilterByte)
341 DECLARE_SHARED_PTR(FieldCacheRangeFilterDouble)
342 DECLARE_SHARED_PTR(FieldCacheRangeFilterInt)
343 DECLARE_SHARED_PTR(FieldCacheRangeFilterLong)
344 DECLARE_SHARED_PTR(FieldCacheRangeFilterString)
347 DECLARE_SHARED_PTR(FieldCacheTermsFilterDocIdSet)
351 DECLARE_SHARED_PTR(FieldDocIdSetIteratorIncrement)
352 DECLARE_SHARED_PTR(FieldDocIdSetIteratorTermDocs)
359 DECLARE_SHARED_PTR(FilterCache)
360 DECLARE_SHARED_PTR(FilterCleaner)
364 DECLARE_SHARED_PTR(FilteredQueryWeight)
380 DECLARE_SHARED_PTR(MatchAllDocsWeight)
381 DECLARE_SHARED_PTR(MatchAllScorer)
384 DECLARE_SHARED_PTR(MultiComparatorsFieldValueHitQueue)
387 DECLARE_SHARED_PTR(MultiSearcherCallableNoSort)
388 DECLARE_SHARED_PTR(MultiSearcherCallableWithSort)
395 DECLARE_SHARED_PTR(NumericUtilsDoubleParser)
396 DECLARE_SHARED_PTR(NumericUtilsIntParser)
397 DECLARE_SHARED_PTR(NumericUtilsLongParser)
398 DECLARE_SHARED_PTR(OneComparatorFieldValueHitQueue)
408 DECLARE_SHARED_PTR(PayloadTermSpanScorer)
409 DECLARE_SHARED_PTR(PayloadTermWeight)
431 DECLARE_SHARED_PTR(ScoreTermQueue)
432 DECLARE_SHARED_PTR(ScoringBooleanQueryRewrite)
436 DECLARE_SHARED_PTR(SimilarityDisableCoord)
438 DECLARE_SHARED_PTR(SimilarityIDFExplanation)
470 DECLARE_SHARED_PTR(TimerThread)
478 DECLARE_SHARED_PTR(ValueSourceScorer)
479 DECLARE_SHARED_PTR(ValueSourceWeight)
483 
484 // store
499 DECLARE_SHARED_PTR(MMapIndexInput)
500 DECLARE_SHARED_PTR(NativeFSLock)
510 DECLARE_SHARED_PTR(SimpleFSIndexInput)
511 DECLARE_SHARED_PTR(SimpleFSIndexOutput)
512 DECLARE_SHARED_PTR(SimpleFSLock)
514 DECLARE_SHARED_PTR(SingleInstanceLock)
516 
517 // util
531 DECLARE_SHARED_PTR(HeapedScorerDoc)
548 DECLARE_SHARED_PTR(ReaderField)
561 }
562 
563 #endif
Lucene::DoubleParser
Interface to parse doubles from document fields.
Definition: FieldCache.h:244
Lucene::PositionIncrementAttribute
The positionIncrement determines the position of this token relative to the previous Token in a Token...
Definition: PositionIncrementAttribute.h:32
Lucene::ConcurrentMergeScheduler
A MergeScheduler that runs each merge using a separate thread, up until a maximum number of threads (...
Definition: ConcurrentMergeScheduler.h:19
Lucene::Analyzer
An Analyzer builds TokenStreams, which analyze text. It thus represents a policy for extracting index...
Definition: Analyzer.h:19
Lucene::NumericRangeFilter
A Filter that only accepts numeric values within a specified range. To use this, you must first index...
Definition: NumericRangeFilter.h:24
Lucene::FieldDoc
A ScoreDoc which also contains information about how to sort the referenced document....
Definition: FieldDoc.h:20
Lucene::MergePolicy
A MergePolicy determines the sequence of primitive merge operations to be used for overall merge and ...
Definition: MergePolicy.h:32
Lucene::SpanQuery
Base class for span-based queries.
Definition: SpanQuery.h:15
Lucene::StandardFilter
Normalizes tokens extracted with StandardTokenizer.
Definition: StandardFilter.h:15
Lucene::FieldCacheTermsFilter
A Filter that only accepts documents whose single term value in the specified field is contained in t...
Definition: FieldCacheTermsFilter.h:46
Lucene::IndexingChain
The IndexingChain must define the getChain(DocumentsWriter) method which returns the DocConsumer that...
Definition: DocumentsWriter.h:423
Lucene::FormatPostingsTermsWriter
Definition: FormatPostingsTermsWriter.h:14
Lucene::MMapDirectory
File-based Directory implementation that uses mmap for reading, and SimpleFSIndexOutput for writing.
Definition: MMapDirectory.h:22
Lucene::InfoStreamOut
Stream override to write messages to a std::cout.
Definition: InfoStream.h:44
Lucene::WildcardTermEnum
Subclass of FilteredTermEnum for enumerating all terms that match the specified wildcard filter term.
Definition: WildcardTermEnum.h:18
Lucene::StandardTokenizerImpl
Definition: StandardTokenizerImpl.h:14
Lucene::FilterManager
Filter caching singleton. It can be used to save filters locally for reuse. Also could be used as a p...
Definition: FilterManager.h:20
Lucene::Cache
Internal cache.
Definition: FieldCacheImpl.h:72
Lucene::FieldDocSortedHitQueue
Collects sorted results from Searchable's and collates them. The elements put into this queue must be...
Definition: FieldDocSortedHitQueue.h:16
Lucene::InvertedDocConsumerPerField
Definition: InvertedDocConsumerPerField.h:14
Lucene::ValueSource
Source of values for basic function queries.
Definition: ValueSource.h:21
Lucene::BufferedIndexOutput
Base implementation class for buffered IndexOutput.
Definition: BufferedIndexOutput.h:15
Lucene::CompressionTools
Simple utility class providing static methods to compress and decompress binary data for stored field...
Definition: CompressionTools.h:15
Lucene::SegmentMergeInfo
Definition: SegmentMergeInfo.h:14
Lucene::HitQueueBase
Definition: HitQueueBase.h:14
Lucene::ExactPhraseScorer
Definition: ExactPhraseScorer.h:14
Lucene::RawPostingList
This is the base class for an in-memory posting list, keyed by a Token. TermsHash maintains a hash ta...
Definition: RawPostingList.h:19
Lucene::NoLockFactory
Use this LockFactory to disable locking entirely. Only one instance of this lock is created....
Definition: NoLockFactory.h:18
Lucene::SegmentMergeQueue
Definition: SegmentMergeQueue.h:14
Lucene::CachingSpanFilter
Wraps another SpanFilter's result and caches it. The purpose is to allow filters to simply filter,...
Definition: CachingSpanFilter.h:17
Lucene::UTF8DecoderStream
Definition: UTF8Stream.h:106
Lucene::SegmentTermPositions
Definition: SegmentTermPositions.h:14
Lucene::SpanScorer
Public for extension only.
Definition: SpanScorer.h:15
Lucene::SegmentMerger
The SegmentMerger class combines two or more Segments, represented by an IndexReader (add,...
Definition: SegmentMerger.h:20
Lucene::Insanity
Simple container for a collection of related CacheEntry objects that in conjunction with each other r...
Definition: FieldCacheSanityChecker.h:95
Lucene::MatchAllDocsQuery
A query that matches all documents.
Definition: MatchAllDocsQuery.h:15
Lucene::SingleInstanceLockFactory
Implements LockFactory for a single in-process instance, meaning all locking will take place through ...
Definition: SingleInstanceLockFactory.h:20
Lucene::TermVectorsWriter
Definition: TermVectorsWriter.h:14
Lucene::NormsWriter
Writes norms. Each thread X field accumulates the norms for the doc/fields it saw,...
Definition: NormsWriter.h:16
Lucene::KeywordAnalyzer
Tokenizes the entire stream as a single token. This is useful for data like zip codes,...
Definition: KeywordAnalyzer.h:16
Lucene::PrefixQuery
A Query that matches documents containing terms with a specified prefix. A PrefixQuery is built by Qu...
Definition: PrefixQuery.h:18
Lucene::PayloadFunction
An abstract class that defines a way for Payload*Query instances to transform the cumulative effects ...
Definition: PayloadFunction.h:18
Lucene::SingleTokenAttributeSource
Definition: DocInverterPerThread.h:44
Lucene::Bucket
Definition: BooleanScorer.h:111
Lucene::MergeScheduler
IndexWriter uses an instance implementing this interface to execute the merges selected by a MergePol...
Definition: MergeScheduler.h:16
Lucene::FilteredTermEnum
Abstract class for enumerating a subset of all terms.
Definition: FilteredTermEnum.h:18
Lucene::CompoundFileReader
Class for accessing a compound stream. This class implements a directory, but is limited to only read...
Definition: CompoundFileReader.h:18
Lucene::CountingDisjunctionSumScorer
Definition: BooleanScorer2.h:125
Lucene::ScoreDoc
Expert: Returned by low-level search implementations.
Definition: ScoreDoc.h:16
Lucene::TopFieldCollector
A Collector that sorts by SortField using FieldComparators.
Definition: TopFieldCollector.h:17
Lucene::IndexDeletionPolicy
Policy for deletion of stale index commits. Implement this interface, and pass it to one of the Index...
Definition: IndexDeletionPolicy.h:27
Lucene::ScoreCachingWrappingScorer
A Scorer which wraps another scorer and caches the score of the current document. Successive calls to...
Definition: ScoreCachingWrappingScorer.h:22
Lucene::DocFieldConsumerPerField
Definition: DocFieldConsumerPerField.h:14
Lucene::Synchronize
Utility class to support locking via a mutex.
Definition: Synchronize.h:16
Lucene::FlagsAttribute
This attribute can be used to pass different flags down the tokenizer chain, eg from one TokenFilter ...
Definition: FlagsAttribute.h:16
Lucene::Field
Definition: Field.h:14
Lucene::StringIndex
Stores term text values and document ordering data.
Definition: FieldCache.h:180
Lucene::DocWriter
Consumer returns this on each doc. This holds any state that must be flushed synchronized "in docID o...
Definition: DocumentsWriter.h:402
Lucene::StoredFieldStatus
Status from testing stored fields.
Definition: CheckIndex.h:275
Lucene::PhraseQueue
Definition: PhraseQueue.h:14
Lucene::InvertedDocConsumerPerThread
Definition: InvertedDocConsumerPerThread.h:14
Lucene::FilteredDocIdSet
Abstract decorator class for a DocIdSet implementation that provides on-demand filtering/validation m...
Definition: FilteredDocIdSet.h:23
Lucene::DocumentsWriterThreadState
Used by DocumentsWriter to maintain per-thread state. We keep a separate Posting hash and other state...
Definition: DocumentsWriterThreadState.h:17
Lucene::LowerCaseFilter
Normalizes token text to lower case.
Definition: LowerCaseFilter.h:15
Lucene::Term
A Term represents a word from text. This is the unit of search. It is composed of two elements,...
Definition: Term.h:20
Lucene::FormatPostingsPositionsConsumer
Definition: FormatPostingsPositionsConsumer.h:14
Lucene::BooleanClause
A clause in a BooleanQuery.
Definition: BooleanClause.h:15
Lucene::PerDocBuffer
RAMFile buffer for DocWriters.
Definition: DocumentsWriter.h:381
Lucene::QueryParserTokenManager
Token Manager.
Definition: QueryParserTokenManager.h:15
Lucene::SegmentTermDocs
Definition: SegmentTermDocs.h:14
Lucene::CachingTokenFilter
This class can be used if the token attributes of a TokenStream are intended to be consumed more than...
Definition: CachingTokenFilter.h:19
Lucene::TermVectorOffsetInfo
The TermVectorOffsetInfo class holds information pertaining to a Term in a TermPositionVector's offse...
Definition: TermVectorOffsetInfo.h:17
Lucene::Directory
A Directory is a flat list of files. Files may be written once, when they are created....
Definition: Directory.h:18
Lucene::NormsWriterPerField
Taps into DocInverter, as an InvertedDocEndConsumer, which is called at the end of inverting each fie...
Definition: NormsWriterPerField.h:16
Lucene::Attribute
Base class for Attributes that can be added to a AttributeSource.
Definition: Attribute.h:18
Lucene::PhraseQuery
A Query that matches documents containing a particular sequence of terms. A PhraseQuery is built by Q...
Definition: PhraseQuery.h:18
Lucene::PorterStemmer
This is the Porter stemming algorithm, coded up as thread-safe ANSI C by the author.
Definition: PorterStemmer.h:26
Lucene::TermAttribute
The term text of a Token.
Definition: TermAttribute.h:15
Lucene::Document
Documents are the unit of indexing and search.
Definition: Document.h:24
Lucene::Spans
An enumeration of span matches. Used to implement span searching. Each span represents a range of ter...
Definition: Spans.h:17
Lucene::PayloadNearSpanScorer
Definition: PayloadNearQuery.h:63
Lucene::Lock
An interprocess mutex lock.
Definition: Lock.h:16
Lucene::TimeLimitingCollector
The TimeLimitingCollector is used to timeout search requests that take longer than the maximum allowe...
Definition: TimeLimitingCollector.h:17
Lucene::InvertedDocEndConsumerPerField
Definition: InvertedDocEndConsumerPerField.h:14
Lucene::ParallelMultiSearcher
Implements parallel search over a set of Searchables.
Definition: ParallelMultiSearcher.h:18
Lucene::PhraseScorer
Scoring functionality for phrase queries. A document is considered matching if it contains the phrase...
Definition: PhraseScorer.h:21
Lucene::FieldCacheEntry
A unique Identifier/Description for each item in the FieldCache. Can be useful for logging/debugging.
Definition: FieldCache.h:255
Lucene::TermsHashConsumerPerThread
Definition: TermsHashConsumerPerThread.h:14
Lucene::TypeAttribute
A Token's lexical type. The Default value is "word".
Definition: TypeAttribute.h:15
Lucene::TermVectorsTermsWriterPerThread
Definition: TermVectorsTermsWriterPerThread.h:14
Lucene::Searcher
An abstract base class for search implementations. Implements the main search methods.
Definition: Searcher.h:18
Lucene::TermVectorStatus
Status from testing stored fields.
Definition: CheckIndex.h:294
Lucene::BitVector
Optimized implementation of a vector of bits.
Definition: BitVector.h:15
Lucene::DefaultSkipListReader
Implements the skip list reader for the default posting list format that stores positions and payload...
Definition: DefaultSkipListReader.h:15
Lucene::PerFieldAnalyzerWrapper
This analyzer is used to facilitate scenarios where different fields require different analysis techn...
Definition: PerFieldAnalyzerWrapper.h:29
Lucene::DisjunctionMaxQuery
A query that generates the union of documents produced by its subqueries, and that scores each docume...
Definition: DisjunctionMaxQuery.h:27
Lucene::IDFExplanation
Small Util class used to pass both an idf factor as well as an explanation for that factor.
Definition: Explanation.h:70
Lucene::PayloadSpanUtil
Experimental class to get set of payloads for most standard Lucene queries. Operates like Highlighter...
Definition: PayloadSpanUtil.h:16
Lucene::TokenStream
A TokenStream enumerates the sequence of tokens, either from Fields of a Document or from query text.
Definition: TokenStream.h:44
Lucene::TermQuery
A Query that matches documents containing a term. This may be combined with other terms with a Boolea...
Definition: TermQuery.h:16
Lucene::SpanNotQuery
Removes matches which overlap with another SpanQuery.
Definition: SpanNotQuery.h:15
Lucene::DoubleCache
Definition: FieldCacheImpl.h:127
Lucene::MergeDocIDRemapper
Remaps docIDs after a merge has completed, where the merged segments had at least one deletion....
Definition: MergeDocIDRemapper.h:17
Lucene::TermsHashConsumer
Definition: TermsHashConsumer.h:14
Lucene::FilteredDocIdSetIterator
Abstract decorator class of a DocIdSetIterator implementation that provides on-demand filter/validati...
Definition: FilteredDocIdSetIterator.h:16
Lucene::RAMOutputStream
A memory-resident IndexOutput implementation.
Definition: RAMOutputStream.h:15
Lucene::FilteredQuery
A query that applies a filter to the results of another query.
Definition: FilteredQuery.h:20
Lucene::CharBlockPool
Definition: CharBlockPool.h:14
Lucene::MultiTermPositions
Definition: DirectoryReader.h:278
Lucene::InfoStream
Utility class to support streaming info messages.
Definition: InfoStream.h:16
Lucene::BufferedReader
Read text from a character-input stream, buffering characters so as to provide for the efficient read...
Definition: BufferedReader.h:16
Lucene::SinkFilter
Definition: TeeSinkTokenFilter.h:95
Lucene::NumericUtils
This is a helper class to generate prefix-encoded representations for numerical values and supplies c...
Definition: NumericUtils.h:37
Lucene::FieldCache
Maintains caches of term values.
Definition: FieldCache.h:17
Lucene::FreqProxTermsWriter
Definition: FreqProxTermsWriter.h:15
Lucene::MaxPayloadFunction
Returns the maximum payload score seen, else 1 if there are no payloads on the doc.
Definition: MaxPayloadFunction.h:17
Lucene::OneMerge
OneMerge provides the information necessary to perform an individual primitive merge operation,...
Definition: MergePolicy.h:76
Lucene::FieldInfos
Access to the Fieldable Info file that describes document fields and whether or not they are indexed....
Definition: FieldInfos.h:18
Lucene::TokenAttributeFactory
Creates a TokenAttributeFactory returning Token as instance for the basic attributes and for all othe...
Definition: Token.h:338
Lucene::DocFieldConsumerPerThread
Definition: DocFieldConsumerPerThread.h:14
Lucene::SegmentInfos
A collection of SegmentInfo objects with methods for operating on those segments in relation to the f...
Definition: SegmentInfos.h:15
Lucene::IntRangeBuilder
Definition: NumericUtils.h:162
Lucene::ByteBlockAllocator
Definition: DocumentsWriter.h:497
Lucene::AbstractField
Definition: AbstractField.h:14
Lucene::AttributeSource
An AttributeSource contains a list of different Attributes, and methods to add and get them....
Definition: AttributeSource.h:43
Lucene::DocValues
Represents field values as different types. Normally created via a ValueSuorce for a particular field...
Definition: DocValues.h:22
Lucene::StandardAnalyzer
Filters StandardTokenizer with StandardFilter, LowerCaseFilter and StopFilter, using a list of Englis...
Definition: StandardAnalyzer.h:23
Lucene::SpanOrQuery
Matches the union of its clauses.
Definition: SpanOrQuery.h:15
Lucene::NumberTools
Provides support for converting longs to Strings, and back again. The strings are structured so that ...
Definition: NumberTools.h:26
Lucene::DocFieldProcessor
This is a DocConsumer that gathers all fields under the same name, and calls per-field consumers to p...
Definition: DocFieldProcessor.h:17
Lucene::ConjunctionScorer
Scorer for conjunctions, sets of queries, all of which are required.
Definition: ConjunctionScorer.h:15
Lucene::MappingCharFilter
Simplistic CharFilter that applies the mappings contained in a NormalizeCharMap to the character stre...
Definition: MappingCharFilter.h:16
Lucene::ByteBlockPoolAllocatorBase
Definition: ByteBlockPool.h:54
Lucene::SortedTermVectorMapper
Store a sorted collection of TermVectorEntrys. Collects all term information into a single,...
Definition: SortedTermVectorMapper.h:22
Lucene::BooleanScorer
BooleanScorer uses a ~16k array to score windows of docs. So it scores docs 0-16k first,...
Definition: BooleanScorer.h:30
Lucene::NumericRangeQuery
A Query that matches numeric values within a specified range. To use this, you must first index the n...
Definition: NumericRangeQuery.h:108
Lucene::AttributeFactory
Definition: AttributeSource.h:14
Lucene::FieldNormStatus
Status from testing field norms.
Definition: CheckIndex.h:237
Lucene::FieldCacheRangeFilter
A range filter built on top of a cached single term field (in FieldCache).
Definition: FieldCacheRangeFilter.h:38
Lucene::FSLockFactory
Base class for file system based locking implementation.
Definition: FSLockFactory.h:15
Lucene::DefaultAttributeFactory
Definition: AttributeSource.h:154
Lucene::FieldMaskingSpanQuery
Wrapper to allow SpanQuery objects participate in composite single-field SpanQueries by 'lying' about...
Definition: FieldMaskingSpanQuery.h:52
Lucene::TermVectorEntry
Convenience class for holding TermVector information.
Definition: TermVectorEntry.h:15
Lucene::TermFreqVector
Provides access to stored term vector of a document field. The vector consists of the name of the fie...
Definition: TermFreqVector.h:18
Lucene::DocState
Definition: DocumentsWriter.h:356
Lucene::LuceneThread
Lucene thread container.
Definition: LuceneThread.h:23
Lucene::CharFilter
Subclasses of CharFilter can be chained to filter CharStream. They can be used as Reader with additio...
Definition: CharFilter.h:17
Lucene::FieldComparator
A FieldComparator compares hits so as to determine their sort order when collecting the top results w...
Definition: FieldComparator.h:42
Lucene::Coordinator
Definition: BooleanScorer2.h:85
Lucene::TermInfosReaderThreadResources
Definition: TermInfosReader.h:74
Lucene::IndexInput
Abstract base class for input from a file in a Directory. A random-access input stream....
Definition: IndexInput.h:17
Lucene::ASCIIFoldingFilter
This class converts alphabetic, numeric, and symbolic Unicode characters which are not in the first 1...
Definition: ASCIIFoldingFilter.h:42
Lucene::StandardTokenizer
A grammar-based tokenizer.
Definition: StandardTokenizer.h:34
Lucene::PayloadAttribute
The start and end character offset of a Token.
Definition: PayloadAttribute.h:15
Lucene::PositionInfo
Definition: SpanFilterResult.h:39
Lucene::AttributeSourceState
This class holds the state of an AttributeSource.
Definition: AttributeSource.h:168
Lucene::ValueSourceQuery
A Query that sets the scores of document to the values obtained from a ValueSource.
Definition: ValueSourceQuery.h:22
Lucene::DocumentsWriter
This class accepts multiple added documents and directly writes a single segment file....
Definition: DocumentsWriter.h:54
Lucene::PorterStemFilter
Transforms the token stream as per the Porter stemming algorithm. Note: the input to the stemming fil...
Definition: PorterStemFilter.h:31
Lucene::FormatPostingsPositionsWriter
Definition: FormatPostingsPositionsWriter.h:14
Lucene::StringCache
Definition: FieldCacheImpl.h:138
Lucene::ReadOnlySegmentReader
Definition: ReadOnlySegmentReader.h:14
DECLARE_SHARED_PTR
#define DECLARE_SHARED_PTR(Type)
Definition: LuceneTypes.h:12
Lucene::RAMInputStream
A memory-resident IndexInput implementation.
Definition: RAMInputStream.h:15
Lucene::ReqOptSumScorer
A Scorer for queries with a required part and an optional part. Delays skipTo() on the optional part ...
Definition: ReqOptSumScorer.h:16
Lucene::ChecksumIndexOutput
Writes bytes through to a primary IndexOutput, computing checksum. Note that you cannot use seek().
Definition: ChecksumIndexOutput.h:17
Lucene::ByteFieldSource
Obtains byte field values from the FieldCache using getBytes() and makes those values available as ot...
Definition: ByteFieldSource.h:24
Lucene::Num
Number of documents a delete term applies to.
Definition: BufferedDeletes.h:43
Lucene::DocFieldConsumersPerThread
Definition: DocFieldConsumersPerThread.h:14
Lucene::PhrasePositions
Position of a term in a document that takes into account the term offset within the phrase.
Definition: PhrasePositions.h:15
Lucene::TokenFilter
A TokenFilter is a TokenStream whose input is another TokenStream.
Definition: TokenFilter.h:18
Lucene::TopFieldDocs
Represents hits returned by Searcher#search(QueryPtr, FilterPtr, int32_t, SortPtr).
Definition: TopFieldDocs.h:15
Lucene::DocIdSet
A DocIdSet contains a set of doc ids. Implementing classes must only implement iterator to provide ac...
Definition: DocIdSet.h:16
Lucene::MultiTermDocs
Definition: DirectoryReader.h:225
Lucene::RAMFile
File used as buffer in RAMDirectory.
Definition: RAMFile.h:15
Lucene::NormsWriterPerThread
Definition: NormsWriterPerThread.h:14
Lucene::ByteSliceWriter
Class to write byte streams into slices of shared byte[]. This is used by DocumentsWriter to hold the...
Definition: ByteSliceWriter.h:16
Lucene::CharTokenizer
An abstract base class for simple, character-oriented tokenizers.
Definition: CharTokenizer.h:15
Lucene::TermVectorsPositionInfo
Container for a term at a position.
Definition: PositionBasedTermVectorMapper.h:49
Lucene::MultiFieldQueryParser
A QueryParser which constructs queries to search multiple fields.
Definition: MultiFieldQueryParser.h:16
Lucene::DocFieldProcessorPerField
Holds all per thread, per field state.
Definition: DocFieldProcessorPerField.h:15
Lucene::CustomScoreQuery
Query that sets document score as a programmatic function of several (sub) scores:
Definition: CustomScoreQuery.h:21
Lucene::DocFieldProcessorPerThreadPerDoc
Definition: DocFieldProcessorPerThread.h:63
Lucene::Weight
Calculate query weights and build query scorers.
Definition: Weight.h:30
Lucene::TopDocsCollector
A base class for all collectors that return a TopDocs output. This collector allows easy extension by...
Definition: TopDocsCollector.h:21
Lucene::SpanFilter
Abstract base class providing a mechanism to restrict searches to a subset of an index and also maint...
Definition: SpanFilter.h:21
Lucene::TeeSinkTokenFilter
This TokenFilter provides the ability to set aside attribute states that have already been analyzed....
Definition: TeeSinkTokenFilter.h:62
Lucene::LetterTokenizer
A LetterTokenizer is a tokenizer that divides text at non-letters. That's to say, it defines tokens a...
Definition: LetterTokenizer.h:19
Lucene::CompoundFileWriter
Combines multiple files into a single compound file. The file format: VInt fileCount {Directory} file...
Definition: CompoundFileWriter.h:27
Lucene::ISOLatin1AccentFilter
A filter that replaces accented characters in the ISO Latin 1 character set (ISO-8859-1) by their una...
Definition: ISOLatin1AccentFilter.h:21
Lucene::KeepOnlyLastCommitDeletionPolicy
This IndexDeletionPolicy implementation that keeps only the most recent commit and immediately remove...
Definition: KeepOnlyLastCommitDeletionPolicy.h:16
Lucene::WaitQueue
Definition: DocumentsWriter.h:469
Lucene::LoadFirstFieldSelector
Load the First field and break. See FieldSelectorResult#LOAD_AND_BREAK.
Definition: LoadFirstFieldSelector.h:16
Lucene::BaseCharFilter
Base utility class for implementing a CharFilter. You subclass this, and then record mappings by call...
Definition: BaseCharFilter.h:16
Lucene::TermsHashPerField
Definition: TermsHashPerField.h:14
Lucene::MapFieldSelector
A FieldSelector based on a Map of field names to FieldSelectorResults.
Definition: MapFieldSelector.h:17
Lucene
Definition: AbstractAllTermDocs.h:12
Lucene::FormatPostingsDocsConsumer
Definition: FormatPostingsDocsConsumer.h:14
Lucene::Explanation
Describes the score computation for document and query.
Definition: Explanation.h:15
Lucene::TopDocs
Represents hits returned by Searcher#search(QueryPtr, FilterPtr, int32_t) and {}.
Definition: TopDocs.h:16
Lucene::CheckAbort
Definition: SegmentMerger.h:122
Lucene::FreqProxTermsWriterPerThread
Definition: FreqProxTermsWriterPerThread.h:14
Lucene::ParallelReader
An IndexReader which reads multiple, parallel indexes. Each index added must have the same number of ...
Definition: ParallelReader.h:26
Lucene::PayloadNearSpanWeight
Definition: PayloadNearQuery.h:52
Lucene::ChecksumIndexInput
Writes bytes through to a primary IndexInput, computing checksum as it goes. Note that you cannot use...
Definition: ChecksumIndexInput.h:17
Lucene::IntBlockPool
Definition: IntBlockPool.h:14
Lucene::LowerCaseTokenizer
LowerCaseTokenizer performs the function of LetterTokenizer and LowerCaseFilter together....
Definition: LowerCaseTokenizer.h:21
Lucene::FuzzyQuery
Implements the fuzzy search query. The similarity measurement is based on the Levenshtein (edit dista...
Definition: FuzzyQuery.h:19
Lucene::FileSwitchDirectory
A Directory instance that switches files between two other Directory instances.
Definition: FileSwitchDirectory.h:21
Lucene::DirectoryReader
An IndexReader which reads indexes with multiple segments.
Definition: DirectoryReader.h:19
Lucene::Parser
Marker interface as super-interface to all parsers. It is used to specify a custom parser to {}.
Definition: FieldCache.h:200
Lucene::Searchable
The interface for search implementations.
Definition: Searchable.h:24
Lucene::CharArraySet
A simple class that stores Strings as char[]'s in a hash table. Note that this is not a general purpo...
Definition: CharArraySet.h:17
Lucene::MinPayloadFunction
Calculates the minimum payload seen.
Definition: MinPayloadFunction.h:15
Lucene::SloppyPhraseScorer
Definition: SloppyPhraseScorer.h:14
Lucene::OrdFieldSource
Obtains the ordinal of the field value from the default Lucene FieldCache using getStringIndex().
Definition: OrdFieldSource.h:31
Lucene::TermsHash
This class implements InvertedDocConsumer, which is passed each token produced by the analyzer on eac...
Definition: TermsHash.h:18
Lucene::RefCount
Tracks the reference count for a single index file.
Definition: IndexFileDeleter.h:130
Lucene::SkipBuffer
Used to buffer the top skip levels.
Definition: MultiLevelSkipListReader.h:88
Lucene::LuceneObject
Base class for all Lucene classes.
Definition: LuceneObject.h:31
Lucene::SimpleFSLockFactory
Implements LockFactory using File#createNewFile().
Definition: SimpleFSLockFactory.h:17
Lucene::WhitespaceTokenizer
A WhitespaceTokenizer is a tokenizer that divides text at whitespace. Adjacent sequences of non-White...
Definition: WhitespaceTokenizer.h:16
Lucene::BucketScorer
Definition: BooleanScorer.h:87
Lucene::IndexFileNameFilter
Filename filter that accept filenames and extensions only created by Lucene.
Definition: IndexFileNameFilter.h:15
Lucene::QueryWrapperFilter
Constrains search results to only match those which also match a provided query.
Definition: QueryWrapperFilter.h:20
Lucene::TermEnum
Abstract class for enumerating terms.
Definition: TermEnum.h:18
Lucene::LogMergePolicy
This class implements a MergePolicy that tries to merge segments into levels of exponentially increas...
Definition: LogMergePolicy.h:24
Lucene::SubScorer
Definition: BooleanScorer.h:146
Lucene::MultipleTermPositions
Allows you to iterate over the TermPositions for multiple Terms as a single TermPositions.
Definition: MultipleTermPositions.h:16
Lucene::LuceneSignal
Utility class to support signaling notifications.
Definition: LuceneSignal.h:16
Lucene::HitQueue
Definition: HitQueue.h:14
Lucene::IndexFileDeleter
This class keeps track of each SegmentInfos instance that is still "live", either because it correspo...
Definition: IndexFileDeleter.h:34
Lucene::BitSet
Definition: BitSet.h:15
Lucene::FieldsWriter
Definition: FieldsWriter.h:14
Lucene::UTF8Result
Definition: UnicodeUtils.h:84
Lucene::TermVectorsTermsWriter
Definition: TermVectorsTermsWriter.h:16
Lucene::DisjunctionMaxScorer
The Scorer for DisjunctionMaxQuery. The union of all documents generated by the the subquery scorers ...
Definition: DisjunctionMaxScorer.h:18
Lucene::QueryTermVector
Definition: QueryTermVector.h:14
Lucene::SinkTokenStream
A filter that decides which AttributeSource states to store in the sink.
Definition: TeeSinkTokenFilter.h:120
Lucene::BufferedIndexInput
Base implementation class for buffered IndexInput.
Definition: BufferedIndexInput.h:15
Lucene::SegmentInfoCollection
A collection of SegmentInfo objects to be used as a base class for SegmentInfos.
Definition: SegmentInfoCollection.h:15
Lucene::SpanWeight
Public for use by other weight implementations.
Definition: SpanWeight.h:15
Lucene::DocFieldProcessorPerThread
Gathers all Fieldables for a document under the same name, updates FieldInfos, and calls per-field co...
Definition: DocFieldProcessorPerThread.h:19
Lucene::IndexStatus
Returned from checkIndex() detailing the health and status of the index.
Definition: CheckIndex.h:108
Lucene::TermPositions
TermPositions provides an interface for enumerating the <document, frequency, <position>*> tuples for...
Definition: TermPositions.h:18
Lucene::KeywordTokenizer
Emits the entire input as a single token.
Definition: KeywordTokenizer.h:15
Lucene::Tokenizer
A Tokenizer is a TokenStream whose input is a Reader.
Definition: Tokenizer.h:20
Lucene::LongCache
Definition: FieldCacheImpl.h:116
Lucene::SegmentInfoStatus
Holds the status of each segment in the index. See segmentInfos.
Definition: CheckIndex.h:168
Lucene::QueryParserConstants
Token literal values and constants.
Definition: QueryParserConstants.h:15
Lucene::OpenBitSetDISI
Definition: OpenBitSetDISI.h:14
Lucene::Scorer
Common scoring functionality for different types of queries.
Definition: Scorer.h:33
Lucene::Future
A Future represents the result of an asynchronous computation. Methods are provided to check if the c...
Definition: ThreadPool.h:22
Lucene::NumericField
This class provides a Field that enables indexing of numeric values for efficient range filtering and...
Definition: NumericField.h:59
Lucene::BufferedDeletes
Holds buffered deletes, by docID, term or query. We hold two instances of this class: one for the del...
Definition: BufferedDeletes.h:19
Lucene::NearSpansUnordered
Similar to NearSpansOrdered, but for the unordered case.
Definition: NearSpansUnordered.h:17
Lucene::PositiveScoresOnlyCollector
A Collector implementation which wraps another Collector and makes sure only documents with scores > ...
Definition: PositiveScoresOnlyCollector.h:16
Lucene::SegmentReader
Definition: SegmentReader.h:15
Lucene::DoubleFieldSource
Obtains double field values from the FieldCache using getDoubles() and makes those values available a...
Definition: DoubleFieldSource.h:25
Lucene::OpenBitSetIterator
An iterator to iterate over set bits in an OpenBitSet. This is faster than nextSetBit() for iterating...
Definition: OpenBitSetIterator.h:17
Lucene::FormatPostingsFieldsWriter
Definition: FormatPostingsFieldsWriter.h:14
Lucene::FreqProxTermsWriterPostingList
Definition: FreqProxTermsWriter.h:41
Lucene::MultiTermEnum
Definition: DirectoryReader.h:195
Lucene::FieldSelector
The FieldSelector allows one to make decisions about what Fields get loaded on a Document by IndexRea...
Definition: FieldSelector.h:16
Lucene::Query
The abstract base class for queries.
Definition: Query.h:31
Lucene::AllTermDocs
Definition: AllTermDocs.h:14
Lucene::FieldsReader
Class responsible for access to stored document fields. It uses <segment>.fdt and <segment>....
Definition: FieldsReader.h:16
Lucene::TermVectorEntryFreqSortedComparator
Compares TermVectorEntrys first by frequency and then by the term (case-sensitive)
Definition: TermVectorEntryFreqSortedComparator.h:15
Lucene::MultiLevelSkipListWriter
This abstract class writes skip lists with multiple levels.
Definition: MultiLevelSkipListWriter.h:36
Lucene::IndexReader
IndexReader is an abstract class, providing an interface for accessing an index. Search of an index i...
Definition: IndexReader.h:39
Lucene::SkipDocWriter
Definition: DocumentsWriter.h:457
Lucene::DocInverterPerThread
This is a DocFieldConsumer that inverts each field, separately, from a Document, and accepts a Invert...
Definition: DocInverterPerThread.h:17
Lucene::Fieldable
Synonymous with Field.
Definition: Fieldable.h:20
Lucene::SegmentTermVector
Definition: SegmentTermVector.h:14
Lucene::ReqExclScorer
A Scorer for queries with a required subscorer and an excluding (prohibited) sub DocIdSetIterator....
Definition: ReqExclScorer.h:16
Lucene::TermInfosWriter
This stores a monotonically increasing set of <Term, TermInfo> pairs in a Directory....
Definition: TermInfosWriter.h:16
Lucene::StoredFieldsWriterPerDoc
Definition: StoredFieldsWriter.h:50
Lucene::TermIndexStatus
Status from testing term index.
Definition: CheckIndex.h:253
Lucene::FilterIndexReader
A FilterIndexReader contains another IndexReader, which it uses as its basic source of data,...
Definition: FilterIndexReader.h:21
Lucene::SimilarityDelegator
Delegating scoring implementation. Useful in Query#getSimilarity(Searcher) implementations,...
Definition: SimilarityDelegator.h:16
Lucene::ConstantScoreAutoRewrite
A rewrite method that tries to pick the best constant-score rewrite method based on term and document...
Definition: MultiTermQuery.h:135
Lucene::SerialMergeScheduler
A MergeScheduler that simply does each merge sequentially, using the current thread.
Definition: SerialMergeScheduler.h:15
Lucene::Payload
A Payload is metadata that can be stored together with each occurrence of a term. This metadata is st...
Definition: Payload.h:21
Lucene::RAMDirectory
A memory-resident Directory implementation. Locking implementation is by default the SingleInstanceLo...
Definition: RAMDirectory.h:17
Lucene::WhitespaceAnalyzer
An Analyzer that uses WhitespaceTokenizer.
Definition: WhitespaceAnalyzer.h:15
Lucene::SegmentTermEnum
Definition: SegmentTermEnum.h:14
Lucene::QueryParserToken
Describes the input token stream.
Definition: QueryParserToken.h:15
Lucene::SortedVIntList
Stores and iterate on sorted integers in compressed form in RAM.
Definition: SortedVIntList.h:22
Lucene::RewriteMethod
Abstract class that defines how the query is rewritten.
Definition: MultiTermQuery.h:122
Lucene::FieldValueHitQueueEntry
Definition: FieldValueHitQueue.h:56
Lucene::StringIndexCache
Definition: FieldCacheImpl.h:149
Lucene::DefaultIndexingChain
This is the current indexing chain: DocConsumer / DocConsumerPerThread --> code: DocFieldProcessor / ...
Definition: DocumentsWriter.h:447
Lucene::ScorerDocQueue
A ScorerDocQueue maintains a partial ordering of its Scorers such that the least Scorer can always be...
Definition: ScorerDocQueue.h:16
Lucene::MultiPhraseQuery
MultiPhraseQuery is a generalized version of PhraseQuery, with an added method add(Term[])....
Definition: MultiPhraseQuery.h:18
Lucene::MultiLevelSkipListReader
This abstract class reads skip lists with multiple levels.
Definition: MultiLevelSkipListReader.h:20
Lucene::IndexReaderWarmer
If getReader has been called (ie, this writer is in near real-time mode), then after a merge complete...
Definition: IndexWriter.h:1100
Lucene::FieldInvertState
This class tracks the number and position / offset parameters of terms being added to the index....
Definition: FieldInvertState.h:16
Lucene::SpanQueryFilter
Constrains search results to only match those which also match a provided query. Also provides positi...
Definition: SpanQueryFilter.h:20
Lucene::LogByteSizeMergePolicy
This is a LogMergePolicy that measures size of a segment as the total byte size of the segment's file...
Definition: LogByteSizeMergePolicy.h:16
Lucene::FieldCacheSource
A base class for ValueSource implementations that retrieve values for a single field from the FieldCa...
Definition: FieldCacheSource.h:28
Lucene::SortField
Stores information about how to sort documents by terms in an individual field. Fields must be indexe...
Definition: SortField.h:16
Lucene::CheckIndex
Basic tool and API to check the health of an index and write a new segments file that removes referen...
Definition: CheckIndex.h:20
Lucene::NormalizeCharMap
Holds a map of String input to String output, to be used with MappingCharFilter.
Definition: NormalizeCharMap.h:15
Lucene::BooleanQuery
A Query that matches documents matching boolean combinations of other queries, eg....
Definition: BooleanQuery.h:18
Lucene::Collator
Convenience class for storing collate objects.
Definition: Collator.h:15
Lucene::TermVectorsTermsWriterPerDoc
Definition: TermVectorsTermsWriter.h:54
Lucene::NearSpansOrdered
A Spans that is formed from the ordered subspans of a SpanNearQuery where the subspans do not overlap...
Definition: NearSpansOrdered.h:31
Lucene::IndexSearcher
Implements search over a single IndexReader.
Definition: IndexSearcher.h:23
Lucene::StoredFieldsWriterPerThread
Definition: StoredFieldsWriterPerThread.h:14
Lucene::TermsHashPerThread
Definition: TermsHashPerThread.h:14
Lucene::DocFieldConsumer
Definition: DocFieldConsumer.h:14
Lucene::AbstractAllTermDocs
Base class for enumerating all but deleted docs.
Definition: AbstractAllTermDocs.h:18
Lucene::MergeSpecification
A MergeSpecification instance provides the information necessary to perform multiple merges....
Definition: MergePolicy.h:119
Lucene::FieldCacheSanityChecker
Provides methods for sanity checking that entries in the FieldCache are not wasteful or inconsistent.
Definition: FieldCacheSanityChecker.h:28
Lucene::ReusableStringReader
Used by DocumentsWriter to implemented a StringReader that can be reset to a new string; we use this ...
Definition: ReusableStringReader.h:16
Lucene::UTF8Decoder
Definition: UTF8Stream.h:81
Lucene::CharReader
CharReader is a Reader wrapper. It reads chars from Reader and outputs CharStream,...
Definition: CharReader.h:16
Lucene::TermBuffer
Definition: TermBuffer.h:14
Lucene::MultiTermQueryWrapperFilter
A wrapper for MultiTermQuery, that exposes its functionality as a Filter.
Definition: MultiTermQueryWrapperFilter.h:22
Lucene::SimpleAnalyzer
An Analyzer that filters LetterTokenizer with LowerCaseFilter.
Definition: SimpleAnalyzer.h:15
Lucene::OpenBitSet
An "open" BitSet implementation that allows direct access to the array of words storing the bits.
Definition: OpenBitSet.h:19
Lucene::SpanTermQuery
Matches spans containing a term.
Definition: SpanTermQuery.h:15
Lucene::IndexCommit
Represents a single commit into an index as seen by the IndexDeletionPolicy or IndexReader.
Definition: IndexCommit.h:22
Lucene::StartEnd
Definition: SpanFilterResult.h:56
Lucene::UTF8EncoderStream
Definition: UTF8Stream.h:67
Lucene::Reader
Abstract class for reading character streams.
Definition: Reader.h:15
Lucene::OffsetAttribute
The start and end character offset of a Token.
Definition: OffsetAttribute.h:15
Lucene::CustomScoreProvider
An instance of this subclass should be returned by CustomScoreQuery#getCustomScoreProvider,...
Definition: CustomScoreProvider.h:21
Lucene::SingleMatchScorer
Count a scorer as a single match.
Definition: BooleanScorer2.h:105
Lucene::PrefixFilter
A Filter that restricts search results to values that have a matching prefix in a given field.
Definition: PrefixFilter.h:15
Lucene::FuzzyTermEnum
Subclass of FilteredTermEnum for enumerating all terms that are similar to the specified filter term.
Definition: FuzzyTermEnum.h:18
Lucene::LockFactory
Base class for Locking implementation. Directory uses instances of this class to implement locking....
Definition: LockFactory.h:23
Lucene::TermRangeTermEnum
Subclass of FilteredTermEnum for enumerating all terms that match the specified range parameters.
Definition: TermRangeTermEnum.h:18
Lucene::TermInfosReader
This stores a monotonically increasing set of <Term, TermInfo> pairs in a Directory....
Definition: TermInfosReader.h:17
Lucene::PayloadTermQuery
This class is very similar to SpanTermQuery except that it factors in the value of the payload locate...
Definition: PayloadTermQuery.h:21
Lucene::LongParser
Interface to parse longs from document fields.
Definition: FieldCache.h:232
Lucene::PriorityQueueScoreDocs
Definition: HitQueueBase.h:45
Lucene::InvertedDocConsumer
Definition: InvertedDocConsumer.h:14
Lucene::WildcardQuery
Implements the wildcard search query. Supported wildcards are *, which matches any character sequence...
Definition: WildcardQuery.h:21
Lucene::ComplexExplanation
Describes the score computation for document and query, and can distinguish a match independent of a ...
Definition: ComplexExplanation.h:16
Lucene::DocInverterPerField
Holds state for inverting all occurrences of a single field in the document. This class doesn't do an...
Definition: DocInverterPerField.h:17
Lucene::ReadOnlyDirectoryReader
Definition: ReadOnlyDirectoryReader.h:14
Lucene::DefaultSimilarity
Default scoring implementation.
Definition: DefaultSimilarity.h:15
Lucene::FSDirectory
Base class for Directory implementations that store index files in the file system....
Definition: FSDirectory.h:29
Lucene::UTF8Encoder
Definition: UTF8Stream.h:44
Lucene::Filter
Abstract base class for restricting which documents may be returned during searching.
Definition: Filter.h:15
Lucene::NumericTokenStream
This class provides a TokenStream for indexing numeric values that can be used by NumericRangeQuery o...
Definition: NumericTokenStream.h:52
Lucene::FileReader
Convenience class for reading character files.
Definition: FileReader.h:15
Lucene::SimpleFSDirectory
A straightforward implementation of FSDirectory using std::ofstream and std::ifstream.
Definition: SimpleFSDirectory.h:15
Lucene::ParallelArrayTermVectorMapper
Models the existing parallel array structure.
Definition: TermVectorsReader.h:118
Lucene::Similarity
Scoring API.
Definition: Similarity.h:427
Lucene::DateTools
Provides support for converting dates to strings and vice-versa. The strings are structured so that l...
Definition: DateTools.h:28
Lucene::StopFilter
Removes stop words from a token stream.
Definition: StopFilter.h:15
Lucene::DocIdSetIterator
This abstract class defines methods to iterate over a set of non-decreasing doc ids....
Definition: DocIdSetIterator.h:17
Lucene::FieldInfo
Definition: FieldInfo.h:14
Lucene::ConstantScoreQuery
A query that wraps a filter and simply returns a constant score equal to the query boost for every do...
Definition: ConstantScoreQuery.h:18
Lucene::TermRangeQuery
A Query that matches documents within an range of terms.
Definition: TermRangeQuery.h:21
Lucene::IndexOutput
Abstract base class for output to a file in a Directory. A random-access output stream....
Definition: IndexOutput.h:18
Lucene::Random
Utility class to generate a stream of pseudorandom numbers.
Definition: Random.h:15
Lucene::WordlistLoader
Loader for text files that represent a list of stopwords.
Definition: WordlistLoader.h:15
Lucene::FieldCacheImpl
The default cache implementation, storing all values in memory. A WeakHashMap is used for storage.
Definition: FieldCacheImpl.h:15
Lucene::StoredFieldsWriter
This is a DocFieldConsumer that writes stored fields.
Definition: StoredFieldsWriter.h:15
Lucene::Sort
Encapsulates sort criteria for returned hits.
Definition: Sort.h:68
Lucene::DocConsumerPerThread
Definition: DocConsumerPerThread.h:14
Lucene::QueryParserCharStream
This interface describes a character stream that maintains line and column number positions of the ch...
Definition: QueryParserCharStream.h:22
Lucene::DateField
Provides support for converting dates to strings and vice-versa. The strings are structured so that l...
Definition: DateField.h:31
Lucene::TermVectorsTermsWriterPostingList
Definition: TermVectorsTermsWriter.h:80
Lucene::FormatPostingsTermsConsumer
Definition: FormatPostingsTermsConsumer.h:14
Lucene::ReaderCommit
Definition: DirectoryReader.h:302
Lucene::FieldSortedTermVectorMapper
For each Field, store a sorted collection of TermVectorEntrys This is not thread-safe.
Definition: FieldSortedTermVectorMapper.h:17
Lucene::ByteBlockPool
Class that Posting and PostingVector use to write byte streams into shared fixed-size byte[] arrays....
Definition: ByteBlockPool.h:23
Lucene::LongRangeBuilder
Callback for splitLongRange. You need to overwrite only one of the methods. NOTE: This is a very low-...
Definition: NumericUtils.h:148
Lucene::ReverseOrdFieldSource
Obtains the ordinal of the field value from the default Lucene FieldCache using getStringIndex() and ...
Definition: ReverseOrdFieldSource.h:31
Lucene::TermInfo
A TermInfo is the record of information stored for a term.
Definition: TermInfo.h:15
Lucene::FieldCacheEntryImpl
Definition: FieldCacheImpl.h:160
Lucene::TermSpans
Public for extension only.
Definition: TermSpans.h:15
Lucene::SpanNearQuery
Matches spans which are near one another. One can specify slop, the maximum number of intervening unm...
Definition: SpanNearQuery.h:16
Lucene::DocFieldConsumers
This is just a "splitter" class: it lets you wrap two DocFieldConsumer instances as a single consumer...
Definition: DocFieldConsumers.h:16
Lucene::TermVectorsTermsWriterPerField
Definition: TermVectorsTermsWriterPerField.h:14
Lucene::MultiReader
An IndexReader which reads multiple indexes, appending their content.
Definition: MultiReader.h:15
Lucene::TermVectorMapper
The TermVectorMapper can be used to map Term Vectors into your own structure instead of the parallel ...
Definition: TermVectorMapper.h:18
Lucene::TermRangeFilter
A Filter that restricts search results to a range of term values in a given field.
Definition: TermRangeFilter.h:22
Lucene::ByteSliceReader
IndexInput that knows how to read the byte slices written by Posting and PostingVector....
Definition: ByteSliceReader.h:16
Lucene::SpanFirstQuery
Matches spans near the beginning of a field.
Definition: SpanFirstQuery.h:16
Lucene::DocFieldConsumersPerField
Definition: DocFieldConsumersPerField.h:14
Lucene::DocIdBitSet
Simple DocIdSet and DocIdSetIterator backed by a BitSet.
Definition: DocIdBitSet.h:15
Lucene::TermScorer
A Scorer for documents matching a Term.
Definition: TermScorer.h:15
Lucene::PositionBasedTermVectorMapper
Definition: PositionBasedTermVectorMapper.h:14
Lucene::IndexWriter
An IndexWriter creates and maintains an index.
Definition: IndexWriter.h:90
Lucene::FieldScoreQuery
A query that scores each document as the value of the numeric input field.
Definition: FieldScoreQuery.h:43
Lucene::CountingConjunctionSumScorer
Definition: BooleanScorer2.h:145
Lucene::CSIndexInput
Implementation of an IndexInput that reads from a portion of the compound file.
Definition: CompoundFileReader.h:83
Lucene::ThreadPool
Utility class to handle a pool of threads.
Definition: ThreadPool.h:46
Lucene::DocFieldConsumersPerDoc
Definition: DocFieldConsumers.h:50
Lucene::DocInverter
This is a DocFieldConsumer that inverts each field, separately, from a Document, and accepts a Invert...
Definition: DocInverter.h:16
Lucene::DisjunctionSumScorer
A Scorer for OR like queries, counterpart of ConjunctionScorer. This Scorer implements {} and uses sk...
Definition: DisjunctionSumScorer.h:16
Lucene::CachingWrapperFilter
Wraps another filter's result and caches it. The purpose is to allow filters to simply filter,...
Definition: CachingWrapperFilter.h:16
Lucene::SnapshotDeletionPolicy
Definition: SnapshotDeletionPolicy.h:14
Lucene::FormatPostingsDocsWriter
Consumes doc & freq, writing them using the current index file format.
Definition: FormatPostingsDocsWriter.h:15
Lucene::NativeFSLockFactory
Implements LockFactory using native file lock.
Definition: NativeFSLockFactory.h:16
Lucene::StringReader
Convenience class for reading strings.
Definition: StringReader.h:15
Lucene::MultiSearcher
Implements search over a set of Searchables.
Definition: MultiSearcher.h:19
Lucene::TopScoreDocCollector
A Collector implementation that collects the top-scoring hits, returning them as a TopDocs....
Definition: TopScoreDocCollector.h:21
Lucene::FormatPostingsFieldsConsumer
Abstract API that consumes terms, doc, freq, prox and payloads postings. Concrete implementations of ...
Definition: FormatPostingsFieldsConsumer.h:16
Lucene::PrefixTermEnum
Subclass of FilteredTermEnum for enumerating all terms that match the specified prefix filter term.
Definition: PrefixTermEnum.h:18
Lucene::BooleanScorerCollector
Definition: BooleanScorer.h:65
Lucene::SegmentInfo
Information about a segment such as it's name, directory, and files related to the segment.
Definition: SegmentInfo.h:16
Lucene::Entry
Definition: FieldCacheImpl.h:51
Lucene::TermVectorsReader
Definition: TermVectorsReader.h:14
Lucene::MultiTermQuery
An abstract Query that matches documents containing a subset of terms provided by a {} enumeration.
Definition: MultiTermQuery.h:31
Lucene::PayloadNearQuery
This class is very similar to SpanNearQuery except that it factors in the value of the payloads locat...
Definition: PayloadNearQuery.h:25
Lucene::TermPositionVector
Extends TermFreqVector to provide additional information about positions in which each of the terms i...
Definition: TermPositionVector.h:16
Lucene::DefaultSkipListWriter
Implements the skip list writer for the default posting list format that stores positions and payload...
Definition: DefaultSkipListWriter.h:15
Lucene::IntParser
Interface to parse ints from document fields.
Definition: FieldCache.h:220
Lucene::QueryParser
The most important method is parse(const String&).
Definition: QueryParser.h:70
Lucene::LogDocMergePolicy
This is a LogMergePolicy that measures size of a segment as the number of documents (not taking delet...
Definition: LogDocMergePolicy.h:16
Lucene::UnicodeResult
Definition: UnicodeUtils.h:89
Lucene::FieldValueHitQueue
A hit queue for sorting by hits by terms in more than one field. Uses FieldCache::DEFAULT for maintai...
Definition: FieldValueHitQueue.h:19
Lucene::DocConsumer
Definition: DocConsumer.h:14
Lucene::BucketTable
A simple hash table of document scores within a range.
Definition: BooleanScorer.h:127
Lucene::InvertedDocEndConsumerPerThread
Definition: InvertedDocEndConsumerPerThread.h:14
Lucene::SegmentWriteState
Definition: SegmentWriteState.h:14
Lucene::SegmentTermPositionVector
Definition: SegmentTermPositionVector.h:14
Lucene::AveragePayloadFunction
Calculate the final score as the average score of all payloads seen.
Definition: AveragePayloadFunction.h:17
Lucene::TermsHashConsumerPerField
Implement this class to plug into the TermsHash processor, which inverts & stores Tokens into a hash ...
Definition: TermsHashConsumerPerField.h:16
Lucene::FreqProxFieldMergeState
Used by DocumentsWriter to merge the postings from multiple ThreadStates when creating a segment.
Definition: FreqProxFieldMergeState.h:15
Lucene::CommitPoint
Holds details for each commit point. This class is also passed to the deletion policy....
Definition: IndexFileDeleter.h:149
Lucene::InvertedDocEndConsumer
Definition: InvertedDocEndConsumer.h:14
Lucene::InfoStreamFile
Stream override to write messages to a file.
Definition: InfoStream.h:29
Lucene::LengthFilter
Removes words that are too long or too short from the stream.
Definition: LengthFilter.h:15
Lucene::StopAnalyzer
Filters LetterTokenizer with LowerCaseFilter and StopFilter.
Definition: StopAnalyzer.h:18
Lucene::ByteParser
Interface to parse bytes from document fields.
Definition: FieldCache.h:208
Lucene::IntFieldSource
Obtains int field values from the FieldCache using getInts() and makes those values available as othe...
Definition: IntFieldSource.h:24
Lucene::InputStreamReader
An InputStreamReader is a bridge from byte streams to character streams.
Definition: InputStreamReader.h:15
Lucene::FastCharStream
An efficient implementation of QueryParserCharStream interface.
Definition: FastCharStream.h:18
Lucene::Token
A Token is an occurrence of a term from the text of a field. It consists of a term's text,...
Definition: Token.h:76
Lucene::SingleTermEnum
Subclass of FilteredTermEnum for enumerating a single term.
Definition: SingleTermEnum.h:18
Lucene::FreqProxTermsWriterPerField
Definition: FreqProxTermsWriterPerField.h:14
Lucene::CharStream
CharStream adds correctOffset functionality over Reader. All Tokenizers accept a CharStream instead o...
Definition: CharStream.h:18
Lucene::UTF16Decoder
Definition: UTF8Stream.h:120
Lucene::IntCache
Definition: FieldCacheImpl.h:105
Lucene::SpanFilterResult
The results of a SpanQueryFilter. Wraps the BitSet and the position information from the SpanQuery.
Definition: SpanFilterResult.h:15
Lucene::CreationPlaceholder
Definition: FieldCache.h:170
Lucene::TermDocs
TermDocs provides an interface for enumerating <document, frequency>; pairs for a term....
Definition: TermDocs.h:19
Lucene::FieldComparatorSource
Provides a FieldComparator for custom field sorting.
Definition: FieldComparatorSource.h:15
Lucene::Collector
Collectors are primarily meant to be used to gather raw results from a search, and implement sorting ...
Definition: Collector.h:100
Lucene::BooleanScorer2
See the description in BooleanScorer, comparing BooleanScorer & BooleanScorer2.
Definition: BooleanScorer2.h:20
Lucene::SetBasedFieldSelector
Declare what fields to load normally and what fields to load lazily.
Definition: SetBasedFieldSelector.h:15
Lucene::ByteCache
Definition: FieldCacheImpl.h:94

clucene.sourceforge.net