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

- Main Page
- Related Pages
- Namespaces
- Data Structures
- Files

- File List
- Globals

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
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
Lucene::ByteBlockPoolAllocatorBase
Definition: ByteBlockPool.h:54
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::TermAttribute
The term text of a Token.
Definition: TermAttribute.h:15
Lucene::Searchable
The interface for search implementations.
Definition: Searchable.h:24
Lucene::LoadFirstFieldSelector
Load the First field and break. See FieldSelectorResult#LOAD_AND_BREAK.
Definition: LoadFirstFieldSelector.h:16
Lucene::SimpleFSLockFactory
Implements LockFactory using File#createNewFile().
Definition: SimpleFSLockFactory.h:17
Lucene::IndexWriter
An IndexWriter creates and maintains an index.
Definition: IndexWriter.h:90
Lucene::BufferedReader
Read text from a character-input stream, buffering characters so as to provide for the efficient read...
Definition: BufferedReader.h:16
Lucene::CheckAbort
Definition: SegmentMerger.h:122
Lucene::SerialMergeScheduler
A MergeScheduler that simply does each merge sequentially, using the current thread.
Definition: SerialMergeScheduler.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::SimpleFSDirectory
A straightforward implementation of FSDirectory using std::ofstream and std::ifstream.
Definition: SimpleFSDirectory.h:15
Lucene::TermsHashConsumer
Definition: TermsHashConsumer.h:14
Lucene::BooleanScorer
BooleanScorer uses a ~16k array to score windows of docs. So it scores docs 0-16k first...
Definition: BooleanScorer.h:30
Lucene::TermEnum
Abstract class for enumerating terms.
Definition: TermEnum.h:18
Lucene::SpanOrQuery
Matches the union of its clauses.
Definition: SpanOrQuery.h:15
Lucene::SkipBuffer
Used to buffer the top skip levels.
Definition: MultiLevelSkipListReader.h:88
Lucene::PositionIncrementAttribute
The positionIncrement determines the position of this token relative to the previous Token in a Token...
Definition: PositionIncrementAttribute.h:32
Lucene::NearSpansUnordered
Similar to NearSpansOrdered, but for the unordered case.
Definition: NearSpansUnordered.h:17
Lucene::ConjunctionScorer
Scorer for conjunctions, sets of queries, all of which are required.
Definition: ConjunctionScorer.h:15
Lucene::UTF8Result
Definition: UnicodeUtils.h:84
Lucene::Entry
Definition: FieldCacheImpl.h:51
Lucene::QueryParserCharStream
This interface describes a character stream that maintains line and column number positions of the ch...
Definition: QueryParserCharStream.h:22
Lucene::StopAnalyzer
Filters LetterTokenizer with LowerCaseFilter and StopFilter.
Definition: StopAnalyzer.h:18
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::FieldCacheRangeFilter
A range filter built on top of a cached single term field (in FieldCache).
Definition: FieldCacheRangeFilter.h:38
Lucene::SetBasedFieldSelector
Declare what fields to load normally and what fields to load lazily.
Definition: SetBasedFieldSelector.h:15
Lucene::ByteCache
Definition: FieldCacheImpl.h:94
Lucene::DocFieldProcessorPerThreadPerDoc
Definition: DocFieldProcessorPerThread.h:63
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::MultiTermEnum
Definition: DirectoryReader.h:195
Lucene::OneMerge
OneMerge provides the information necessary to perform an individual primitive merge operation...
Definition: MergePolicy.h:76
Lucene::IntFieldSource
Obtains int field values from the FieldCache using getInts() and makes those values available as othe...
Definition: IntFieldSource.h:24
Lucene::LuceneSignal
Utility class to support signaling notifications.
Definition: LuceneSignal.h:16
Lucene::AttributeSourceState
This class holds the state of an AttributeSource.
Definition: AttributeSource.h:168
Lucene::StoredFieldStatus
Status from testing stored fields.
Definition: CheckIndex.h:275
Lucene::PositiveScoresOnlyCollector
A Collector implementation which wraps another Collector and makes sure only documents with scores > ...
Definition: PositiveScoresOnlyCollector.h:16
Lucene::LowerCaseTokenizer
LowerCaseTokenizer performs the function of LetterTokenizer and LowerCaseFilter together. It divides text at non-letters and converts them to lower case. While it is functionally equivalent to the combination of LetterTokenizer and LowerCaseFilter, there is a performance advantage to doing the two tasks at once, hence this (redundant) implementation.
Definition: LowerCaseTokenizer.h:21
Lucene::RefCount
Tracks the reference count for a single index file.
Definition: IndexFileDeleter.h:130
Lucene::CommitPoint
Holds details for each commit point. This class is also passed to the deletion policy. Note: this class has a natural ordering that is inconsistent with equals.
Definition: IndexFileDeleter.h:149
Lucene::SpanWeight
Public for use by other weight implementations.
Definition: SpanWeight.h:15
Lucene::TermsHashPerField
Definition: TermsHashPerField.h:14
Lucene::MapFieldSelector
A FieldSelector based on a Map of field names to FieldSelectorResults.
Definition: MapFieldSelector.h:17
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::Coordinator
Definition: BooleanScorer2.h:85
Lucene::Attribute
Base class for Attributes that can be added to a AttributeSource.
Definition: Attribute.h:18
Lucene::FormatPostingsTermsConsumer
Definition: FormatPostingsTermsConsumer.h:14
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::MMapDirectory
File-based Directory implementation that uses mmap for reading, and SimpleFSIndexOutput for writing...
Definition: MMapDirectory.h:22
Lucene::FormatPostingsFieldsWriter
Definition: FormatPostingsFieldsWriter.h:14
Lucene::DocFieldProcessorPerThread
Gathers all Fieldables for a document under the same name, updates FieldInfos, and calls per-field co...
Definition: DocFieldProcessorPerThread.h:19
Lucene::TypeAttribute
A Token's lexical type. The Default value is "word".
Definition: TypeAttribute.h:15
Lucene::DocumentsWriter
This class accepts multiple added documents and directly writes a single segment file. It does this more efficiently than creating a single segment per document (with DocumentWriter) and doing standard merges on those segments.
Definition: DocumentsWriter.h:54
Lucene::PriorityQueueScoreDocs
Definition: HitQueueBase.h:45
Lucene::TermRangeQuery
A Query that matches documents within an range of terms.
Definition: TermRangeQuery.h:21
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::PhraseScorer
Scoring functionality for phrase queries. A document is considered matching if it contains the phrase...
Definition: PhraseScorer.h:21
Lucene::FieldMaskingSpanQuery
Wrapper to allow SpanQuery objects participate in composite single-field SpanQueries by 'lying' about...
Definition: FieldMaskingSpanQuery.h:52
Lucene::StringCache
Definition: FieldCacheImpl.h:138
Lucene::TermRangeTermEnum
Subclass of FilteredTermEnum for enumerating all terms that match the specified range parameters...
Definition: TermRangeTermEnum.h:18
Lucene::IntCache
Definition: FieldCacheImpl.h:105
Lucene::LogMergePolicy
This class implements a MergePolicy that tries to merge segments into levels of exponentially increas...
Definition: LogMergePolicy.h:24
Lucene::DocFieldConsumersPerThread
Definition: DocFieldConsumersPerThread.h:14
Lucene::OrdFieldSource
Obtains the ordinal of the field value from the default Lucene FieldCache using getStringIndex().
Definition: OrdFieldSource.h:31
Lucene::NumberTools
Provides support for converting longs to Strings, and back again. The strings are structured so that ...
Definition: NumberTools.h:26
Lucene::TopScoreDocCollector
A Collector implementation that collects the top-scoring hits, returning them as a TopDocs...
Definition: TopScoreDocCollector.h:21
Lucene::NormsWriterPerThread
Definition: NormsWriterPerThread.h:14
Lucene::FreqProxTermsWriter
Definition: FreqProxTermsWriter.h:15
Lucene::BufferedIndexOutput
Base implementation class for buffered IndexOutput.
Definition: BufferedIndexOutput.h:15
Lucene::SortField
Stores information about how to sort documents by terms in an individual field. Fields must be indexe...
Definition: SortField.h:16
Lucene::FilteredQuery
A query that applies a filter to the results of another query.
Definition: FilteredQuery.h:20
Lucene::FileSwitchDirectory
A Directory instance that switches files between two other Directory instances.
Definition: FileSwitchDirectory.h:21
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::KeepOnlyLastCommitDeletionPolicy
This IndexDeletionPolicy implementation that keeps only the most recent commit and immediately remove...
Definition: KeepOnlyLastCommitDeletionPolicy.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::ComplexExplanation
Describes the score computation for document and query, and can distinguish a match independent of a ...
Definition: ComplexExplanation.h:16
Lucene::OpenBitSet
An "open" BitSet implementation that allows direct access to the array of words storing the bits...
Definition: OpenBitSet.h:19
Lucene::IntParser
Interface to parse ints from document fields.
Definition: FieldCache.h:220
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::StringIndexCache
Definition: FieldCacheImpl.h:149
Lucene::WhitespaceTokenizer
A WhitespaceTokenizer is a tokenizer that divides text at whitespace. Adjacent sequences of non-White...
Definition: WhitespaceTokenizer.h:16
Lucene::InvertedDocEndConsumer
Definition: InvertedDocEndConsumer.h:14
Lucene::OpenBitSetDISI
Definition: OpenBitSetDISI.h:14
Lucene::MergeSpecification
A MergeSpecification instance provides the information necessary to perform multiple merges...
Definition: MergePolicy.h:119
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::IntRangeBuilder
Definition: NumericUtils.h:162
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::NearSpansOrdered
A Spans that is formed from the ordered subspans of a SpanNearQuery where the subspans do not overlap...
Definition: NearSpansOrdered.h:31
Lucene::MultiPhraseQuery
MultiPhraseQuery is a generalized version of PhraseQuery, with an added method add(Term[]). To use this class, to search for the phrase "Microsoft app*" first use add(Term) on the term "Microsoft", then find all terms that have "app" as prefix using IndexReader.terms(Term), and use MultiPhraseQuery.add(Term[] terms) to add them to the query.
Definition: MultiPhraseQuery.h:18
Lucene::FieldCacheSource
A base class for ValueSource implementations that retrieve values for a single field from the FieldCa...
Definition: FieldCacheSource.h:28
Lucene::SegmentTermPositionVector
Definition: SegmentTermPositionVector.h:14
Lucene::CharReader
CharReader is a Reader wrapper. It reads chars from Reader and outputs CharStream, defining an identify function correctOffset method that simply returns the provided offset.
Definition: CharReader.h:16
Lucene::Sort
Encapsulates sort criteria for returned hits.
Definition: Sort.h:68
Lucene::FilteredDocIdSetIterator
Abstract decorator class of a DocIdSetIterator implementation that provides on-demand filter/validati...
Definition: FilteredDocIdSetIterator.h:16
Lucene::UTF8DecoderStream
Definition: UTF8Stream.h:106
Lucene::FilteredDocIdSet
Abstract decorator class for a DocIdSet implementation that provides on-demand filtering/validation m...
Definition: FilteredDocIdSet.h:23
Lucene::Reader
Abstract class for reading character streams.
Definition: Reader.h:15
Lucene::DocFieldConsumer
Definition: DocFieldConsumer.h:14
Lucene::RAMDirectory
A memory-resident Directory implementation. Locking implementation is by default the SingleInstanceLo...
Definition: RAMDirectory.h:17
Lucene::StoredFieldsWriterPerDoc
Definition: StoredFieldsWriter.h:50
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::MultipleTermPositions
Allows you to iterate over the TermPositions for multiple Terms as a single TermPositions.
Definition: MultipleTermPositions.h:16
Lucene::FastCharStream
An efficient implementation of QueryParserCharStream interface.
Definition: FastCharStream.h:18
Lucene::ScorerDocQueue
A ScorerDocQueue maintains a partial ordering of its Scorers such that the least Scorer can always be...
Definition: ScorerDocQueue.h:16
Lucene::PorterStemmer
This is the Porter stemming algorithm, coded up as thread-safe ANSI C by the author.
Definition: PorterStemmer.h:26
Lucene::FSLockFactory
Base class for file system based locking implementation.
Definition: FSLockFactory.h:15
Lucene::CachingWrapperFilter
Wraps another filter's result and caches it. The purpose is to allow filters to simply filter...
Definition: CachingWrapperFilter.h:16
Lucene::TermVectorsPositionInfo
Container for a term at a position.
Definition: PositionBasedTermVectorMapper.h:49
Lucene::IndexCommit
Represents a single commit into an index as seen by the IndexDeletionPolicy or IndexReader.
Definition: IndexCommit.h:22
Lucene::TopFieldCollector
A Collector that sorts by SortField using FieldComparators.
Definition: TopFieldCollector.h:17
Lucene::SegmentTermEnum
Definition: SegmentTermEnum.h:14
Lucene::PerDocBuffer
RAMFile buffer for DocWriters.
Definition: DocumentsWriter.h:381
Lucene::Filter
Abstract base class for restricting which documents may be returned during searching.
Definition: Filter.h:15
Lucene::NormsWriter
Writes norms. Each thread X field accumulates the norms for the doc/fields it saw, then the flush method below merges all of these together into a single _X.nrm file.
Definition: NormsWriter.h:16
Lucene::DefaultSkipListReader
Implements the skip list reader for the default posting list format that stores positions and payload...
Definition: DefaultSkipListReader.h:15
Lucene::TermVectorEntry
Convenience class for holding TermVector information.
Definition: TermVectorEntry.h:15
Lucene::TermsHashPerThread
Definition: TermsHashPerThread.h:14
Lucene::FormatPostingsPositionsWriter
Definition: FormatPostingsPositionsWriter.h:14
Lucene::PhraseQueue
Definition: PhraseQueue.h:14
Lucene::IndexStatus
Returned from checkIndex() detailing the health and status of the index.
Definition: CheckIndex.h:108
Lucene::FieldDocSortedHitQueue
Collects sorted results from Searchable's and collates them. The elements put into this queue must be...
Definition: FieldDocSortedHitQueue.h:16
Lucene::DocFieldConsumerPerField
Definition: DocFieldConsumerPerField.h:14
Lucene::FileReader
Convenience class for reading character files.
Definition: FileReader.h:15
Lucene::LongParser
Interface to parse longs from document fields.
Definition: FieldCache.h:232
Lucene::TopDocsCollector
A base class for all collectors that return a TopDocs output. This collector allows easy extension by...
Definition: TopDocsCollector.h:21
Lucene::MultiTermQuery
An abstract Query that matches documents containing a subset of terms provided by a FilteredTermEnum ...
Definition: MultiTermQuery.h:31
Lucene::Cache
Internal cache.
Definition: FieldCacheImpl.h:72
Lucene::DateField
Provides support for converting dates to strings and vice-versa. The strings are structured so that l...
Definition: DateField.h:31
Lucene::DocumentsWriterThreadState
Used by DocumentsWriter to maintain per-thread state. We keep a separate Posting hash and other state...
Definition: DocumentsWriterThreadState.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::StopFilter
Removes stop words from a token stream.
Definition: StopFilter.h:15
Lucene::SegmentMergeQueue
Definition: SegmentMergeQueue.h:14
Lucene::DocIdSetIterator
This abstract class defines methods to iterate over a set of non-decreasing doc ids. Note that this class assumes it iterates on doc Ids, and therefore NO_MORE_DOCS is set to { NO_MORE_DOCS} in order to be used as a sentinel object. Implementations of this class are expected to consider INT_MAX as an invalid value.
Definition: DocIdSetIterator.h:17
Lucene::QueryParserTokenManager
Token Manager.
Definition: QueryParserTokenManager.h:15
Lucene::SortedTermVectorMapper
Store a sorted collection of TermVectorEntrys. Collects all term information into a single...
Definition: SortedTermVectorMapper.h:22
Lucene::StringReader
Convenience class for reading strings.
Definition: StringReader.h:15
Lucene::FieldInvertState
This class tracks the number and position / offset parameters of terms being added to the index...
Definition: FieldInvertState.h:16
Lucene::TermVectorsTermsWriterPerField
Definition: TermVectorsTermsWriterPerField.h:14
Lucene::StartEnd
Definition: SpanFilterResult.h:56
Lucene::ThreadPool
Utility class to handle a pool of threads.
Definition: ThreadPool.h:46
Lucene::TermSpans
Public for extension only.
Definition: TermSpans.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::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::Similarity
Scoring API.
Definition: Similarity.h:427
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::AllTermDocs
Definition: AllTermDocs.h:14
Lucene::FormatPostingsFieldsConsumer
Abstract API that consumes terms, doc, freq, prox and payloads postings. Concrete implementations of ...
Definition: FormatPostingsFieldsConsumer.h:16
Lucene::NumericUtils
This is a helper class to generate prefix-encoded representations for numerical values and supplies c...
Definition: NumericUtils.h:37
Lucene::MatchAllDocsQuery
A query that matches all documents.
Definition: MatchAllDocsQuery.h:15
Lucene::BooleanScorer2
See the description in BooleanScorer, comparing BooleanScorer & BooleanScorer2.
Definition: BooleanScorer2.h:20
Lucene::BooleanScorerCollector
Definition: BooleanScorer.h:63
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::CharBlockPool
Definition: CharBlockPool.h:14
Lucene::SingleInstanceLockFactory
Implements LockFactory for a single in-process instance, meaning all locking will take place through ...
Definition: SingleInstanceLockFactory.h:20
Lucene::PrefixQuery
A Query that matches documents containing terms with a specified prefix. A PrefixQuery is built by Qu...
Definition: PrefixQuery.h:18
Lucene::FormatPostingsPositionsConsumer
Definition: FormatPostingsPositionsConsumer.h:14
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::MultiTermPositions
Definition: DirectoryReader.h:278
Lucene::MergeDocIDRemapper
Remaps docIDs after a merge has completed, where the merged segments had at least one deletion...
Definition: MergeDocIDRemapper.h:17
Lucene::FilterIndexReader
A FilterIndexReader contains another IndexReader, which it uses as its basic source of data...
Definition: FilterIndexReader.h:21
Lucene::InvertedDocEndConsumerPerThread
Definition: InvertedDocEndConsumerPerThread.h:14
Lucene::IndexFileNameFilter
Filename filter that accept filenames and extensions only created by Lucene.
Definition: IndexFileNameFilter.h:15
Lucene::SortedVIntList
Stores and iterate on sorted integers in compressed form in RAM.
Definition: SortedVIntList.h:22
Lucene::TermRangeFilter
A Filter that restricts search results to a range of term values in a given field.
Definition: TermRangeFilter.h:22
Lucene::LengthFilter
Removes words that are too long or too short from the stream.
Definition: LengthFilter.h:15
Lucene::ReadOnlyDirectoryReader
Definition: ReadOnlyDirectoryReader.h:14
Lucene::DoubleCache
Definition: FieldCacheImpl.h:127
Lucene::MaxPayloadFunction
Returns the maximum payload score seen, else 1 if there are no payloads on the doc.
Definition: MaxPayloadFunction.h:17
Lucene::DefaultSimilarity
Default scoring implementation.
Definition: DefaultSimilarity.h:15
Lucene::DirectoryReader
An IndexReader which reads indexes with multiple segments.
Definition: DirectoryReader.h:19
Lucene::DocFieldConsumerPerThread
Definition: DocFieldConsumerPerThread.h:14
Lucene::Lock
An interprocess mutex lock.
Definition: Lock.h:16
Lucene::SinkTokenStream
A filter that decides which AttributeSource states to store in the sink.
Definition: TeeSinkTokenFilter.h:120
Lucene::AbstractAllTermDocs
Base class for enumerating all but deleted docs.
Definition: AbstractAllTermDocs.h:18
Lucene::PrefixTermEnum
Subclass of FilteredTermEnum for enumerating all terms that match the specified prefix filter term...
Definition: PrefixTermEnum.h:18
Lucene::CharStream
CharStream adds correctOffset functionality over Reader. All Tokenizers accept a CharStream instead o...
Definition: CharStream.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::QueryWrapperFilter
Constrains search results to only match those which also match a provided query.
Definition: QueryWrapperFilter.h:20
Lucene::TermVectorEntryFreqSortedComparator
Compares TermVectorEntrys first by frequency and then by the term (case-sensitive) ...
Definition: TermVectorEntryFreqSortedComparator.h:15
Lucene::Directory
A Directory is a flat list of files. Files may be written once, when they are created. Once a file is created it may only be opened for read, or deleted. Random access is permitted both when reading and writing. Directory locking is implemented by an instance of LockFactory, and can be changed for each Directory instance using setLockFactory.
Definition: Directory.h:18
Lucene::Query
The abstract base class for queries.
Definition: Query.h:31
Lucene::Fieldable
Synonymous with Field.
Definition: Fieldable.h:20
Lucene::UTF8Decoder
Definition: UTF8Stream.h:81
Lucene::Future
A Future represents the result of an asynchronous computation. Methods are provided to check if the c...
Definition: ThreadPool.h:22
Lucene::SpanFirstQuery
Matches spans near the beginning of a field.
Definition: SpanFirstQuery.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::Spans
An enumeration of span matches. Used to implement span searching. Each span represents a range of ter...
Definition: Spans.h:17
Lucene::QueryTermVector
Definition: QueryTermVector.h:14
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::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::UTF16Decoder
Definition: UTF8Stream.h:120
Lucene::TimeLimitingCollector
The TimeLimitingCollector is used to timeout search requests that take longer than the maximum allowe...
Definition: TimeLimitingCollector.h:17
Lucene::InvertedDocConsumer
Definition: InvertedDocConsumer.h:14
Lucene::TermPositions
TermPositions provides an interface for enumerating the <document, frequency, <position>*> tuples for...
Definition: TermPositions.h:18
Lucene::SegmentTermVector
Definition: SegmentTermVector.h:14
Lucene::BufferedIndexInput
Base implementation class for buffered IndexInput.
Definition: BufferedIndexInput.h:15
Lucene::TermsHash
This class implements InvertedDocConsumer, which is passed each token produced by the analyzer on eac...
Definition: TermsHash.h:18
Lucene::WildcardTermEnum
Subclass of FilteredTermEnum for enumerating all terms that match the specified wildcard filter term...
Definition: WildcardTermEnum.h:18
Lucene::FieldComparator
A FieldComparator compares hits so as to determine their sort order when collecting the top results w...
Definition: FieldComparator.h:42
Lucene::Num
Number of documents a delete term applies to.
Definition: BufferedDeletes.h:43
Lucene::ReaderCommit
Definition: DirectoryReader.h:302
Lucene::Document
Documents are the unit of indexing and search.
Definition: Document.h:24
Lucene::Collator
Convenience class for storing collate objects.
Definition: Collator.h:15
Lucene::FieldComparatorSource
Provides a FieldComparator for custom field sorting.
Definition: FieldComparatorSource.h:15
Lucene::DefaultAttributeFactory
Definition: AttributeSource.h:154
Lucene::CountingDisjunctionSumScorer
Definition: BooleanScorer2.h:125
Lucene::PayloadSpanUtil
Experimental class to get set of payloads for most standard Lucene queries. Operates like Highlighter...
Definition: PayloadSpanUtil.h:16
Lucene::Scorer
Common scoring functionality for different types of queries.
Definition: Scorer.h:22
Lucene::ParallelArrayTermVectorMapper
Models the existing parallel array structure.
Definition: TermVectorsReader.h:118
Lucene::FieldCacheImpl
The default cache implementation, storing all values in memory. A WeakHashMap is used for storage...
Definition: FieldCacheImpl.h:15
Lucene::PerFieldAnalyzerWrapper
This analyzer is used to facilitate scenarios where different fields require different analysis techn...
Definition: PerFieldAnalyzerWrapper.h:29
Lucene::PayloadNearSpanScorer
Definition: PayloadNearQuery.h:63
Lucene::AveragePayloadFunction
Calculate the final score as the average score of all payloads seen.
Definition: AveragePayloadFunction.h:17
Lucene::DocState
Definition: DocumentsWriter.h:356
Lucene::TermVectorsTermsWriterPerThread
Definition: TermVectorsTermsWriterPerThread.h:14
Lucene::UTF8Encoder
Definition: UTF8Stream.h:44
Lucene::FSDirectory
Base class for Directory implementations that store index files in the file system. There are currently three core subclasses:
Definition: FSDirectory.h:29
Lucene::BooleanQuery
A Query that matches documents matching boolean combinations of other queries, eg. TermQuerys, PhraseQuerys or other BooleanQuerys.
Definition: BooleanQuery.h:18
Lucene::PositionBasedTermVectorMapper
Definition: PositionBasedTermVectorMapper.h:14
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::TermVectorsTermsWriterPerDoc
Definition: TermVectorsTermsWriter.h:54
Lucene::SegmentMergeInfo
Definition: SegmentMergeInfo.h:14
Lucene::Searcher
An abstract base class for search implementations. Implements the main search methods.
Definition: Searcher.h:18
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::FieldInfo
Definition: FieldInfo.h:14
Lucene::SegmentInfoStatus
Holds the status of each segment in the index. See segmentInfos.
Definition: CheckIndex.h:168
Lucene::SingleTermEnum
Subclass of FilteredTermEnum for enumerating a single term.
Definition: SingleTermEnum.h:18
Lucene::SpanFilterResult
The results of a SpanQueryFilter. Wraps the BitSet and the position information from the SpanQuery...
Definition: SpanFilterResult.h:15
Lucene::ByteParser
Interface to parse bytes from document fields.
Definition: FieldCache.h:208
Lucene::RewriteMethod
Abstract class that defines how the query is rewritten.
Definition: MultiTermQuery.h:122
Lucene::CountingConjunctionSumScorer
Definition: BooleanScorer2.h:145
Lucene::BitVector
Optimized implementation of a vector of bits.
Definition: BitVector.h:15
Lucene::RAMFile
File used as buffer in RAMDirectory.
Definition: RAMFile.h:15
Lucene::Analyzer
An Analyzer builds TokenStreams, which analyze text. It thus represents a policy for extracting index...
Definition: Analyzer.h:19
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::FieldDoc
A ScoreDoc which also contains information about how to sort the referenced document. In addition to the document number and score, this object contains an array of values for the document from the field(s) used to sort. For example, if the sort criteria was to sort by fields "a", "b" then "c", the fields object array will have three elements, corresponding respectively to the term values for the document in fields "a", "b" and "c". The class of each element in the array will be either Integer, Double or String depending on the type of values in the terms of each field.
Definition: FieldDoc.h:20
Lucene::MultiLevelSkipListReader
This abstract class reads skip lists with multiple levels.
Definition: MultiLevelSkipListReader.h:20
Lucene::ParallelMultiSearcher
Implements parallel search over a set of Searchables.
Definition: ParallelMultiSearcher.h:18
Lucene::SnapshotDeletionPolicy
Definition: SnapshotDeletionPolicy.h:14
Lucene::NormalizeCharMap
Holds a map of String input to String output, to be used with MappingCharFilter.
Definition: NormalizeCharMap.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::FieldCacheSanityChecker
Provides methods for sanity checking that entries in the FieldCache are not wasteful or inconsistent...
Definition: FieldCacheSanityChecker.h:28
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::DocConsumerPerThread
Definition: DocConsumerPerThread.h:14
Lucene::SpanScorer
Public for extension only.
Definition: SpanScorer.h:15
Lucene::FieldSortedTermVectorMapper
For each Field, store a sorted collection of TermVectorEntrys This is not thread-safe.
Definition: FieldSortedTermVectorMapper.h:17
Lucene::StoredFieldsWriterPerThread
Definition: StoredFieldsWriterPerThread.h:14
Lucene::DocValues
Represents field values as different types. Normally created via a ValueSuorce for a particular field...
Definition: DocValues.h:22
Lucene::TopDocs
Represents hits returned by Searcher#search(QueryPtr, FilterPtr, int32_t) and Searcher#search(QueryPt...
Definition: TopDocs.h:16
Lucene::NormsWriterPerField
Taps into DocInverter, as an InvertedDocEndConsumer, which is called at the end of inverting each fie...
Definition: NormsWriterPerField.h:16
Lucene::LuceneObject
Base class for all Lucene classes.
Definition: LuceneObject.h:31
Lucene::MappingCharFilter
Simplistic CharFilter that applies the mappings contained in a NormalizeCharMap to the character stre...
Definition: MappingCharFilter.h:16
Lucene::StoredFieldsWriter
This is a DocFieldConsumer that writes stored fields.
Definition: StoredFieldsWriter.h:15
Lucene::MultiReader
An IndexReader which reads multiple indexes, appending their content.
Definition: MultiReader.h:15
Lucene::DoubleParser
Interface to parse doubles from document fields.
Definition: FieldCache.h:244
Lucene::LockFactory
Base class for Locking implementation. Directory uses instances of this class to implement locking...
Definition: LockFactory.h:23
Lucene::TermVectorMapper
The TermVectorMapper can be used to map Term Vectors into your own structure instead of the parallel ...
Definition: TermVectorMapper.h:18
Lucene::AbstractField
Definition: AbstractField.h:14
Lucene::DocIdBitSet
Simple DocIdSet and DocIdSetIterator backed by a BitSet.
Definition: DocIdBitSet.h:15
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::Explanation
Describes the score computation for document and query.
Definition: Explanation.h:15
Lucene::RAMOutputStream
A memory-resident IndexOutput implementation.
Definition: RAMOutputStream.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::FreqProxTermsWriterPerField
Definition: FreqProxTermsWriterPerField.h:14
Lucene::CompressionTools
Simple utility class providing static methods to compress and decompress binary data for stored field...
Definition: CompressionTools.h:15
Lucene::DocInverter
This is a DocFieldConsumer that inverts each field, separately, from a Document, and accepts a Invert...
Definition: DocInverter.h:16
Lucene
Definition: AbstractAllTermDocs.h:12
Lucene::PositionInfo
Definition: SpanFilterResult.h:39
Lucene::StandardTokenizer
A grammar-based tokenizer.
Definition: StandardTokenizer.h:34
Lucene::LongCache
Definition: FieldCacheImpl.h:116
Lucene::IndexOutput
Abstract base class for output to a file in a Directory. A random-access output stream. Used for all Lucene index output operations.
Definition: IndexOutput.h:18
Lucene::FormatPostingsDocsWriter
Consumes doc & freq, writing them using the current index file format.
Definition: FormatPostingsDocsWriter.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::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::TermInfosWriter
This stores a monotonically increasing set of <Term, TermInfo> pairs in a Directory. A TermInfos can be written once, in order.
Definition: TermInfosWriter.h:16
Lucene::CreationPlaceholder
Definition: FieldCache.h:170
Lucene::RAMInputStream
A memory-resident IndexInput implementation.
Definition: RAMInputStream.h:15
Lucene::FilteredTermEnum
Abstract class for enumerating a subset of all terms.
Definition: FilteredTermEnum.h:18
Lucene::ReadOnlySegmentReader
Definition: ReadOnlySegmentReader.h:14
Lucene::SingleTokenAttributeSource
Definition: DocInverterPerThread.h:44
Lucene::ScoreCachingWrappingScorer
A Scorer which wraps another scorer and caches the score of the current document. Successive calls to...
Definition: ScoreCachingWrappingScorer.h:22
Lucene::SpanQuery
Base class for span-based queries.
Definition: SpanQuery.h:15
Lucene::StandardTokenizerImpl
Definition: StandardTokenizerImpl.h:14
Lucene::TokenFilter
A TokenFilter is a TokenStream whose input is another TokenStream.
Definition: TokenFilter.h:18
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::TermVectorsTermsWriter
Definition: TermVectorsTermsWriter.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::TermBuffer
Definition: TermBuffer.h:14
Lucene::FieldSelector
The FieldSelector allows one to make decisions about what Fields get loaded on a Document by IndexRea...
Definition: FieldSelector.h:16
Lucene::StandardFilter
Normalizes tokens extracted with StandardTokenizer.
Definition: StandardFilter.h:15
Lucene::DocFieldProcessorPerField
Holds all per thread, per field state.
Definition: DocFieldProcessorPerField.h:15
Lucene::FuzzyQuery
Implements the fuzzy search query. The similarity measurement is based on the Levenshtein (edit dista...
Definition: FuzzyQuery.h:19
Lucene::FieldsWriter
Definition: FieldsWriter.h:14
Lucene::SkipDocWriter
Definition: DocumentsWriter.h:457
Lucene::FreqProxFieldMergeState
Used by DocumentsWriter to merge the postings from multiple ThreadStates when creating a segment...
Definition: FreqProxFieldMergeState.h:15
Lucene::BooleanClause
A clause in a BooleanQuery.
Definition: BooleanClause.h:15
DECLARE_SHARED_PTR
#define DECLARE_SHARED_PTR(Type)
Definition: LuceneTypes.h:12
Lucene::DisjunctionSumScorer
A Scorer for OR like queries, counterpart of ConjunctionScorer. This Scorer implements Scorer#skipTo(...
Definition: DisjunctionSumScorer.h:16
Lucene::FieldCacheEntryImpl
Definition: FieldCacheImpl.h:160
Lucene::WaitQueue
Definition: DocumentsWriter.h:469
Lucene::FreqProxTermsWriterPostingList
Definition: FreqProxTermsWriter.h:41
Lucene::BucketTable
A simple hash table of document scores within a range.
Definition: BooleanScorer.h:119
Lucene::SegmentMerger
The SegmentMerger class combines two or more Segments, represented by an IndexReader (add...
Definition: SegmentMerger.h:20
Lucene::FuzzyTermEnum
Subclass of FilteredTermEnum for enumerating all terms that are similar to the specified filter term...
Definition: FuzzyTermEnum.h:18
Lucene::SpanNotQuery
Removes matches which overlap with another SpanQuery.
Definition: SpanNotQuery.h:15
Lucene::CharTokenizer
An abstract base class for simple, character-oriented tokenizers.
Definition: CharTokenizer.h:15
Lucene::DocFieldConsumersPerDoc
Definition: DocFieldConsumers.h:50
Lucene::FieldCacheEntry
A unique Identifier/Description for each item in the FieldCache. Can be useful for logging/debugging...
Definition: FieldCache.h:255
Lucene::ByteBlockAllocator
Definition: DocumentsWriter.h:497
Lucene::DoubleFieldSource
Obtains double field values from the FieldCache using getDoubles() and makes those values available a...
Definition: DoubleFieldSource.h:25
Lucene::FormatPostingsDocsConsumer
Definition: FormatPostingsDocsConsumer.h:14
Lucene::SegmentTermPositions
Definition: SegmentTermPositions.h:14
Lucene::Collector
Collectors are primarily meant to be used to gather raw results from a search, and implement sorting ...
Definition: Collector.h:100
Lucene::IndexingChain
The IndexingChain must define the getChain(DocumentsWriter) method which returns the DocConsumer that...
Definition: DocumentsWriter.h:423
Lucene::PayloadAttribute
The start and end character offset of a Token.
Definition: PayloadAttribute.h:15
Lucene::WhitespaceAnalyzer
An Analyzer that uses WhitespaceTokenizer.
Definition: WhitespaceAnalyzer.h:15
Lucene::InfoStream
Utility class to support streaming info messages.
Definition: InfoStream.h:16
Lucene::WordlistLoader
Loader for text files that represent a list of stopwords.
Definition: WordlistLoader.h:15
Lucene::InfoStreamOut
Stream override to write messages to a std::cout.
Definition: InfoStream.h:44
Lucene::SimilarityDelegator
Delegating scoring implementation. Useful in Query#getSimilarity(Searcher) implementations, to override only certain methods of a Searcher's Similarity implementation.
Definition: SimilarityDelegator.h:16
Lucene::ReverseOrdFieldSource
Obtains the ordinal of the field value from the default Lucene FieldCache using getStringIndex() and ...
Definition: ReverseOrdFieldSource.h:31
Lucene::InvertedDocConsumerPerField
Definition: InvertedDocConsumerPerField.h:14
Lucene::SegmentInfoCollection
A collection of SegmentInfo objects to be used as a base class for SegmentInfos.
Definition: SegmentInfoCollection.h:15
Lucene::TermVectorsTermsWriterPostingList
Definition: TermVectorsTermsWriter.h:80
Lucene::TermVectorsReader
Definition: TermVectorsReader.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::Insanity
Simple container for a collection of related CacheEntry objects that in conjunction with each other r...
Definition: FieldCacheSanityChecker.h:95
Lucene::TermInfosReaderThreadResources
Definition: TermInfosReader.h:74
Lucene::ChecksumIndexOutput
Writes bytes through to a primary IndexOutput, computing checksum. Note that you cannot use seek()...
Definition: ChecksumIndexOutput.h:17
Lucene::HitQueue
Definition: HitQueue.h:14
Lucene::IndexSearcher
Implements search over a single IndexReader.
Definition: IndexSearcher.h:23
Lucene::ByteSliceReader
IndexInput that knows how to read the byte slices written by Posting and PostingVector. We read the bytes in each slice until we hit the end of that slice at which point we read the forwarding address of the next slice and then jump to it.
Definition: ByteSliceReader.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::TermInfosReader
This stores a monotonically increasing set of <Term, TermInfo> pairs in a Directory. Pairs are accessed either by Term or by ordinal position the set.
Definition: TermInfosReader.h:17
Lucene::AttributeFactory
Definition: AttributeSource.h:14
Lucene::InvertedDocConsumerPerThread
Definition: InvertedDocConsumerPerThread.h:14
Lucene::LuceneThread
Lucene thread container.
Definition: LuceneThread.h:23
Lucene::FormatPostingsTermsWriter
Definition: FormatPostingsTermsWriter.h:14
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::SegmentWriteState
Definition: SegmentWriteState.h:14
Lucene::NumericField
This class provides a Field that enables indexing of numeric values for efficient range filtering and...
Definition: NumericField.h:59
Lucene::TokenAttributeFactory
Creates a TokenAttributeFactory returning Token as instance for the basic attributes and for all othe...
Definition: Token.h:338
Lucene::Synchronize
Utility class to support locking via a mutex.
Definition: Synchronize.h:16
Lucene::InfoStreamFile
Stream override to write messages to a file.
Definition: InfoStream.h:29
Lucene::FieldValueHitQueueEntry
Definition: FieldValueHitQueue.h:56
Lucene::CSIndexInput
Implementation of an IndexInput that reads from a portion of the compound file.
Definition: CompoundFileReader.h:83
Lucene::DocIdSet
A DocIdSet contains a set of doc ids. Implementing classes must only implement iterator to provide ac...
Definition: DocIdSet.h:16
Lucene::DisjunctionMaxScorer
The Scorer for DisjunctionMaxQuery. The union of all documents generated by the the subquery scorers ...
Definition: DisjunctionMaxScorer.h:18
Lucene::SubScorer
Definition: BooleanScorer.h:138
Lucene::TermsHashConsumerPerField
Implement this class to plug into the TermsHash processor, which inverts & stores Tokens into a hash ...
Definition: TermsHashConsumerPerField.h:16
Lucene::TermScorer
A Scorer for documents matching a Term.
Definition: TermScorer.h:15
Lucene::SinkFilter
Definition: TeeSinkTokenFilter.h:95
Lucene::InputStreamReader
An InputStreamReader is a bridge from byte streams to character streams.
Definition: InputStreamReader.h:15
Lucene::QueryParserConstants
Token literal values and constants.
Definition: QueryParserConstants.h:15
Lucene::SegmentInfos
A collection of SegmentInfo objects with methods for operating on those segments in relation to the f...
Definition: SegmentInfos.h:15
Lucene::MultiSearcher
Implements search over a set of Searchables.
Definition: MultiSearcher.h:19
Lucene::Tokenizer
A Tokenizer is a TokenStream whose input is a Reader.
Definition: Tokenizer.h:20
Lucene::UnicodeResult
Definition: UnicodeUtils.h:89
Lucene::PayloadNearSpanWeight
Definition: PayloadNearQuery.h:52
Lucene::SpanTermQuery
Matches spans containing a term.
Definition: SpanTermQuery.h:15
Lucene::CustomScoreProvider
An instance of this subclass should be returned by CustomScoreQuery#getCustomScoreProvider, if you want to modify the custom score calculation of a CustomScoreQuery.
Definition: CustomScoreProvider.h:21
Lucene::KeywordTokenizer
Emits the entire input as a single token.
Definition: KeywordTokenizer.h:15
Lucene::StandardAnalyzer
Filters StandardTokenizer with StandardFilter, LowerCaseFilter and StopFilter, using a list of Englis...
Definition: StandardAnalyzer.h:23
Lucene::BaseCharFilter
Base utility class for implementing a CharFilter. You subclass this, and then record mappings by call...
Definition: BaseCharFilter.h:16
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::FlagsAttribute
This attribute can be used to pass different flags down the tokenizer chain, eg from one TokenFilter ...
Definition: FlagsAttribute.h:16
Lucene::WildcardQuery
Implements the wildcard search query. Supported wildcards are *, which matches any character sequence...
Definition: WildcardQuery.h:21
Lucene::IntBlockPool
Definition: IntBlockPool.h:14
Lucene::DateTools
Provides support for converting dates to strings and vice-versa. The strings are structured so that l...
Definition: DateTools.h:28
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::PrefixFilter
A Filter that restricts search results to values that have a matching prefix in a given field...
Definition: PrefixFilter.h:15
Lucene::ParallelReader
An IndexReader which reads multiple, parallel indexes. Each index added must have the same number of ...
Definition: ParallelReader.h:26
Lucene::SegmentInfo
Information about a segment such as it's name, directory, and files related to the segment...
Definition: SegmentInfo.h:16
Lucene::IndexReader
IndexReader is an abstract class, providing an interface for accessing an index. Search of an index i...
Definition: IndexReader.h:39
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::MultiLevelSkipListWriter
This abstract class writes skip lists with multiple levels.
Definition: MultiLevelSkipListWriter.h:36
Lucene::NativeFSLockFactory
Implements LockFactory using native file lock.
Definition: NativeFSLockFactory.h:16
Lucene::MergePolicy
A MergePolicy determines the sequence of primitive merge operations to be used for overall merge and ...
Definition: MergePolicy.h:32
Lucene::ScoreDoc
Expert: Returned by low-level search implementations.
Definition: ScoreDoc.h:16
Lucene::TermDocs
TermDocs provides an interface for enumerating <document, frequency>; pairs for a term...
Definition: TermDocs.h:19
Lucene::InvertedDocEndConsumerPerField
Definition: InvertedDocEndConsumerPerField.h:14
Lucene::TopFieldDocs
Represents hits returned by Searcher#search(QueryPtr, FilterPtr, int32_t, SortPtr).
Definition: TopFieldDocs.h:15
Lucene::CharFilter
Subclasses of CharFilter can be chained to filter CharStream. They can be used as Reader with additio...
Definition: CharFilter.h:17
Lucene::SingleMatchScorer
Count a scorer as a single match.
Definition: BooleanScorer2.h:105
Lucene::CustomScoreQuery
Query that sets document score as a programmatic function of several (sub) scores: ...
Definition: CustomScoreQuery.h:21
Lucene::LowerCaseFilter
Normalizes token text to lower case.
Definition: LowerCaseFilter.h:15
Lucene::TermVectorsWriter
Definition: TermVectorsWriter.h:14
Lucene::UTF8EncoderStream
Definition: UTF8Stream.h:67
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::SpanFilter
Abstract base class providing a mechanism to restrict searches to a subset of an index and also maint...
Definition: SpanFilter.h:21
Lucene::IndexInput
Abstract base class for input from a file in a Directory. A random-access input stream. Used for all Lucene index input operations.
Definition: IndexInput.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::PhrasePositions
Position of a term in a document that takes into account the term offset within the phrase...
Definition: PhrasePositions.h:15
Lucene::ValueSource
Source of values for basic function queries.
Definition: ValueSource.h:21
Lucene::TeeSinkTokenFilter
This TokenFilter provides the ability to set aside attribute states that have already been analyzed...
Definition: TeeSinkTokenFilter.h:62
Lucene::ChecksumIndexInput
Writes bytes through to a primary IndexInput, computing checksum as it goes. Note that you cannot use...
Definition: ChecksumIndexInput.h:17
Lucene::SimpleAnalyzer
An Analyzer that filters LetterTokenizer with LowerCaseFilter.
Definition: SimpleAnalyzer.h:15
Lucene::FreqProxTermsWriterPerThread
Definition: FreqProxTermsWriterPerThread.h:14
Lucene::MultiTermDocs
Definition: DirectoryReader.h:225
Lucene::ByteFieldSource
Obtains byte field values from the FieldCache using getBytes() and makes those values available as ot...
Definition: ByteFieldSource.h:24
Lucene::Random
Utility class to generate a stream of pseudorandom numbers.
Definition: Random.h:15
Lucene::DefaultIndexingChain
This is the current indexing chain: DocConsumer / DocConsumerPerThread –> code: DocFieldProcessor / ...
Definition: DocumentsWriter.h:447
Lucene::FieldCache
Maintains caches of term values.
Definition: FieldCache.h:17
Lucene::ReqExclScorer
A Scorer for queries with a required subscorer and an excluding (prohibited) sub DocIdSetIterator. This Scorer implements Scorer#skipTo(int32_t), and it uses the skipTo() on the given scorers.
Definition: ReqExclScorer.h:16
Lucene::CompoundFileWriter
Combines multiple files into a single compound file. The file format: VInt fileCount {Directory} file...
Definition: CompoundFileWriter.h:27
Lucene::CachingSpanFilter
Wraps another SpanFilter's result and caches it. The purpose is to allow filters to simply filter...
Definition: CachingSpanFilter.h:17
Lucene::FieldInfos
Access to the Fieldable Info file that describes document fields and whether or not they are indexed...
Definition: FieldInfos.h:18
Lucene::TermVectorOffsetInfo
The TermVectorOffsetInfo class holds information pertaining to a Term in a TermPositionVector's offse...
Definition: TermVectorOffsetInfo.h:17
Lucene::MultiFieldQueryParser
A QueryParser which constructs queries to search multiple fields.
Definition: MultiFieldQueryParser.h:16
Lucene::ValueSourceQuery
A Query that sets the scores of document to the values obtained from a ValueSource.
Definition: ValueSourceQuery.h:22
Lucene::TermsHashConsumerPerThread
Definition: TermsHashConsumerPerThread.h:14
Lucene::PorterStemFilter
Transforms the token stream as per the Porter stemming algorithm. Note: the input to the stemming fil...
Definition: PorterStemFilter.h:31
Lucene::DocFieldConsumersPerField
Definition: DocFieldConsumersPerField.h:14
Lucene::ASCIIFoldingFilter
This class converts alphabetic, numeric, and symbolic Unicode characters which are not in the first 1...
Definition: ASCIIFoldingFilter.h:42
Lucene::FieldScoreQuery
A query that scores each document as the value of the numeric input field.
Definition: FieldScoreQuery.h:43
Lucene::TermPositionVector
Extends TermFreqVector to provide additional information about positions in which each of the terms i...
Definition: TermPositionVector.h:16
Lucene::Bucket
Definition: BooleanScorer.h:103
Lucene::HitQueueBase
Definition: HitQueueBase.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::SpanNearQuery
Matches spans which are near one another. One can specify slop, the maximum number of intervening unm...
Definition: SpanNearQuery.h:16
Lucene::BitSet
Definition: BitSet.h:15
Lucene::SegmentTermDocs
Definition: SegmentTermDocs.h:14
Lucene::Weight
Calculate query weights and build query scorers.
Definition: Weight.h:30
Lucene::BucketScorer
Definition: BooleanScorer.h:85
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::TermVectorStatus
Status from testing stored fields.
Definition: CheckIndex.h:294
Lucene::SegmentReader
Definition: SegmentReader.h:15
Lucene::MergeScheduler
IndexWriter uses an instance implementing this interface to execute the merges selected by a MergePol...
Definition: MergeScheduler.h:16
Lucene::NumericTokenStream
This class provides a TokenStream for indexing numeric values that can be used by NumericRangeQuery o...
Definition: NumericTokenStream.h:52
Lucene::MinPayloadFunction
Calculates the minimum payload seen.
Definition: MinPayloadFunction.h:15
Lucene::TermIndexStatus
Status from testing term index.
Definition: CheckIndex.h:253
Lucene::SloppyPhraseScorer
Definition: SloppyPhraseScorer.h:14
Lucene::FieldNormStatus
Status from testing field norms.
Definition: CheckIndex.h:237
Lucene::IndexFileDeleter
This class keeps track of each SegmentInfos instance that is still "live", either because it correspo...
Definition: IndexFileDeleter.h:34
Lucene::MultiTermQueryWrapperFilter
A wrapper for MultiTermQuery, that exposes its functionality as a Filter.
Definition: MultiTermQueryWrapperFilter.h:22
Lucene::TermInfo
A TermInfo is the record of information stored for a term.
Definition: TermInfo.h:15
Lucene::KeywordAnalyzer
Tokenizes the entire stream as a single token. This is useful for data like zip codes, ids, and some product names.
Definition: KeywordAnalyzer.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::DocConsumer
Definition: DocConsumer.h:14
Lucene::FieldsReader
Class responsible for access to stored document fields. It uses <segment>.fdt and <segment>...
Definition: FieldsReader.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::StringIndex
Stores term text values and document ordering data.
Definition: FieldCache.h:180
Lucene::Field
Definition: Field.h:14
Lucene::AttributeSource
An AttributeSource contains a list of different Attributes, and methods to add and get them...
Definition: AttributeSource.h:43
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::OffsetAttribute
The start and end character offset of a Token.
Definition: OffsetAttribute.h:15
Lucene::NoLockFactory
Use this LockFactory to disable locking entirely. Only one instance of this lock is created...
Definition: NoLockFactory.h:18

clucene.sourceforge.net