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

Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 1 2 3 4 5 6 7 8]

C Lucene::Array< TYPE > | Utility template class to handle sharable arrays of simple data types
C Lucene::ArrayData< TYPE > |
C Lucene::Constants | Some useful Lucene constants
►C Lucene::CycleCheck | Debug utility to track shared_ptr utilization
C Lucene::CycleCheckT< TYPE > |
►C boost::enable_shared_from_this |
►C Lucene::LuceneObject | Base class for all Lucene classes
C Lucene::CloseableThreadLocal< Lucene::TermInfosReaderThreadResources > |
C Lucene::CloseableThreadLocal< Lucene::TermVectorsReader > |
C Lucene::CloseableThreadLocal< Lucene::IndexInput > |
C Lucene::CloseableThreadLocal< Lucene::LuceneObject > |
►C Lucene::PriorityQueue< ScoreDocPtr > |
C Lucene::PriorityQueueScoreDocs |
►C Lucene::PriorityQueue< PhrasePositionsPtr > |
C Lucene::PhraseQueue |
►C Lucene::PriorityQueue< SegmentMergeInfoPtr > |
C Lucene::SegmentMergeQueue |
►C Lucene::PriorityQueue< FieldDocPtr > |
C Lucene::FieldDocSortedHitQueue | Collects sorted results from Searchable's and collates them. The elements put into this queue must be of type FieldDoc
►C Lucene::TranslationResult< uint8_t > |
C Lucene::UTF8Result |
►C Lucene::TranslationResult< wchar_t > |
C Lucene::UnicodeResult |
►C Lucene::AbstractAllTermDocs | Base class for enumerating all but deleted docs
C Lucene::AllTermDocs |
►C Lucene::AbstractField |
C Lucene::Field |
C Lucene::LazyField |

C Lucene::NumericField

This class provides a Field that enables indexing of numeric values for efficient range filtering and sorting. The native types int32_t, int64_t and double are directly supported. However, any value that can be converted into these native types can also be indexed. For example, date/time values represented by a {} can be translated into a int64_t value. If you don't need millisecond precision, you can quantize the value, either by dividing the result or using the separate getters (for year, month, etc.) to construct an int32_t or int64_t value

►C Lucene::Analyzer | An Analyzer builds TokenStreams, which analyze text. It thus represents a policy for extracting index terms from text
C Lucene::KeywordAnalyzer | Tokenizes the entire stream as a single token. This is useful for data like zip codes, ids, and some product names
C Lucene::PerFieldAnalyzerWrapper | This analyzer is used to facilitate scenarios where different fields require different analysis techniques. Use addAnalyzer to add a non-default analyzer on a field name basis
C Lucene::SimpleAnalyzer | An Analyzer that filters LetterTokenizer with LowerCaseFilter
C Lucene::StandardAnalyzer | Filters StandardTokenizer with StandardFilter, LowerCaseFilter and StopFilter, using a list of English stop words
C Lucene::StopAnalyzer | Filters LetterTokenizer with LowerCaseFilter and StopFilter
C Lucene::WhitespaceAnalyzer | An Analyzer that uses WhitespaceTokenizer
►C Lucene::Attribute | Base class for Attributes that can be added to a AttributeSource
C Lucene::FlagsAttribute | This attribute can be used to pass different flags down the tokenizer chain, eg from one TokenFilter to another one
C Lucene::OffsetAttribute | The start and end character offset of a Token
C Lucene::PayloadAttribute | The start and end character offset of a Token
C Lucene::PositionIncrementAttribute | The positionIncrement determines the position of this token relative to the previous Token in a TokenStream, used in phrase searching
C Lucene::TermAttribute | The term text of a Token
C Lucene::Token | A Token is an occurrence of a term from the text of a field. It consists of a term's text, the start and end offset of the term in the text of the field and a type string
C Lucene::TypeAttribute | A Token's lexical type. The Default value is "word"
►C Lucene::AttributeFactory |
C Lucene::DefaultAttributeFactory |
C Lucene::TokenAttributeFactory | Creates a TokenAttributeFactory returning Token as instance for the basic attributes and for all other attributes calls the given delegate factory

►C Lucene::AttributeSource

An AttributeSource contains a list of different Attributes, and methods to add and get them. There can only be a single instance of an attribute in the same AttributeSource instance. This is ensured by passing in the actual type of the Attribute (Class<Attribute>) to the addAttribute(Class), which then checks if an instance of that type is already present. If yes, it returns the instance, otherwise it creates a new instance and returns it

C Lucene::SingleTokenAttributeSource |
►C Lucene::TokenStream | A TokenStream enumerates the sequence of tokens, either from Fields of a Document or from query text
C Lucene::NumericTokenStream | This class provides a TokenStream for indexing numeric values that can be used by NumericRangeQuery or NumericRangeFilter
C Lucene::SinkTokenStream | A filter that decides which AttributeSource states to store in the sink
►C Lucene::TokenFilter | A TokenFilter is a TokenStream whose input is another TokenStream
C Lucene::ASCIIFoldingFilter | This class converts alphabetic, numeric, and symbolic Unicode characters which are not in the first 127 ASCII characters (the "Basic Latin" Unicode block) into their ASCII equivalents, if one exists
C Lucene::CachingTokenFilter | This class can be used if the token attributes of a TokenStream are intended to be consumed more than once. It caches all token attribute states locally in a List
C Lucene::ISOLatin1AccentFilter | A filter that replaces accented characters in the ISO Latin 1 character set (ISO-8859-1) by their unaccented equivalent. The case will not be altered
C Lucene::LengthFilter | Removes words that are too long or too short from the stream
C Lucene::LowerCaseFilter | Normalizes token text to lower case
C Lucene::PorterStemFilter | Transforms the token stream as per the Porter stemming algorithm. Note: the input to the stemming filter must already be in lower case, so you will need to use LowerCaseFilter or LowerCaseTokenizer further down the Tokenizer chain in order for this to work properly
C Lucene::StandardFilter | Normalizes tokens extracted with StandardTokenizer
C Lucene::StopFilter | Removes stop words from a token stream
C Lucene::TeeSinkTokenFilter | This TokenFilter provides the ability to set aside attribute states that have already been analyzed. This is useful in situations where multiple fields share many common analysis steps and then go their separate ways
►C Lucene::Tokenizer | A Tokenizer is a TokenStream whose input is a Reader
►C Lucene::CharTokenizer | An abstract base class for simple, character-oriented tokenizers
►C Lucene::LetterTokenizer | A LetterTokenizer is a tokenizer that divides text at non-letters. That's to say, it defines tokens as maximal strings of adjacent letters, as defined UnicodeUtil::isAlpha(c) predicate
C 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
C Lucene::WhitespaceTokenizer | A WhitespaceTokenizer is a tokenizer that divides text at whitespace. Adjacent sequences of non-Whitespace characters form tokens
C Lucene::KeywordTokenizer | Emits the entire input as a single token
C Lucene::StandardTokenizer | A grammar-based tokenizer
C Lucene::AttributeSourceState | This class holds the state of an AttributeSource
C Lucene::Base64 |
C Lucene::BitSet |
C Lucene::BitUtil | A variety of high efficiency bit twiddling routines
C Lucene::BitVector | Optimized implementation of a vector of bits
C Lucene::BooleanClause | A clause in a BooleanQuery
C Lucene::Bucket |
C Lucene::BucketTable | A simple hash table of document scores within a range
C Lucene::BufferedDeletes | Holds buffered deletes, by docID, term or query. We hold two instances of this class: one for the deletes prior to the last flush, the other for deletes after the last flush. This is so if we need to abort (discard all buffered docs) we can also discard the buffered deletes yet keep the deletes done during previously flushed segments

C Lucene::ByteBlockPool

Class that Posting and PostingVector use to write byte streams into shared fixed-size byte[] arrays. The idea is to allocate slices of increasing lengths. For example, the first slice is 5 bytes, the next slice is 14, etc. We start by writing our bytes into the first 5 bytes. When we hit the end of the slice, we allocate the next slice and then write the address of the new slice into the last 4 bytes of the previous slice (the "forwarding address")

►C Lucene::ByteBlockPoolAllocatorBase |
C Lucene::ByteBlockAllocator |
C Lucene::ByteSliceWriter | Class to write byte streams into slices of shared byte[]. This is used by DocumentsWriter to hold the posting list for many terms in RAM
►C Lucene::Cache | Internal cache
C Lucene::ByteCache |
C Lucene::DoubleCache |
C Lucene::IntCache |
C Lucene::LongCache |
C Lucene::StringCache |
C Lucene::StringIndexCache |
C Lucene::CharArraySet | A simple class that stores Strings as char[]'s in a hash table. Note that this is not a general purpose class. For example, it cannot remove items from the set, nor does it resize its hash table to be smaller, etc. It is designed to be quick to test if a char[] is in the set without the necessity of converting it to a String first
C Lucene::CharBlockPool |
C Lucene::CharFolder | Utility class for folding character case
►C Lucene::CheckAbort |
C Lucene::CheckAbortNull |
C Lucene::CheckIndex | Basic tool and API to check the health of an index and write a new segments file that removes reference to problematic segments
C Lucene::CloseableThreadLocal< TYPE > | General purpose thread-local map
C Lucene::Collator | Convenience class for storing collate objects
►C Lucene::Collector | Collectors are primarily meant to be used to gather raw results from a search, and implement sorting or custom result filtering, collation, etc
C Lucene::BooleanScorerCollector |
C Lucene::PositiveScoresOnlyCollector | A Collector implementation which wraps another Collector and makes sure only documents with scores > 0 are collected
C Lucene::TimeLimitingCollector | The TimeLimitingCollector is used to timeout search requests that take longer than the maximum allowed search time limit. After this time is exceeded, the search thread is stopped by throwing a TimeExceededException
►C Lucene::TopDocsCollector | A base class for all collectors that return a TopDocs output. This collector allows easy extension by providing a single constructor which accepts a PriorityQueue as well as protected members for that priority queue and a counter of the number of total hits
C Lucene::TopFieldCollector | A Collector that sorts by SortField using FieldComparators

C Lucene::TopScoreDocCollector

A Collector implementation that collects the top-scoring hits, returning them as a TopDocs. This is used by IndexSearcher to implement TopDocs-based search. Hits are sorted by score descending and then (when the scores are tied) docID ascending. When you create an instance of this collector you should know in advance whether documents are going to be collected in doc Id order or not

C Lucene::CompoundFileWriter | Combines multiple files into a single compound file. The file format: VInt fileCount {Directory} fileCount entries with the following structure: int64_t dataOffset String fileName {File Data} fileCount entries with the raw data of the corresponding file
C Lucene::CompressionTools | Simple utility class providing static methods to compress and decompress binary data for stored fields
C Lucene::Coordinator |
C Lucene::CreationPlaceholder |
C 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
C Lucene::DateField | Provides support for converting dates to strings and vice-versa. The strings are structured so that lexicographic sorting orders by date, which makes them suitable for use as field values and search terms
C Lucene::DateTools | Provides support for converting dates to strings and vice-versa. The strings are structured so that lexicographic sorting orders them by date, which makes them suitable for use as field values and search terms
►C 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
C Lucene::CompoundFileReader | Class for accessing a compound stream. This class implements a directory, but is limited to only read operations. Directory methods that would normally modify data throw an exception
►C Lucene::FSDirectory | Base class for Directory implementations that store index files in the file system. There are currently three core subclasses:
C Lucene::MMapDirectory | File-based Directory implementation that uses mmap for reading, and SimpleFSIndexOutput for writing
C Lucene::SimpleFSDirectory | A straightforward implementation of FSDirectory using std::ofstream and std::ifstream
C Lucene::FileSwitchDirectory | A Directory instance that switches files between two other Directory instances
C Lucene::RAMDirectory | A memory-resident Directory implementation. Locking implementation is by default the SingleInstanceLockFactory but can be changed with setLockFactory. Lock acquisition sequence: RAMDirectory, then RAMFile
►C Lucene::DocConsumer |
C Lucene::DocFieldProcessor | This is a DocConsumer that gathers all fields under the same name, and calls per-field consumers to process field by field. This class doesn't doesn't do any "real" work of its own: it just forwards the fields to a DocFieldConsumer
►C Lucene::DocConsumerPerThread |
C Lucene::DocFieldProcessorPerThread | Gathers all Fieldables for a document under the same name, updates FieldInfos, and calls per-field consumers to process field by field
►C Lucene::DocFieldConsumer |
C Lucene::DocFieldConsumers | This is just a "splitter" class: it lets you wrap two DocFieldConsumer instances as a single consumer
C Lucene::DocInverter | This is a DocFieldConsumer that inverts each field, separately, from a Document, and accepts a InvertedTermsConsumer to process those terms
►C Lucene::DocFieldConsumerPerField |
C Lucene::DocFieldConsumersPerField |
C Lucene::DocInverterPerField | Holds state for inverting all occurrences of a single field in the document. This class doesn't do anything itself; instead, it forwards the tokens produced by analysis to its own consumer (InvertedDocConsumerPerField). It also interacts with an endConsumer (InvertedDocEndConsumerPerField)
►C Lucene::DocFieldConsumerPerThread |
C Lucene::DocFieldConsumersPerThread |
C Lucene::DocInverterPerThread | This is a DocFieldConsumer that inverts each field, separately, from a Document, and accepts a InvertedTermsConsumer to process those terms
C Lucene::DocFieldProcessorPerField | Holds all per thread, per field state
►C Lucene::DocIdSet | A DocIdSet contains a set of doc ids. Implementing classes must only implement iterator to provide access to the set
C Lucene::DocIdBitSet | Simple DocIdSet and DocIdSetIterator backed by a BitSet
C Lucene::FilteredDocIdSet | Abstract decorator class for a DocIdSet implementation that provides on-demand filtering/validation mechanism on a given DocIdSet
►C Lucene::OpenBitSet | An "open" BitSet implementation that allows direct access to the array of words storing the bits
C Lucene::OpenBitSetDISI |
C Lucene::SortedVIntList | Stores and iterate on sorted integers in compressed form in RAM
►C 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 {@value 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
C Lucene::FilteredDocIdSetIterator | Abstract decorator class of a DocIdSetIterator implementation that provides on-demand filter/validation mechanism on an underlying DocIdSetIterator. See FilteredDocIdSet
C Lucene::OpenBitSetIterator | An iterator to iterate over set bits in an OpenBitSet. This is faster than nextSetBit() for iterating over the complete set of bits, especially when the density of the bits set is high
►C Lucene::Scorer | Common scoring functionality for different types of queries

C Lucene::BooleanScorer

BooleanScorer uses a ~16k array to score windows of docs. So it scores docs 0-16k first, then docs 16-32k, etc. For each window it iterates through all query terms and accumulates a score in table[doc%16k]. It also stores in the table a bitmask representing which terms contributed to the score. Non-zero scores are chained in a linked list. At the end of scoring each window it then iterates through the linked list and, if the bitmask matches the boolean constraints, collects a hit. For boolean queries with lots of frequent terms this can be much faster, since it does not need to update a priority queue for each posting, instead performing constant-time operations per posting. The only downside is that it results in hits being delivered out-of-order within the window, which means it cannot be nested within other scorers. But it works well as a top-level scorer

C Lucene::BooleanScorer2 | See the description in BooleanScorer, comparing BooleanScorer & BooleanScorer2
C Lucene::BucketScorer |
►C Lucene::ConjunctionScorer | Scorer for conjunctions, sets of queries, all of which are required
C Lucene::CountingConjunctionSumScorer |
C Lucene::DisjunctionMaxScorer | The Scorer for DisjunctionMaxQuery. The union of all documents generated by the the subquery scorers is generated in document number order. The score for each document is the maximum of the scores computed by the subquery scorers that generate that document, plus tieBreakerMultiplier times the sum of the scores for the other subqueries that generate the document
►C Lucene::DisjunctionSumScorer | A Scorer for OR like queries, counterpart of ConjunctionScorer. This Scorer implements {} and uses skipTo() on the given Scorers
C Lucene::CountingDisjunctionSumScorer |

►C Lucene::PhraseScorer

Scoring functionality for phrase queries. A document is considered matching if it contains the phrase-query terms at "valid" positions. What "valid positions" are depends on the type of the phrase query: for an exact phrase query terms are required to appear in adjacent locations, while for a sloppy phrase query some distance between the terms is allowed. The abstract method {} of extending classes is invoked for each document containing all the phrase query terms, in order to compute the frequency of the phrase query in that document. A non zero frequency means a match

C Lucene::ExactPhraseScorer |
C Lucene::SloppyPhraseScorer |
C 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
C Lucene::ReqOptSumScorer | A Scorer for queries with a required part and an optional part. Delays skipTo() on the optional part until a score() is needed. This Scorer implements Scorer#skipTo(int32_t)
C Lucene::ScoreCachingWrappingScorer | A Scorer which wraps another scorer and caches the score of the current document. Successive calls to score() will return the same result and will not invoke the wrapped Scorer's score() method, unless the current document has changed
C Lucene::SingleMatchScorer | Count a scorer as a single match
►C Lucene::SpanScorer | Public for extension only
C Lucene::PayloadNearSpanScorer |
C Lucene::TermScorer | A Scorer for documents matching a Term
C Lucene::DocState |
►C Lucene::DocValues | Represents field values as different types. Normally created via a ValueSuorce for a particular field and reader
C Lucene::DoubleDocValues |
►C Lucene::DocWriter | Consumer returns this on each doc. This holds any state that must be flushed synchronized "in docID order". We gather these and flush them in order
C Lucene::DocFieldConsumersPerDoc |
C Lucene::DocFieldProcessorPerThreadPerDoc |
C Lucene::SkipDocWriter |
C Lucene::StoredFieldsWriterPerDoc |
C Lucene::TermVectorsTermsWriterPerDoc |
C Lucene::Document | Documents are the unit of indexing and search
C 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
C Lucene::DocumentsWriterThreadState | Used by DocumentsWriter to maintain per-thread state. We keep a separate Posting hash and other state for each thread and then merge postings hashes from all threads when writing the segment
C Lucene::Entry |
►C Lucene::Explanation | Describes the score computation for document and query
C Lucene::ComplexExplanation | Describes the score computation for document and query, and can distinguish a match independent of a positive value
C Lucene::FastCharStream | An efficient implementation of QueryParserCharStream interface
►C Lucene::FieldCacheEntry | A unique Identifier/Description for each item in the FieldCache. Can be useful for logging/debugging
C Lucene::FieldCacheEntryImpl |
C Lucene::FieldCacheImpl | The default cache implementation, storing all values in memory. A WeakHashMap is used for storage
C Lucene::FieldCacheSanityChecker | Provides methods for sanity checking that entries in the FieldCache are not wasteful or inconsistent
►C Lucene::FieldComparator | A FieldComparator compares hits so as to determine their sort order when collecting the top results with TopFieldCollector. The concrete public FieldComparator classes here correspond to the SortField types
►C Lucene::NumericComparator< int64_t > |
C Lucene::LongComparator | Parses field's values as long (using FieldCache#getLongs and sorts by ascending value
►C Lucene::NumericComparator< double > |
C Lucene::DoubleComparator | Parses field's values as double (using FieldCache#getDoubles and sorts by ascending value
C Lucene::RelevanceComparator | Sorts by descending relevance. NOTE: if you are sorting only by descending relevance and then secondarily by ascending docID, performance is faster using TopScoreDocCollector directly (which {} uses when no Sort} is specified)
►C Lucene::NumericComparator< int32_t > |
C Lucene::DocComparator | Sorts by ascending docID
C Lucene::IntComparator | Parses field's values as int (using FieldCache#getInts and sorts by ascending value
►C Lucene::NumericComparator< uint8_t > |
C Lucene::ByteComparator | Parses field's values as byte (using FieldCache#getBytes and sorts by ascending value
C Lucene::NumericComparator< TYPE > |
C Lucene::StringComparatorLocale | Sorts by a field's value using the Collator for a given Locale

C Lucene::StringOrdValComparator

Sorts by field's natural String sort order, using ordinals. This is functionally equivalent to {}, but it first resolves the string to their relative ordinal positions (using the index returned by FieldCache#getStringIndex}), and does most comparisons using the ordinals. For medium to large results, this comparator will be much faster than StringValComparator}. For very small result sets it may be slower

C Lucene::StringValComparator | Sorts by field's natural String sort order. All comparisons are done using String.compare, which is slow for medium to large result sets but possibly very fast for very small results sets
C Lucene::FieldComparatorSource | Provides a FieldComparator for custom field sorting
C Lucene::FieldInfo |
C Lucene::FieldInfos | Access to the Fieldable Info file that describes document fields and whether or not they are indexed. Each segment has a separate Fieldable Info file. Objects of this class are thread-safe for multiple readers, but only one thread can be adding documents at a time, with no other reader or writer threads accessing this object
C Lucene::FieldInvertState | This class tracks the number and position / offset parameters of terms being added to the index. The information collected in this class is also used to calculate the normalization factor for a field
C Lucene::FieldNormStatus | Status from testing field norms
►C Lucene::FieldSelector | The FieldSelector allows one to make decisions about what Fields get loaded on a Document by IndexReader#document(int32_t, FieldSelector)
C Lucene::LoadFirstFieldSelector | Load the First field and break. See FieldSelectorResult#LOAD_AND_BREAK
C Lucene::MapFieldSelector | A FieldSelector based on a Map of field names to FieldSelectorResults
C Lucene::SetBasedFieldSelector | Declare what fields to load normally and what fields to load lazily
C Lucene::FieldsReader | Class responsible for access to stored document fields. It uses <segment>.fdt and <segment>.fdx; files
C Lucene::FieldsWriter |
►C Lucene::Filter | Abstract base class for restricting which documents may be returned during searching
C Lucene::CachingWrapperFilter | Wraps another filter's result and caches it. The purpose is to allow filters to simply filter, and then wrap with this class to add caching
C Lucene::FieldCacheRangeFilter | A range filter built on top of a cached single term field (in FieldCache)
C Lucene::FieldCacheTermsFilter | A Filter that only accepts documents whose single term value in the specified field is contained in the provided set of allowed terms
►C Lucene::MultiTermQueryWrapperFilter | A wrapper for MultiTermQuery, that exposes its functionality as a Filter
C Lucene::NumericRangeFilter | A Filter that only accepts numeric values within a specified range. To use this, you must first index the numeric values using NumericField (NumericTokenStream)
C Lucene::PrefixFilter | A Filter that restricts search results to values that have a matching prefix in a given field
C Lucene::TermRangeFilter | A Filter that restricts search results to a range of term values in a given field
C Lucene::QueryWrapperFilter | Constrains search results to only match those which also match a provided query
►C Lucene::SpanFilter | Abstract base class providing a mechanism to restrict searches to a subset of an index and also maintains and returns position information
C Lucene::CachingSpanFilter | Wraps another SpanFilter's result and caches it. The purpose is to allow filters to simply filter, and then wrap with this class to add caching
C Lucene::SpanQueryFilter | Constrains search results to only match those which also match a provided query. Also provides position information about where each document matches at the cost of extra space compared with the QueryWrapperFilter. There is an added cost to this above what is stored in a QueryWrapperFilter. Namely, the position information for each matching document is stored
C Lucene::FilterManager | Filter caching singleton. It can be used to save filters locally for reuse. Also could be used as a persistent storage for any filter as long as the filter provides a proper hashCode(), as that is used as the key in the cache
►C Lucene::FilterTermDocs | Base class for filtering TermDocs implementations
C Lucene::FilterTermPositions | Base class for filtering TermPositions implementations
►C Lucene::FormatPostingsDocsConsumer |
C Lucene::FormatPostingsDocsWriter | Consumes doc & freq, writing them using the current index file format
►C Lucene::FormatPostingsFieldsConsumer | Abstract API that consumes terms, doc, freq, prox and payloads postings. Concrete implementations of this actually do "something" with the postings (write it into the index in a specific format)
C Lucene::FormatPostingsFieldsWriter |
►C Lucene::FormatPostingsPositionsConsumer |
C Lucene::FormatPostingsPositionsWriter |
►C Lucene::FormatPostingsTermsConsumer |
C Lucene::FormatPostingsTermsWriter |
C Lucene::FreqProxFieldMergeState | Used by DocumentsWriter to merge the postings from multiple ThreadStates when creating a segment
C Lucene::Future | A Future represents the result of an asynchronous computation. Methods are provided to check if the computation is complete, to wait for its completion, and to retrieve the result of the computation. The result can only be retrieved using method get when the computation has completed, blocking if necessary until it is ready
►C Lucene::HitQueueBase |
C Lucene::FieldValueHitQueue | A hit queue for sorting by hits by terms in more than one field. Uses FieldCache::DEFAULT for maintaining internal term lookup tables
C Lucene::HitQueue |
C Lucene::IDFExplanation | Small Util class used to pass both an idf factor as well as an explanation for that factor
►C Lucene::IndexCommit | Represents a single commit into an index as seen by the IndexDeletionPolicy or IndexReader
C 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
C Lucene::ReaderCommit |

►C Lucene::IndexDeletionPolicy

Policy for deletion of stale index commits. Implement this interface, and pass it to one of the IndexWriter or IndexReader constructors, to customize when older point-in-time commits are deleted from the index directory. The default deletion policy is KeepOnlyLastCommitDeletionPolicy, which always removes old commits as soon as a new commit is done (this matches the behavior before 2.2)

C Lucene::KeepOnlyLastCommitDeletionPolicy | This IndexDeletionPolicy implementation that keeps only the most recent commit and immediately removes all prior commits after a new commit is done. This is the default deletion policy
C Lucene::SnapshotDeletionPolicy |

C Lucene::IndexFileDeleter

This class keeps track of each SegmentInfos instance that is still "live", either because it corresponds to a segments_N file in the Directory (a "commit", ie. a committed SegmentInfos) or because it's an in-memory SegmentInfos that a writer is actively updating but has not yet committed. This class uses simple reference counting to map the live SegmentInfos instances to individual files in the Directory

C Lucene::IndexFileNameFilter | Filename filter that accept filenames and extensions only created by Lucene
C Lucene::IndexFileNames | Constants representing filenames and extensions used by Lucene
►C 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
►C Lucene::BufferedIndexInput | Base implementation class for buffered IndexInput
C Lucene::CSIndexInput | Implementation of an IndexInput that reads from a portion of the compound file
C 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
C Lucene::ChecksumIndexInput | Writes bytes through to a primary IndexInput, computing checksum as it goes. Note that you cannot use seek()
C Lucene::RAMInputStream | A memory-resident IndexInput implementation
C Lucene::SkipBuffer | Used to buffer the top skip levels
►C 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
C Lucene::BufferedIndexOutput | Base implementation class for buffered IndexOutput
C Lucene::ChecksumIndexOutput | Writes bytes through to a primary IndexOutput, computing checksum. Note that you cannot use seek()
C Lucene::RAMOutputStream | A memory-resident IndexOutput implementation
►C Lucene::IndexReader | IndexReader is an abstract class, providing an interface for accessing an index. Search of an index is done entirely through this abstract interface, so that any subclass which implements it is searchable
►C Lucene::DirectoryReader | An IndexReader which reads indexes with multiple segments
C Lucene::ReadOnlyDirectoryReader |

C Lucene::FilterIndexReader

A FilterIndexReader contains another IndexReader, which it uses as its basic source of data, possibly transforming the data along the way or providing additional functionality. The class FilterIndexReader itself simply implements all abstract methods of IndexReader with versions that pass all requests to the contained index reader. Subclasses of FilterIndexReader may further override some of these methods and may also provide additional methods and fields

C Lucene::MultiReader | An IndexReader which reads multiple indexes, appending their content
C Lucene::ParallelReader | An IndexReader which reads multiple, parallel indexes. Each index added must have the same number of documents, but typically each contains different fields. Each document contains the union of the fields of all documents with the same document number. When searching, matches for a query term are from the first index added that has the field
►C Lucene::SegmentReader |
C Lucene::ReadOnlySegmentReader |
C Lucene::IndexReaderWarmer | If getReader has been called (ie, this writer is in near real-time mode), then after a merge completes, this class can be invoked to warm the reader on the newly merged segment, before the merge commits. This is not required for near real-time search, but will reduce search latency on opening a new near real-time reader after a merge completes
C Lucene::IndexStatus | Returned from checkIndex() detailing the health and status of the index
C Lucene::IndexWriter | An IndexWriter creates and maintains an index
►C Lucene::IndexingChain | The IndexingChain must define the getChain(DocumentsWriter) method which returns the DocConsumer that the DocumentsWriter calls to process the documents

C Lucene::DefaultIndexingChain

This is the current indexing chain: DocConsumer / DocConsumerPerThread --> code: DocFieldProcessor / DocFieldProcessorPerThread --> DocFieldConsumer / DocFieldConsumerPerThread / DocFieldConsumerPerField --> code: DocFieldConsumers / DocFieldConsumersPerThread / DocFieldConsumersPerField --> code: DocInverter / DocInverterPerThread / DocInverterPerField --> InvertedDocConsumer / InvertedDocConsumerPerThread / InvertedDocConsumerPerField --> code: TermsHash / TermsHashPerThread / TermsHashPerField --> TermsHashConsumer / TermsHashConsumerPerThread / TermsHashConsumerPerField --> code: FreqProxTermsWriter / FreqProxTermsWriterPerThread / FreqProxTermsWriterPerField --> code: TermVectorsTermsWriter / TermVectorsTermsWriterPerThread / TermVectorsTermsWriterPerField --> InvertedDocEndConsumer / InvertedDocConsumerPerThread / InvertedDocConsumerPerField --> code: NormsWriter / NormsWriterPerThread / NormsWriterPerField --> code: StoredFieldsWriter / StoredFieldsWriterPerThread / StoredFieldsWriterPerField

►C Lucene::InfoStream | Utility class to support streaming info messages
C Lucene::InfoStreamFile | Stream override to write messages to a file
C Lucene::InfoStreamNull | Null stream override to eat messages
C Lucene::InfoStreamOut | Stream override to write messages to a std::cout
C Lucene::Insanity | Simple container for a collection of related CacheEntry objects that in conjunction with each other represent some "insane" usage of the FieldCache
C Lucene::IntBlockPool |
C Lucene::IntRangeBuilder |
►C Lucene::InvertedDocConsumer |
C Lucene::TermsHash | This class implements InvertedDocConsumer, which is passed each token produced by the analyzer on each field. It stores these tokens in a hash table, and allocates separate byte streams per token. Consumers of this class, eg FreqProxTermsWriter and TermVectorsTermsWriter, write their own byte streams under each term
►C Lucene::InvertedDocConsumerPerField |
C Lucene::TermsHashPerField |
►C Lucene::InvertedDocConsumerPerThread |
C Lucene::TermsHashPerThread |
►C Lucene::InvertedDocEndConsumer |
C 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
►C Lucene::InvertedDocEndConsumerPerField |
C Lucene::NormsWriterPerField | Taps into DocInverter, as an InvertedDocEndConsumer, which is called at the end of inverting each field. We just look at the length for the field (docState.length) and record the norm
►C Lucene::InvertedDocEndConsumerPerThread |
C Lucene::NormsWriterPerThread |
C Lucene::Lock | An interprocess mutex lock
►C Lucene::LockFactory | Base class for Locking implementation. Directory uses instances of this class to implement locking. Note that there are some useful tools to verify that your LockFactory is working correctly: {}, LockStressTest}, { LockVerifyServer}
►C Lucene::FSLockFactory | Base class for file system based locking implementation
C Lucene::NativeFSLockFactory | Implements LockFactory using native file lock
C Lucene::SimpleFSLockFactory | Implements LockFactory using File#createNewFile()
C Lucene::NoLockFactory | Use this LockFactory to disable locking entirely. Only one instance of this lock is created. You should call getNoLockFactory() to get the instance
C Lucene::SingleInstanceLockFactory | Implements LockFactory for a single in-process instance, meaning all locking will take place through this one instance. Only use this LockFactory when you are certain all IndexReaders and IndexWriters for a given index are running against a single shared in-process Directory instance. This is currently the default locking for RAMDirectory
C Lucene::LongRangeBuilder | Callback for splitLongRange. You need to overwrite only one of the methods. NOTE: This is a very low-level interface, the method signatures may change in later versions
C Lucene::LuceneThread | Lucene thread container
C Lucene::MergeDocIDRemapper | Remaps docIDs after a merge has completed, where the merged segments had at least one deletion. This is used to renumber the buffered deletes in IndexWriter when a merge of segments with deletions commits
►C Lucene::MergePolicy | A MergePolicy determines the sequence of primitive merge operations to be used for overall merge and optimize operations

►C Lucene::LogMergePolicy

This class implements a MergePolicy that tries to merge segments into levels of exponentially increasing size, where each level has fewer segments than the value of the merge factor. Whenever extra segments (beyond the merge factor upper bound) are encountered, all segments within the level are merged. You can get or set the merge factor using getMergeFactor() and setMergeFactor(int) respectively

C Lucene::LogByteSizeMergePolicy | This is a LogMergePolicy that measures size of a segment as the total byte size of the segment's files
C Lucene::LogDocMergePolicy | This is a LogMergePolicy that measures size of a segment as the number of documents (not taking deletions into account)
►C Lucene::MergeScheduler | IndexWriter uses an instance implementing this interface to execute the merges selected by a MergePolicy. The default MergeScheduler is ConcurrentMergeScheduler

C Lucene::ConcurrentMergeScheduler

A MergeScheduler that runs each merge using a separate thread, up until a maximum number of threads (setMaxThreadCount) at which when a merge is needed, the thread(s) that are updating the index will pause until one or more merges completes. This is a simple way to use concurrency in the indexing process without having to create and manage application level threads

C Lucene::SerialMergeScheduler | A MergeScheduler that simply does each merge sequentially, using the current thread
C Lucene::MergeSpecification | A MergeSpecification instance provides the information necessary to perform multiple merges. It simply contains a list of OneMerge instances
►C Lucene::MultiLevelSkipListReader | This abstract class reads skip lists with multiple levels
C Lucene::DefaultSkipListReader | Implements the skip list reader for the default posting list format that stores positions and payloads
►C Lucene::MultiLevelSkipListWriter | This abstract class writes skip lists with multiple levels
C Lucene::DefaultSkipListWriter | Implements the skip list writer for the default posting list format that stores positions and payloads
►C Lucene::MultiTermDocs |
C Lucene::MultiTermPositions |
C Lucene::MultipleTermPositions | Allows you to iterate over the TermPositions for multiple Terms as a single TermPositions
C Lucene::NormalizeCharMap | Holds a map of String input to String output, to be used with MappingCharFilter
C Lucene::Num | Number of documents a delete term applies to
C Lucene::NumberTools | Provides support for converting longs to Strings, and back again. The strings are structured so that lexicographic sorting order is preserved
C Lucene::NumericUtils | This is a helper class to generate prefix-encoded representations for numerical values and supplies converters to represent double values as sortable integers/longs
C Lucene::OneMerge | OneMerge provides the information necessary to perform an individual primitive merge operation, resulting in a single new segment. The merge spec includes the subset of segments to be merged as well as whether the new segment should use the compound file format
►C Lucene::Parser | Marker interface as super-interface to all parsers. It is used to specify a custom parser to {}
C Lucene::ByteParser | Interface to parse bytes from document fields
C Lucene::DoubleParser | Interface to parse doubles from document fields
C Lucene::IntParser | Interface to parse ints from document fields
C Lucene::LongParser | Interface to parse longs from document fields
C Lucene::Payload | A Payload is metadata that can be stored together with each occurrence of a term. This metadata is stored inline in the posting list of the specific term
►C Lucene::PayloadFunction | An abstract class that defines a way for Payload*Query instances to transform the cumulative effects of payload scores for a document
C Lucene::AveragePayloadFunction | Calculate the final score as the average score of all payloads seen
C Lucene::MaxPayloadFunction | Returns the maximum payload score seen, else 1 if there are no payloads on the doc
C Lucene::MinPayloadFunction | Calculates the minimum payload seen
C Lucene::PayloadSpanUtil | Experimental class to get set of payloads for most standard Lucene queries. Operates like Highlighter - IndexReader should only contain doc of interest, best to use MemoryIndex
C Lucene::PhrasePositions | Position of a term in a document that takes into account the term offset within the phrase
C Lucene::PorterStemmer | This is the Porter stemming algorithm, coded up as thread-safe ANSI C by the author
C Lucene::PositionInfo |
C Lucene::PriorityQueue< TYPE > | A PriorityQueue maintains a partial ordering of its elements such that the least element can always be found in constant time. Put()'s and pop()'s require log(size) time
►C Lucene::Query | The abstract base class for queries
C Lucene::BooleanQuery | A Query that matches documents matching boolean combinations of other queries, eg. TermQuerys, PhraseQuerys or other BooleanQuerys
C Lucene::ConstantScoreQuery | A query that wraps a filter and simply returns a constant score equal to the query boost for every document in the filter
C Lucene::CustomScoreQuery | Query that sets document score as a programmatic function of several (sub) scores:

C Lucene::DisjunctionMaxQuery

A query that generates the union of documents produced by its subqueries, and that scores each document with the maximum score for that document as produced by any subquery, plus a tie breaking increment for any additional matching subqueries. This is useful when searching for a word in multiple fields with different boost factors (so that the fields cannot be combined equivalently into a single search field). We want the primary score to be the one associated with the highest boost, not the sum of the field scores (as BooleanQuery would give). If the query is "albino elephant" this ensures that "albino" matching one field and "elephant" matching another gets a higher score than "albino" matching both fields. To get this result, use both BooleanQuery and DisjunctionMaxQuery: for each term a DisjunctionMaxQuery searches for it in each field, while the set of these DisjunctionMaxQuery's is combined into a BooleanQuery. The tie breaker capability allows results that include the same term in multiple fields to be judged better than results that include this term in only the best of those multiple fields, without confusing this with the better case of two different terms in the multiple fields

C Lucene::FilteredQuery | A query that applies a filter to the results of another query
C Lucene::MatchAllDocsQuery | A query that matches all documents
C 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
►C Lucene::MultiTermQuery | An abstract Query that matches documents containing a subset of terms provided by a {} enumeration
C Lucene::FuzzyQuery | Implements the fuzzy search query. The similarity measurement is based on the Levenshtein (edit distance) algorithm
C Lucene::NumericRangeQuery | A Query that matches numeric values within a specified range. To use this, you must first index the numeric values using NumericField (expert: NumericTokenStream). If your terms are instead textual, you should use TermRangeQuery. NumericRangeFilter is the filter equivalent of this query
C Lucene::PrefixQuery | A Query that matches documents containing terms with a specified prefix. A PrefixQuery is built by QueryParser for input like app*
C Lucene::TermRangeQuery | A Query that matches documents within an range of terms
C Lucene::WildcardQuery | Implements the wildcard search query. Supported wildcards are *, which matches any character sequence (including the empty one), and ?, which matches any single character. Note this query can be slow, as it needs to iterate over many terms. In order to prevent extremely slow WildcardQueries, a Wildcard term should not start with one of the wildcards * or ?
C Lucene::PhraseQuery | A Query that matches documents containing a particular sequence of terms. A PhraseQuery is built by QueryParser for input like "new york"
►C Lucene::SpanQuery | Base class for span-based queries
C Lucene::FieldMaskingSpanQuery | Wrapper to allow SpanQuery objects participate in composite single-field SpanQueries by 'lying' about their search field. That is, the masked SpanQuery will function as normal, but SpanQuery#getField() simply hands back the value supplied in this class's constructor
C Lucene::SpanFirstQuery | Matches spans near the beginning of a field
►C Lucene::SpanNearQuery | Matches spans which are near one another. One can specify slop, the maximum number of intervening unmatched positions, as well as whether matches are required to be in-order
C Lucene::PayloadNearQuery | This class is very similar to SpanNearQuery except that it factors in the value of the payloads located at each of the positions where the TermSpans occurs
C Lucene::SpanNotQuery | Removes matches which overlap with another SpanQuery
C Lucene::SpanOrQuery | Matches the union of its clauses
►C Lucene::SpanTermQuery | Matches spans containing a term
C Lucene::PayloadTermQuery | This class is very similar to SpanTermQuery except that it factors in the value of the payload located at each of the positions where the Term occurs
C Lucene::TermQuery | A Query that matches documents containing a term. This may be combined with other terms with a BooleanQuery
►C Lucene::ValueSourceQuery | A Query that sets the scores of document to the values obtained from a ValueSource
C Lucene::FieldScoreQuery | A query that scores each document as the value of the numeric input field
C Lucene::QueryParseError | Utility class to handle query parse errors
►C Lucene::QueryParser | The most important method is parse(const String&)
C Lucene::MultiFieldQueryParser | A QueryParser which constructs queries to search multiple fields
C Lucene::QueryParserToken | Describes the input token stream
C Lucene::QueryParserTokenManager | Token Manager
C Lucene::QueryTermVector |
►C Lucene::RAMFile | File used as buffer in RAMDirectory
C Lucene::PerDocBuffer | RAMFile buffer for DocWriters
C Lucene::Random | Utility class to generate a stream of pseudorandom numbers

►C Lucene::RawPostingList

This is the base class for an in-memory posting list, keyed by a Token. TermsHash maintains a hash table holding one instance of this per unique Token. Consumers of TermsHash (TermsHashConsumer) must subclass this class with its own concrete class. FreqProxTermsWriterPostingList is a private inner class used for the freq/prox postings, and TermVectorsTermsWriterPostingList is a private inner class used to hold TermVectors postings

C Lucene::FreqProxTermsWriterPostingList |
C Lucene::TermVectorsTermsWriterPostingList |
►C Lucene::Reader | Abstract class for reading character streams
C Lucene::BufferedReader | Read text from a character-input stream, buffering characters so as to provide for the efficient reading of characters, arrays, and lines
►C Lucene::CharStream | CharStream adds correctOffset functionality over Reader. All Tokenizers accept a CharStream instead of Reader as input, which enables arbitrary character based filtering before tokenization. The correctOffset method fixed offsets to account for removal or insertion of characters, so that the offsets reported in the tokens match the character offsets of the original Reader
►C Lucene::CharFilter | Subclasses of CharFilter can be chained to filter CharStream. They can be used as Reader with additional offset correction. Tokenizers will automatically use correctOffset if a CharFilter/CharStream subclass is used
►C Lucene::BaseCharFilter | Base utility class for implementing a CharFilter. You subclass this, and then record mappings by calling addOffCorrectMap, and then invoke the correct method to correct an offset
C Lucene::MappingCharFilter | Simplistic CharFilter that applies the mappings contained in a NormalizeCharMap to the character stream, and correcting the resulting changes to the offsets
C 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
C Lucene::FileReader | Convenience class for reading character files
C Lucene::InputStreamReader | An InputStreamReader is a bridge from byte streams to character streams
C Lucene::ReusableStringReader | Used by DocumentsWriter to implemented a StringReader that can be reset to a new string; we use this when tokenizing the string value from a Field
C Lucene::StringReader | Convenience class for reading strings
C Lucene::ReaderUtil | Common util methods for dealing with IndexReaders
C Lucene::RefCount | Tracks the reference count for a single index file
►C Lucene::RewriteMethod | Abstract class that defines how the query is rewritten
C Lucene::ConstantScoreAutoRewrite | A rewrite method that tries to pick the best constant-score rewrite method based on term and document counts from the query. If both the number of terms and documents is small enough, then {} is used. Otherwise, #CONSTANT_SCORE_FILTER_REWRITE} is used
►C Lucene::ScoreDoc | Expert: Returned by low-level search implementations

C 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

C Lucene::FieldValueHitQueueEntry |
C Lucene::ScorerDocQueue | A ScorerDocQueue maintains a partial ordering of its Scorers such that the least Scorer can always be found in constant time. Put()'s and pop()'s require log(size) time. The ordering is by Scorer::doc()
►C Lucene::Searcher | An abstract base class for search implementations. Implements the main search methods
C Lucene::IndexSearcher | Implements search over a single IndexReader
►C Lucene::MultiSearcher | Implements search over a set of Searchables
C Lucene::ParallelMultiSearcher | Implements parallel search over a set of Searchables
C Lucene::SegmentInfo | Information about a segment such as it's name, directory, and files related to the segment
►C Lucene::SegmentInfoCollection | A collection of SegmentInfo objects to be used as a base class for SegmentInfos
C Lucene::SegmentInfos | A collection of SegmentInfo objects with methods for operating on those segments in relation to the file system
C Lucene::SegmentInfoStatus | Holds the status of each segment in the index. See segmentInfos
C Lucene::SegmentMergeInfo |
C Lucene::SegmentMerger | Combines two or more Segments, represented by an IndexReader (add, into a single Segment. After adding the appropriate readers, call the merge method to combine the segments
►C Lucene::SegmentTermDocs |
C Lucene::SegmentTermPositions |
►C Lucene::SegmentTermVector |
C Lucene::SegmentTermPositionVector |
C Lucene::SegmentWriteState |
►C Lucene::Similarity | Scoring API
C Lucene::DefaultSimilarity | Default scoring implementation
C Lucene::SimilarityDelegator | Delegating scoring implementation. Useful in Query#getSimilarity(Searcher) implementations, to override only certain methods of a Searcher's Similarity implementation
C Lucene::SimpleLRUCache< KEY, VALUE, HASH, EQUAL > | General purpose LRU cache map. Accessing an entry will keep the entry cached. get(const KEY&) and put(const KEY&, const VALUE&) results in an access to the corresponding entry
►C Lucene::SinkFilter |
C Lucene::AcceptAllSinkFilter |
C Lucene::SmallDouble | Floating point numbers smaller than 32 bits
C Lucene::Sort | Encapsulates sort criteria for returned hits
C Lucene::SortField | Stores information about how to sort documents by terms in an individual field. Fields must be indexed in order to sort by them
C Lucene::SpanFilterResult | The results of a SpanQueryFilter. Wraps the BitSet and the position information from the SpanQuery
►C Lucene::Spans | An enumeration of span matches. Used to implement span searching. Each span represents a range of term positions within a document. Matches are enumerated in order, by increasing document number, within that by increasing start position and finally by increasing end position
C Lucene::NearSpansOrdered | A Spans that is formed from the ordered subspans of a SpanNearQuery where the subspans do not overlap and have a maximum slop between them
C Lucene::NearSpansUnordered | Similar to NearSpansOrdered, but for the unordered case
C Lucene::TermSpans | Public for extension only
C Lucene::StandardTokenizerImpl |
C Lucene::StartEnd |
C Lucene::StoredFieldStatus | Status from testing stored fields
C Lucene::StoredFieldsWriter | This is a DocFieldConsumer that writes stored fields
C Lucene::StoredFieldsWriterPerThread |
C Lucene::StringIndex | Stores term text values and document ordering data
C Lucene::SubScorer |
C Lucene::Term | A Term represents a word from text. This is the unit of search. It is composed of two elements, the text of the word, as a string, and the name of the field that the text occurred in, an interned string
C Lucene::TermBuffer |
►C Lucene::TermEnum | Abstract class for enumerating terms
C Lucene::FilterTermEnum | Base class for filtering TermEnum implementations
►C Lucene::FilteredTermEnum | Abstract class for enumerating a subset of all terms
C Lucene::FuzzyTermEnum | Subclass of FilteredTermEnum for enumerating all terms that are similar to the specified filter term
C Lucene::PrefixTermEnum | Subclass of FilteredTermEnum for enumerating all terms that match the specified prefix filter term
C Lucene::SingleTermEnum | Subclass of FilteredTermEnum for enumerating a single term
C Lucene::TermRangeTermEnum | Subclass of FilteredTermEnum for enumerating all terms that match the specified range parameters
C Lucene::WildcardTermEnum | Subclass of FilteredTermEnum for enumerating all terms that match the specified wildcard filter term
C Lucene::MultiTermEnum |
C Lucene::SegmentTermEnum |
C Lucene::TermIndexStatus | Status from testing term index
C Lucene::TermInfo | A TermInfo is the record of information stored for a term
C 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
C Lucene::TermInfosReaderThreadResources |
C Lucene::TermInfosWriter | This stores a monotonically increasing set of <Term, TermInfo> pairs in a Directory. A TermInfos can be written once, in order
C Lucene::TermVectorEntry | Convenience class for holding TermVector information
C Lucene::TermVectorEntryFreqSortedComparator | Compares TermVectorEntrys first by frequency and then by the term (case-sensitive)
►C Lucene::TermVectorMapper | The TermVectorMapper can be used to map Term Vectors into your own structure instead of the parallel array structure used by IndexReader#getTermFreqVector(int,String)
C Lucene::FieldSortedTermVectorMapper | For each Field, store a sorted collection of TermVectorEntrys This is not thread-safe
C Lucene::ParallelArrayTermVectorMapper | Models the existing parallel array structure
C Lucene::PositionBasedTermVectorMapper |
C Lucene::SortedTermVectorMapper | Store a sorted collection of TermVectorEntrys. Collects all term information into a single, sorted set
C Lucene::TermVectorOffsetInfo | Holds information pertaining to a Term in a TermPositionVector's offset information. This offset information is the character offset as set during the Analysis phase (and thus may not be the actual offset in the original content)
C Lucene::TermVectorStatus | Status from testing stored fields
C Lucene::TermVectorsPositionInfo | Container for a term at a position
C Lucene::TermVectorsReader |
C Lucene::TermVectorsWriter |
►C Lucene::TermsHashConsumer |
C Lucene::FreqProxTermsWriter |
C Lucene::TermVectorsTermsWriter |
►C Lucene::TermsHashConsumerPerField | Implement this class to plug into the TermsHash processor, which inverts & stores Tokens into a hash table and provides an API for writing bytes into multiple streams for each unique Token
C Lucene::FreqProxTermsWriterPerField |
C Lucene::TermVectorsTermsWriterPerField |
►C Lucene::TermsHashConsumerPerThread |
C Lucene::FreqProxTermsWriterPerThread |
C Lucene::TermVectorsTermsWriterPerThread |
C Lucene::ThreadPool | Utility class to handle a pool of threads
►C Lucene::TopDocs | Represents hits returned by Searcher#search(QueryPtr, FilterPtr, int32_t) and {}
C Lucene::TopFieldDocs | Represents hits returned by Searcher#search(QueryPtr, FilterPtr, int32_t, SortPtr)
C Lucene::TranslationResult< TYPE > | Utility class that contains utf8 and unicode translations
►C Lucene::UTF8Base |
C Lucene::UTF16Decoder |
►C Lucene::UTF8Decoder |
C Lucene::UTF8DecoderStream |
►C Lucene::UTF8Encoder |
C Lucene::UTF8EncoderStream |
►C Lucene::ValueSource | Source of values for basic function queries
►C Lucene::FieldCacheSource | A base class for ValueSource implementations that retrieve values for a single field from the FieldCache
C Lucene::ByteFieldSource | Obtains byte field values from the FieldCache using getBytes() and makes those values available as other numeric types, casting as needed
C Lucene::DoubleFieldSource | Obtains double field values from the FieldCache using getDoubles() and makes those values available as other numeric types, casting as needed
C Lucene::IntFieldSource | Obtains int field values from the FieldCache using getInts() and makes those values available as other numeric types, casting as needed
C Lucene::OrdFieldSource | Obtains the ordinal of the field value from the default Lucene FieldCache using getStringIndex()
C Lucene::ReverseOrdFieldSource | Obtains the ordinal of the field value from the default Lucene FieldCache using getStringIndex() and reverses the order
C Lucene::WaitQueue |
►C Lucene::Weight | Calculate query weights and build query scorers
►C Lucene::SpanWeight | Public for use by other weight implementations
C Lucene::PayloadNearSpanWeight |
C Lucene::WordlistLoader | Loader for text files that represent a list of stopwords
►C std::exception |
C Lucene::LuceneException | Lucene exception container
►C Lucene::Fieldable | Synonymous with Field
C Lucene::AbstractField |
►C Lucene::FieldCache | Maintains caches of term values
C Lucene::FieldCacheImpl | The default cache implementation, storing all values in memory. A WeakHashMap is used for storage
C Lucene::CompoundFileReader::FileEntry |
C Lucene::CompoundFileWriter::FileEntry |
C Lucene::QueryParser::JJCalls |
C Lucene::LuceneSignal | Utility class to support signaling notifications
►C Lucene::LuceneSync | Base class for all Lucene synchronised classes
C Lucene::Collection< ScoreDocPtr > |
C Lucene::Collection< RawPostingListPtr > |
C Lucene::Collection< FieldInfoPtr > |
C Lucene::Collection< SortFieldPtr > |
C Lucene::Collection< RAMOutputStreamPtr > |
C Lucene::Collection< IndexCommitPtr > |
C Lucene::Collection< DocFieldProcessorPerThreadPerDocPtr > |
C Lucene::Collection< int64_t > |
C Lucene::Collection< Lucene::Collection< TermVectorOffsetInfoPtr > > |
C Lucene::Collection< FieldCacheEntryPtr > |
C Lucene::Collection< Lucene::HashSet< String > > |
C Lucene::Collection< double > |
C Lucene::Collection< IndexInputPtr > |
C Lucene::Collection< DocWriterPtr > |
C Lucene::Collection< PhrasePositionsPtr > |
C Lucene::Collection< ScorerPtr > |
C Lucene::Collection< TermInfoPtr > |
C Lucene::Collection< SpanQueryPtr > |
C Lucene::Collection< SegmentMergeInfoPtr > |
C Lucene::Collection< OneMergePtr > |
C Lucene::Collection< Lucene::CompoundFileWriter::FileEntry > |
C Lucene::Collection< SpansPtr > |
C Lucene::Collection< FieldComparatorPtr > |
C Lucene::Collection< String > |
C Lucene::Collection< DocumentsWriterThreadStatePtr > |
C Lucene::Collection< QueryPtr > |
C Lucene::Collection< TermVectorOffsetInfoPtr > |
C Lucene::Collection< SinkTokenStreamPtr > |
C Lucene::Collection< HeapedScorerDocPtr > |
C Lucene::Collection< DocFieldConsumersPerDocPtr > |
C Lucene::Collection< ValueSourceQueryPtr > |
C Lucene::Collection< CommitPointPtr > |
C Lucene::Collection< uint8_t > |
C Lucene::Collection< Lucene::Collection< TermPtr > > |
C Lucene::Collection< Lucene::Collection< int32_t > > |
C Lucene::Collection< SegmentInfoStatusPtr > |
C Lucene::Collection< ConcurrentMergeSchedulerPtr > |
C Lucene::Collection< int32_t > |
C Lucene::Collection< TermVectorsTermsWriterPerDocPtr > |
C Lucene::Collection< JJCallsPtr > |
C Lucene::Collection< SearchablePtr > |
C Lucene::Collection< CollatorPtr > |
C Lucene::Collection< IntArray > |
C Lucene::Collection< wchar_t > |
C Lucene::Collection< IndexReaderPtr > |
C Lucene::Collection< ExplanationPtr > |
C Lucene::Collection< AttributeSourceStatePtr > |
C Lucene::Collection< ByteArray > |
C Lucene::Collection< ComparableValue > |
C Lucene::Collection< DocFieldProcessorPerFieldPtr > |
C Lucene::Collection< PositionInfoPtr > |
C Lucene::Collection< StartEndPtr > |
C Lucene::Collection< UTF8ResultPtr > |
C Lucene::Collection< StoredFieldsWriterPerDocPtr > |
C Lucene::Collection< TermDocsPtr > |
C Lucene::Collection< FieldablePtr > |
C Lucene::Collection< BucketPtr > |
C Lucene::Collection< SegmentInfoPtr > |
C Lucene::Collection< SegmentReaderPtr > |
C Lucene::Collection< TermPtr > |
C Lucene::Collection< SpansCellPtr > |
C Lucene::Collection< TermVectorEntryPtr > |
C Lucene::Collection< CharArray > |
C Lucene::Collection< BooleanClausePtr > |
C Lucene::HashMap< String, FieldSelector::FieldSelectorResult > |
►C Lucene::HashMap< KEY, VALUE, boost::hash< KEY >, std::equal_to< KEY > > |
C Lucene::WeakHashMap< KEY, VALUE, HASH, EQUAL > | Utility template class to handle weak keyed maps
C Lucene::HashMap< String, FileEntryPtr > |
C Lucene::HashMap< MAPKEY, set_type, MAPHASH, MAPEQUAL > |
C Lucene::HashMap< String, DateTools::Resolution > |
C Lucene::HashSet< String > |
C Lucene::Map< int64_t, localDataPtr > |
C Lucene::Set< LuceneObjectPtr * > |
C Lucene::Collection< TYPE > | Utility template class to handle collections that can be safely copied and shared
C Lucene::HashMap< KEY, VALUE, HASH, EQUAL > | Utility template class to handle hash maps that can be safely copied and shared
C Lucene::HashSet< TYPE, HASH, EQUAL > | Utility template class to handle hash set collections that can be safely copied and shared
C Lucene::LuceneObject | Base class for all Lucene classes
C Lucene::Map< KEY, VALUE, LESS > | Utility template class to handle maps that can be safely copied and shared
C Lucene::Set< TYPE, LESS > | Utility template class to handle set based collections that can be safely copied and shared
C Lucene::LuceneVersion | Use by certain classes to match version compatibility across releases of Lucene
C Lucene::MapOfSets< MAPKEY, MAPHASH, MAPEQUAL, SETVALUE, SETHASH, SETEQUAL > | Helper class for keeping Lists of Objects associated with keys
C Lucene::MiscUtils |
►C ParentException |
C Lucene::ExceptionTemplate< ParentException, Type > |
►C Lucene::QueryParserCharStream | This interface describes a character stream that maintains line and column number positions of the characters. It also has the capability to backup the stream to some extent. An implementation of this interface is used in the QueryParserTokenManager
C Lucene::FastCharStream | An efficient implementation of QueryParserCharStream interface
►C Lucene::QueryParserConstants | Token literal values and constants
C Lucene::QueryParser | The most important method is parse(const String&)
C Lucene::QueryParserTokenManager | Token Manager
C Lucene::ScorerVisitor |
►C Lucene::Searchable | The interface for search implementations
C Lucene::Searcher | An abstract base class for search implementations. Implements the main search methods
C Lucene::StringUtils |
C Lucene::Synchronize | Utility class to support locking via a mutex
C Lucene::SyncLock | Utility class to support scope locking
►C Lucene::TermDocs | TermDocs provides an interface for enumerating <document, frequency>; pairs for a term. The document portion names each document containing the term. Documents are indicated by number. The frequency portion gives the number of times the term occurred in each document. The pairs are ordered by document number
C Lucene::AbstractAllTermDocs | Base class for enumerating all but deleted docs
►C Lucene::TermPositions | TermPositions provides an interface for enumerating the <document, frequency, <position>*> tuples for a term. The document and frequency are the same as for a TermDocs. The positions portion lists the ordinal positions of each occurrence of a term in a document
C Lucene::FilterTermDocs | Base class for filtering TermDocs implementations
C Lucene::MultiTermDocs |
C Lucene::MultipleTermPositions | Allows you to iterate over the TermPositions for multiple Terms as a single TermPositions
C Lucene::SegmentTermDocs |
►C Lucene::TermFreqVector | Provides access to stored term vector of a document field. The vector consists of the name of the field, an array of the terms that occur in the field of the Document and a parallel array of frequencies. Thus, getTermFrequencies()[5] corresponds with the frequency of getTerms()[5], assuming there are at least 5 terms in the Document
C Lucene::QueryTermVector |
►C Lucene::TermPositionVector | Extends TermFreqVector to provide additional information about positions in which each of the terms is found. A TermPositionVector not necessarily contains both positions and offsets, but at least one of these arrays exists
C Lucene::SegmentTermVector |
C Lucene::TestPoint | Used for unit testing as a substitute for stack trace
C Lucene::TestScope |
C Lucene::UnicodeUtil |
C Lucene::VariantUtils |

clucene.sourceforge.net