All Classes

Base class for Field implementations

An Analyzer builds TokenStreams, which analyze text.

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.

Base class for Attributes that can be added to a AttributeSource.

An AttributeSource contains a list of different AttributeImpls, and methods to add and get them.

This class holds the state of an AttributeSource.

Base utility class for implementing a CharFilter.

Bits impl of the specified length with all bits set.

A variety of high efficiency bit twiddling routines.

A clause in a BooleanQuery.

A Query that matches documents matching boolean combinations of other queries, e.g.

Base implementation class for buffered IndexInput.

Builds a minimal FST (maps an IntsRef term to an arbitrary output) from pre-sorted terms with outputs.

Expert: this is invoked by Builder whenever a suffix is serialized.

DataInput backed by a byte array.

Class that Posting and PostingVector use to write byte streams into shared fixed-size byte[] arrays.

A simple ByteBlockPool.Allocator that never recycles.

Expert: obtains single byte field values from the FieldCache using getBytes() and makes those values available as other numeric types, casting as needed.

Represents byte[], as a slice (offset + length) into an existing byte[].

Holds a single input (BytesRef) + output pair.

Manages allocation of the per-term addresses.

Thrown if a BytesRef exceeds the BytesRefHash limit of ByteBlockPool.BYTE_BLOCK_SIZE-2.

A simple iterator interface for BytesRef iteration.

Wraps another SpanFilter's result and caches it.

Wraps another filter's result and caches it.

CharacterUtils provides a unified interface to Character-related operations to implement backwards compatible character operations based on a Version instance.

A simple class that stores key Strings as char[]'s in a hash table.

Subclasses of CharFilter can be chained to filter CharStream.

Represents char[], as a slice (offset + length) into an existing char[].

This interface describes a character stream that maintains line and column number positions of the characters.

The term text of a Token.

Basic tool and API to check the health of an index and write a new segments file that removes reference to problematic segments.

Status from testing field norms.

Status from testing stored fields.

Status from testing stored fields.

Writes bytes through to a primary IndexOutput, computing checksum.

Normalizes tokens extracted with ClassicTokenizer.

Java's builtin ThreadLocal has a serious flaw: it can take an arbitrarily long amount of time to dereference the things you had stored in it, even once the ThreadLocal instance itself is no longer referenced.

Filters KeywordTokenizer with CollationKeyFilter.

Methods for manipulating (sorting) collections.

Class containing some useful methods used by command line tools

Combines multiple files into a single compound file.

A MergeScheduler that runs each merge using a separate thread.

A query that wraps another query or a filter and simply returns a constant score equal to the query boost for every document that matches the filter or query.

Simple counter class

Query that sets document score as a programmatic function of several (sub) scores: the score of its subQuery (any query) (optional) the score of its ValueSourceQuery (or queries).

Abstract base class for performing write operations of Lucene's low-level data types.

Provides support for converting dates to strings and vice-versa.

Expert: Default scoring implementation.

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.

A DocIdSet contains a set of doc ids.

Documents are the unit of indexing and search.

Simple concurrent LRU cache, using a "double barrel" approach where two ConcurrentHashMaps record entries.

A dummy lock as a replacement for ReentrantLock to disable locking

Small Util class used to pass both an idf factor as well as an explanation for that factor.

A field is a section of a Document.

Specifies whether and how a field should be stored.

Synonymous with Field.

Interface to parse bytes from document fields.

Interface to parse floats from document fields.

Interface to parse long from document fields.

Interface to parse shorts from document fields.

Base class for DocIdSet to be used with FieldCache.

Provides methods for sanity checking that entries in the FieldCache are not wasteful or inconsistent.

An Enumeration of the different types of "insane" behavior that may be detected in a FieldCache.

A Filter that only accepts documents whose single term value in the specified field is contained in the provided set of allowed terms.

Parses field's values as byte (using FieldCache.getBytes(org.apache.lucene.index.IndexReader, java.lang.String) and sorts by ascending value

Parses field's values as double (using FieldCache.getDoubles(org.apache.lucene.index.IndexReader, java.lang.String) and sorts by ascending value

Parses field's values as int (using FieldCache.getInts(org.apache.lucene.index.IndexReader, java.lang.String) and sorts by ascending value

Parses field's values as short (using FieldCache.getShorts(org.apache.lucene.index.IndexReader, java.lang.String) and sorts by ascending value

Sorts by field's natural String sort order, using ordinals.

Provides a FieldComparator for custom field sorting.

Access to the Fieldable Info file that describes document fields and whether or not they are indexed.

Collection of FieldInfos (accessible by number or by name).

Wrapper to allow SpanQuery objects participate in composite single-field SpanQueries by 'lying' about their search field.

A query that scores each document as the value of the numeric input field.

Similar to a FileFilter, the FieldSelector allows one to make decisions about what Fields get loaded on a Document by IndexReader.document(int,org.apache.lucene.document.FieldSelector)

For each Field, store a sorted collection of TermVectorEntrys

Expert: A hit queue for sorting by hits by terms in more than one field.

Expert: A Directory instance that switches files between two other Directory instances.

Abstract decorator class for a DocIdSet implementation that provides on-demand filtering/validation mechanism on a given DocIdSet.

A query that applies a filter to the results of another query.

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.

Base class for filtering TermEnum implementations.

Abstract base class for TokenFilters that may remove tokens.

BitSet of fixed length (numBits), backed by accessible (FixedBitSet.getBits()) long[], accessed with an int index, implementing Bits and DocIdSet.

This attribute can be used to pass different flags down the tokenizer chain, eg from one TokenFilter to another one.

Base class for file system based locking implementation.

Represents a single arc.

Specifies allowed range of each int input label for this FST.

Subclass of FilteredTermEnum for enumerating all terms that are similar to the specified filter term.

Provides support for converting byte sequences to Strings and back again.

Expert: policy for deletion of stale index commits.

This class contains useful constants representing filenames and extensions used by lucene, as well as convenience methods for querying whether a file name matches an extension (matchesExtension), as well as generating file names from a segment name, generation and extension ( fileNameFromGeneration, segmentFileName).

This exception is thrown when Lucene detects an index that is too old for this Lucene version

Signals that no index was found in the Directory.

IndexReader is an abstract class, providing an interface for accessing an index.

Implements search over a single IndexReader.

An IndexWriter creates and maintains an index.

Specifies the open mode for IndexWriter: IndexWriterConfig.OpenMode.CREATE - creates a new index or overwrites an existing one.

Expert: obtains int field values from the FieldCache using getInts() and makes those values available as other numeric types, casting as needed.

Represents int[], as a slice (offset + length) into an existing int[].

Holds a single input (IntsRef) + output pair.

"Tokenizes" the entire stream as a single token.

This attribute can be used to mark a token as a keyword.

Emits the entire input as a single token.

A LetterTokenizer is a tokenizer that divides text at non-letters.

This TokenFilter limits the number of tokens while indexing.

An interprocess mutex lock.

Base class for Locking implementation.

This exception is thrown when the write.lock could not be released.

Simple standalone server that must be running when you use VerifyingLockFactory.

This is a LogMergePolicy that measures size of a segment as the number of documents (not taking deletions into account).

Normalizes token text to lower case.

Lucene's package information, including version.

A FieldSelector based on a Map of field names to FieldSelectorResults

Simplistic CharFilter that applies the mappings contained in a NormalizeCharMap to the character stream, and correcting the resulting changes to the offsets.

Returns the maximum payload score seen, else 1 if there are no payloads on the doc.

A MergeSpecification instance provides the information necessary to perform multiple merges.

Expert: IndexWriter uses an instance implementing this interface to execute the merges selected by a MergePolicy.

File-based Directory implementation that uses mmap for reading, and FSDirectory.FSIndexOutput for writing.

A QueryParser which constructs queries to search multiple fields.

Allows you to iterate over the TermPositions for multiple Terms as a single TermPositions.

A rewrite method that tries to pick the best constant-score rewrite method based on term and document counts from the query.

A rewrite method that first translates each term into BooleanClause.Occur.SHOULD clause in a BooleanQuery, but the scores are only computed as the boost.

A wrapper for MultiTermQuery, that exposes its functionality as a Filter.

Implements LockFactory using native OS file locks.

Similar to NearSpansOrdered, but for the unordered case.

An FSDirectory implementation that uses java.nio's FileChannel's positional read, which allows multiple threads to read from the same file without synchronizing.

An IndexDeletionPolicy which keeps all index commits around, never deleting them.

A MergePolicy which never returns merges to execute (hence it's name).

A null FST Outputs implementation; use this if you just want to build an FSA.

This exception is thrown when you try to list a non-existent directory.

Utility class to manage sharing near-real-time searchers across multiple searching thread.

NRTManager invokes this interface to notify it when a caller is waiting for a specific generation searcher to be visible.

Data type of the value in NumericField.

A Query that matches numeric values within a specified range.

This is a helper class to generate prefix-encoded representations for numerical values and supplies converters to represent float/double values as sortable integers/longs.

Expert: Callback for NumericUtils.splitLongRange(org.apache.lucene.util.NumericUtils.LongRangeBuilder, int, long, long).

The start and end character offset of a Token.

OpenBitSet with added methods to bulk-update the bits from a DocIdSetIterator.

Expert: obtains the ordinal of the field value from the default Lucene Fieldcache using getStringIndex().

A DataOutput wrapping a plain OutputStream.

A packed integer array that can be modified.

A simple base for Readers that keeps track of valueCount and bitsPerValue.

Represents a logical byte[] as a series of pages.

An FST Outputs implementation, holding two other outputs.

A Payload is metadata that can be stored together with each occurrence of a term.

The payload of a Token.

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.

Returns a PayloadProcessorProvider.PayloadProcessor for a given Term which allows processing the payloads of different terms differently.

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.

A SnapshotDeletionPolicy which adds a persistence layer so that snapshots can be maintained across the life of an application.

Transforms the token stream as per the Porter stemming algorithm.

Container for a term at a position

The positionIncrement determines the position of this token relative to the previous Token in a TokenStream, used in phrase searching.

See PositionLengthAttribute.

A Collector implementation which wraps another Collector and makes sure only documents with scores > 0 are collected.

A Query that matches documents containing terms with a specified prefix.

A PriorityQueue maintains a partial ordering of its elements such that the least element can always be found in constant time.

This class is generated by JavaCC.

Token literal values and constants.

A memory-resident Directory implementation.

A memory-resident IndexInput implementation.

Estimates the size (memory representation) of Java objects.

Common util methods for dealing with IndexReaders.

A ByteBlockPool.Allocator implementation that recycles unused byte blocks in a buffer and reuses them in subsequent calls to RecyclingByteBlockAllocator.getByteBlock().

An convenience subclass of Analyzer that makes it easy to implement TokenStream reuse.

Expert: obtains the ordinal of the field value from the default Lucene FieldCache using getStringIndex() and reverses the order.

A Scorer which wraps another scorer and caches the score of the current document.

Expert: Common scoring functionality for different types of queries.

Factory class used by SearcherManager and NRTManager to create new IndexSearchers.

Simple pruner that drops any searcher older by more than the specified seconds, than the newest searcher.

Utility class to safely share IndexSearcher instances across multiple threads, while periodically reopening.

A collection of segmentInfo objects with methods for operating on those segments in relation to the file system.

IndexReader implementation over a single segment.

Holder class for common parameters used during write.

Declare what fields to load normally and what fields to load lazily

Thrown when SetOnce.set(Object) is called more than once.

Expert: Scoring API.

An Analyzer that filters LetterTokenizer with LowerCaseFilter

Implements LockFactory using File.createNewFile().

Implements LockFactory for a single in-process instance, meaning all locking will take place through this one instance.

Floating point numbers smaller than 32 bits.

Encapsulates sort criteria for returned hits.

Stores and iterate on sorted integers in compressed form in RAM.

Stores information about how to sort documents by terms in an individual field.

The results of a SpanQueryFilter.

Wraps any MultiTermQuery as a SpanQuery, so it can be nested within other SpanQuery classes.

A rewrite method that first translates each term into a SpanTermQuery in a BooleanClause.Occur.SHOULD clause in a BooleanQuery, and keeps the scores as computed by the query.

Matches spans which are near one another.

Matches the union of its clauses.

Base class for filtering a SpanQuery based on the position of a match.

Checks to see if the SpanPositionCheckQuery.getMatch() lies between a start and end position

Constrains search results to only match those which also match a provided query.

Public for extension only.

Expert-only.

Filters StandardTokenizer with StandardFilter, LowerCaseFilter and StopFilter, using a list of English stop words.

A grammar-based tokenizer constructed with JFlex.

Filters LetterTokenizer with LowerCaseFilter and StopFilter.

Base class for Analyzers that need to make use of stopword sets.

Subclasses of StringInterner are required to return the same single String object for all equal strings.

A filter that decides which AttributeSource states to store in the sink.

A Term represents a word from text.

Abstract class for enumerating terms.

TermPositions provides an interface for enumerating the <document, frequency, <position>* > tuples for a term.

A Query that matches documents containing a term.

A Query that matches documents within an range of terms.

Expert: Public for extension only

Compares TermVectorEntrys first by frequency and then by the term (case-sensitive)

The TermVectorOffsetInfo class holds information pertaining to a Term in a TermPositionVector's offset information.

Merges segments of approximately equal size, subject to an allowed number of segments per tier.

The TimeLimitingCollector is used to timeout search requests that take longer than the maximum allowed search time limit.

Describes the input token stream.

A TokenFilter is a TokenStream whose input is another TokenStream.

Token Manager Error.

Represents hits returned by Searcher.search(Query,Filter,int) and Searcher.search(Query,int).

A Collector that sorts by SortField using FieldComparators.

A Collector implementation that collects the top-scoring hits, returning them as a TopDocs.

Helper methods to ease implementing Object.toString().

An interface for implementations that support 2-phase commit.

Thrown by TwoPhaseCommitTool.execute(TwoPhaseCommit...) when an object fails to commit().

A wrapper of a TwoPhaseCommit, which delegates all calls to the wrapped object, passing the specified commitData.

A Token's lexical type.

Filters UAX29URLEmailTokenizer with StandardFilter, LowerCaseFilter and StopFilter, using a list of English stop words.

This class implements Word Break rules from the Unicode Text Segmentation algorithm, as specified in Unicode Standard Annex #29 URLs and email addresses are also tokenized according to the relevant RFCs.

Holds decoded UTF16 code units.

This MergePolicy is used for upgrading all existing segments of an index when calling IndexWriter.forceMerge(int).

Holds two long outputs.

Holds a single input (IntsRef) + output, returned by Util.shortestPaths(org.apache.lucene.util.fst.FST<T>, org.apache.lucene.util.fst.FST.Arc<T>, java.util.Comparator<T>, int).

Expert: A Query that sets the scores of document to the values obtained from a ValueSource.

Use by certain classes to match version compatibility across releases of Lucene.

Implements a combination of WeakHashMap and IdentityHashMap.

An Analyzer that uses WhitespaceTokenizer.

Implements the wildcard search query.

Loader for text files that represent a list of stopwords.