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

Loading...
Searching...
No Matches
LuceneTypes.h
Go to the documentation of this file.
1
2// 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
20 DECLARE_SHARED_PTR(Analyzer)
21 DECLARE_SHARED_PTR(ASCIIFoldingFilter)
22 DECLARE_SHARED_PTR(BaseCharFilter)
23 DECLARE_SHARED_PTR(CachingTokenFilter)
24 DECLARE_SHARED_PTR(CharArraySet)
25 DECLARE_SHARED_PTR(CharFilter)
26 DECLARE_SHARED_PTR(CharReader)
27 DECLARE_SHARED_PTR(CharStream)
28 DECLARE_SHARED_PTR(CharTokenizer)
29 DECLARE_SHARED_PTR(FlagsAttribute)
30 DECLARE_SHARED_PTR(ISOLatin1AccentFilter)
31 DECLARE_SHARED_PTR(KeywordAnalyzer)
32 DECLARE_SHARED_PTR(KeywordTokenizer)
33 DECLARE_SHARED_PTR(LengthFilter)
34 DECLARE_SHARED_PTR(LetterTokenizer)
35 DECLARE_SHARED_PTR(LowerCaseFilter)
36 DECLARE_SHARED_PTR(LowerCaseTokenizer)
37 DECLARE_SHARED_PTR(MappingCharFilter)
38 DECLARE_SHARED_PTR(NormalizeCharMap)
39 DECLARE_SHARED_PTR(NumericTokenStream)
40 DECLARE_SHARED_PTR(OffsetAttribute)
41 DECLARE_SHARED_PTR(PayloadAttribute)
42 DECLARE_SHARED_PTR(PerFieldAnalyzerWrapper)
43 DECLARE_SHARED_PTR(PorterStemFilter)
44 DECLARE_SHARED_PTR(PorterStemmer)
45 DECLARE_SHARED_PTR(PositionIncrementAttribute)
46 DECLARE_SHARED_PTR(SimpleAnalyzer)
47 DECLARE_SHARED_PTR(SinkFilter)
48 DECLARE_SHARED_PTR(SinkTokenStream)
49 DECLARE_SHARED_PTR(StandardAnalyzer)
50 DECLARE_SHARED_PTR(StandardAnalyzerSavedStreams)
51 DECLARE_SHARED_PTR(StandardFilter)
52 DECLARE_SHARED_PTR(StandardTokenizer)
53 DECLARE_SHARED_PTR(StandardTokenizerImpl)
54 DECLARE_SHARED_PTR(StopAnalyzer)
55 DECLARE_SHARED_PTR(StopAnalyzerSavedStreams)
56 DECLARE_SHARED_PTR(StopFilter)
57 DECLARE_SHARED_PTR(TeeSinkTokenFilter)
58 DECLARE_SHARED_PTR(TermAttribute)
59 DECLARE_SHARED_PTR(Token)
60 DECLARE_SHARED_PTR(TokenAttributeFactory)
61 DECLARE_SHARED_PTR(TokenFilter)
62 DECLARE_SHARED_PTR(Tokenizer)
63 DECLARE_SHARED_PTR(TokenStream)
64 DECLARE_SHARED_PTR(TypeAttribute)
65 DECLARE_SHARED_PTR(WhitespaceAnalyzer)
66 DECLARE_SHARED_PTR(WhitespaceTokenizer)
67 DECLARE_SHARED_PTR(WordlistLoader)
68
69// document
70 DECLARE_SHARED_PTR(AbstractField)
71 DECLARE_SHARED_PTR(CompressionTools)
72 DECLARE_SHARED_PTR(DateField)
73 DECLARE_SHARED_PTR(DateTools)
74 DECLARE_SHARED_PTR(Document)
75 DECLARE_SHARED_PTR(Field)
76 DECLARE_SHARED_PTR(Fieldable)
77 DECLARE_SHARED_PTR(FieldSelector)
78 DECLARE_SHARED_PTR(LoadFirstFieldSelector)
79 DECLARE_SHARED_PTR(MapFieldSelector)
80 DECLARE_SHARED_PTR(NumberTools)
81 DECLARE_SHARED_PTR(NumericField)
82 DECLARE_SHARED_PTR(SetBasedFieldSelector)
83
84// index
85 DECLARE_SHARED_PTR(AbstractAllTermDocs)
86 DECLARE_SHARED_PTR(AllTermDocs)
87 DECLARE_SHARED_PTR(BufferedDeletes)
88 DECLARE_SHARED_PTR(ByteBlockAllocator)
89 DECLARE_SHARED_PTR(ByteBlockPool)
90 DECLARE_SHARED_PTR(ByteBlockPoolAllocatorBase)
91 DECLARE_SHARED_PTR(ByteSliceReader)
92 DECLARE_SHARED_PTR(ByteSliceWriter)
93 DECLARE_SHARED_PTR(CharBlockPool)
94 DECLARE_SHARED_PTR(CheckAbort)
95 DECLARE_SHARED_PTR(CheckIndex)
96 DECLARE_SHARED_PTR(CommitPoint)
97 DECLARE_SHARED_PTR(CompoundFileReader)
98 DECLARE_SHARED_PTR(CompoundFileWriter)
99 DECLARE_SHARED_PTR(ConcurrentMergeScheduler)
100 DECLARE_SHARED_PTR(CoreReaders)
101 DECLARE_SHARED_PTR(CSIndexInput)
102 DECLARE_SHARED_PTR(DefaultIndexingChain)
103 DECLARE_SHARED_PTR(DefaultSkipListReader)
104 DECLARE_SHARED_PTR(DefaultSkipListWriter)
105 DECLARE_SHARED_PTR(DirectoryReader)
106 DECLARE_SHARED_PTR(DocConsumer)
107 DECLARE_SHARED_PTR(DocConsumerPerThread)
108 DECLARE_SHARED_PTR(DocFieldConsumer)
109 DECLARE_SHARED_PTR(DocFieldConsumerPerField)
110 DECLARE_SHARED_PTR(DocFieldConsumerPerThread)
111 DECLARE_SHARED_PTR(DocFieldConsumers)
112 DECLARE_SHARED_PTR(DocFieldConsumersPerDoc)
113 DECLARE_SHARED_PTR(DocFieldConsumersPerField)
114 DECLARE_SHARED_PTR(DocFieldConsumersPerThread)
115 DECLARE_SHARED_PTR(DocFieldProcessor)
116 DECLARE_SHARED_PTR(DocFieldProcessorPerField)
117 DECLARE_SHARED_PTR(DocFieldProcessorPerThread)
118 DECLARE_SHARED_PTR(DocFieldProcessorPerThreadPerDoc)
119 DECLARE_SHARED_PTR(DocInverter)
120 DECLARE_SHARED_PTR(DocInverterPerField)
121 DECLARE_SHARED_PTR(DocInverterPerThread)
122 DECLARE_SHARED_PTR(DocState)
123 DECLARE_SHARED_PTR(DocumentsWriter)
124 DECLARE_SHARED_PTR(DocumentsWriterThreadState)
125 DECLARE_SHARED_PTR(DocWriter)
126 DECLARE_SHARED_PTR(FieldInfo)
127 DECLARE_SHARED_PTR(FieldInfos)
128 DECLARE_SHARED_PTR(FieldInvertState)
129 DECLARE_SHARED_PTR(FieldNormStatus)
130 DECLARE_SHARED_PTR(FieldSortedTermVectorMapper)
131 DECLARE_SHARED_PTR(FieldsReader)
132 DECLARE_SHARED_PTR(FieldsReaderLocal)
133 DECLARE_SHARED_PTR(FieldsWriter)
134 DECLARE_SHARED_PTR(FilterIndexReader)
135 DECLARE_SHARED_PTR(FindSegmentsModified)
136 DECLARE_SHARED_PTR(FindSegmentsOpen)
137 DECLARE_SHARED_PTR(FindSegmentsRead)
138 DECLARE_SHARED_PTR(FindSegmentsReopen)
139 DECLARE_SHARED_PTR(FormatPostingsDocsConsumer)
140 DECLARE_SHARED_PTR(FormatPostingsDocsWriter)
141 DECLARE_SHARED_PTR(FormatPostingsFieldsConsumer)
142 DECLARE_SHARED_PTR(FormatPostingsFieldsWriter)
143 DECLARE_SHARED_PTR(FormatPostingsPositionsConsumer)
144 DECLARE_SHARED_PTR(FormatPostingsPositionsWriter)
145 DECLARE_SHARED_PTR(FormatPostingsTermsConsumer)
146 DECLARE_SHARED_PTR(FormatPostingsTermsWriter)
147 DECLARE_SHARED_PTR(FreqProxFieldMergeState)
148 DECLARE_SHARED_PTR(FreqProxTermsWriter)
149 DECLARE_SHARED_PTR(FreqProxTermsWriterPerField)
150 DECLARE_SHARED_PTR(FreqProxTermsWriterPerThread)
151 DECLARE_SHARED_PTR(FreqProxTermsWriterPostingList)
152 DECLARE_SHARED_PTR(IndexCommit)
153 DECLARE_SHARED_PTR(IndexDeletionPolicy)
154 DECLARE_SHARED_PTR(IndexFileDeleter)
155 DECLARE_SHARED_PTR(IndexFileNameFilter)
156 DECLARE_SHARED_PTR(IndexingChain)
157 DECLARE_SHARED_PTR(IndexReader)
158 DECLARE_SHARED_PTR(IndexReaderWarmer)
159 DECLARE_SHARED_PTR(IndexStatus)
160 DECLARE_SHARED_PTR(IndexWriter)
161 DECLARE_SHARED_PTR(IntBlockPool)
162 DECLARE_SHARED_PTR(IntQueue)
163 DECLARE_SHARED_PTR(InvertedDocConsumer)
164 DECLARE_SHARED_PTR(InvertedDocConsumerPerField)
165 DECLARE_SHARED_PTR(InvertedDocConsumerPerThread)
166 DECLARE_SHARED_PTR(InvertedDocEndConsumer)
167 DECLARE_SHARED_PTR(InvertedDocEndConsumerPerField)
168 DECLARE_SHARED_PTR(InvertedDocEndConsumerPerThread)
169 DECLARE_SHARED_PTR(KeepOnlyLastCommitDeletionPolicy)
170 DECLARE_SHARED_PTR(LogByteSizeMergePolicy)
171 DECLARE_SHARED_PTR(LogDocMergePolicy)
172 DECLARE_SHARED_PTR(LogMergePolicy)
173 DECLARE_SHARED_PTR(MergeDocIDRemapper)
174 DECLARE_SHARED_PTR(MergePolicy)
175 DECLARE_SHARED_PTR(MergeScheduler)
176 DECLARE_SHARED_PTR(MergeSpecification)
177 DECLARE_SHARED_PTR(MergeThread)
178 DECLARE_SHARED_PTR(MultiLevelSkipListReader)
179 DECLARE_SHARED_PTR(MultiLevelSkipListWriter)
180 DECLARE_SHARED_PTR(MultipleTermPositions)
181 DECLARE_SHARED_PTR(MultiReader)
182 DECLARE_SHARED_PTR(MultiTermDocs)
183 DECLARE_SHARED_PTR(MultiTermEnum)
184 DECLARE_SHARED_PTR(MultiTermPositions)
185 DECLARE_SHARED_PTR(MyCommitPoint)
186 DECLARE_SHARED_PTR(MySegmentTermDocs)
187 DECLARE_SHARED_PTR(Norm)
188 DECLARE_SHARED_PTR(NormsWriter)
189 DECLARE_SHARED_PTR(NormsWriterPerField)
190 DECLARE_SHARED_PTR(NormsWriterPerThread)
191 DECLARE_SHARED_PTR(Num)
192 DECLARE_SHARED_PTR(OneMerge)
193 DECLARE_SHARED_PTR(ParallelArrayTermVectorMapper)
194 DECLARE_SHARED_PTR(ParallelReader)
195 DECLARE_SHARED_PTR(ParallelTermEnum)
196 DECLARE_SHARED_PTR(ParallelTermDocs)
197 DECLARE_SHARED_PTR(ParallelTermPositions)
198 DECLARE_SHARED_PTR(Payload)
199 DECLARE_SHARED_PTR(PerDocBuffer)
200 DECLARE_SHARED_PTR(PositionBasedTermVectorMapper)
201 DECLARE_SHARED_PTR(RawPostingList)
202 DECLARE_SHARED_PTR(ReaderCommit)
203 DECLARE_SHARED_PTR(ReaderPool)
204 DECLARE_SHARED_PTR(ReadOnlyDirectoryReader)
205 DECLARE_SHARED_PTR(ReadOnlySegmentReader)
206 DECLARE_SHARED_PTR(RefCount)
207 DECLARE_SHARED_PTR(ReusableStringReader)
208 DECLARE_SHARED_PTR(SegmentInfo)
209 DECLARE_SHARED_PTR(SegmentInfoCollection)
210 DECLARE_SHARED_PTR(SegmentInfos)
211 DECLARE_SHARED_PTR(SegmentInfoStatus)
212 DECLARE_SHARED_PTR(SegmentMergeInfo)
213 DECLARE_SHARED_PTR(SegmentMergeQueue)
214 DECLARE_SHARED_PTR(SegmentMerger)
215 DECLARE_SHARED_PTR(SegmentReader)
216 DECLARE_SHARED_PTR(SegmentReaderRef)
217 DECLARE_SHARED_PTR(SegmentTermDocs)
218 DECLARE_SHARED_PTR(SegmentTermEnum)
219 DECLARE_SHARED_PTR(SegmentTermPositions)
220 DECLARE_SHARED_PTR(SegmentTermPositionVector)
221 DECLARE_SHARED_PTR(SegmentTermVector)
222 DECLARE_SHARED_PTR(SegmentWriteState)
223 DECLARE_SHARED_PTR(SerialMergeScheduler)
224 DECLARE_SHARED_PTR(SingleTokenAttributeSource)
225 DECLARE_SHARED_PTR(SkipBuffer)
226 DECLARE_SHARED_PTR(SkipDocWriter)
227 DECLARE_SHARED_PTR(SnapshotDeletionPolicy)
228 DECLARE_SHARED_PTR(SortedTermVectorMapper)
229 DECLARE_SHARED_PTR(StoredFieldStatus)
230 DECLARE_SHARED_PTR(StoredFieldsWriter)
231 DECLARE_SHARED_PTR(StoredFieldsWriterPerDoc)
232 DECLARE_SHARED_PTR(StoredFieldsWriterPerThread)
233 DECLARE_SHARED_PTR(Term)
234 DECLARE_SHARED_PTR(TermBuffer)
235 DECLARE_SHARED_PTR(TermEnum)
236 DECLARE_SHARED_PTR(TermDocs)
237 DECLARE_SHARED_PTR(TermFreqVector)
238 DECLARE_SHARED_PTR(TermIndexStatus)
239 DECLARE_SHARED_PTR(TermInfo)
240 DECLARE_SHARED_PTR(TermInfosReader)
241 DECLARE_SHARED_PTR(TermInfosReaderThreadResources)
242 DECLARE_SHARED_PTR(TermInfosWriter)
243 DECLARE_SHARED_PTR(TermPositions)
244 DECLARE_SHARED_PTR(TermPositionsQueue)
245 DECLARE_SHARED_PTR(TermPositionVector)
246 DECLARE_SHARED_PTR(TermsHash)
247 DECLARE_SHARED_PTR(TermsHashConsumer)
248 DECLARE_SHARED_PTR(TermsHashConsumerPerField)
249 DECLARE_SHARED_PTR(TermsHashConsumerPerThread)
250 DECLARE_SHARED_PTR(TermsHashPerField)
251 DECLARE_SHARED_PTR(TermsHashPerThread)
252 DECLARE_SHARED_PTR(TermVectorEntry)
253 DECLARE_SHARED_PTR(TermVectorEntryFreqSortedComparator)
254 DECLARE_SHARED_PTR(TermVectorMapper)
255 DECLARE_SHARED_PTR(TermVectorOffsetInfo)
256 DECLARE_SHARED_PTR(TermVectorsReader)
257 DECLARE_SHARED_PTR(TermVectorStatus)
258 DECLARE_SHARED_PTR(TermVectorsTermsWriter)
259 DECLARE_SHARED_PTR(TermVectorsTermsWriterPerDoc)
260 DECLARE_SHARED_PTR(TermVectorsTermsWriterPerField)
261 DECLARE_SHARED_PTR(TermVectorsTermsWriterPerThread)
262 DECLARE_SHARED_PTR(TermVectorsTermsWriterPostingList)
263 DECLARE_SHARED_PTR(TermVectorsWriter)
264 DECLARE_SHARED_PTR(TermVectorsPositionInfo)
265 DECLARE_SHARED_PTR(WaitQueue)
266
267// query parser
268 DECLARE_SHARED_PTR(FastCharStream)
269 DECLARE_SHARED_PTR(MultiFieldQueryParser)
270 DECLARE_SHARED_PTR(QueryParser)
271 DECLARE_SHARED_PTR(QueryParserCharStream)
272 DECLARE_SHARED_PTR(QueryParserConstants)
273 DECLARE_SHARED_PTR(QueryParserToken)
274 DECLARE_SHARED_PTR(QueryParserTokenManager)
275
276// search
277 DECLARE_SHARED_PTR(AveragePayloadFunction)
278 DECLARE_SHARED_PTR(BooleanClause)
279 DECLARE_SHARED_PTR(BooleanQuery)
280 DECLARE_SHARED_PTR(BooleanScorer)
281 DECLARE_SHARED_PTR(BooleanScorerCollector)
282 DECLARE_SHARED_PTR(BooleanScorer2)
283 DECLARE_SHARED_PTR(BooleanWeight)
284 DECLARE_SHARED_PTR(Bucket)
285 DECLARE_SHARED_PTR(BucketScorer)
286 DECLARE_SHARED_PTR(BucketTable)
287 DECLARE_SHARED_PTR(ByteCache)
288 DECLARE_SHARED_PTR(ByteFieldSource)
289 DECLARE_SHARED_PTR(ByteParser)
290 DECLARE_SHARED_PTR(Cache)
291 DECLARE_SHARED_PTR(CachedDfSource)
292 DECLARE_SHARED_PTR(CachingSpanFilter)
293 DECLARE_SHARED_PTR(CachingWrapperFilter)
294 DECLARE_SHARED_PTR(CellQueue)
295 DECLARE_SHARED_PTR(Collector)
296 DECLARE_SHARED_PTR(ComplexExplanation)
297 DECLARE_SHARED_PTR(ConjunctionScorer)
298 DECLARE_SHARED_PTR(ConstantScoreAutoRewrite)
299 DECLARE_SHARED_PTR(ConstantScoreAutoRewriteDefault)
300 DECLARE_SHARED_PTR(ConstantScoreBooleanQueryRewrite)
301 DECLARE_SHARED_PTR(ConstantScoreFilterRewrite)
302 DECLARE_SHARED_PTR(ConstantScoreQuery)
303 DECLARE_SHARED_PTR(ConstantScorer)
304 DECLARE_SHARED_PTR(ConstantWeight)
305 DECLARE_SHARED_PTR(Coordinator)
306 DECLARE_SHARED_PTR(CountingConjunctionSumScorer)
307 DECLARE_SHARED_PTR(CountingDisjunctionSumScorer)
308 DECLARE_SHARED_PTR(CreationPlaceholder)
309 DECLARE_SHARED_PTR(CustomScoreProvider)
310 DECLARE_SHARED_PTR(CustomScoreQuery)
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)
318 DECLARE_SHARED_PTR(DefaultSimilarity)
319 DECLARE_SHARED_PTR(DisjunctionMaxQuery)
320 DECLARE_SHARED_PTR(DisjunctionMaxScorer)
321 DECLARE_SHARED_PTR(DisjunctionMaxWeight)
322 DECLARE_SHARED_PTR(DisjunctionSumScorer)
323 DECLARE_SHARED_PTR(DocIdSet)
324 DECLARE_SHARED_PTR(DocIdSetIterator)
325 DECLARE_SHARED_PTR(DocValues)
326 DECLARE_SHARED_PTR(DoubleCache)
327 DECLARE_SHARED_PTR(DoubleFieldSource)
328 DECLARE_SHARED_PTR(DoubleParser)
329 DECLARE_SHARED_PTR(EmptyDocIdSet)
330 DECLARE_SHARED_PTR(EmptyDocIdSetIterator)
331 DECLARE_SHARED_PTR(Entry)
332 DECLARE_SHARED_PTR(ExactPhraseScorer)
333 DECLARE_SHARED_PTR(Explanation)
334 DECLARE_SHARED_PTR(FieldCache)
335 DECLARE_SHARED_PTR(FieldCacheDocIdSet)
336 DECLARE_SHARED_PTR(FieldCacheEntry)
337 DECLARE_SHARED_PTR(FieldCacheEntryImpl)
338 DECLARE_SHARED_PTR(FieldCacheImpl)
339 DECLARE_SHARED_PTR(FieldCacheRangeFilter)
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)
345 DECLARE_SHARED_PTR(FieldCacheSource)
346 DECLARE_SHARED_PTR(FieldCacheTermsFilter)
347 DECLARE_SHARED_PTR(FieldCacheTermsFilterDocIdSet)
348 DECLARE_SHARED_PTR(FieldComparator)
349 DECLARE_SHARED_PTR(FieldComparatorSource)
350 DECLARE_SHARED_PTR(FieldDoc)
351 DECLARE_SHARED_PTR(FieldDocIdSetIteratorIncrement)
352 DECLARE_SHARED_PTR(FieldDocIdSetIteratorTermDocs)
353 DECLARE_SHARED_PTR(FieldDocSortedHitQueue)
354 DECLARE_SHARED_PTR(FieldMaskingSpanQuery)
355 DECLARE_SHARED_PTR(FieldScoreQuery)
356 DECLARE_SHARED_PTR(FieldValueHitQueue)
357 DECLARE_SHARED_PTR(FieldValueHitQueueEntry)
358 DECLARE_SHARED_PTR(Filter)
359 DECLARE_SHARED_PTR(FilterCache)
360 DECLARE_SHARED_PTR(FilterCleaner)
361 DECLARE_SHARED_PTR(FilteredDocIdSet)
362 DECLARE_SHARED_PTR(FilteredDocIdSetIterator)
363 DECLARE_SHARED_PTR(FilteredQuery)
364 DECLARE_SHARED_PTR(FilteredQueryWeight)
365 DECLARE_SHARED_PTR(FilteredTermEnum)
366 DECLARE_SHARED_PTR(FilterItem)
367 DECLARE_SHARED_PTR(FilterManager)
368 DECLARE_SHARED_PTR(FuzzyQuery)
369 DECLARE_SHARED_PTR(FuzzyTermEnum)
370 DECLARE_SHARED_PTR(HitQueue)
371 DECLARE_SHARED_PTR(HitQueueBase)
372 DECLARE_SHARED_PTR(IDFExplanation)
373 DECLARE_SHARED_PTR(IndexSearcher)
374 DECLARE_SHARED_PTR(IntCache)
375 DECLARE_SHARED_PTR(IntFieldSource)
376 DECLARE_SHARED_PTR(IntParser)
377 DECLARE_SHARED_PTR(LongCache)
378 DECLARE_SHARED_PTR(LongParser)
379 DECLARE_SHARED_PTR(MatchAllDocsQuery)
380 DECLARE_SHARED_PTR(MatchAllDocsWeight)
381 DECLARE_SHARED_PTR(MatchAllScorer)
382 DECLARE_SHARED_PTR(MaxPayloadFunction)
383 DECLARE_SHARED_PTR(MinPayloadFunction)
384 DECLARE_SHARED_PTR(MultiComparatorsFieldValueHitQueue)
385 DECLARE_SHARED_PTR(MultiPhraseQuery)
386 DECLARE_SHARED_PTR(MultiSearcher)
387 DECLARE_SHARED_PTR(MultiSearcherCallableNoSort)
388 DECLARE_SHARED_PTR(MultiSearcherCallableWithSort)
389 DECLARE_SHARED_PTR(MultiTermQuery)
390 DECLARE_SHARED_PTR(MultiTermQueryWrapperFilter)
391 DECLARE_SHARED_PTR(NearSpansOrdered)
392 DECLARE_SHARED_PTR(NearSpansUnordered)
393 DECLARE_SHARED_PTR(NumericRangeFilter)
394 DECLARE_SHARED_PTR(NumericRangeQuery)
395 DECLARE_SHARED_PTR(NumericUtilsDoubleParser)
396 DECLARE_SHARED_PTR(NumericUtilsIntParser)
397 DECLARE_SHARED_PTR(NumericUtilsLongParser)
398 DECLARE_SHARED_PTR(OneComparatorFieldValueHitQueue)
399 DECLARE_SHARED_PTR(OrdFieldSource)
400 DECLARE_SHARED_PTR(ParallelMultiSearcher)
401 DECLARE_SHARED_PTR(Parser)
402 DECLARE_SHARED_PTR(PayloadFunction)
403 DECLARE_SHARED_PTR(PayloadNearQuery)
404 DECLARE_SHARED_PTR(PayloadNearSpanScorer)
405 DECLARE_SHARED_PTR(PayloadNearSpanWeight)
406 DECLARE_SHARED_PTR(PayloadSpanUtil)
407 DECLARE_SHARED_PTR(PayloadTermQuery)
408 DECLARE_SHARED_PTR(PayloadTermSpanScorer)
409 DECLARE_SHARED_PTR(PayloadTermWeight)
410 DECLARE_SHARED_PTR(PhrasePositions)
411 DECLARE_SHARED_PTR(PhraseQuery)
412 DECLARE_SHARED_PTR(PhraseQueue)
413 DECLARE_SHARED_PTR(PhraseScorer)
414 DECLARE_SHARED_PTR(PositionInfo)
415 DECLARE_SHARED_PTR(PositiveScoresOnlyCollector)
416 DECLARE_SHARED_PTR(PrefixFilter)
417 DECLARE_SHARED_PTR(PrefixQuery)
418 DECLARE_SHARED_PTR(PrefixTermEnum)
419 DECLARE_SHARED_PTR(PriorityQueueScoreDocs)
420 DECLARE_SHARED_PTR(Query)
421 DECLARE_SHARED_PTR(QueryTermVector)
422 DECLARE_SHARED_PTR(QueryWrapperFilter)
423 DECLARE_SHARED_PTR(ReqExclScorer)
424 DECLARE_SHARED_PTR(ReqOptSumScorer)
425 DECLARE_SHARED_PTR(RewriteMethod)
426 DECLARE_SHARED_PTR(ReverseOrdFieldSource)
427 DECLARE_SHARED_PTR(ScoreCachingWrappingScorer)
428 DECLARE_SHARED_PTR(ScoreDoc)
429 DECLARE_SHARED_PTR(Scorer)
430 DECLARE_SHARED_PTR(ScoreTerm)
431 DECLARE_SHARED_PTR(ScoreTermQueue)
432 DECLARE_SHARED_PTR(ScoringBooleanQueryRewrite)
433 DECLARE_SHARED_PTR(Searchable)
434 DECLARE_SHARED_PTR(Searcher)
435 DECLARE_SHARED_PTR(Similarity)
436 DECLARE_SHARED_PTR(SimilarityDisableCoord)
437 DECLARE_SHARED_PTR(SimilarityDelegator)
438 DECLARE_SHARED_PTR(SimilarityIDFExplanation)
439 DECLARE_SHARED_PTR(SingleMatchScorer)
440 DECLARE_SHARED_PTR(SingleTermEnum)
441 DECLARE_SHARED_PTR(SloppyPhraseScorer)
442 DECLARE_SHARED_PTR(Sort)
443 DECLARE_SHARED_PTR(SortField)
444 DECLARE_SHARED_PTR(SpanFilter)
445 DECLARE_SHARED_PTR(SpanFilterResult)
446 DECLARE_SHARED_PTR(SpanFirstQuery)
447 DECLARE_SHARED_PTR(SpanNearQuery)
448 DECLARE_SHARED_PTR(SpanNotQuery)
449 DECLARE_SHARED_PTR(SpanOrQuery)
450 DECLARE_SHARED_PTR(SpanQuery)
451 DECLARE_SHARED_PTR(SpanQueryFilter)
452 DECLARE_SHARED_PTR(SpanQueue)
453 DECLARE_SHARED_PTR(Spans)
454 DECLARE_SHARED_PTR(SpansCell)
455 DECLARE_SHARED_PTR(SpanScorer)
456 DECLARE_SHARED_PTR(SpanTermQuery)
457 DECLARE_SHARED_PTR(SpanWeight)
458 DECLARE_SHARED_PTR(StartEnd)
459 DECLARE_SHARED_PTR(StringCache)
460 DECLARE_SHARED_PTR(StringIndex)
461 DECLARE_SHARED_PTR(StringIndexCache)
462 DECLARE_SHARED_PTR(SubScorer)
463 DECLARE_SHARED_PTR(TermQuery)
464 DECLARE_SHARED_PTR(TermRangeFilter)
465 DECLARE_SHARED_PTR(TermRangeQuery)
466 DECLARE_SHARED_PTR(TermRangeTermEnum)
467 DECLARE_SHARED_PTR(TermScorer)
468 DECLARE_SHARED_PTR(TermSpans)
469 DECLARE_SHARED_PTR(TimeLimitingCollector)
470 DECLARE_SHARED_PTR(TimerThread)
471 DECLARE_SHARED_PTR(TopDocs)
472 DECLARE_SHARED_PTR(TopDocsCollector)
473 DECLARE_SHARED_PTR(TopFieldCollector)
474 DECLARE_SHARED_PTR(TopFieldDocs)
475 DECLARE_SHARED_PTR(TopScoreDocCollector)
476 DECLARE_SHARED_PTR(ValueSource)
477 DECLARE_SHARED_PTR(ValueSourceQuery)
478 DECLARE_SHARED_PTR(ValueSourceScorer)
479 DECLARE_SHARED_PTR(ValueSourceWeight)
480 DECLARE_SHARED_PTR(Weight)
481 DECLARE_SHARED_PTR(WildcardQuery)
482 DECLARE_SHARED_PTR(WildcardTermEnum)
483
484// store
485 DECLARE_SHARED_PTR(BufferedIndexInput)
486 DECLARE_SHARED_PTR(BufferedIndexOutput)
487 DECLARE_SHARED_PTR(ChecksumIndexInput)
488 DECLARE_SHARED_PTR(ChecksumIndexOutput)
489 DECLARE_SHARED_PTR(Directory)
490 DECLARE_SHARED_PTR(FileSwitchDirectory)
491 DECLARE_SHARED_PTR(FSDirectory)
492 DECLARE_SHARED_PTR(FSLockFactory)
493 DECLARE_SHARED_PTR(IndexInput)
494 DECLARE_SHARED_PTR(IndexOutput)
495 DECLARE_SHARED_PTR(InputFile)
496 DECLARE_SHARED_PTR(Lock)
497 DECLARE_SHARED_PTR(LockFactory)
498 DECLARE_SHARED_PTR(MMapDirectory)
499 DECLARE_SHARED_PTR(MMapIndexInput)
500 DECLARE_SHARED_PTR(NativeFSLock)
501 DECLARE_SHARED_PTR(NativeFSLockFactory)
502 DECLARE_SHARED_PTR(NoLock)
503 DECLARE_SHARED_PTR(NoLockFactory)
504 DECLARE_SHARED_PTR(OutputFile)
505 DECLARE_SHARED_PTR(RAMDirectory)
506 DECLARE_SHARED_PTR(RAMFile)
507 DECLARE_SHARED_PTR(RAMInputStream)
508 DECLARE_SHARED_PTR(RAMOutputStream)
509 DECLARE_SHARED_PTR(SimpleFSDirectory)
510 DECLARE_SHARED_PTR(SimpleFSIndexInput)
511 DECLARE_SHARED_PTR(SimpleFSIndexOutput)
512 DECLARE_SHARED_PTR(SimpleFSLock)
513 DECLARE_SHARED_PTR(SimpleFSLockFactory)
514 DECLARE_SHARED_PTR(SingleInstanceLock)
515 DECLARE_SHARED_PTR(SingleInstanceLockFactory)
516
517// util
518 DECLARE_SHARED_PTR(Attribute)
519 DECLARE_SHARED_PTR(AttributeFactory)
520 DECLARE_SHARED_PTR(AttributeSource)
521 DECLARE_SHARED_PTR(AttributeSourceState)
522 DECLARE_SHARED_PTR(BitSet)
523 DECLARE_SHARED_PTR(BitVector)
524 DECLARE_SHARED_PTR(BufferedReader)
525 DECLARE_SHARED_PTR(Collator)
526 DECLARE_SHARED_PTR(DefaultAttributeFactory)
527 DECLARE_SHARED_PTR(DocIdBitSet)
528 DECLARE_SHARED_PTR(FieldCacheSanityChecker)
529 DECLARE_SHARED_PTR(FileReader)
530 DECLARE_SHARED_PTR(Future)
531 DECLARE_SHARED_PTR(HeapedScorerDoc)
532 DECLARE_SHARED_PTR(InfoStream)
533 DECLARE_SHARED_PTR(InfoStreamFile)
534 DECLARE_SHARED_PTR(InfoStreamOut)
535 DECLARE_SHARED_PTR(InputStreamReader)
536 DECLARE_SHARED_PTR(Insanity)
537 DECLARE_SHARED_PTR(IntRangeBuilder)
538 DECLARE_SHARED_PTR(LongRangeBuilder)
539 DECLARE_SHARED_PTR(LuceneObject)
540 DECLARE_SHARED_PTR(LuceneSignal)
541 DECLARE_SHARED_PTR(LuceneThread)
542 DECLARE_SHARED_PTR(NumericUtils)
543 DECLARE_SHARED_PTR(OpenBitSet)
544 DECLARE_SHARED_PTR(OpenBitSetDISI)
545 DECLARE_SHARED_PTR(OpenBitSetIterator)
546 DECLARE_SHARED_PTR(Random)
547 DECLARE_SHARED_PTR(Reader)
548 DECLARE_SHARED_PTR(ReaderField)
549 DECLARE_SHARED_PTR(ScorerDocQueue)
550 DECLARE_SHARED_PTR(SortedVIntList)
551 DECLARE_SHARED_PTR(StringReader)
552 DECLARE_SHARED_PTR(Synchronize)
553 DECLARE_SHARED_PTR(ThreadPool)
554 DECLARE_SHARED_PTR(UnicodeResult)
555 DECLARE_SHARED_PTR(UTF8Decoder)
556 DECLARE_SHARED_PTR(UTF8DecoderStream)
557 DECLARE_SHARED_PTR(UTF8Encoder)
558 DECLARE_SHARED_PTR(UTF8EncoderStream)
559 DECLARE_SHARED_PTR(UTF8Result)
560 DECLARE_SHARED_PTR(UTF16Decoder)
561}
562
563#endif
DECLARE_SHARED_PTR
#define DECLARE_SHARED_PTR(Type)
Definition LuceneTypes.h:12
Lucene::ASCIIFoldingFilter
This class converts alphabetic, numeric, and symbolic Unicode characters which are not in the first 1...
Definition ASCIIFoldingFilter.h:42
Lucene::AbstractAllTermDocs
Base class for enumerating all but deleted docs.
Definition AbstractAllTermDocs.h:18
Lucene::AbstractField
Definition AbstractField.h:14
Lucene::AllTermDocs
Definition AllTermDocs.h:14
Lucene::Analyzer
An Analyzer builds TokenStreams, which analyze text. It thus represents a policy for extracting index...
Definition Analyzer.h:19
Lucene::AttributeFactory
Definition AttributeSource.h:14
Lucene::AttributeSourceState
This class holds the state of an AttributeSource.
Definition AttributeSource.h:168
Lucene::AttributeSource
An AttributeSource contains a list of different Attributes, and methods to add and get them....
Definition AttributeSource.h:43
Lucene::Attribute
Base class for Attributes that can be added to a AttributeSource.
Definition Attribute.h:18
Lucene::AveragePayloadFunction
Calculate the final score as the average score of all payloads seen.
Definition AveragePayloadFunction.h:17
Lucene::BaseCharFilter
Base utility class for implementing a CharFilter. You subclass this, and then record mappings by call...
Definition BaseCharFilter.h:16
Lucene::BitSet
Definition BitSet.h:15
Lucene::BitVector
Optimized implementation of a vector of bits.
Definition BitVector.h:15
Lucene::BooleanClause
A clause in a BooleanQuery.
Definition BooleanClause.h:15
Lucene::BooleanQuery
A Query that matches documents matching boolean combinations of other queries, eg....
Definition BooleanQuery.h:18
Lucene::BooleanScorer2
See the description in BooleanScorer, comparing BooleanScorer & BooleanScorer2.
Definition BooleanScorer2.h:20
Lucene::BooleanScorerCollector
Definition BooleanScorer.h:66
Lucene::BooleanScorer
BooleanScorer uses a ~16k array to score windows of docs. So it scores docs 0-16k first,...
Definition BooleanScorer.h:30
Lucene::BucketScorer
Definition BooleanScorer.h:90
Lucene::BucketTable
A simple hash table of document scores within a range.
Definition BooleanScorer.h:131
Lucene::Bucket
Definition BooleanScorer.h:114
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::BufferedIndexInput
Base implementation class for buffered IndexInput.
Definition BufferedIndexInput.h:15
Lucene::BufferedIndexOutput
Base implementation class for buffered IndexOutput.
Definition BufferedIndexOutput.h:15
Lucene::BufferedReader
Read text from a character-input stream, buffering characters so as to provide for the efficient read...
Definition BufferedReader.h:16
Lucene::ByteBlockAllocator
Definition DocumentsWriter.h:497
Lucene::ByteBlockPoolAllocatorBase
Definition ByteBlockPool.h:54
Lucene::ByteBlockPool
Class that Posting and PostingVector use to write byte streams into shared fixed-size byte[] arrays....
Definition ByteBlockPool.h:23
Lucene::ByteCache
Definition FieldCacheImpl.h:94
Lucene::ByteFieldSource
Obtains byte field values from the FieldCache using getBytes() and makes those values available as ot...
Definition ByteFieldSource.h:24
Lucene::ByteParser
Interface to parse bytes from document fields.
Definition FieldCache.h:208
Lucene::ByteSliceReader
IndexInput that knows how to read the byte slices written by Posting and PostingVector....
Definition ByteSliceReader.h:16
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::CSIndexInput
Implementation of an IndexInput that reads from a portion of the compound file.
Definition CompoundFileReader.h:83
Lucene::Cache
Internal cache.
Definition FieldCacheImpl.h:72
Lucene::CachingSpanFilter
Wraps another SpanFilter's result and caches it. The purpose is to allow filters to simply filter,...
Definition CachingSpanFilter.h:17
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::CachingWrapperFilter
Wraps another filter's result and caches it. The purpose is to allow filters to simply filter,...
Definition CachingWrapperFilter.h:16
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::CharBlockPool
Definition CharBlockPool.h:14
Lucene::CharFilter
Subclasses of CharFilter can be chained to filter CharStream. They can be used as Reader with additio...
Definition CharFilter.h:17
Lucene::CharReader
CharReader is a Reader wrapper. It reads chars from Reader and outputs CharStream,...
Definition CharReader.h:16
Lucene::CharStream
CharStream adds correctOffset functionality over Reader. All Tokenizers accept a CharStream instead o...
Definition CharStream.h:18
Lucene::CharTokenizer
An abstract base class for simple, character-oriented tokenizers.
Definition CharTokenizer.h:15
Lucene::CheckAbort
Definition SegmentMerger.h:122
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::ChecksumIndexInput
Writes bytes through to a primary IndexInput, computing checksum as it goes. Note that you cannot use...
Definition ChecksumIndexInput.h:17
Lucene::ChecksumIndexOutput
Writes bytes through to a primary IndexOutput, computing checksum. Note that you cannot use seek().
Definition ChecksumIndexOutput.h:17
Lucene::Collator
Convenience class for storing collate objects.
Definition Collator.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::CommitPoint
Holds details for each commit point. This class is also passed to the deletion policy....
Definition IndexFileDeleter.h:149
Lucene::ComplexExplanation
Describes the score computation for document and query, and can distinguish a match independent of a ...
Definition ComplexExplanation.h:16
Lucene::CompoundFileReader
Class for accessing a compound stream. This class implements a directory, but is limited to only read...
Definition CompoundFileReader.h:18
Lucene::CompoundFileWriter
Combines multiple files into a single compound file. The file format: VInt fileCount {Directory} file...
Definition CompoundFileWriter.h:27
Lucene::CompressionTools
Simple utility class providing static methods to compress and decompress binary data for stored field...
Definition CompressionTools.h:15
Lucene::ConcurrentMergeScheduler
A MergeScheduler that runs each merge using a separate thread, up until a maximum number of threads (...
Definition ConcurrentMergeScheduler.h:19
Lucene::ConjunctionScorer
Scorer for conjunctions, sets of queries, all of which are required.
Definition ConjunctionScorer.h:15
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::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::Coordinator
Definition BooleanScorer2.h:85
Lucene::CountingConjunctionSumScorer
Definition BooleanScorer2.h:145
Lucene::CountingDisjunctionSumScorer
Definition BooleanScorer2.h:125
Lucene::CreationPlaceholder
Definition FieldCache.h:170
Lucene::CustomScoreProvider
An instance of this subclass should be returned by CustomScoreQuery#getCustomScoreProvider,...
Definition CustomScoreProvider.h:21
Lucene::CustomScoreQuery
Query that sets document score as a programmatic function of several (sub) scores:
Definition CustomScoreQuery.h:21
Lucene::DateField
Provides support for converting dates to strings and vice-versa. The strings are structured so that l...
Definition DateField.h:31
Lucene::DateTools
Provides support for converting dates to strings and vice-versa. The strings are structured so that l...
Definition DateTools.h:28
Lucene::DefaultAttributeFactory
Definition AttributeSource.h:154
Lucene::DefaultIndexingChain
This is the current indexing chain: DocConsumer / DocConsumerPerThread --> code: DocFieldProcessor / ...
Definition DocumentsWriter.h:447
Lucene::DefaultSimilarity
Default scoring implementation.
Definition DefaultSimilarity.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::DefaultSkipListWriter
Implements the skip list writer for the default posting list format that stores positions and payload...
Definition DefaultSkipListWriter.h:15
Lucene::DirectoryReader
An IndexReader which reads indexes with multiple segments.
Definition DirectoryReader.h:19
Lucene::Directory
A Directory is a flat list of files. Files may be written once, when they are created....
Definition Directory.h:18
Lucene::DisjunctionMaxQuery
A query that generates the union of documents produced by its subqueries, and that scores each docume...
Definition DisjunctionMaxQuery.h:27
Lucene::DisjunctionMaxScorer
The Scorer for DisjunctionMaxQuery. The union of all documents generated by the the subquery scorers ...
Definition DisjunctionMaxScorer.h:18
Lucene::DisjunctionSumScorer
A Scorer for OR like queries, counterpart of ConjunctionScorer. This Scorer implements Scorer#skipTo(...
Definition DisjunctionSumScorer.h:16
Lucene::DocConsumerPerThread
Definition DocConsumerPerThread.h:14
Lucene::DocConsumer
Definition DocConsumer.h:14
Lucene::DocFieldConsumerPerField
Definition DocFieldConsumerPerField.h:14
Lucene::DocFieldConsumerPerThread
Definition DocFieldConsumerPerThread.h:14
Lucene::DocFieldConsumer
Definition DocFieldConsumer.h:14
Lucene::DocFieldConsumersPerDoc
Definition DocFieldConsumers.h:50
Lucene::DocFieldConsumersPerField
Definition DocFieldConsumersPerField.h:14
Lucene::DocFieldConsumersPerThread
Definition DocFieldConsumersPerThread.h:14
Lucene::DocFieldConsumers
This is just a "splitter" class: it lets you wrap two DocFieldConsumer instances as a single consumer...
Definition DocFieldConsumers.h:16
Lucene::DocFieldProcessorPerField
Holds all per thread, per field state.
Definition DocFieldProcessorPerField.h:15
Lucene::DocFieldProcessorPerThreadPerDoc
Definition DocFieldProcessorPerThread.h:63
Lucene::DocFieldProcessorPerThread
Gathers all Fieldables for a document under the same name, updates FieldInfos, and calls per-field co...
Definition DocFieldProcessorPerThread.h:19
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::DocIdBitSet
Simple DocIdSet and DocIdSetIterator backed by a BitSet.
Definition DocIdBitSet.h:15
Lucene::DocIdSetIterator
This abstract class defines methods to iterate over a set of non-decreasing doc ids....
Definition DocIdSetIterator.h:17
Lucene::DocIdSet
A DocIdSet contains a set of doc ids. Implementing classes must only implement iterator to provide ac...
Definition DocIdSet.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::DocInverterPerThread
This is a DocFieldConsumer that inverts each field, separately, from a Document, and accepts a Invert...
Definition DocInverterPerThread.h:17
Lucene::DocInverter
This is a DocFieldConsumer that inverts each field, separately, from a Document, and accepts a Invert...
Definition DocInverter.h:16
Lucene::DocState
Definition DocumentsWriter.h:356
Lucene::DocValues
Represents field values as different types. Normally created via a ValueSuorce for a particular field...
Definition DocValues.h:22
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::Document
Documents are the unit of indexing and search.
Definition Document.h:24
Lucene::DocumentsWriterThreadState
Used by DocumentsWriter to maintain per-thread state. We keep a separate Posting hash and other state...
Definition DocumentsWriterThreadState.h:17
Lucene::DocumentsWriter
This class accepts multiple added documents and directly writes a single segment file....
Definition DocumentsWriter.h:54
Lucene::DoubleCache
Definition FieldCacheImpl.h:127
Lucene::DoubleFieldSource
Obtains double field values from the FieldCache using getDoubles() and makes those values available a...
Definition DoubleFieldSource.h:25
Lucene::DoubleParser
Interface to parse doubles from document fields.
Definition FieldCache.h:244
Lucene::Entry
Definition FieldCacheImpl.h:51
Lucene::ExactPhraseScorer
Definition ExactPhraseScorer.h:14
Lucene::Explanation
Describes the score computation for document and query.
Definition Explanation.h:15
Lucene::FSDirectory
Base class for Directory implementations that store index files in the file system....
Definition FSDirectory.h:29
Lucene::FSLockFactory
Base class for file system based locking implementation.
Definition FSLockFactory.h:15
Lucene::FastCharStream
An efficient implementation of QueryParserCharStream interface.
Definition FastCharStream.h:18
Lucene::FieldCacheEntryImpl
Definition FieldCacheImpl.h:160
Lucene::FieldCacheEntry
A unique Identifier/Description for each item in the FieldCache. Can be useful for logging/debugging.
Definition FieldCache.h:255
Lucene::FieldCacheImpl
The default cache implementation, storing all values in memory. A WeakHashMap is used for storage.
Definition FieldCacheImpl.h:15
Lucene::FieldCacheRangeFilter
A range filter built on top of a cached single term field (in FieldCache).
Definition FieldCacheRangeFilter.h:38
Lucene::FieldCacheSanityChecker
Provides methods for sanity checking that entries in the FieldCache are not wasteful or inconsistent.
Definition FieldCacheSanityChecker.h:28
Lucene::FieldCacheSource
A base class for ValueSource implementations that retrieve values for a single field from the FieldCa...
Definition FieldCacheSource.h:28
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::FieldCache
Maintains caches of term values.
Definition FieldCache.h:17
Lucene::FieldComparatorSource
Provides a FieldComparator for custom field sorting.
Definition FieldComparatorSource.h:15
Lucene::FieldComparator
A FieldComparator compares hits so as to determine their sort order when collecting the top results w...
Definition FieldComparator.h:42
Lucene::FieldDocSortedHitQueue
Collects sorted results from Searchable's and collates them. The elements put into this queue must be...
Definition FieldDocSortedHitQueue.h:16
Lucene::FieldDoc
A ScoreDoc which also contains information about how to sort the referenced document....
Definition FieldDoc.h:20
Lucene::FieldInfo
Definition FieldInfo.h:14
Lucene::FieldInfos
Access to the Fieldable Info file that describes document fields and whether or not they are indexed....
Definition FieldInfos.h:18
Lucene::FieldInvertState
This class tracks the number and position / offset parameters of terms being added to the index....
Definition FieldInvertState.h:16
Lucene::FieldMaskingSpanQuery
Wrapper to allow SpanQuery objects participate in composite single-field SpanQueries by 'lying' about...
Definition FieldMaskingSpanQuery.h:52
Lucene::FieldNormStatus
Status from testing field norms.
Definition CheckIndex.h:237
Lucene::FieldScoreQuery
A query that scores each document as the value of the numeric input field.
Definition FieldScoreQuery.h:43
Lucene::FieldSelector
The FieldSelector allows one to make decisions about what Fields get loaded on a Document by IndexRea...
Definition FieldSelector.h:16
Lucene::FieldSortedTermVectorMapper
For each Field, store a sorted collection of TermVectorEntrys This is not thread-safe.
Definition FieldSortedTermVectorMapper.h:17
Lucene::FieldValueHitQueueEntry
Definition FieldValueHitQueue.h:56
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::Field
Definition Field.h:14
Lucene::Fieldable
Synonymous with Field.
Definition Fieldable.h:20
Lucene::FieldsReader
Class responsible for access to stored document fields. It uses <segment>.fdt and <segment>....
Definition FieldsReader.h:16
Lucene::FieldsWriter
Definition FieldsWriter.h:14
Lucene::FileReader
Convenience class for reading character files.
Definition FileReader.h:15
Lucene::FileSwitchDirectory
A Directory instance that switches files between two other Directory instances.
Definition FileSwitchDirectory.h:21
Lucene::FilterIndexReader
A FilterIndexReader contains another IndexReader, which it uses as its basic source of data,...
Definition FilterIndexReader.h:21
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::Filter
Abstract base class for restricting which documents may be returned during searching.
Definition Filter.h:15
Lucene::FilteredDocIdSetIterator
Abstract decorator class of a DocIdSetIterator implementation that provides on-demand filter/validati...
Definition FilteredDocIdSetIterator.h:16
Lucene::FilteredDocIdSet
Abstract decorator class for a DocIdSet implementation that provides on-demand filtering/validation m...
Definition FilteredDocIdSet.h:23
Lucene::FilteredQuery
A query that applies a filter to the results of another query.
Definition FilteredQuery.h:20
Lucene::FilteredTermEnum
Abstract class for enumerating a subset of all terms.
Definition FilteredTermEnum.h:18
Lucene::FlagsAttribute
This attribute can be used to pass different flags down the tokenizer chain, eg from one TokenFilter ...
Definition FlagsAttribute.h:16
Lucene::FormatPostingsDocsConsumer
Definition FormatPostingsDocsConsumer.h:14
Lucene::FormatPostingsDocsWriter
Consumes doc & freq, writing them using the current index file format.
Definition FormatPostingsDocsWriter.h:15
Lucene::FormatPostingsFieldsConsumer
Abstract API that consumes terms, doc, freq, prox and payloads postings. Concrete implementations of ...
Definition FormatPostingsFieldsConsumer.h:16
Lucene::FormatPostingsFieldsWriter
Definition FormatPostingsFieldsWriter.h:14
Lucene::FormatPostingsPositionsConsumer
Definition FormatPostingsPositionsConsumer.h:14
Lucene::FormatPostingsPositionsWriter
Definition FormatPostingsPositionsWriter.h:14
Lucene::FormatPostingsTermsConsumer
Definition FormatPostingsTermsConsumer.h:14
Lucene::FormatPostingsTermsWriter
Definition FormatPostingsTermsWriter.h:14
Lucene::FreqProxFieldMergeState
Used by DocumentsWriter to merge the postings from multiple ThreadStates when creating a segment.
Definition FreqProxFieldMergeState.h:15
Lucene::FreqProxTermsWriterPerField
Definition FreqProxTermsWriterPerField.h:14
Lucene::FreqProxTermsWriterPerThread
Definition FreqProxTermsWriterPerThread.h:14
Lucene::FreqProxTermsWriterPostingList
Definition FreqProxTermsWriter.h:41
Lucene::FreqProxTermsWriter
Definition FreqProxTermsWriter.h:15
Lucene::Future
A Future represents the result of an asynchronous computation. Methods are provided to check if the c...
Definition ThreadPool.h:24
Lucene::FuzzyQuery
Implements the fuzzy search query. The similarity measurement is based on the Levenshtein (edit dista...
Definition FuzzyQuery.h:19
Lucene::FuzzyTermEnum
Subclass of FilteredTermEnum for enumerating all terms that are similar to the specified filter term.
Definition FuzzyTermEnum.h:18
Lucene::HitQueueBase
Definition HitQueueBase.h:14
Lucene::HitQueue
Definition HitQueue.h:14
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::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::IndexCommit
Represents a single commit into an index as seen by the IndexDeletionPolicy or IndexReader.
Definition IndexCommit.h:22
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::IndexFileDeleter
This class keeps track of each SegmentInfos instance that is still "live", either because it correspo...
Definition IndexFileDeleter.h:34
Lucene::IndexFileNameFilter
Filename filter that accept filenames and extensions only created by Lucene.
Definition IndexFileNameFilter.h:15
Lucene::IndexInput
Abstract base class for input from a file in a Directory. A random-access input stream....
Definition IndexInput.h:17
Lucene::IndexOutput
Abstract base class for output to a file in a Directory. A random-access output stream....
Definition IndexOutput.h:18
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::IndexReader
IndexReader is an abstract class, providing an interface for accessing an index. Search of an index i...
Definition IndexReader.h:39
Lucene::IndexSearcher
Implements search over a single IndexReader.
Definition IndexSearcher.h:23
Lucene::IndexStatus
Returned from checkIndex() detailing the health and status of the index.
Definition CheckIndex.h:108
Lucene::IndexWriter
An IndexWriter creates and maintains an index.
Definition IndexWriter.h:90
Lucene::IndexingChain
The IndexingChain must define the getChain(DocumentsWriter) method which returns the DocConsumer that...
Definition DocumentsWriter.h:423
Lucene::InfoStreamFile
Stream override to write messages to a file.
Definition InfoStream.h:29
Lucene::InfoStreamOut
Stream override to write messages to a std::cout.
Definition InfoStream.h:44
Lucene::InfoStream
Utility class to support streaming info messages.
Definition InfoStream.h:16
Lucene::InputStreamReader
An InputStreamReader is a bridge from byte streams to character streams.
Definition InputStreamReader.h:15
Lucene::Insanity
Simple container for a collection of related CacheEntry objects that in conjunction with each other r...
Definition FieldCacheSanityChecker.h:95
Lucene::IntBlockPool
Definition IntBlockPool.h:14
Lucene::IntCache
Definition FieldCacheImpl.h:105
Lucene::IntFieldSource
Obtains int field values from the FieldCache using getInts() and makes those values available as othe...
Definition IntFieldSource.h:24
Lucene::IntParser
Interface to parse ints from document fields.
Definition FieldCache.h:220
Lucene::IntRangeBuilder
Definition NumericUtils.h:162
Lucene::InvertedDocConsumerPerField
Definition InvertedDocConsumerPerField.h:14
Lucene::InvertedDocConsumerPerThread
Definition InvertedDocConsumerPerThread.h:14
Lucene::InvertedDocConsumer
Definition InvertedDocConsumer.h:14
Lucene::InvertedDocEndConsumerPerField
Definition InvertedDocEndConsumerPerField.h:14
Lucene::InvertedDocEndConsumerPerThread
Definition InvertedDocEndConsumerPerThread.h:14
Lucene::InvertedDocEndConsumer
Definition InvertedDocEndConsumer.h:14
Lucene::KeepOnlyLastCommitDeletionPolicy
This IndexDeletionPolicy implementation that keeps only the most recent commit and immediately remove...
Definition KeepOnlyLastCommitDeletionPolicy.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::KeywordTokenizer
Emits the entire input as a single token.
Definition KeywordTokenizer.h:15
Lucene::LengthFilter
Removes words that are too long or too short from the stream.
Definition LengthFilter.h:15
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::LoadFirstFieldSelector
Load the First field and break. See FieldSelectorResult#LOAD_AND_BREAK.
Definition LoadFirstFieldSelector.h:16
Lucene::LockFactory
Base class for Locking implementation. Directory uses instances of this class to implement locking....
Definition LockFactory.h:23
Lucene::Lock
An interprocess mutex lock.
Definition Lock.h:16
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::LogDocMergePolicy
This is a LogMergePolicy that measures size of a segment as the number of documents (not taking delet...
Definition LogDocMergePolicy.h:16
Lucene::LogMergePolicy
This class implements a MergePolicy that tries to merge segments into levels of exponentially increas...
Definition LogMergePolicy.h:24
Lucene::LongCache
Definition FieldCacheImpl.h:116
Lucene::LongParser
Interface to parse longs from document fields.
Definition FieldCache.h:232
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::LowerCaseFilter
Normalizes token text to lower case.
Definition LowerCaseFilter.h:15
Lucene::LowerCaseTokenizer
LowerCaseTokenizer performs the function of LetterTokenizer and LowerCaseFilter together....
Definition LowerCaseTokenizer.h:21
Lucene::LuceneObject
Base class for all Lucene classes.
Definition LuceneObject.h:31
Lucene::LuceneSignal
Utility class to support signaling notifications.
Definition LuceneSignal.h:16
Lucene::LuceneThread
Lucene thread container.
Definition LuceneThread.h:23
Lucene::MMapDirectory
File-based Directory implementation that uses mmap for reading, and SimpleFSIndexOutput for writing.
Definition MMapDirectory.h:22
Lucene::MapFieldSelector
A FieldSelector based on a Map of field names to FieldSelectorResults.
Definition MapFieldSelector.h:17
Lucene::MappingCharFilter
Simplistic CharFilter that applies the mappings contained in a NormalizeCharMap to the character stre...
Definition MappingCharFilter.h:16
Lucene::MatchAllDocsQuery
A query that matches all documents.
Definition MatchAllDocsQuery.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::MergeDocIDRemapper
Remaps docIDs after a merge has completed, where the merged segments had at least one deletion....
Definition MergeDocIDRemapper.h:17
Lucene::MergePolicy
A MergePolicy determines the sequence of primitive merge operations to be used for overall merge and ...
Definition MergePolicy.h:32
Lucene::MergeScheduler
IndexWriter uses an instance implementing this interface to execute the merges selected by a MergePol...
Definition MergeScheduler.h:16
Lucene::MergeSpecification
A MergeSpecification instance provides the information necessary to perform multiple merges....
Definition MergePolicy.h:119
Lucene::MinPayloadFunction
Calculates the minimum payload seen.
Definition MinPayloadFunction.h:15
Lucene::MultiFieldQueryParser
A QueryParser which constructs queries to search multiple fields.
Definition MultiFieldQueryParser.h:16
Lucene::MultiLevelSkipListReader
This abstract class reads skip lists with multiple levels.
Definition MultiLevelSkipListReader.h:20
Lucene::MultiLevelSkipListWriter
This abstract class writes skip lists with multiple levels.
Definition MultiLevelSkipListWriter.h:36
Lucene::MultiPhraseQuery
MultiPhraseQuery is a generalized version of PhraseQuery, with an added method add(Term[])....
Definition MultiPhraseQuery.h:18
Lucene::MultiReader
An IndexReader which reads multiple indexes, appending their content.
Definition MultiReader.h:15
Lucene::MultiSearcher
Implements search over a set of Searchables.
Definition MultiSearcher.h:19
Lucene::MultiTermDocs
Definition DirectoryReader.h:225
Lucene::MultiTermEnum
Definition DirectoryReader.h:195
Lucene::MultiTermPositions
Definition DirectoryReader.h:278
Lucene::MultiTermQueryWrapperFilter
A wrapper for MultiTermQuery, that exposes its functionality as a Filter.
Definition MultiTermQueryWrapperFilter.h:22
Lucene::MultiTermQuery
An abstract Query that matches documents containing a subset of terms provided by a FilteredTermEnum ...
Definition MultiTermQuery.h:31
Lucene::MultipleTermPositions
Allows you to iterate over the TermPositions for multiple Terms as a single TermPositions.
Definition MultipleTermPositions.h:16
Lucene::NativeFSLockFactory
Implements LockFactory using native file lock.
Definition NativeFSLockFactory.h:16
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::NearSpansUnordered
Similar to NearSpansOrdered, but for the unordered case.
Definition NearSpansUnordered.h:17
Lucene::NoLockFactory
Use this LockFactory to disable locking entirely. Only one instance of this lock is created....
Definition NoLockFactory.h:18
Lucene::NormalizeCharMap
Holds a map of String input to String output, to be used with MappingCharFilter.
Definition NormalizeCharMap.h:15
Lucene::NormsWriterPerField
Taps into DocInverter, as an InvertedDocEndConsumer, which is called at the end of inverting each fie...
Definition NormsWriterPerField.h:16
Lucene::NormsWriterPerThread
Definition NormsWriterPerThread.h:14
Lucene::NormsWriter
Writes norms. Each thread X field accumulates the norms for the doc/fields it saw,...
Definition NormsWriter.h:16
Lucene::Num
Number of documents a delete term applies to.
Definition BufferedDeletes.h:43
Lucene::NumberTools
Provides support for converting longs to Strings, and back again. The strings are structured so that ...
Definition NumberTools.h:26
Lucene::NumericField
This class provides a Field that enables indexing of numeric values for efficient range filtering and...
Definition NumericField.h:59
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::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::NumericTokenStream
This class provides a TokenStream for indexing numeric values that can be used by NumericRangeQuery o...
Definition NumericTokenStream.h:52
Lucene::NumericUtils
This is a helper class to generate prefix-encoded representations for numerical values and supplies c...
Definition NumericUtils.h:37
Lucene::OffsetAttribute
The start and end character offset of a Token.
Definition OffsetAttribute.h:15
Lucene::OneMerge
OneMerge provides the information necessary to perform an individual primitive merge operation,...
Definition MergePolicy.h:76
Lucene::OpenBitSetDISI
Definition OpenBitSetDISI.h:14
Lucene::OpenBitSetIterator
An iterator to iterate over set bits in an OpenBitSet. This is faster than nextSetBit() for iterating...
Definition OpenBitSetIterator.h:17
Lucene::OpenBitSet
An "open" BitSet implementation that allows direct access to the array of words storing the bits.
Definition OpenBitSet.h:19
Lucene::OrdFieldSource
Obtains the ordinal of the field value from the default Lucene FieldCache using getStringIndex().
Definition OrdFieldSource.h:31
Lucene::ParallelArrayTermVectorMapper
Models the existing parallel array structure.
Definition TermVectorsReader.h:118
Lucene::ParallelMultiSearcher
Implements parallel search over a set of Searchables.
Definition ParallelMultiSearcher.h:18
Lucene::ParallelReader
An IndexReader which reads multiple, parallel indexes. Each index added must have the same number of ...
Definition ParallelReader.h:26
Lucene::Parser
Marker interface as super-interface to all parsers. It is used to specify a custom parser to SortFiel...
Definition FieldCache.h:200
Lucene::PayloadAttribute
The start and end character offset of a Token.
Definition PayloadAttribute.h:15
Lucene::PayloadFunction
An abstract class that defines a way for Payload*Query instances to transform the cumulative effects ...
Definition PayloadFunction.h:18
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::PayloadNearSpanScorer
Definition PayloadNearQuery.h:63
Lucene::PayloadNearSpanWeight
Definition PayloadNearQuery.h:52
Lucene::PayloadSpanUtil
Experimental class to get set of payloads for most standard Lucene queries. Operates like Highlighter...
Definition PayloadSpanUtil.h:16
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::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::PerDocBuffer
RAMFile buffer for DocWriters.
Definition DocumentsWriter.h:381
Lucene::PerFieldAnalyzerWrapper
This analyzer is used to facilitate scenarios where different fields require different analysis techn...
Definition PerFieldAnalyzerWrapper.h:29
Lucene::PhrasePositions
Position of a term in a document that takes into account the term offset within the phrase.
Definition PhrasePositions.h:15
Lucene::PhraseQuery
A Query that matches documents containing a particular sequence of terms. A PhraseQuery is built by Q...
Definition PhraseQuery.h:18
Lucene::PhraseQueue
Definition PhraseQueue.h:16
Lucene::PhraseScorer
Scoring functionality for phrase queries. A document is considered matching if it contains the phrase...
Definition PhraseScorer.h:22
Lucene::PorterStemFilter
Transforms the token stream as per the Porter stemming algorithm. Note: the input to the stemming fil...
Definition PorterStemFilter.h:31
Lucene::PorterStemmer
This is the Porter stemming algorithm, coded up as thread-safe ANSI C by the author.
Definition PorterStemmer.h:26
Lucene::PositionBasedTermVectorMapper
Definition PositionBasedTermVectorMapper.h:14
Lucene::PositionIncrementAttribute
The positionIncrement determines the position of this token relative to the previous Token in a Token...
Definition PositionIncrementAttribute.h:32
Lucene::PositionInfo
Definition SpanFilterResult.h:39
Lucene::PositiveScoresOnlyCollector
A Collector implementation which wraps another Collector and makes sure only documents with scores > ...
Definition PositiveScoresOnlyCollector.h:16
Lucene::PrefixFilter
A Filter that restricts search results to values that have a matching prefix in a given field.
Definition PrefixFilter.h:15
Lucene::PrefixQuery
A Query that matches documents containing terms with a specified prefix. A PrefixQuery is built by Qu...
Definition PrefixQuery.h:18
Lucene::PrefixTermEnum
Subclass of FilteredTermEnum for enumerating all terms that match the specified prefix filter term.
Definition PrefixTermEnum.h:18
Lucene::PriorityQueueScoreDocs
Definition HitQueueBase.h:45
Lucene::QueryParserCharStream
This interface describes a character stream that maintains line and column number positions of the ch...
Definition QueryParserCharStream.h:22
Lucene::QueryParserConstants
Token literal values and constants.
Definition QueryParserConstants.h:15
Lucene::QueryParserTokenManager
Token Manager.
Definition QueryParserTokenManager.h:15
Lucene::QueryParserToken
Describes the input token stream.
Definition QueryParserToken.h:15
Lucene::QueryParser
The most important method is parse(const String&).
Definition QueryParser.h:70
Lucene::QueryTermVector
Definition QueryTermVector.h:14
Lucene::QueryWrapperFilter
Constrains search results to only match those which also match a provided query.
Definition QueryWrapperFilter.h:20
Lucene::Query
The abstract base class for queries.
Definition Query.h:31
Lucene::RAMDirectory
A memory-resident Directory implementation. Locking implementation is by default the SingleInstanceLo...
Definition RAMDirectory.h:17
Lucene::RAMFile
File used as buffer in RAMDirectory.
Definition RAMFile.h:15
Lucene::RAMInputStream
A memory-resident IndexInput implementation.
Definition RAMInputStream.h:15
Lucene::RAMOutputStream
A memory-resident IndexOutput implementation.
Definition RAMOutputStream.h:15
Lucene::Random
Utility class to generate a stream of pseudorandom numbers.
Definition Random.h:15
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::ReadOnlyDirectoryReader
Definition ReadOnlyDirectoryReader.h:14
Lucene::ReadOnlySegmentReader
Definition ReadOnlySegmentReader.h:14
Lucene::ReaderCommit
Definition DirectoryReader.h:302
Lucene::Reader
Abstract class for reading character streams.
Definition Reader.h:15
Lucene::RefCount
Tracks the reference count for a single index file.
Definition IndexFileDeleter.h:130
Lucene::ReqExclScorer
A Scorer for queries with a required subscorer and an excluding (prohibited) sub DocIdSetIterator....
Definition ReqExclScorer.h:16
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::ReusableStringReader
Used by DocumentsWriter to implemented a StringReader that can be reset to a new string; we use this ...
Definition ReusableStringReader.h:16
Lucene::ReverseOrdFieldSource
Obtains the ordinal of the field value from the default Lucene FieldCache using getStringIndex() and ...
Definition ReverseOrdFieldSource.h:31
Lucene::RewriteMethod
Abstract class that defines how the query is rewritten.
Definition MultiTermQuery.h:122
Lucene::ScoreCachingWrappingScorer
A Scorer which wraps another scorer and caches the score of the current document. Successive calls to...
Definition ScoreCachingWrappingScorer.h:22
Lucene::ScoreDoc
Expert: Returned by low-level search implementations.
Definition ScoreDoc.h:16
Lucene::ScorerDocQueue
A ScorerDocQueue maintains a partial ordering of its Scorers such that the least Scorer can always be...
Definition ScorerDocQueue.h:16
Lucene::Scorer
Common scoring functionality for different types of queries.
Definition Scorer.h:33
Lucene::Searchable
The interface for search implementations.
Definition Searchable.h:24
Lucene::Searcher
An abstract base class for search implementations. Implements the main search methods.
Definition Searcher.h:18
Lucene::SegmentInfoCollection
A collection of SegmentInfo objects to be used as a base class for SegmentInfos.
Definition SegmentInfoCollection.h:15
Lucene::SegmentInfoStatus
Holds the status of each segment in the index. See segmentInfos.
Definition CheckIndex.h:168
Lucene::SegmentInfo
Information about a segment such as it's name, directory, and files related to the segment.
Definition SegmentInfo.h:16
Lucene::SegmentInfos
A collection of SegmentInfo objects with methods for operating on those segments in relation to the f...
Definition SegmentInfos.h:15
Lucene::SegmentMergeInfo
Definition SegmentMergeInfo.h:14
Lucene::SegmentMergeQueue
Definition SegmentMergeQueue.h:14
Lucene::SegmentMerger
The SegmentMerger class combines two or more Segments, represented by an IndexReader (add,...
Definition SegmentMerger.h:20
Lucene::SegmentReader
Definition SegmentReader.h:15
Lucene::SegmentTermDocs
Definition SegmentTermDocs.h:14
Lucene::SegmentTermEnum
Definition SegmentTermEnum.h:14
Lucene::SegmentTermPositionVector
Definition SegmentTermPositionVector.h:14
Lucene::SegmentTermPositions
Definition SegmentTermPositions.h:14
Lucene::SegmentTermVector
Definition SegmentTermVector.h:14
Lucene::SegmentWriteState
Definition SegmentWriteState.h:14
Lucene::SerialMergeScheduler
A MergeScheduler that simply does each merge sequentially, using the current thread.
Definition SerialMergeScheduler.h:15
Lucene::SetBasedFieldSelector
Declare what fields to load normally and what fields to load lazily.
Definition SetBasedFieldSelector.h:15
Lucene::SimilarityDelegator
Delegating scoring implementation. Useful in Query#getSimilarity(Searcher) implementations,...
Definition SimilarityDelegator.h:16
Lucene::Similarity
Scoring API.
Definition Similarity.h:427
Lucene::SimpleAnalyzer
An Analyzer that filters LetterTokenizer with LowerCaseFilter.
Definition SimpleAnalyzer.h:15
Lucene::SimpleFSDirectory
A straightforward implementation of FSDirectory using std::ofstream and std::ifstream.
Definition SimpleFSDirectory.h:15
Lucene::SimpleFSLockFactory
Implements LockFactory using File#createNewFile().
Definition SimpleFSLockFactory.h:17
Lucene::SingleInstanceLockFactory
Implements LockFactory for a single in-process instance, meaning all locking will take place through ...
Definition SingleInstanceLockFactory.h:20
Lucene::SingleMatchScorer
Count a scorer as a single match.
Definition BooleanScorer2.h:105
Lucene::SingleTermEnum
Subclass of FilteredTermEnum for enumerating a single term.
Definition SingleTermEnum.h:18
Lucene::SingleTokenAttributeSource
Definition DocInverterPerThread.h:44
Lucene::SinkFilter
Definition TeeSinkTokenFilter.h:95
Lucene::SinkTokenStream
A filter that decides which AttributeSource states to store in the sink.
Definition TeeSinkTokenFilter.h:120
Lucene::SkipBuffer
Used to buffer the top skip levels.
Definition MultiLevelSkipListReader.h:88
Lucene::SkipDocWriter
Definition DocumentsWriter.h:457
Lucene::SloppyPhraseScorer
Definition SloppyPhraseScorer.h:14
Lucene::SnapshotDeletionPolicy
Definition SnapshotDeletionPolicy.h:14
Lucene::SortField
Stores information about how to sort documents by terms in an individual field. Fields must be indexe...
Definition SortField.h:16
Lucene::Sort
Encapsulates sort criteria for returned hits.
Definition Sort.h:68
Lucene::SortedTermVectorMapper
Store a sorted collection of TermVectorEntrys. Collects all term information into a single,...
Definition SortedTermVectorMapper.h:22
Lucene::SortedVIntList
Stores and iterate on sorted integers in compressed form in RAM.
Definition SortedVIntList.h:22
Lucene::SpanFilterResult
The results of a SpanQueryFilter. Wraps the BitSet and the position information from the SpanQuery.
Definition SpanFilterResult.h:15
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::SpanFirstQuery
Matches spans near the beginning of a field.
Definition SpanFirstQuery.h:16
Lucene::SpanNearQuery
Matches spans which are near one another. One can specify slop, the maximum number of intervening unm...
Definition SpanNearQuery.h:16
Lucene::SpanNotQuery
Removes matches which overlap with another SpanQuery.
Definition SpanNotQuery.h:15
Lucene::SpanOrQuery
Matches the union of its clauses.
Definition SpanOrQuery.h:15
Lucene::SpanQueryFilter
Constrains search results to only match those which also match a provided query. Also provides positi...
Definition SpanQueryFilter.h:20
Lucene::SpanQuery
Base class for span-based queries.
Definition SpanQuery.h:15
Lucene::SpanScorer
Public for extension only.
Definition SpanScorer.h:15
Lucene::SpanTermQuery
Matches spans containing a term.
Definition SpanTermQuery.h:15
Lucene::SpanWeight
Public for use by other weight implementations.
Definition SpanWeight.h:15
Lucene::Spans
An enumeration of span matches. Used to implement span searching. Each span represents a range of ter...
Definition Spans.h:17
Lucene::StandardAnalyzer
Filters StandardTokenizer with StandardFilter, LowerCaseFilter and StopFilter, using a list of Englis...
Definition StandardAnalyzer.h:23
Lucene::StandardFilter
Normalizes tokens extracted with StandardTokenizer.
Definition StandardFilter.h:15
Lucene::StandardTokenizerImpl
Definition StandardTokenizerImpl.h:14
Lucene::StandardTokenizer
A grammar-based tokenizer.
Definition StandardTokenizer.h:34
Lucene::StartEnd
Definition SpanFilterResult.h:56
Lucene::StopAnalyzer
Filters LetterTokenizer with LowerCaseFilter and StopFilter.
Definition StopAnalyzer.h:18
Lucene::StopFilter
Removes stop words from a token stream.
Definition StopFilter.h:15
Lucene::StoredFieldStatus
Status from testing stored fields.
Definition CheckIndex.h:275
Lucene::StoredFieldsWriterPerDoc
Definition StoredFieldsWriter.h:50
Lucene::StoredFieldsWriterPerThread
Definition StoredFieldsWriterPerThread.h:14
Lucene::StoredFieldsWriter
This is a DocFieldConsumer that writes stored fields.
Definition StoredFieldsWriter.h:15
Lucene::StringCache
Definition FieldCacheImpl.h:138
Lucene::StringIndexCache
Definition FieldCacheImpl.h:149
Lucene::StringIndex
Stores term text values and document ordering data.
Definition FieldCache.h:180
Lucene::StringReader
Convenience class for reading strings.
Definition StringReader.h:15
Lucene::SubScorer
Definition BooleanScorer.h:151
Lucene::Synchronize
Utility class to support locking via a mutex.
Definition Synchronize.h:18
Lucene::TeeSinkTokenFilter
This TokenFilter provides the ability to set aside attribute states that have already been analyzed....
Definition TeeSinkTokenFilter.h:62
Lucene::TermAttribute
The term text of a Token.
Definition TermAttribute.h:15
Lucene::TermBuffer
Definition TermBuffer.h:14
Lucene::TermDocs
TermDocs provides an interface for enumerating <document, frequency>; pairs for a term....
Definition TermDocs.h:19
Lucene::TermEnum
Abstract class for enumerating terms.
Definition TermEnum.h:18
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::TermIndexStatus
Status from testing term index.
Definition CheckIndex.h:253
Lucene::TermInfo
A TermInfo is the record of information stored for a term.
Definition TermInfo.h:15
Lucene::TermInfosReaderThreadResources
Definition TermInfosReader.h:74
Lucene::TermInfosReader
This stores a monotonically increasing set of <Term, TermInfo> pairs in a Directory....
Definition TermInfosReader.h:17
Lucene::TermInfosWriter
This stores a monotonically increasing set of <Term, TermInfo> pairs in a Directory....
Definition TermInfosWriter.h:16
Lucene::TermPositionVector
Extends TermFreqVector to provide additional information about positions in which each of the terms i...
Definition TermPositionVector.h:16
Lucene::TermPositions
TermPositions provides an interface for enumerating the <document, frequency, <position>*> tuples for...
Definition TermPositions.h:18
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::TermRangeFilter
A Filter that restricts search results to a range of term values in a given field.
Definition TermRangeFilter.h:22
Lucene::TermRangeQuery
A Query that matches documents within an range of terms.
Definition TermRangeQuery.h:21
Lucene::TermRangeTermEnum
Subclass of FilteredTermEnum for enumerating all terms that match the specified range parameters.
Definition TermRangeTermEnum.h:18
Lucene::TermScorer
A Scorer for documents matching a Term.
Definition TermScorer.h:15
Lucene::TermSpans
Public for extension only.
Definition TermSpans.h:15
Lucene::TermVectorEntryFreqSortedComparator
Compares TermVectorEntrys first by frequency and then by the term (case-sensitive)
Definition TermVectorEntryFreqSortedComparator.h:15
Lucene::TermVectorEntry
Convenience class for holding TermVector information.
Definition TermVectorEntry.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::TermVectorOffsetInfo
The TermVectorOffsetInfo class holds information pertaining to a Term in a TermPositionVector's offse...
Definition TermVectorOffsetInfo.h:17
Lucene::TermVectorStatus
Status from testing stored fields.
Definition CheckIndex.h:294
Lucene::TermVectorsPositionInfo
Container for a term at a position.
Definition PositionBasedTermVectorMapper.h:49
Lucene::TermVectorsReader
Definition TermVectorsReader.h:14
Lucene::TermVectorsTermsWriterPerDoc
Definition TermVectorsTermsWriter.h:54
Lucene::TermVectorsTermsWriterPerField
Definition TermVectorsTermsWriterPerField.h:14
Lucene::TermVectorsTermsWriterPerThread
Definition TermVectorsTermsWriterPerThread.h:14
Lucene::TermVectorsTermsWriterPostingList
Definition TermVectorsTermsWriter.h:80
Lucene::TermVectorsTermsWriter
Definition TermVectorsTermsWriter.h:16
Lucene::TermVectorsWriter
Definition TermVectorsWriter.h:14
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::TermsHashConsumerPerField
Implement this class to plug into the TermsHash processor, which inverts & stores Tokens into a hash ...
Definition TermsHashConsumerPerField.h:16
Lucene::TermsHashConsumerPerThread
Definition TermsHashConsumerPerThread.h:14
Lucene::TermsHashConsumer
Definition TermsHashConsumer.h:14
Lucene::TermsHashPerField
Definition TermsHashPerField.h:14
Lucene::TermsHashPerThread
Definition TermsHashPerThread.h:14
Lucene::TermsHash
This class implements InvertedDocConsumer, which is passed each token produced by the analyzer on eac...
Definition TermsHash.h:18
Lucene::ThreadPool
Utility class to handle a pool of threads.
Definition ThreadPool.h:48
Lucene::TimeLimitingCollector
The TimeLimitingCollector is used to timeout search requests that take longer than the maximum allowe...
Definition TimeLimitingCollector.h:17
Lucene::TokenAttributeFactory
Creates a TokenAttributeFactory returning Token as instance for the basic attributes and for all othe...
Definition Token.h:338
Lucene::TokenFilter
A TokenFilter is a TokenStream whose input is another TokenStream.
Definition TokenFilter.h:18
Lucene::TokenStream
A TokenStream enumerates the sequence of tokens, either from Fields of a Document or from query text.
Definition TokenStream.h:44
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::Tokenizer
A Tokenizer is a TokenStream whose input is a Reader.
Definition Tokenizer.h:20
Lucene::TopDocsCollector
A base class for all collectors that return a TopDocs output. This collector allows easy extension by...
Definition TopDocsCollector.h:21
Lucene::TopDocs
Represents hits returned by Searcher#search(QueryPtr, FilterPtr, int32_t) and Searcher#search(QueryPt...
Definition TopDocs.h:16
Lucene::TopFieldCollector
A Collector that sorts by SortField using FieldComparators.
Definition TopFieldCollector.h:17
Lucene::TopFieldDocs
Represents hits returned by Searcher#search(QueryPtr, FilterPtr, int32_t, SortPtr).
Definition TopFieldDocs.h:15
Lucene::TopScoreDocCollector
A Collector implementation that collects the top-scoring hits, returning them as a TopDocs....
Definition TopScoreDocCollector.h:21
Lucene::TypeAttribute
A Token's lexical type. The Default value is "word".
Definition TypeAttribute.h:15
Lucene::UTF16Decoder
Definition UTF8Stream.h:120
Lucene::UTF8DecoderStream
Definition UTF8Stream.h:106
Lucene::UTF8Decoder
Definition UTF8Stream.h:81
Lucene::UTF8EncoderStream
Definition UTF8Stream.h:67
Lucene::UTF8Encoder
Definition UTF8Stream.h:44
Lucene::UTF8Result
Definition UnicodeUtils.h:84
Lucene::UnicodeResult
Definition UnicodeUtils.h:89
Lucene::ValueSourceQuery
A Query that sets the scores of document to the values obtained from a ValueSource.
Definition ValueSourceQuery.h:22
Lucene::ValueSource
Source of values for basic function queries.
Definition ValueSource.h:21
Lucene::WaitQueue
Definition DocumentsWriter.h:469
Lucene::Weight
Calculate query weights and build query scorers.
Definition Weight.h:30
Lucene::WhitespaceAnalyzer
An Analyzer that uses WhitespaceTokenizer.
Definition WhitespaceAnalyzer.h:15
Lucene::WhitespaceTokenizer
A WhitespaceTokenizer is a tokenizer that divides text at whitespace. Adjacent sequences of non-White...
Definition WhitespaceTokenizer.h:16
Lucene::WildcardQuery
Implements the wildcard search query. Supported wildcards are *, which matches any character sequence...
Definition WildcardQuery.h:21
Lucene::WildcardTermEnum
Subclass of FilteredTermEnum for enumerating all terms that match the specified wildcard filter term.
Definition WildcardTermEnum.h:18
Lucene::WordlistLoader
Loader for text files that represent a list of stopwords.
Definition WordlistLoader.h:15
Lucene
Definition AbstractAllTermDocs.h:12

clucene.sourceforge.net