All Classes and Interfaces (Lucene 10.5.0 core API)
Description: class index

# All Classes and Interfaces

Class
Description
AbstractAnalysisFactory
Abstract parent class for analysis factories `TokenizerFactory`, `TokenFilterFactory` and `CharFilterFactory`.
AbstractDocIdSetIterator
Abstract implementation of a `DocIdSetIterator` that tracks the current doc ID.
AbstractIterator<E>
Simplifies the implementation of iterators a bit.
AbstractKnnCollector
AbstractKnnCollector is the default implementation for a knn collector used for gathering kNN results and providing topDocs from the gathered neighbors
AbstractPagedMutable<T>
Base implementation for `PagedMutable` and `PagedGrowableWriter`.
AcceptDocs
Higher-level abstraction for document acceptance filtering.
Accountable
An object whose JVM heap memory usage can be computed.
Accountables
Helper methods for constructing nested resource descriptions and debugging RAM usage.
AfterEffect
This class acts as the base class for the implementations of the first normalization of the informative content in the DFR framework.
AfterEffectB
Model of the information gain based on the ratio of two Bernoulli processes.
AfterEffectL
Model of the information gain based on Laplace's law of succession.
AlreadyClosedException
This exception is thrown when there is an attempt to access something that has already been closed.
AnalysisSPILoader<S>
Helper class for loading named SPIs from classpath (e.g.
Analyzer
An Analyzer builds TokenStreams, which analyze text.
Analyzer.ReuseStrategy
Strategy defining how TokenStreamComponents are reused per call to `Analyzer.tokenStream(String, java.io.Reader)`.
Analyzer.TokenStreamComponents
This class encapsulates the outer components of a token stream.
AnalyzerWrapper
Extension to `Analyzer` suitable for Analyzers which wrap other Analyzers.
ArrayUtil
Methods for manipulating arrays.
ArrayUtil.ByteArrayComparator
Comparator for a fixed number of bytes.
Attribute
Base interface for attributes.
AttributeFactory
An AttributeFactory creates instances of `AttributeImpl`s.
AttributeFactory.StaticImplementationAttributeFactory<A>
Expert: AttributeFactory returning an instance of the given `clazz` for the attributes it implements.
AttributeImpl
Base class for Attributes that can be added to a `AttributeSource`.
AttributeReflector
This interface is used to reflect contents of `AttributeSource` or `AttributeImpl`.
AttributeSource
An AttributeSource contains a list of different `AttributeImpl`s, and methods to add and get them.
AttributeSource.State
This class holds the state of an AttributeSource.
Automata
Construction of basic automata.
Automaton
Represents an automaton and all its states and transitions.
Automaton.Builder
Records new states and transitions and then `Automaton.Builder.finish()` creates the `Automaton`.
AutomatonProvider
Automaton provider for `RegExp.` `RegExp.toAutomaton(AutomatonProvider)`
AutomatonQuery
A `Query` that will match terms against a finite-state machine.
AutomatonTermsEnum
A FilteredTermsEnum that enumerates terms based upon what is accepted by a DFA.
AutomatonToTokenStream
Converts an Automaton into a TokenStream.
Axiomatic
Axiomatic approaches for IR.
AxiomaticF1EXP
F1EXP is defined as Sum(tf(term_doc_freq)*ln(docLen)*IDF(term)) where IDF(t) = pow((N+1)/df(t), k) N=total num of docs, df=doc freq
AxiomaticF1LOG
F1LOG is defined as Sum(tf(term_doc_freq)*ln(docLen)*IDF(term)) where IDF(t) = ln((N+1)/df(t)) N=total num of docs, df=doc freq
AxiomaticF2EXP
F2EXP is defined as Sum(tfln(term_doc_freq, docLen)*IDF(term)) where IDF(t) = pow((N+1)/df(t), k) N=total num of docs, df=doc freq
AxiomaticF2LOG
F2EXP is defined as Sum(tfln(term_doc_freq, docLen)*IDF(term)) where IDF(t) = ln((N+1)/df(t)) N=total num of docs, df=doc freq
AxiomaticF3EXP
F3EXP is defined as Sum(tf(term_doc_freq)*IDF(term)-gamma(docLen, queryLen)) where IDF(t) = pow((N+1)/df(t), k) N=total num of docs, df=doc freq gamma(docLen, queryLen) = (docLen-queryLen)*queryLen*s/avdl NOTE: the gamma function of this similarity creates negative scores
AxiomaticF3LOG
F3EXP is defined as Sum(tf(term_doc_freq)*IDF(term)-gamma(docLen, queryLen)) where IDF(t) = ln((N+1)/df(t)) N=total num of docs, df=doc freq gamma(docLen, queryLen) = (docLen-queryLen)*queryLen*s/avdl NOTE: the gamma function of this similarity creates negative scores
BaseCompositeReader<R>
Base class for implementing `CompositeReader`s based on an array of sub-readers.
BaseDirectory
Base implementation for a concrete `Directory` that uses a `LockFactory` for locking.
BaseQuantizedByteVectorValues
A version of `ByteVectorValues` for Scalar quantization scores.
BaseTermsEnum
A base TermsEnum that adds default implementations for `BaseTermsEnum.attributes()` `BaseTermsEnum.termState()` `BaseTermsEnum.seekExact(BytesRef)` `BaseTermsEnum.seekExact(BytesRef, TermState)` In some cases, the default implementation may be slow and consume huge memory, so subclass SHOULD have its own implementation if possible.
BasicModel
This class acts as the base class for the specific basic model implementations in the DFR framework.
BasicModelG
Geometric as limiting form of the Bose-Einstein model.
BasicModelIF
An approximation of the I(ne) model.
BasicModelIn
The basic tf-idf model of randomness.
BasicModelIne
Tf-idf model of randomness, based on a mixture of Poisson and inverse document frequency.
BasicStats
Stores all statistics commonly used ranking methods.
BayesianScoreEstimator
Estimates `BayesianScoreQuery` parameters (alpha, beta, base rate) from corpus statistics via pseudo-query sampling.
BayesianScoreEstimator.Parameters
Estimated parameters for `BayesianScoreQuery`.
BayesianScoreQuery
A query wrapper that transforms the inner query's score into a calibrated probability via sigmoid calibration: `P = sigmoid(alpha * (score - beta))`.
BinaryColumn
A `Column` that provides variable-size binary values via a tuple cursor.
BinaryDocValues
A per-document numeric value.
BinaryDocValuesField
Field that stores a per-document `BytesRef` value.
BinaryPoint
An indexed binary field for fast range filters.
BinaryRangeDocValues
A binary representation of a range that wraps a BinaryDocValues field
BinarySortField
SortField for `BinaryDocValues`, usable as an index sort.
BinarySortField.Provider
A SortFieldProvider for this sort
BitDocIdSet
Implementation of the `DocIdSet` interface on top of a `BitSet`.
BitMixer
Bit mixing utilities.
Bits
Interface for Bitset-like structures.
Bits.MatchAllBits
Bits impl of the specified length with all bits set.
Bits.MatchNoBits
Bits impl of the specified length with no bits set.
BitSet
Base implementation for a bit set.
BitSetIterator
A `DocIdSetIterator` which iterates over set bits in a bit set.
BitUtil
A variety of high efficiency bit twiddling routines and encoders for primitives.
BKDConfig
Basic parameters for indexing points on the BKD tree.
BKDRadixSelector
Offline Radix selector for BKD tree.
BKDRadixSelector.PathSlice
Sliced reference to points in an PointWriter.
BKDReader
Handles reading a block KD-tree in byte[] space previously written with `BKDWriter`.
BKDWriter
Recursively builds a block KD-tree to assign all incoming points in N-dim space to smaller and smaller N-dim rectangles (cells) until the number of points in a given rectangle is <= `config.maxPointsInLeafNode()`.
BlendedTermQuery
A `Query` that blends index statistics across multiple terms.
BlendedTermQuery.Builder
A Builder for `BlendedTermQuery`.
BlendedTermQuery.DisjunctionMaxRewrite
A `BlendedTermQuery.RewriteMethod` that creates a `DisjunctionMaxQuery` out of the sub queries.
BlendedTermQuery.RewriteMethod
A `BlendedTermQuery.RewriteMethod` defines how queries for individual terms should be merged.
BlockingFloatHeap
A blocking bounded min heap that stores floats.
BlockPackedReaderIterator
Reader for sequences of longs written with `BlockPackedWriter`.
BlockPackedWriter
A writer for large sequences of longs.
BlockTermState
Holds all state required for `PostingsReaderBase` to produce a `PostingsEnum` without re-seeking the terms dict.
BM25Similarity
BM25 Similarity.
BooleanClause
A clause in a BooleanQuery.
BooleanClause.Occur
Specifies how clauses are to occur in matching documents.
BooleanQuery
A Query that matches documents matching boolean combinations of other queries, e.g.
BooleanQuery.Builder
A builder for boolean queries.
BooleanSimilarity
Simple similarity that gives terms a score that is equal to their query boost.
BoostAttribute
Add this `Attribute` to a `TermsEnum` returned by `MultiTermQuery.getTermsEnum(Terms,AttributeSource)` and update the boost on each returned term.
BoostAttributeImpl
Implementation class for `BoostAttribute`.
BoostQuery
A `Query` wrapper that allows to give a boost to the wrapped query.
BufferAllocationException
BufferAllocationException forked from HPPC.
BufferedChecksum
Wraps another `Checksum` with an internal buffer to speed up checksum calculations.
BufferedChecksumIndexInput
Simple implementation of `ChecksumIndexInput` that wraps another input and delegates calls.
BufferedIndexInput
Base implementation class for buffered `IndexInput`.
BufferingKnnVectorsWriter
Buffers up pending vector value(s) per doc, then flushes when segment flushes.
BulkScorer
This class is used to score a range of documents at once, and is returned by `Weight.bulkScorer(org.apache.lucene.index.LeafReaderContext)`.
ByteArrayDataInput
DataInput backed by a byte array.
ByteArrayDataOutput
DataOutput backed by a byte array.
ByteBlockPool
This class enables the allocation of fixed-size buffers and their management as part of a buffer array.
ByteBlockPool.Allocator
Abstract class for allocating and freeing byte blocks.
ByteBlockPool.DirectAllocator
A simple `ByteBlockPool.Allocator` that never recycles.
ByteBlockPool.DirectTrackingAllocator
A simple `ByteBlockPool.Allocator` that never recycles, but tracks how much total RAM is in use.
ByteBuffersDataInput
A `DataInput` implementing `RandomAccessInput` and reading data from a list of `ByteBuffer`s.
ByteBuffersDataOutput
A `DataOutput` storing data in a list of `ByteBuffer`s.
ByteBuffersDataOutput.ByteBufferRecycler
An implementation of a `ByteBuffer` allocation and recycling policy.
ByteBuffersDirectory
A `ByteBuffer`-based `Directory` implementation that can be used to store index files on the heap.
ByteBuffersIndexInput
An `IndexInput` implementing `RandomAccessInput` and backed by a `ByteBuffersDataInput`.
ByteBuffersIndexOutput
An `IndexOutput` writing to a `ByteBuffersDataOutput`.
ByteRunAutomaton
Automaton representation for matching UTF-8 byte[].
ByteRunnable
A runnable automaton accepting byte array as input
ByteSequenceOutputs
An FST `Outputs` implementation where each output is a sequence of bytes.
BytesRef
Represents byte[], as a slice (offset + length) into an existing byte[].
BytesRefArray
A simple append only random-access `BytesRef` array that stores full copies of the appended bytes in a `ByteBlockPool`.
BytesRefArray.IndexedBytesRefIterator
An extension of `BytesRefIterator` that allows retrieving the index of the current element
BytesRefArray.SortState
Used to iterate the elements of an array in a given order.
BytesRefBlockPool
Represents a logical list of ByteRef backed by a `ByteBlockPool`.
BytesRefBuilder
A builder for `BytesRef` instances.
BytesRefComparator
Specialized `BytesRef` comparator that `StringSorter` has optimizations for.
BytesRefFSTEnum<T>
Enumerates all input (BytesRef) + output pairs in an FST.
BytesRefFSTEnum.InputOutput<T>
Holds a single input (BytesRef) + output pair.
BytesRefHash
`BytesRefHash` is a special purpose hash-map like data-structure optimized for `BytesRef` instances.
BytesRefHash.BytesStartArray
Manages allocation of the per-term addresses.
BytesRefHash.DirectBytesStartArray
A simple `BytesRefHash.BytesStartArray` that tracks memory allocation using a private `Counter` instance.
BytesRefHash.MaxBytesLengthExceededException
Thrown if a `BytesRef` exceeds the `BytesRefHash` limit of `ByteBlockPool.BYTE_BLOCK_SIZE`-2.
BytesRefIterator
A simple iterator interface for `BytesRef` iteration.
BytesRefValuesCursor
A values cursor over a dense `BinaryColumn`.
BytesTermAttribute
This attribute can be used if you have the raw term bytes to be indexed.
BytesTermAttributeImpl
Implementation class for `BytesTermAttribute`.
ByteVectorSimilarityQuery
Search for all (approximate) byte vectors above a similarity threshold.
ByteVectorValues
This class provides access to per-document floating point vector values indexed as `KnnByteVectorField`.
CachingCollector
Caches all docs, and optionally also scores, coming from a search, and is then able to replay them to another collector.
CachingTokenFilter
This class can be used if the token attributes of a TokenStream are intended to be consumed more than once.
CharacterRunAutomaton
Automaton representation for matching char[].
CharacterUtils
Utility class to write tokenizers or token filters.
CharacterUtils.CharacterBuffer
A simple IO buffer to use with `CharacterUtils.fill(CharacterBuffer, Reader)`.
CharArrayMap<V>
A simple class that stores key Strings as char[]'s in a hash table.
CharArraySet
A simple class that stores Strings as char[]'s in a hash table.
CharCursor
Forked from HPPC, holding int index and char value.
CharFilter
Subclasses of CharFilter can be chained to filter a Reader They can be used as `Reader` with additional offset correction.
CharFilterFactory
Abstract parent class for analysis factories that create `CharFilter` instances.
CharHashSet
A hash set of `char`s, implemented using open addressing with linear probing for collision resolution.
CharObjectHashMap<VType>
A hash map of `char` to `Object`, implemented using open addressing with linear probing for collision resolution.
CharObjectHashMap.CharObjectCursor<VType>
Forked from HPPC, holding int index,key and value
CharSequenceOutputs
An FST `Outputs` implementation where each output is a sequence of characters.
CharsRef
Represents char[], as a slice (offset + length) into an existing char[].
CharsRefBuilder
A builder for `CharsRef` instances.
CharTermAttribute
The term text of a Token.
CharTermAttributeImpl
Default implementation of `CharTermAttribute`.
CheckedIntConsumer<T>
Like `IntConsumer`, but may throw checked exceptions.
CheckIndex
Basic tool and API to check the health of an index and write a new segments file that removes reference to problematic segments.
CheckIndex.CheckIndexException
The marker RuntimeException used by CheckIndex APIs when index integrity failure is detected.
CheckIndex.Level
Class with static variables with information about CheckIndex's -level parameter.
CheckIndex.Options
Run-time configuration options for CheckIndex commands.
CheckIndex.Status
Returned from `CheckIndex.checkIndex()` detailing the health and status of the index.
CheckIndex.Status.DocValuesStatus
Status from testing DocValues
CheckIndex.Status.FieldInfoStatus
Status from testing field infos.
CheckIndex.Status.FieldNormStatus
Status from testing field norms.
CheckIndex.Status.IndexSortStatus
Status from testing index sort
CheckIndex.Status.LiveDocStatus
Status from testing livedocs
CheckIndex.Status.PointsStatus
Status from testing PointValues
CheckIndex.Status.SegmentInfoStatus
Holds the status of each segment in the index.
CheckIndex.Status.SoftDeletesStatus
Status from testing soft deletes
CheckIndex.Status.StoredFieldStatus
Status from testing stored fields.
CheckIndex.Status.TermIndexStatus
Status from testing term index.
CheckIndex.Status.TermVectorStatus
Status from testing stored fields.
CheckIndex.Status.VectorValuesStatus
Status from testing vector values
CheckIndex.VerifyPointsVisitor
Walks the entire N-dimensional points space, verifying that all points fall within the last cell's boundaries.
ChecksumIndexInput
Extension of IndexInput, computing checksum as it goes.
Circle
Represents a circle on the Earth's surface defined by a center point and radius.
ClassicSimilarity
Expert: Historical scoring implementation.
ClassLoaderUtils
Helper class used by ServiceLoader to investigate parent/child relationships of `ClassLoader`s.
ClasspathResourceLoader
Simple `ResourceLoader` that uses `ClassLoader.getResourceAsStream(String)` and `Class.forName(String,boolean,ClassLoader)` to open resources and classes, respectively.
CloseableRandomVectorScorerSupplier
A supplier that creates `UpdateableRandomVectorScorer` from an ordinal.
CloseableThreadLocal<T>
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.
Codec
Encodes/decodes an inverted index segment.
CodecReader
LeafReader implemented by codec APIs.
CodecUtil
Utility class for reading and writing versioned headers.
CollectionStatistics
Contains statistics for a collection (field).
CollectionTerminatedException
Throw this exception in `LeafCollector.collect(int)` to prematurely terminate collection of the current leaf.
CollectionUtil
Methods for manipulating (sorting) and creating collections.
Collector
Expert: Collectors are primarily meant to be used to gather raw results from a search, and implement sorting or custom result filtering, collation, etc.
CollectorManager<C,T>
A manager of collectors.
Column
A single field's values across multiple documents in a `ColumnBatch`.
Column.Density
Whether a column has a value for every document in the batch.
ColumnBatch
A column-oriented batch of documents for indexing.
ColumnFieldAdapter
Lightweight adapter that presents a `Column`'s current cursor value as an `IndexableField` so it can be fed through the row-oriented indexing pass (stored fields and term inversion).
ColumnValidation
Static validation and bounds-checking helpers for the columnar indexing path.
CombinedFieldQuery
A `Query` that treats multiple fields as a single stream and scores terms as if they had been indexed in a single field whose values would be the union of the values of the provided fields.
CombinedFieldQuery.Builder
A builder for `CombinedFieldQuery`.
CommandLineUtil
Class containing some useful methods used by command line tools
CompetitiveImpactAccumulator
This class accumulates the (freq, norm) pairs that may produce competitive scores.
CompiledAutomaton
Immutable class holding compiled details for a given Automaton.
CompiledAutomaton.AUTOMATON_TYPE
Automata are compiled into different internal forms for the most efficient execution depending upon the language they accept.
Component2D
2D Geometry object that supports spatial relationships with bounding boxes, triangles and points.
Component2D.WithinRelation
Used by withinTriangle to check the within relationship between a triangle and the query shape (e.g.
CompositeReader
Instances of this reader type can only be used to get stored fields from the underlying LeafReaders, but it is not possible to directly retrieve postings.
CompositeReaderContext
`IndexReaderContext` for `CompositeReader` instance.
CompoundDirectory
A read-only `Directory` that consists of a view over a compound file.
CompoundFormat
Encodes/decodes compound files
CompressionMode
A compression mode.
Compressor
A data compressor.
ConcurrentHnswMerger
This merger merges graph in a concurrent manner, by using `HnswConcurrentMergeBuilder`
ConcurrentMergeScheduler
A `MergeScheduler` that runs each merge using a separate thread.
ConcurrentMergeSchedulerAccess
Access to `ConcurrentMergeScheduler` internals exposed to the test framework.
ConjunctionUtils
Helper methods for building conjunction iterators
Constants
Some useful constants.
ConstantScoreQuery
A query that wraps another query and simply returns a constant score equal to 1 for every document that matches the query.
ConstantScoreQuery.ConstantBulkScorer
We return this as our `BulkScorer` so that if the CSQ wraps a query with its own optimized top-level scorer (e.g.
ConstantScoreScorer
A constant-scoring `Scorer`.
ConstantScoreScorerSupplier
Specialization of `ScorerSupplier` for queries that produce constant scores.
ConstantScoreWeight
A Weight that has a constant score equal to the boost of the wrapped query.
ControlledRealTimeReopenThread<T>
Utility class that runs a thread to manage periodicc reopens of a `ReferenceManager`, with methods to wait for a specific index changes to become visible.
CorruptIndexException
This exception is thrown when Lucene detects an inconsistency in the index.
Counter
Simple counter class
DataAccessHint
Hint on the data access pattern likely to be used
DataInput
Abstract base class for performing read operations of Lucene's low-level data types.
DataOutput
Abstract base class for performing write operations of Lucene's low-level data types.
DateTools
Provides support for converting dates to strings and vice-versa.
DateTools.Resolution
Specifies the time granularity.
Decompressor
A decompressor.
DefaultFlatVectorScorer
Default implementation of `FlatVectorsScorer`.
DeflateWithPresetDictCompressionMode
A compression mode that trades speed for compression ratio.
DelegatingAnalyzerWrapper
An analyzer wrapper, that doesn't allow to wrap components or readers.
DenseLiveDocs
`LiveDocs` implementation optimized for dense deletions.
DenseLiveDocs.Builder
Builder for creating DenseLiveDocs instances with optional pre-computed deleted count.
DFISimilarity
Implements the Divergence from Independence (DFI) model based on Chi-square statistics (i.e., standardized Chi-squared distance from independence in term frequency tf).
DFRSimilarity
Implements the divergence from randomness (DFR) framework introduced in Gianni Amati and Cornelis Joost Van Rijsbergen.
DictionaryColumn
A `Column` that provides string or binary values via a pre-defined term dictionary plus per-doc ordinals into that dictionary.
DirectMonotonicReader
Retrieves an instance previously written by `DirectMonotonicWriter`.
DirectMonotonicReader.Meta
In-memory metadata that needs to be kept around for `DirectMonotonicReader` to read data from disk.
DirectMonotonicWriter
Write monotonically-increasing sequences of integers.
Directory
A `Directory` provides an abstraction layer for storing a list of files.
DirectoryReader
DirectoryReader is an implementation of `CompositeReader` that can read indexes in a `Directory`.
DirectReader
Retrieves an instance previously written by `DirectWriter`
DirectWriter
Class for writing packed integers to be directly read from Directory.
DisiPriorityQueue
A priority queue of DocIdSetIterators that orders by current doc ID.
DisiWrapper
Wrapper used in `DisiPriorityQueue`.
DisjunctionDISIApproximation
A `DocIdSetIterator` which is a disjunction of the approximations of the provided iterators.
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.
Distribution
The probabilistic distribution used to model term occurrence in information-based models.
DistributionLL
Log-logistic distribution.
DistributionSPL
The smoothed power-law (SPL) distribution for the information-based framework that is described in the original paper.
DocAndFloatFeatureBuffer
Wrapper around parallel arrays storing doc IDs and their corresponding features, stored as Java floats.
DocAndScoreAccBuffer
Wrapper around parallel arrays storing doc IDs and their corresponding score accumulators.
DocBaseBitSetIterator
A `DocIdSetIterator` like `BitSetIterator` but has a doc base in order to avoid storing previous 0s.
DocComparator
Comparator that sorts by asc _doc
DocIDMerger<T>
Utility class to help merging documents from sub-readers according to either simple concatenated (unsorted) order, or by a specified index-time sort, skipping deleted documents and remapping non-deleted documents.
DocIDMerger.Sub
Represents one sub-reader being merged
DocIdSet
A DocIdSet contains a set of doc ids.
DocIdSetBuilder
A builder of `DocIdSet`s.
DocIdSetBuilder.BulkAdder
Utility class to efficiently add many docs in one go.
DocIdSetBulkIterator
Bulk iterator over a `DocIdSetIterator`.
DocIdSetIterator
This abstract class defines methods to iterate over a set of non-decreasing doc ids.
DocIdStream
A stream of doc IDs.
DocsWithFieldSet
Accumulator for documents that have a value for a field.
Document
Documents are the unit of indexing and search.
DocumentStoredFieldVisitor
A `StoredFieldVisitor` that creates a `Document` from stored fields.
DocValues
This class contains utility methods and constants for DocValues
DocValuesBulkDecodeSupport
Interface for SIMD-accelerated doc values bulk decode operations.
DocValuesConsumer
Abstract API that consumes numeric, binary and sorted docvalues.
DocValuesFormat
Encodes/decodes per-document values.
DocValuesProducer
Abstract API that produces numeric, binary, sorted, sortedset, and sortednumeric docvalues.
DocValuesRangeIterator
A `TwoPhaseIterator` over doc values that skips documents with values that lie outside a specific range, using a `SkipBlockRangeIterator` as an approximation
DocValuesRangeSupport
Interface for SIMD-accelerated doc values range operations.
DocValuesRewriteMethod
Rewrites MultiTermQueries into a filter, using DocValues for term enumeration.
DocValuesSkipIndexType
Options for skip indexes on doc values.
DocValuesSkipper
Skipper for `DocValues`.
DocValuesType
DocValues types.
DoubleComparator
Comparator based on `Double.compare(double, double)` for `numHits`.
DoubleCursor
Forked from HPPC, holding int index and double value.
DoubleDocValuesField
Syntactic sugar for encoding doubles as NumericDocValues via `Double.doubleToRawLongBits(double)`.
DoubleField
Field that stores a per-document `double` value for scoring, sorting or value retrieval and index the field for fast range filters.
DoublePoint
An indexed `double` field for fast range filters.
DoubleRange
An indexed Double Range field.
DoubleRangeDocValuesField
DocValues field for DoubleRange.
DoubleValues
Per-segment, per-document double values, which can be calculated at search-time
DoubleValuesSource
Base class for producing `DoubleValues`
DoubleValuesSourceRescorer
A `Rescorer` that uses provided DoubleValuesSource to rescore first pass hits.
EmptyDocValuesProducer
Abstract base class implementing a `DocValuesProducer` that has no doc values.
ExactPhraseMatcher
Expert: Find exact phrases
ExitableDirectoryReader
The `ExitableDirectoryReader` wraps a real index `DirectoryReader` and allows for a `QueryTimeout` implementation object to be checked periodically to see if the thread should exit or not.
ExitableDirectoryReader.ExitableFilterAtomicReader
Wrapper class for another FilterAtomicReader.
ExitableDirectoryReader.ExitableSubReaderWrapper
Wrapper class for a SubReaderWrapper that is used by the ExitableDirectoryReader.
ExitableDirectoryReader.ExitableTerms
Wrapper class for another Terms implementation that is used by ExitableFields.
ExitableDirectoryReader.ExitableTermsEnum
Wrapper class for TermsEnum that is used by ExitableTerms for implementing an exitable enumeration of terms.
ExitableDirectoryReader.ExitingReaderException
Exception that is thrown to prematurely terminate a term enumeration.
Explanation
Expert: Describes the score computation for document and query.
FeatureField
`Field` that can be used to store static scoring factors into documents.
Field
Expert: directly create a field for a document.
Field.Store
Specifies whether and how a field should be stored.
FieldComparator<T>
Expert: a FieldComparator compares hits so as to determine their sort order when collecting the top results with `TopFieldCollector`.
FieldComparator.RelevanceComparator
Sorts by descending relevance.
FieldComparator.TermValComparator
Sorts by field's natural Term sort order.
FieldComparatorSource
Provides a `FieldComparator` for custom field sorting.
FieldDoc
Expert: A ScoreDoc which also contains information about how to sort the referenced document.
FieldExistsQuery
A `Query` that matches documents that contain either a `KnnFloatVectorField`, `KnnByteVectorField` or a field that indexes norms or doc values.
FieldInfo
Access to the Field Info file that describes document fields and whether or not they are indexed.
FieldInfos
Collection of `FieldInfo`s (accessible by number or by name).
FieldInfosFormat
Encodes/decodes `FieldInfos`
FieldInvertState
This class tracks the number and position / offset parameters of terms being added to the index.
FieldReader
BlockTree's implementation of `Terms`.
Fields
Provides a `Terms` index for fields that have it, and lists which fields do.
FieldsConsumer
Abstract API that consumes terms, doc, freq, prox, offset and payloads postings.
FieldsIndexWriter
Efficient index format for block-based `Codec`s.
FieldsProducer
Abstract API that produces terms, doc, freq, prox, offset and payloads postings.
FieldType
Describes the properties of a field.
FieldValueHitQueue<T>
Expert: A hit queue for sorting by hits by terms in more than one field.
FieldValueHitQueue.Entry
Extension of ScoreDoc to also store the `FieldComparator` slot.
FileDataHint
Hints on the type of data stored in the file
FileDeleter
This class provides ability to track the reference counts of a set of index files and delete them when their counts decreased to 0.
FileDeleter.MsgType
Types of messages this file deleter will broadcast REF: messages about reference FILE: messages about file
FileDeleter.RefCount
Tracks the reference count for a single index file:
FileSwitchDirectory
Expert: A Directory instance that switches files between two other Directory instances.
FileTypeHint
Hints on the type of file being opened.
FilterBinaryDocValues
Delegates all methods to a wrapped `BinaryDocValues`.
FilterCodec
A codec that forwards all its method calls to another codec.
FilterCodecReader
A `FilterCodecReader` contains another CodecReader, which it uses as its basic source of data, possibly transforming the data along the way or providing additional functionality.
FilterCollector
`Collector` delegator.
FilterDirectory
Directory implementation that delegates calls to another directory.
FilterDirectoryReader
A FilterDirectoryReader wraps another DirectoryReader, allowing implementations to transform or extend it.
FilterDirectoryReader.DelegatingCacheHelper
A DelegatingCacheHelper is a CacheHelper specialization for implementing long-lived caching behaviour for FilterDirectoryReader subclasses.
FilterDirectoryReader.SubReaderWrapper
Factory class passed to FilterDirectoryReader constructor that allows subclasses to wrap the filtered DirectoryReader's subreaders.
FilterDocIdSetIterator
Wrapper around a `DocIdSetIterator`.
FilteredDocIdSetIterator
Abstract decorator class of a DocIdSetIterator implementation that provides on-demand filter/validation mechanism on an underlying DocIdSetIterator.
FilteredHnswGraphSearcher
Searches an HNSW graph to find nearest neighbors to a query vector.
FilteredTermsEnum
Abstract class for enumerating a subset of all terms.
FilteredTermsEnum.AcceptStatus
Return value, if term should be accepted or the iteration should `END`.
FilterIndexInput
IndexInput implementation that delegates calls to another directory.
FilterIndexInputAccess
Access to `FilterIndexInput` internals exposed to the test framework.
FilterIndexOutput
IndexOutput implementation that delegates calls to another directory.
FilteringTokenFilter
Abstract base class for TokenFilters that may remove tokens.
FilterIterator<T,InnerT>
An `Iterator` implementation that filters elements with a boolean predicate.
FilterLeafCollector
`LeafCollector` delegator.
FilterLeafReader
A `FilterLeafReader` contains another LeafReader, which it uses as its basic source of data, possibly transforming the data along the way or providing additional functionality.
FilterLeafReader.FilterFields
Base class for filtering `Fields` implementations.
FilterLeafReader.FilterPostingsEnum
Base class for filtering `PostingsEnum` implementations.
FilterLeafReader.FilterTerms
Base class for filtering `Terms` implementations.
FilterLeafReader.FilterTermsEnum
Base class for filtering `TermsEnum` implementations.
FilterMatchesIterator
A MatchesIterator that delegates all calls to another MatchesIterator
FilterMergePolicy
A wrapper for `MergePolicy` instances.
FilterNumericDocValues
Delegates all methods to a wrapped `NumericDocValues`.
FilterScorable
Filter a `Scorable`, intercepting methods and optionally changing their return values
FilterScorer
A `FilterScorer` contains another `Scorer`, which it uses as its basic source of data, possibly transforming the data along the way or providing additional functionality.
FilterSortedDocValues
Delegates all methods to a wrapped `SortedDocValues`.
FilterSortedNumericDocValues
Delegates all methods to a wrapped `SortedNumericDocValues`.
FilterSortedSetDocValues
Delegates all methods to a wrapped `SortedSetDocValues`.
FilterWeight
A `FilterWeight` contains another `Weight` and implements all abstract methods by calling the contained weight's method.
FiniteStringsIterator
Iterates all accepted strings.
FixedBitSet
BitSet of fixed length (numBits), backed by accessible (`FixedBitSet.getBits()`) long[], accessed with an int index, implementing `Bits` and `DocIdSet`.
FixedLengthBytesRefArray
Just like `BytesRefArray` except all values have the same length.
FlagsAttribute
This attribute can be used to pass different flags down the `Tokenizer` chain, e.g.
FlagsAttributeImpl
Default implementation of `FlagsAttribute`.
FlatFieldVectorsWriter<T>
Vectors' writer for a field
FlatVectorScorerUtil
Utilities for `FlatVectorsScorer`.
FlatVectorsFormat
Encodes/decodes per-document vectors and provides a scoring interface for the flat stored vectors
FlatVectorsReader
Reads vectors from an index.
FlatVectorsScorer
Provides mechanisms to score vectors that are stored in a flat file The purpose of this class is for providing flexibility to the codec utilizing the vectors
FlatVectorsWriter
Vectors' writer for a field that allows additional indexing logic to be implemented by the caller
FloatArrayList
An array-backed list of `float`.
FloatComparator
Comparator based on `Float.compare(float, float)` for `numHits`.
FloatCursor
Forked from HPPC, holding int index and float value.
FloatDocValuesField
Syntactic sugar for encoding floats as NumericDocValues via `Float.floatToRawIntBits(float)`.
FloatField
Field that stores a per-document `float` value for scoring, sorting or value retrieval and index the field for fast range filters.
FloatHeap
A bounded min heap that stores floats.
FloatPoint
An indexed `float` field for fast range filters.
FloatRange
An indexed Float Range field.
FloatRangeDocValuesField
DocValues field for FloatRange.
FloatToFloatFunction
Simple interface to map one float to another (useful in scaling scores).
FloatVectorSimilarityQuery
Search for all (approximate) float vectors above a similarity threshold.
FloatVectorValues
This class provides access to per-document floating point vector values indexed as `KnnFloatVectorField`.
FlushInfo
A FlushInfo provides information required for a FLUSH context.
ForUtil
Inspired from https://fulmicoton.com/posts/bitpacking/ Encodes multiple integers in one to get SIMD-like speedups.
FreqAndNormBuffer
Wrapper around parallel arrays storing term frequencies and length normalization factors.
FrequencyTrackingRingBuffer
A ring buffer that tracks the frequency of the integers that it contains.
FSDirectory
Base class for Directory implementations that store index files in the file system.
FSLockFactory
Base class for file system based locking implementation.
FST<T>
Represents an finite state machine (FST), using a compact byte[] format.
FST.Arc<T>
Represents a single arc.
FST.BytesReader
Reads bytes stored in an FST.
FST.FSTMetadata<T>
Represents the FST metadata.
FST.INPUT_TYPE
Specifies allowed range of each int input label for this FST.
FSTCompiler<T>
Builds a minimal FST (maps an IntsRef term to an arbitrary output) from pre-sorted terms with outputs.
FSTCompiler.Builder<T>
Fluent-style constructor for FST `FSTCompiler`.
FSTReader
Abstraction for reading bytes necessary for FST.
FullPrecisionFloatVectorSimilarityValuesSource
A `DoubleValuesSource` that computes vector similarity between a query vector and raw full precision vectors indexed in provided `KnnFloatVectorField` in documents.
FuzzyQuery
Implements the fuzzy search query.
FuzzyTermsEnum
Subclass of TermsEnum for enumerating all terms that are similar to the specified filter term.
FuzzyTermsEnum.FuzzyTermsException
Thrown to indicate that there was an issue creating a fuzzy query for a given term.
GeoEncodingUtils
reusable geopoint encoding methods
GeoEncodingUtils.Component2DPredicate
A predicate that checks whether a given point is within a component2D geometry.
GeoEncodingUtils.DistancePredicate
A predicate that checks whether a given point is within a distance of another point.
Geometry
Base class for `LatLonGeometry` and `XYGeometry`
GeoUtils
Utility methods for geo-spatial calculations and coordinate validation.
GeoUtils.WindingOrder
used to define the orientation of 3 points -1 = Clockwise 0 = Colinear 1 = Counter-clockwise
GraphTokenFilter
An abstract TokenFilter that exposes its input stream as a graph
GraphTokenStreamFiniteStrings
Consumes a TokenStream and creates an `Automaton` where the transition labels are terms from the `TermToBytesRefAttribute`.
GroupVIntUtil
This class contains utility methods and constants for group varint
GroupVIntUtil.IntReader
Deprecated.
No longer used.
GrowableWriter
Implements `PackedInts.Mutable`, but grows the bit count of the underlying packed ints on-demand.
HasIndexSlice
Implementors can return the IndexInput from which their values are read.
HasKnnVectorValues
Implementors can return the KnnVectorValues from which their scorers read.
HeapPointReader
Utility class to read buffered points from in-heap arrays.
HeapPointWriter
Utility class to write new points into in-heap arrays.
HitQueue
Expert: Priority queue containing hit docs
HnswBuilder
Interface for builder building the `OnHeapHnswGraph`
HnswConcurrentMergeBuilder
A graph builder that manages multiple workers, it only supports adding the whole graph all at once.
HnswGraph
Hierarchical Navigable Small World graph.
HnswGraph.ArrayNodesIterator
NodesIterator that accepts nodes as an integer array.
HnswGraph.CollectionNodesIterator
Nodes iterator based on set representation of nodes.
HnswGraph.DenseNodesIterator
NodesIterator that enumerates [0, size)
HnswGraph.NodesIterator
Iterator over the graph nodes on a certain level.
HnswGraphBuilder
Builder for HNSW graph.
HnswGraphBuilder.GraphBuilderKnnCollector
A restricted, specialized knnCollector that can be used when building a graph.
HnswGraphMerger
Abstraction of merging multiple graphs into one on-heap graph
HnswGraphProvider
An interface that provides an HNSW graph.
HnswGraphSearcher
Searches an HNSW graph to find nearest neighbors to a query vector.
HnswQueueSaturationCollector
A `KnnCollector.Decorator` that early exits when nearest neighbor queue keeps saturating beyond a 'patience' parameter.
HnswUtil
Utilities for use in tests involving HNSW graphs
IBSimilarity
Provides a framework for the family of information-based models, as described in Stéphane Clinchant and Eric Gaussier.
IgnoreRandomChains
Annotation to not test a class or constructor with `TestRandomChains` integration test.
Impact
Per-document scoring factors.
Impacts
Information about upcoming impacts, ie.
ImpactsDISI
`DocIdSetIterator` that skips non-competitive docs thanks to the indexed impacts.
ImpactsEnum
Extension of `PostingsEnum` which also provides information about upcoming impacts.
ImpactsSource
Source of `Impacts`.
IncrementalHnswGraphMerger
This merges multiple graphs in a single thread in incremental fashion.
IncrementalHnswGraphMerger.GraphReader
Represents a vector reader that contains graph info.
Independence
Computes the measure of divergence from independence for DFI scoring functions.
IndependenceChiSquared
Normalized chi-squared measure of distance from independence
IndependenceSaturated
Saturated measure of distance from independence
IndependenceStandardized
Standardized measure of distance from independence
IndexableField
Represents a single field for indexing.
IndexableFieldType
Describes the properties of a field.
IndexCommit
Expert: represents a single commit into an index as seen by the `IndexDeletionPolicy` or `IndexReader`.
IndexDeletionPolicy
Expert: policy for deletion of stale `index commits`.
IndexedDISI
Disk-based implementation of a `DocIdSetIterator` which can return the index of the current document, i.e.
IndexFileNames
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`).
IndexFormatTooNewException
This exception is thrown when Lucene detects an index that is newer than this Lucene version.
IndexFormatTooOldException
This exception is thrown when Lucene detects an index that is too old for this Lucene version
IndexInput
Abstract base class for input from a file in a `Directory`.
IndexNotFoundException
Signals that no index was found in the Directory.
IndexOptions
Controls how much information is stored in the postings lists.
IndexOrDocValuesQuery
A query that uses either an index structure (points or terms) or doc values in order to run a query, depending which one is more efficient.
IndexOutput
A `DataOutput` for appending data to a file in a `Directory`.
IndexPackageAccess
Access to `org.apache.lucene.index` package internals exposed to the test framework.
IndexPackageAccess.FieldInfosBuilder
Public type exposing `FieldInfo` internal builders.
IndexReader
IndexReader is an abstract class, providing an interface for accessing a point-in-time view of an index.
IndexReader.CacheHelper
A utility class that gives hooks in order to help build a cache based on the data that is contained in this index.
IndexReader.CacheKey
A cache key identifying a resource that is being cached on.
IndexReader.ClosedListener
A listener that is called when a resource gets closed.
IndexReaderContext
A struct like class that represents a hierarchical relationship between `IndexReader` instances.
IndexSearcher
Implements search over a single IndexReader.
IndexSearcher.LeafReaderContextPartition
Holds information about a specific leaf context and the corresponding range of doc ids to search within.
IndexSearcher.LeafSlice
A class holding a subset of the `IndexSearcher`s leaf contexts to be executed within a single thread.
IndexSearcher.TooManyClauses
Thrown when an attempt is made to add more than `IndexSearcher.TooManyClauses.getMaxClauseCount()` clauses.
IndexSearcher.TooManyNestedClauses
Thrown when a client attempts to execute a Query that has more than `IndexSearcher.TooManyClauses.getMaxClauseCount()` total clauses cumulatively in all of its children.
IndexSorter
Handles how documents should be sorted in an index, both within a segment and between segments.
IndexSorter.BinaryDocValuesProvider
Provide a BinaryDocValues instance for a LeafReader
IndexSorter.BinarySorter
Sorts documents by the bytes of a `BinaryDocValues` instance, using the given comparator.
IndexSorter.ComparableProvider
Used for sorting documents across segments
IndexSorter.ComparableValues
Caches the sort value of the current document of every segment being merged, and compares them.
IndexSorter.DocComparator
A comparator of doc IDs, used for sorting documents within a segment
IndexSorter.DoubleSorter
Sorts documents based on double values from a NumericDocValues instance
IndexSorter.FloatSorter
Sorts documents based on float values from a NumericDocValues instance
IndexSorter.IntSorter
Sorts documents based on integer values from a NumericDocValues instance
IndexSorter.LongSorter
Sorts documents based on long values from a NumericDocValues instance
IndexSorter.NumericDocValuesProvider
Provide a NumericDocValues instance for a LeafReader
IndexSorter.SortedDocValuesProvider
Provide a SortedDocValues instance for a LeafReader
IndexSorter.StringSorter
Sorts documents based on terms from a SortedDocValues instance
IndexSortSortedNumericDocValuesRangeQuery
A range query that can take advantage of the fact that the index is sorted to speed up execution.
IndexUpgrader
This is an easy-to-use tool that upgrades all segments of an index from previous Lucene versions to the current segment file format.
IndexWriter
An `IndexWriter` creates and maintains an index.
IndexWriter.DocStats
DocStats for this index
IndexWriter.IndexReaderWarmer
If `DirectoryReader.open(IndexWriter)` 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.
IndexWriterAccess
Access to `IndexWriter` internals exposed to the test framework.
IndexWriterConfig
Holds all the configuration that is used to create an `IndexWriter`.
IndexWriterConfig.OpenMode
Specifies the open mode for `IndexWriter`.
IndexWriterEventListener
A callback event listener for recording key events happened inside IndexWriter
IndriAndQuery
A Query that matches documents matching combinations of subqueries.
IndriAndScorer
Combines scores of subscorers.
IndriAndWeight
The Weight for IndriAndQuery, used to normalize, score and explain these queries.
IndriDirichletSimilarity
Bayesian smoothing using Dirichlet priors as implemented in the Indri Search engine (http://www.lemurproject.org/indri.php).
IndriDirichletSimilarity.IndriCollectionModel
Models `p(w|C)` as the number of occurrences of the term in the collection, divided by the total number of tokens `+ 1`.
IndriDisjunctionScorer
The Indri implemenation of a disjunction scorer which stores the subscorers for the child queries.
IndriQuery
A Basic abstract query that all IndriQueries can extend to implement toString, equals, getClauses, and iterator.
IndriScorer
The Indri parent scorer that stores the boost so that IndriScorers can use the boost outside of the term.
InetAddressPoint
An indexed 128-bit `InetAddress` field.
InetAddressRange
An indexed InetAddress Range Field
InfoStream
Debugging API for Lucene classes such as `IndexWriter` and `SegmentInfos`.
InitializedHnswGraphBuilder
This creates a graph builder that is initialized with the provided HnswGraph.
InPlaceMergeSorter
`Sorter` implementation based on the merge-sort algorithm that merges in place (no extra memory will be allocated).
InputStreamDataInput
A `DataInput` wrapping a plain `InputStream`.
IntArrayList
An array-backed list of `int`.
IntBlockPool
A pool for int blocks similar to `ByteBlockPool`
IntBlockPool.Allocator
Abstract class for allocating and freeing int blocks.
IntBlockPool.DirectAllocator
A simple `IntBlockPool.Allocator` that never recycles.
IntComparator
Comparator based on `Integer.compare(int, int)` for `numHits`.
IntCursor
Forked from HPPC, holding int index and int value.
IntDoubleHashMap
A hash map of `int` to `double`, implemented using open addressing with linear probing for collision resolution.
IntDoubleHashMap.IntDoubleCursor
Forked from HPPC, holding int index,key and value
IntField
Field that stores a per-document `int` value for scoring, sorting or value retrieval and index the field for fast range filters.
IntFloatHashMap
A hash map of `int` to `float`, implemented using open addressing with linear probing for collision resolution.
IntFloatHashMap.IntFloatCursor
Forked from HPPC, holding int index,key and value
IntHashSet
A hash set of `int`s, implemented using open addressing with linear probing for collision resolution.
IntIntHashMap
A hash map of `int` to `int`, implemented using open addressing with linear probing for collision resolution.
IntIntHashMap.IntIntCursor
Forked from HPPC, holding int index,key and value
IntLongHashMap
A hash map of `int` to `long`, implemented using open addressing with linear probing for collision resolution.
IntLongHashMap.IntLongCursor
Forked from HPPC, holding int index,key and value
IntObjectHashMap<VType>
A hash map of `int` to `Object`, implemented using open addressing with linear probing for collision resolution.
IntObjectHashMap.IntObjectCursor<VType>
Forked from HPPC, holding int index,key and value
IntPoint
An indexed `int` field for fast range filters.
IntRange
An indexed Integer Range field.
IntRangeDocValuesField
DocValues field for IntRange.
IntroSelector
Adaptive selection algorithm based on the introspective quick select algorithm.
IntroSorter
`Sorter` implementation based on a variant of the quicksort algorithm called introsort: when the recursion level exceeds the log of the length of the array to sort, it falls back to heapsort.
IntSequenceOutputs
An FST `Outputs` implementation where each output is a sequence of ints.
IntsRef
Represents int[], as a slice (offset + length) into an existing int[].
IntsRefBuilder
A builder for `IntsRef` instances.
IntsRefFSTEnum<T>
Enumerates all input (IntsRef) + output pairs in an FST.
IntsRefFSTEnum.InputOutput<T>
Holds a single input (IntsRef) + output pair.
IntToIntFunction
Native int to int function
InvertableType
Describes how an `IndexableField` should be inverted for indexing terms and postings.
IOBooleanSupplier
Boolean supplier that is allowed to throw an IOException.
IOConsumer<T>
An IO operation with a single input that may throw an IOException.
IOContext
IOContext holds additional details on the merge/search context.
IOContext.Context
Context is an enumerator which specifies the context in which the Directory is being used.
IOContext.FileOpenHint
Implemented by classes that can specify hints on how the file will be used
IOFunction<T,R>
A Function that may throw an IOException
IORunnable
A Runnable that may throw an IOException
IOSupplier<T>
This is a result supplier that is allowed to throw an IOException.
IOUtils
Utilities for dealing with `Closeable`s.
JavaLoggingInfoStream
InfoStream implementation that logs every message using Java Utils Logging (JUL) with the supplied log level.
KeepLastNCommitsDeletionPolicy
This `IndexDeletionPolicy` implementation keeps the last N commits and removes all prior commits after a new commit is done.
KeepOnlyLastCommitDeletionPolicy
This `IndexDeletionPolicy` implementation that keeps only the most recent commit and immediately removes all prior commits after a new commit is done.
KeywordAttribute
This attribute can be used to mark a token as a keyword.
KeywordAttributeImpl
Default implementation of `KeywordAttribute`.
KeywordField
Field that indexes a per-document String or `BytesRef` into an inverted index for fast filtering, stores values in a columnar fashion using `DocValuesType.SORTED_SET` doc values for sorting and faceting, and optionally stores values as stored fields for top-hits retrieval.
KnnByteVectorField
A field that contains a single byte numeric vector (or none) for each document.
KnnByteVectorQuery
Uses `KnnVectorsReader.search(String, byte[], KnnCollector, AcceptDocs)` to perform nearest neighbour search.
KnnCollector
KnnCollector is a knn collector used for gathering kNN results and providing topDocs from the gathered neighbors
KnnCollector.Decorator
KnnCollector.Decorator is the base class for decorators of KnnCollector objects, which extend the object with new behaviors.
KnnCollectorManager
KnnCollectorManager responsible for creating `KnnCollector` instances.
KnnFieldVectorsWriter<T>
Vectors writer for a field.
KnnFloatVectorField
A field that contains a single floating-point numeric vector (or none) for each document.
KnnFloatVectorQuery
Uses `KnnVectorsReader.search(String, float[], KnnCollector, AcceptDocs)` to perform nearest neighbour search.
KnnSearchStrategy
KnnSearchStrategy is a strategy for kNN search, providing additional search strategy configuration
KnnSearchStrategy.Hnsw
A strategy for kNN search that uses HNSW
KnnSearchStrategy.Patience
A strategy for kNN search on HNSW that early exits when nearest neighbor collection rate saturates.
KnnSearchStrategy.Seeded
A strategy for kNN search that uses a set of entry points to start the search
KnnVectorsFormat
Encodes/decodes per-document vector and any associated indexing structures required to support nearest-neighbor search
KnnVectorsReader
Reads vectors from an index.
KnnVectorsWriter
Writes vectors to an index.
KnnVectorsWriter.MergedVectorValues
View over multiple vector values supporting iterator-style access via DocIdMerger.
KnnVectorValues
This class abstracts addressing of document vector values indexed as `KnnFloatVectorField` or `KnnByteVectorField`.
KnnVectorValues.DocIndexIterator
A DocIdSetIterator that also provides an index() method tracking a distinct ordinal for a vector associated with each doc.
Lambda
The lambda (λw) parameter in information-based models.
LambdaDF
Computes lambda as `docFreq+1 / numberOfDocuments+1`.
LambdaTTF
Computes lambda as `totalTermFreq+1 / numberOfDocuments+1`.
LateInteractionField
A field for storing multi-vector values for late interaction models.
LateInteractionFloatValuesSource
A `DoubleValuesSource` that scores documents using similarity between a multi-vector query, and indexed document multi-vectors.
LateInteractionFloatValuesSource.ScoreFunction
Defines the function to compute similarity score between query and document multi-vectors
LateInteractionRescorer
Rescores top N results from a first pass query using a `LateInteractionFloatValuesSource`
LatLonDocValuesField
An per-document location field.
LatLonGeometry
Lat/Lon Geometry object.
LatLonPoint
An indexed location field.
LatLonShape
An geo shape utility class for indexing and searching gis geometries whose vertices are latitude, longitude values (in decimal degrees).
LatLonShapeDocValues
A concrete implementation of `ShapeDocValues` for storing binary doc value representation of `LatLonShape` geometries in a `LatLonShapeDocValuesField`
LatLonShapeDocValuesField
Concrete implementation of a `ShapeDocValuesField` for geographic geometries.
LeafCollector
Collector decouples the score from the collected doc: the score computation is skipped entirely if it's not needed.
LeafFieldComparator
Expert: comparator that gets instantiated on each leaf from a top-level `FieldComparator` instance.
LeafMetaData
Provides read-only metadata about a leaf.
LeafReader
`LeafReader` is an abstract class, providing an interface for accessing an index.
LeafReaderContext
`IndexReaderContext` for `LeafReader` instances.
LegacyQuantizedByteVectorValues
A version of `BaseQuantizedByteVectorValues`, but additionally retrieving score correction offset for Scalar quantization scores.
LevenshteinAutomata
Class to construct DFAs that match a word within some edit distance.
LimitedFiniteStringsIterator
`FiniteStringsIterator` which limits the number of iterated accepted strings.
Line
Represents a line on the earth's surface.
LiveDocs
Extension of `Bits` that provides efficient iteration over deleted documents.
LiveDocsFormat
Format for live/deleted documents
LiveFieldValues<S,T>
Tracks live field values across NRT reader reopens.
LiveIndexWriterConfig
Holds all the configuration used by `IndexWriter` with few setters for settings that can be changed on an `IndexWriter` instance "live".
LMDirichletSimilarity
Bayesian smoothing using Dirichlet priors.
LMJelinekMercerSimilarity
Language model based on the Jelinek-Mercer smoothing method.
LMSimilarity
Abstract superclass for language modeling Similarities.
LMSimilarity.CollectionModel
A strategy for computing the collection language model.
LMSimilarity.DefaultCollectionModel
Models `p(w|C)` as the number of occurrences of the term in the collection, divided by the total number of tokens `+ 1`.
LMSimilarity.LMStats
Stores the collection distribution of the current term.
Lock
An interprocess mutex lock.
LockFactory
Base class for Locking implementation.
LockObtainFailedException
This exception is thrown when the `write.lock` could not be acquired.
LockReleaseFailedException
This exception is thrown when the `write.lock` could not be released.
LockStressTest
Simple standalone tool that forever acquires and releases a lock using a specific `LockFactory`.
LockValidatingDirectoryWrapper
This class makes a best-effort check that a provided `Lock` is valid before any destructive filesystem operation.
LockVerifyServer
Simple standalone server that must be running when you use `VerifyingLockFactory`.
LogByteSizeMergePolicy
This is a `LogMergePolicy` that measures size of a segment as the total byte size of the segment's files.
LogDocMergePolicy
This is a `LogMergePolicy` that measures size of a segment as the number of documents (not taking deletions into account).
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.
LogOddsFusionQuery
A query that combines sub-query probability scores via log-odds fusion.
LongArrayList
An array-backed list of `long`.
LongBitSet
BitSet of fixed length (numBits), backed by accessible (`LongBitSet.getBits()`) long[], accessed with a long index.
LongColumn
A `Column` that provides long values.
LongColumn.NumericKind
The numeric interpretation of the column's long values.
LongComparator
Comparator based on `Long.compare(long, long)` for `numHits`.
LongCursor
Forked from HPPC, holding int index and long value.
LongField
Field that stores a per-document `long` value for scoring, sorting or value retrieval and index the field for fast range filters.
LongFloatHashMap
A hash map of `long` to `float`, implemented using open addressing with linear probing for collision resolution.
LongFloatHashMap.LongFloatCursor
Forked from HPPC, holding int index,key and value
LongHashSet
A hash set of `long`s, implemented using open addressing with linear probing for collision resolution.
LongHeap
A min heap that stores longs; a primitive priority queue that like all priority queues maintains a partial ordering of its elements such that the least element can always be found in constant time.
LongIntHashMap
A hash map of `long` to `int`, implemented using open addressing with linear probing for collision resolution.
LongIntHashMap.LongIntCursor
Forked from HPPC, holding int index,key and value
LongObjectHashMap<VType>
A hash map of `long` to `Object`, implemented using open addressing with linear probing for collision resolution.
LongObjectHashMap.LongObjectCursor<VType>
Forked from HPPC, holding int index,key and value
LongPoint
An indexed `long` field for fast range filters.
LongRange
An indexed Long Range field.
LongRangeDocValuesField
DocValues field for LongRange.
LongsRef
Represents long[], as a slice (offset + length) into an existing long[].
LongTupleCursor
A tuple cursor over a `LongColumn`.
LongValues
Per-segment, per-document long values, which can be calculated at search-time
LongValues
Abstraction over an array of longs.
LongValuesCursor
A values cursor over a dense `LongColumn`.
LongValuesSource
Base class for producing `LongValues`
LongValuesSource.ConstantLongValuesSource
A ConstantLongValuesSource that always returns a constant value
LowercaseAsciiCompression
Utility class that can efficiently compress arrays that mostly contain characters in the [0x1F,0x3F) or [0x5F,0x7F) ranges, which notably include all digits, lowercase characters, '.', '-' and '_'.
LowerCaseFilter
Normalizes token text to lower case.
LRUQueryCache
A `QueryCache` that evicts queries using a LRU (least-recently-used) eviction policy in order to remain under a given maximum size and number of bytes used.
LRUQueryCache.CacheAndCount
Cache of doc ids with a count.
LSBRadixSorter
A LSB Radix sorter for unsigned int values.
Lucene103BlockTreeTermsReader
A block-based terms index and dictionary that assigns terms to variable length blocks according to how they share prefixes.
Lucene103BlockTreeTermsWriter
Block-based terms index and dictionary writer.
Lucene104Codec
Implements the Lucene 10.4 index format
Lucene104Codec.Mode
Configuration option for the codec.
Lucene104HnswScalarQuantizedVectorsFormat
A vectors format that uses HNSW graph to store and search for vectors.
Lucene104PostingsFormat
Lucene 10.4 postings format, which encodes postings in packed integer blocks for fast decode.
Lucene104PostingsFormat.IntBlockTermState
Holds all state required for `Lucene104PostingsReader` to produce a `PostingsEnum` without re-seeking the terms dict.
Lucene104PostingsReader
Concrete class that reads docId(maybe frq,pos,offset,payloads) list with postings format.
Lucene104PostingsWriter
Writer for `Lucene104PostingsFormat`.
Lucene104ScalarQuantizedVectorScorer
Vector scorer over OptimizedScalarQuantized vectors
Lucene104ScalarQuantizedVectorsFormat
The quantization format used here is a per-vector optimized scalar quantization.
Lucene104ScalarQuantizedVectorsReader
Reader for scalar quantized vectors in the Lucene 10.4 format.
Lucene104ScalarQuantizedVectorsReader.ScalarQuantizedVectorValues
Vector values holding row and quantized vector values
Lucene104ScalarQuantizedVectorsWriter
Writes quantized vector values and metadata to index segments in the format for Lucene 10.4.
Lucene90CompoundFormat
Lucene 9.0 compound file format
Lucene90CompressingStoredFieldsFormat
A `StoredFieldsFormat` that compresses documents in chunks in order to improve the compression ratio.
Lucene90CompressingStoredFieldsReader
`StoredFieldsReader` impl for `Lucene90CompressingStoredFieldsFormat`.
Lucene90CompressingStoredFieldsWriter
`StoredFieldsWriter` impl for `Lucene90CompressingStoredFieldsFormat`.
Lucene90CompressingTermVectorsFormat
A `TermVectorsFormat` that compresses chunks of documents together in order to improve the compression ratio.
Lucene90CompressingTermVectorsReader
`TermVectorsReader` for `Lucene90CompressingTermVectorsFormat`.
Lucene90CompressingTermVectorsWriter
`TermVectorsWriter` for `Lucene90CompressingTermVectorsFormat`.
Lucene90DocValuesFormat
Lucene 9.0 DocValues format.
Lucene90LiveDocsFormat
Lucene 9.0 live docs format
Lucene90NormsFormat
Lucene 9.0 Score normalization format.
Lucene90PointsFormat
Lucene 9.0 point format, which encodes dimensional values in a block KD-tree structure for fast 1D range and N dimensional shape intersection filtering.
Lucene90PointsReader
Reads point values previously written with `Lucene90PointsWriter`
Lucene90PointsWriter
Writes dimensional values
Lucene90StoredFieldsFormat
Lucene 9.0 stored fields format.
Lucene90StoredFieldsFormat.Mode
Configuration option for stored fields.
Lucene90TermVectorsFormat
Lucene 9.0 `term vectors format`.
Lucene94FieldInfosFormat
Lucene 9.0 Field Infos format.
Lucene99FlatVectorsFormat
Lucene 9.9 flat vector format, which encodes numeric vector values
Lucene99FlatVectorsReader
Reads vectors from the index segments.
Lucene99FlatVectorsWriter
Writes vector values to index segments.
Lucene99HnswVectorsFormat
Lucene 9.9 vector format, which encodes numeric vector values into an associated graph connecting the documents having values.
Lucene99HnswVectorsReader
Reads vectors from the index segments along with index data structures supporting KNN search.
Lucene99HnswVectorsWriter
Writes vector values and knn graphs to index segments.
Lucene99ScalarQuantizedVectorScorer
Optimized scalar quantized implementation of `FlatVectorsScorer` for quantized vectors stored in the Lucene99 format.
Lucene99SegmentInfoFormat
Lucene 9.9 Segment info format.
LZ4
LZ4 compression and decompression routines.
LZ4.FastCompressionHashTable
Simple lossy `LZ4.HashTable` that only stores the last ocurrence for each hash on `2^14` bytes of memory.
LZ4.HighCompressionHashTable
A higher-precision `LZ4.HashTable`.
LZ4WithPresetDictCompressionMode
A compression mode that compromises on the compression ratio to provide fast compression and decompression.
MapOfSets<K,V>
Helper class for keeping Lists of Objects associated with keys.
MappedMultiFields
A `Fields` implementation that merges multiple Fields into one, and maps around deleted documents.
MatchAllDocsQuery
A query that matches all documents.
Matches
Reports the positions and optionally offsets of all matching terms in a query for a single document
MatchesIterator
An iterator over match positions (and optionally offsets) for a single document and field
MatchesUtils
Contains static functions that aid the implementation of `Matches` and `MatchesIterator` interfaces.
MatchingReaders
Computes which segments have identical field name to number mappings, which allows stored fields and term vectors in this codec to be bulk-merged.
MatchNoDocsQuery
A query that matches no documents.
MathUtil
Math static utility methods.
MaxNonCompetitiveBoostAttribute
Add this `Attribute` to a fresh `AttributeSource` before calling `MultiTermQuery.getTermsEnum(Terms,AttributeSource)`.
MaxNonCompetitiveBoostAttributeImpl
Implementation class for `MaxNonCompetitiveBoostAttribute`.
MaxScoreCache
Compute maximum scores based on `Impacts` and keep them in a cache in order not to run expensive similarity score computations multiple times on the same data.
MaxSizedFloatArrayList
An array-backed list of `float` with a maximum size limit.
MaxSizedIntArrayList
An array-backed list of `int` with a maximum size limit.
MergedIterator<T>
Provides a merged sorted view from several sorted iterators.
MergeInfo
A MergeInfo provides information required for a MERGE context.
MergePolicy
Expert: a MergePolicy determines the sequence of primitive merge operations.
MergePolicy.MergeAbortedException
Thrown when a merge was explicitly aborted because `IndexWriter.abortMerges()` was called.
MergePolicy.MergeContext
This interface represents the current context of the merge selection process.
MergePolicy.MergeException
Exception thrown if there are any problems while executing a merge.
MergePolicy.MergeObserver
Observer for merge operations returned by `IndexWriter.forceMergeDeletes(boolean)`.
MergePolicy.MergeSpecification
A MergeSpecification instance provides the information necessary to perform multiple merges.
MergePolicy.OneMerge
OneMerge provides the information necessary to perform an individual primitive merge operation, resulting in a single new segment.
MergePolicy.OneMergeProgress
Progress and state for an executing merge.
MergePolicy.OneMergeProgress.PauseReason
Reason for pausing the merge thread.
MergeRateLimiter
This is the `RateLimiter` that `IndexWriter` assigns to each running merge, to give `MergeScheduler`s ionice like control.
MergeScheduler
Expert: `IndexWriter` uses an instance implementing this interface to execute the merges selected by a `MergePolicy`.
MergeScheduler.MergeSource
Provides access to new merges and executes the actual merge
MergeState
Holds common state used during segment merging.
MergeState.DocMap
A map of doc IDs.
MergeTrigger
MergeTrigger is passed to `MergePolicy.findMerges(MergeTrigger, SegmentInfos, MergePolicy.MergeContext)` to indicate the event that triggered the merge.
MergingHnswGraphBuilder
A graph builder that is used during segments' merging.
MMapDirectory
File-based `Directory` implementation that uses mmap for reading, and `FSDirectory.FSIndexOutput` for writing.
ModuleResourceLoader
Simple `ResourceLoader` that uses `Module.getResourceAsStream(String)` and `Class.forName(Module,String)` to open resources and classes, respectively.
MonotonicBlockPackedReader
Provides random access to a stream written with `MonotonicBlockPackedWriter`.
MonotonicBlockPackedWriter
A writer for large monotonically increasing sequences of positive longs.
MSBRadixSorter
Radix sorter for variable-length strings.
MultiBits
Concatenates multiple Bits together, on every lookup.
MultiCollector
A `Collector` which allows running a search with several `Collector`s.
MultiCollectorManager
A `CollectorManager` implements which wrap a set of `CollectorManager` as `MultiCollector` acts for `Collector`.
MultiDocValues
A wrapper for CompositeIndexReader providing access to DocValues.
MultiDocValues.MultiSortedDocValues
Implements SortedDocValues over n subs, using an OrdinalMap
MultiDocValues.MultiSortedSetDocValues
Implements MultiSortedSetDocValues over n subs, using an OrdinalMap
MultiFields
Provides a single `Fields` term index view over an `IndexReader`.
MultiLeafKnnCollector
MultiLeafKnnCollector is a specific KnnCollector that can exchange the top collected results across segments through a shared global queue.
MultiLeafReader
Utility methods for working with a `IndexReader` as if it were a `LeafReader`.
MultiLevelSkipListReader
This abstract class reads skip lists with multiple levels.
MultiLevelSkipListWriter
This abstract class writes skip lists with multiple levels.
MultiPhraseQuery
A generalized version of `PhraseQuery`, with the possibility of adding more than one term at the same position that are treated as a disjunction (OR).
MultiPhraseQuery.Builder
A builder for multi-phrase queries
MultiPhraseQuery.UnionFullPostingsEnum
Slower version of UnionPostingsEnum that delegates offsets and positions, for use by MatchesIterator
MultiPhraseQuery.UnionPostingsEnum
Takes the logical union of multiple PostingsEnum iterators.
MultiPostingsEnum
Exposes `PostingsEnum`, merged from `PostingsEnum` API of sub-segments.
MultiPostingsEnum.EnumWithSlice
Holds a `PostingsEnum` along with the corresponding `ReaderSlice`.
MultiReader
A `CompositeReader` which reads multiple indexes, appending their content.
Multiset<T>
A `Multiset` is a set that allows for duplicate elements.
MultiSimilarity
Implements the CombSUM method for combining evidence from multiple similarity values described in: Joseph A.
MultiTermQuery
An abstract `Query` that matches documents containing a subset of terms provided by a `FilteredTermsEnum` enumeration.
MultiTermQuery.RewriteMethod
Abstract class that defines how the query is rewritten.
MultiTermQuery.TopTermsBlendedFreqScoringRewrite
A rewrite method that first translates each term into `BooleanClause.Occur.SHOULD` clause in a BooleanQuery, but adjusts the frequencies used for scoring to be blended across the terms, otherwise the rarest term typically ranks highest (often not useful eg in the set of expanded terms in a FuzzyQuery).
MultiTermQuery.TopTermsBoostOnlyBooleanQueryRewrite
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.
MultiTermQuery.TopTermsScoringBooleanQueryRewrite
A rewrite method that first translates each term into `BooleanClause.Occur.SHOULD` clause in a BooleanQuery, and keeps the scores as computed by the query.
MultiTerms
Exposes flex API, merged from flex API of sub-segments.
MultiTermsEnum
Exposes `TermsEnum` API, merged from `TermsEnum` API of sub-segments.
MultiVectorSimilarity
Interface to define the similarity function between multi-vectors
MutablePointTree
One leaf `PointValues.PointTree` whose order of points can be changed.
MutablePointTreeReaderUtils
Utility APIs for sorting and partitioning buffered points.
MutableValue
Base class for all mutable values.
MutableValueBool
`MutableValue` implementation of type `boolean`.
MutableValueDate
`MutableValue` implementation of type `Date`.
MutableValueDouble
`MutableValue` implementation of type `double`.
MutableValueFloat
`MutableValue` implementation of type `float`.
MutableValueInt
`MutableValue` implementation of type `int`.
MutableValueLong
`MutableValue` implementation of type `long`.
MutableValueStr
`MutableValue` implementation of type `String`.
NamedMatches
Utility class to help extract the set of sub queries that have matched from a larger query.
NamedSPILoader<S>
Helper class for loading named SPIs from classpath (e.g.
NamedSPILoader.NamedSPI
Interface to support `NamedSPILoader.lookup(String)` by name.
NamedThreadFactory
A default `ThreadFactory` implementation that accepts the name prefix of the created threads as a constructor argument.
NativeFSLockFactory
Implements `LockFactory` using native OS file locks.
NeighborArray
NeighborArray encodes the neighbors of a node and their mutual scores in the HNSW graph as a pair of growable arrays.
NeighborQueue
NeighborQueue uses a `TernaryLongHeap` to store lists of arcs in an HNSW graph, represented as a neighbor node id with an associated score packed together as a sortable long, which is sorted primarily by score.
NFARunAutomaton
A RunAutomaton that does not require DFA.
NGramPhraseQuery
This is a `PhraseQuery` which is optimized for n-gram phrase query.
NIOFSDirectory
An `FSDirectory` implementation that uses java.nio's FileChannel's positional read, which allows multiple threads to read from the same file without synchronizing.
NoDeletionPolicy
An `IndexDeletionPolicy` which keeps all index commits around, never deleting them.
NoLockFactory
Use this `LockFactory` to disable locking entirely.
NoMergePolicy
A `MergePolicy` which never returns merges to execute.
NoMergeScheduler
A `MergeScheduler` which never executes any merges.
NoOutputs
A null FST `Outputs` implementation; use this if you just want to build an FSA.
Normalization
This class acts as the base class for the implementations of the term frequency normalization methods in the DFR framework.
Normalization.NoNormalization
Implementation used when there is no normalization.
NormalizationH1
Normalization model that assumes a uniform distribution of the term frequency.
NormalizationH2
Normalization model in which the term frequency is inversely related to the length.
NormalizationH3
Dirichlet Priors normalization
NormalizationZ
Pareto-Zipf Normalization
NormsConsumer
Abstract API that consumes normalization values.
NormsFormat
Encodes/decodes per-document score normalization values.
NormsProducer
Abstract API that produces field normalization values
NotDocIdSet
This `DocIdSet` encodes the negation of another `DocIdSet`.
NRTCachingDirectory
Wraps a RAM-resident directory around any provided delegate directory, to be used during NRT search.
NumericComparator<T>
Abstract numeric comparator for comparing numeric values.
NumericDocValues
A per-document numeric value.
NumericDocValuesField
Field that stores a per-document `long` value for scoring, sorting or value retrieval.
NumericDocValuesRangeQuery
A Query over a range of long values
NumericFieldStats
Utility class for retrieving global numeric field statistics from index metadata structures, without accessing individual documents.
NumericFieldStats.Stats
Holds the global statistics for a numeric field.
NumericUtils
Helper APIs to encode numeric values as sortable bytes and vice-versa.
ObjectCursor<VType>
Forked from HPPC, holding int index and Object value.
ObjectTupleCursor<T>
A tuple cursor over a `Column` whose values are objects.
OffHeapByteVectorValues
Read the vector values from the index input.
OffHeapByteVectorValues.DenseOffHeapVectorValues
Dense vector values that are stored off-heap.
OffHeapFloatVectorValues
Read the vector values from the index input.
OffHeapFloatVectorValues.DenseOffHeapVectorValues
Dense vector values that are stored off-heap.
OffHeapFSTStore
Provides off heap storage of finite state machine (FST), using underlying index input instead of byte store on heap
OffHeapScalarQuantizedVectorValues
Scalar quantized vector values loaded from off-heap
OfflinePointReader
Reads points from disk in a fixed-with format, previously written with `OfflinePointWriter`.
OfflinePointWriter
Writes points to disk in a fixed-with format.
OfflineSorter
On-disk sorting of byte arrays.
OfflineSorter.BufferSize
A bit more descriptive unit for constructors.
OfflineSorter.ByteSequencesReader
Utility class to read length-prefixed byte[] entries from an input.
OfflineSorter.ByteSequencesWriter
Utility class to emit length-prefixed byte[] entries to an output stream for sorting.
OffsetAttribute
The start and end character offset of a Token.
OffsetAttributeImpl
Default implementation of `OffsetAttribute`.
OneMergeWrappingMergePolicy
A wrapping merge policy that wraps the `MergePolicy.OneMerge` objects returned by the wrapped merge policy.
OnHeapFSTStore
Provides storage of finite state machine (FST), using byte array or byte store allocated on heap.
OnHeapHnswGraph
An `HnswGraph` where all nodes and connections are held in memory.
Operations
Automata operations.
OptimizedScalarQuantizer
This is a scalar quantizer that optimizes the quantization intervals for a given vector.
OptimizedScalarQuantizer.QuantizationResult
Quantization result containing the lower and upper interval bounds, the additional correction
OrdinalMap
Maps per-segment ordinals to/from global ordinal space, using a compact packed-ints representation.
OrdinalsCursor
A dense values cursor over a `DictionaryColumn`.
OrdinalsTupleCursor
A tuple cursor over a `DictionaryColumn`.
OrdinalTranslatedKnnCollector
Wraps a provided KnnCollector object, translating the provided vectorId ordinal to a documentId
OrdTermState
An ordinal based `TermState`
OrdToDocDISIReaderConfiguration
Configuration for `DirectMonotonicReader` and `IndexedDISI` for reading sparse vectors.
Outputs<T>
Represents the outputs for an FST, providing the basic algebra required for building and traversing the FST.
OutputStreamDataOutput
A `DataOutput` wrapping a plain `OutputStream`.
OutputStreamIndexOutput
Implementation class for buffered `IndexOutput` that writes to an `OutputStream`.
PackedDataInput
A `DataInput` wrapper to read unaligned, variable-length packed integers.
PackedDataOutput
A `DataOutput` wrapper to write unaligned, variable-length packed integers.
PackedInts
Simplistic compression for array of unsigned long values.
PackedInts.Decoder
A decoder for packed integers.
PackedInts.Encoder
An encoder for packed integers.
PackedInts.Format
A format to write packed ints.
PackedInts.FormatAndBits
Simple class that holds a format and a number of bits per value.
PackedInts.Mutable
A packed integer array that can be modified.
PackedInts.NullReader
A `PackedInts.Reader` which has all its values equal to 0 (bitsPerValue = 0).
PackedInts.Reader
A read-only random access array of positive integers.
PackedInts.ReaderIterator
Run-once iterator interface, to decode previously saved PackedInts.
PackedInts.Writer
A write-once Writer.
PackedLongValues
Utility class to compress integers into a `LongValues` instance.
PackedLongValues.Builder
A Builder for a `PackedLongValues` instance.
PackedTokenAttributeImpl
Default implementation of the common attributes used by Lucene: `CharTermAttribute` `TypeAttribute` `PositionIncrementAttribute` `PositionLengthAttribute` `OffsetAttribute` `TermFrequencyAttribute`
PagedBytes
Represents a logical byte[] as a series of pages.
PagedBytes.Reader
Provides methods to read BytesRefs from a frozen PagedBytes.
PagedGrowableWriter
A `PagedGrowableWriter`.
PagedMutable
A `PagedMutable`.
PairOutputs<A,B>
An FST `Outputs` implementation, holding two other outputs.
PairOutputs.Pair<A,B>
Holds a single pair of two outputs.
ParallelCompositeReader
An `CompositeReader` which reads multiple, parallel indexes.
ParallelLeafReader
An `LeafReader` which reads multiple, parallel indexes.
PatienceKnnVectorQuery
This is a version of knn vector query that exits early when HNSW queue saturates over a `#saturationThreshold` for more than `#patience` times.
PayloadAttribute
The payload of a Token.
PayloadAttributeImpl
Default implementation of `PayloadAttribute`.
PerFieldDocValuesFormat
Enables per field docvalues support.
PerFieldKnnVectorsFormat
Enables per field numeric vector support.
PerFieldKnnVectorsFormat.FieldsReader
VectorReader that can wrap multiple delegate readers, selected by field.
PerFieldPostingsFormat
Enables per field postings support.
PerFieldSimilarityWrapper
Provides the ability to use a different `Similarity` for different fields.
PersistentSnapshotDeletionPolicy
A `SnapshotDeletionPolicy` which adds a persistence layer so that snapshots can be maintained across the life of an application.
PhraseMatcher
Base class for exact and sloppy phrase matching
PhraseQuery
A Query that matches documents containing a particular sequence of terms.
PhraseQuery.Builder
A builder for phrase queries.
PhraseQuery.PostingsAndFreq
Term postings and position information for phrase matching
PhraseWeight
Expert: Weight class for phrase matching
Point
Represents a point on the earth's surface.
PointInSetQuery
Abstract query class to find all documents whose single or multi-dimensional point values, previously indexed with e.g.
PointInSetQuery.Stream
Iterator of encoded point values.
PointRangeQuery
Abstract class for range queries against single or multidimensional points such as `IntPoint`.
PointReader
One pass iterator through all points previously written with a `PointWriter`, abstracting away whether points are read from (offline) disk or simple arrays in heap.
PointsFormat
Encodes/decodes indexed points.
PointsReader
Abstract API to visit point values.
PointsWriter
Abstract API to write points
PointValue
Represents a dimensional point value written in the BKD tree.
PointValues
Access to indexed numeric values.
PointValues.IntersectVisitor
We recurse the `PointValues.PointTree`, using a provided instance of this to guide the recursion.
PointValues.PointTree
Basic operations to read the KD-tree.
PointValues.Relation
Used by `PointValues.intersect(org.apache.lucene.index.PointValues.IntersectVisitor)` to check how each recursive cell corresponds to the query.
PointWriter
Appends many points, and then at the end provides a `PointReader` to iterate those points.
Polygon
Represents a closed polygon on the earth's surface.
PositionIncrementAttribute
Determines the position of this token relative to the previous Token in a TokenStream, used in phrase searching.
PositionIncrementAttributeImpl
Default implementation of `PositionIncrementAttribute`.
PositionLengthAttribute
Determines how many positions this token spans.
PositionLengthAttributeImpl
Default implementation of `PositionLengthAttribute`.
PositiveIntOutputs
An FST `Outputs` implementation where each output is a non-negative long value.
PositiveScoresOnlyCollector
A `Collector` implementation which wraps another `Collector` and makes sure only documents with scores > 0 are collected.
PostingDecodingUtil
Utility class to decode postings.
PostingIndexInput
Wrapper around an `IndexInput` and a `ForUtil` that optionally optimizes decoding using vectorization.
PostingsEnum
Iterates through the postings.
PostingsFormat
Encodes/decodes terms, postings, and proximity data.
PostingsReaderBase
The core terms dictionaries (BlockTermsReader, BlockTreeTermsReader) interact with a single instance of this class to manage creation of `PostingsEnum` and `ImpactsEnum` instances.
PostingsWriterBase
Class that plugs into term dictionaries, such as `Lucene103BlockTreeTermsWriter`, and handles writing postings.
PrefetchableFlatVectorScorer
A `FlatVectorsScorer` wrapper that enables prefetching of vector data before scoring.
PrefixCodedTerms
Prefix codes term instances (prefixes are shared).
PrefixCodedTerms.Builder
Builds a PrefixCodedTerms: call add repeatedly, then finish.
PrefixCodedTerms.TermIterator
An iterator over the list of terms stored in a `PrefixCodedTerms`.
PrefixQuery
A Query that matches documents containing terms with a specified prefix.
PreloadHint
A hint that the file should be preloaded into memory
PrintStreamInfoStream
InfoStream implementation over a `PrintStream` such as `System.out`.
PriorityQueue<T>
A priority queue maintains a partial ordering of its elements such that the least element can always be found in constant time.
Pruning
Controls `LeafFieldComparator` how to skip documents
PushPostingsWriterBase
Extension of `PostingsWriterBase`, adding a push API for writing each element of the postings.
QuantizedByteVectorValues
Scalar quantized byte vector values
QuantizedByteVectorValues.ScalarEncoding
Allowed encodings for scalar quantization.
QuantizedVectorsReader
Quantized vector reader
Query
The abstract base class for queries.
QueryBuilder
Creates queries from the `Analyzer` chain.
QueryBuilder.TermAndBoost
Wraps a term and boost
QueryCache
A cache for queries.
QueryCachingPolicy
A policy defining which filters should be cached.
QueryRescorer
A `Rescorer` that uses a provided Query to assign scores to the first-pass hits.
QueryTimeout
Query timeout abstraction that controls whether a query should continue or be stopped.
QueryTimeoutImpl
An implementation of `QueryTimeout` that can be used by the `ExitableDirectoryReader` class to time out and exit out when a query takes a long time to rewrite.
QueryVisitor
Allows recursion through a query tree
RadixSelector
Radix selector.
RamUsageEstimator
Estimates the size (memory representation) of Java objects.
RandomAccessInput
Random Access Index API.
RandomVectorScorer
A `RandomVectorScorer` for scoring random nodes in batches against an abstract query.
RandomVectorScorer.AbstractRandomVectorScorer
Creates a default scorer for random access vectors.
RandomVectorScorerSupplier
A supplier that creates `RandomVectorScorer` from an ordinal.
RangeFieldQuery
Query class for searching `RangeField` types by a defined `PointValues.Relation`.
RangeFieldQuery.QueryType
Used by `RangeFieldQuery` to check how each internal or leaf node relates to the query.
RateLimitedIndexOutput
A `rate limiting` `IndexOutput`
RateLimiter
Abstract base class to rate limit IO.
RateLimiter.SimpleRateLimiter
Simple class to rate limit IO.
RawTFSimilarity
Similarity that returns the raw TF as score.
ReadAdvice
Advice regarding the read access pattern.
ReaderManager
Utility class to safely share `DirectoryReader` instances across multiple threads, while periodically reopening.
ReaderSlice
Subreader slice from a parent composite reader.
ReaderUtil
Common util methods for dealing with `IndexReader`s and `IndexReaderContext`s.
ReadOnceHint
A `IOContext.FileOpenHint` indicating the file will only be read once, sequentially
Rectangle
Represents a rectangular bounding box on Earth's surface.
RecyclingByteBlockAllocator
A `ByteBlockPool.Allocator` implementation that recycles unused byte blocks in a buffer and reuses them in subsequent calls to `RecyclingByteBlockAllocator.getByteBlock()`.
RecyclingIntBlockAllocator
A `IntBlockPool.Allocator` implementation that recycles unused int blocks in a buffer and reuses them in subsequent calls to `RecyclingIntBlockAllocator.getIntBlock()`.
RefCount<T>
Manages reference counting for a given object.
ReferenceManager<G>
Utility class to safely share instances of a certain type across multiple threads, while periodically refreshing them.
ReferenceManager.RefreshListener
Use to receive notification when a refresh has finished.
RefreshCommitSupplier
Expert: Interface to supply commit for searcher refresh.
RegExp
Regular Expression extension to `Automaton`.
RegExp.Kind
The type of expression represented by a RegExp node.
RegexpQuery
A fast regular expression query based on the `org.apache.lucene.util.automaton` package.
Rescorer
Re-scores the topN results (`TopDocs`) from an original query.
RescoreTopNQuery
A Query that re-scores another Query with a `DoubleValuesSource` function and cut-off the results at top N.
ResourceLoader
Abstraction for loading resources (streams, files, and classes).
ResourceLoaderAware
Interface for a component that needs to be initialized by an implementation of `ResourceLoader`.
RoaringDocIdSet
`DocIdSet` implementation inspired from http://roaringbitmap.org/
RoaringDocIdSet.Builder
A builder of `RoaringDocIdSet`s.
RollingBuffer<T>
Acts like forever growing T[], but internally uses a circular buffer to reuse instances of T.
RollingBuffer.Resettable
Implement to reset an instance
RunAutomaton
Finite-state automaton with fast run operation.
SameThreadExecutorService
An `ExecutorService` that executes tasks immediately in the calling thread during submit.
ScalarQuantizedVectorScorer
Default scalar quantized implementation of `FlatVectorsScorer`.
ScalarQuantizedVectorScorer.ScalarQuantizedRandomVectorScorerSupplier
Quantized vector scorer supplier
ScalarQuantizedVectorSimilarity
Calculates and adjust the scores correctly for quantized vectors given the scalar quantization parameters
ScalarQuantizedVectorSimilarity.ByteVectorComparator
Compares two byte vectors
ScalarQuantizedVectorSimilarity.DotProduct
Calculates dot product on quantized vectors, applying the appropriate corrections
ScalarQuantizedVectorSimilarity.Euclidean
Calculates euclidean distance on quantized vectors, applying the appropriate corrections
ScalarQuantizedVectorSimilarity.MaximumInnerProduct
Calculates max inner product on quantized vectors, applying the appropriate corrections
ScalarQuantizer
Will scalar quantize float vectors into `int8` byte values.
Scorable
Allows access to the score of a Query
Scorable.ChildScorable
A child Scorer and its relationship to its parent.
ScoreCachingWrappingScorer
A `Scorer` which wraps another scorer and caches the score of the current document.
ScoreDoc
Holds one hit in `TopDocs`.
ScoreMode
Different modes of search.
Scorer
Expert: Common scoring functionality for different types of queries.
ScorerSupplier
A supplier of `Scorer`.
ScoringRewrite<B>
Base rewrite method that translates each term into a query, and keeps the scores as computed by the query.
SearcherFactory
Factory class used by `SearcherManager` to create new IndexSearchers.
SearcherLifetimeManager
Keeps track of current plus old IndexSearchers, closing the old ones once they have timed out.
SearcherLifetimeManager.PruneByAge
Simple pruner that drops any searcher older by more than the specified seconds, than the newest searcher.
SearcherLifetimeManager.Pruner
See `SearcherLifetimeManager.prune(org.apache.lucene.search.SearcherLifetimeManager.Pruner)`.
SearcherManager
Utility class to safely share `IndexSearcher` instances across multiple threads, while periodically reopening.
SeededKnnVectorQuery
This is a version of knn vector query that provides a query seed to initiate the vector search.
SegmentCacheable
Interface defining whether or not an object can be cached against a `LeafReader`
SegmentCommitInfo
Embeds a [read-only] SegmentInfo and adds per-commit fields.
SegmentInfo
Information about a segment such as its name, directory, and files related to the segment.
SegmentInfoFormat
Expert: Controls the format of the `SegmentInfo` (segment metadata file).
SegmentInfos
A collection of segmentInfo objects with methods for operating on those segments in relation to the file system.
SegmentInfos.FindSegmentsFile<T>
Utility class for executing code that needs to do something with the current segments file.
SegmentOrder
Utility class to re-order segments within an IndexReader to assist in early termination.
SegmentReader
IndexReader implementation over a single segment.
SegmentReaderAccess
Access to `SegmentReader` internals exposed to the test framework.
SegmentReadState
Holder class for common parameters used during read.
SegmentWriteState
Holder class for common parameters used during write.
Selector
An implementation of a selection algorithm, ie.
SentenceAttribute
This attribute tracks what sentence a given token belongs to as well as potentially other sentence specific attributes.
SentenceAttributeImpl
Default implementation of `SentenceAttribute`.
SentinelIntSet
A native int hash-based set where one value is reserved to mean "EMPTY" internally.
SerialMergeScheduler
A `MergeScheduler` that simply does each merge sequentially, using the current thread.
SetOnce<T>
A convenient class which offers a semi-immutable object wrapper implementation which allows one to set the value of an object exactly once, and retrieve it many times.
SetOnce.AlreadySetException
Thrown when `SetOnce.set(Object)` is called more than once.
ShapeDocValuesField
A doc values field for `LatLonShape` and `XYShape` that uses `ShapeDocValues` as the underlying binary doc value format.
ShapeField
A base shape utility class used for both LatLon (spherical) and XY (cartesian) shape fields.
ShapeField.DecodedTriangle
Represents a encoded triangle using `ShapeField.decodeTriangle(byte[], DecodedTriangle)`.
ShapeField.DecodedTriangle.TYPE
type of triangle
ShapeField.QueryRelation
Query Relation Types *
ShapeField.Triangle
polygons are decomposed into tessellated triangles using `Tessellator` these triangles are encoded and inserted as separate indexed POINT fields
Similarity
Similarity defines the components of Lucene scoring.
Similarity.BulkSimScorer
Specialization of `Similarity.SimScorer` for bulk-computation of scores.
Similarity.SimScorer
Stores the weight for a query across the indexed collection.
SimilarityBase
A subclass of `Similarity` that provides a simplified API for its descendants.
SimpleCollector
Base `Collector` implementation that is used to collect all contexts.
SimpleFieldComparator<T>
Base `FieldComparator` implementation that is used for all contexts.
SimpleFSLockFactory
Implements `LockFactory` using `Files.createFile(java.nio.file.Path, java.nio.file.attribute.FileAttribute<?>...)`.
SimpleMergedSegmentWarmer
A very simple merged segment warmer that just ensures data structures are initialized.
SimpleWKTShapeParser
Parses shape geometry represented in WKT format
SimpleWKTShapeParser.ShapeType
Enumerated type for Shapes
SingleInstanceLockFactory
Implements `LockFactory` for a single in-process instance, meaning all locking will take place through this one instance.
SingleTermsEnum
Subclass of FilteredTermsEnum for enumerating a single term.
SkipBlockRangeIterator
A DocIdSetIterator that returns all documents within DocValuesSkipper blocks that have minimum and maximum values that fall within a specified range.
SkipBlockRangeIterator.Match
The match state of the current positioned block
SleepingLockWrapper
Directory that wraps another, and that sleeps and retries if obtaining the lock fails.
SloppyMath
Math functions that trade off accuracy for speed.
SloppyPhraseMatcher
Find all slop-valid position-combinations (matches) encountered while traversing/hopping the PhrasePositions.
SlowCodecReaderWrapper
Wraps arbitrary readers for merging.
SlowImpactsEnum
`ImpactsEnum` that doesn't index impacts but implements the API in a legal way.
SmallFloat
Floating point numbers smaller than 32 bits.
SnapshotDeletionPolicy
An `IndexDeletionPolicy` that wraps any other `IndexDeletionPolicy` and adds the ability to hold and later release snapshots of an index.
SoftDeletesDirectoryReaderWrapper
This reader filters out documents that have a doc values value in the given field and treat these documents as soft deleted.
SoftDeletesRetentionMergePolicy
This `MergePolicy` allows to carry over soft deleted documents across merges.
Sort
Encapsulates sort criteria for returned hits.
SortedDocValues
A per-document byte[] with presorted values.
SortedDocValuesField
Field that stores a per-document `BytesRef` value, indexed for sorting.
SortedNumericDocValues
A list of per-document numeric values, sorted according to `Long.compare(long, long)`.
SortedNumericDocValuesField
Field that stores a per-document `long` values for scoring, sorting or value retrieval.
SortedNumericSelector
Selects a value from the document's list to use as the representative value
SortedNumericSelector.Type
Type of selection to perform.
SortedNumericSortField
SortField for `SortedNumericDocValues`.
SortedNumericSortField.Provider
A SortFieldProvider for this sort field
SortedSetDocValues
A multi-valued version of `SortedDocValues`.
SortedSetDocValuesField
Field that stores a set of per-document `BytesRef` values, indexed for faceting,grouping,joining.
SortedSetSelector
Selects a value from the document's set to use as the representative value
SortedSetSelector.Type
Type of selection to perform.
SortedSetSortField
SortField for `SortedSetDocValues`.
SortedSetSortField.Provider
A SortFieldProvider for this sort
Sorter
Sorts documents of a given index by returning a permutation on the document IDs.
Sorter
Base class for sorting algorithms implementations.
Sorter.DocMap
A permutation of doc IDs.
SortField
Stores information about how to sort documents by terms in an individual field.
SortField.Provider
A SortFieldProvider for field sorts
SortField.Type
Specifies the type of the terms to be sorted, or special types such as CUSTOM
SortFieldProvider
Reads/Writes a named SortField from a segment info file, used to record index sorts
SortingCodecReader
An `CodecReader` which supports sorting documents by a given `Sort`.
SortingCodecReader.SortingValuesIterator
Iterator over KnnVectorValues accepting a mapping to differently-sorted docs.
SortRescorer
A `Rescorer` that re-sorts according to a provided Sort.
SparseFixedBitSet
A bit set that only stores longs that have at least one bit which is set.
SparseLiveDocs
`LiveDocs` implementation optimized for sparse deletions.
SparseLiveDocs.Builder
Builder for creating SparseLiveDocs instances with optional pre-computed deleted count.
StableMSBRadixSorter
Stable radix sorter for variable-length strings.
StableMSBRadixSorter.MergeSorter
A MergeSorter taking advantage of temporary storage.
StandardAnalyzer
Filters `StandardTokenizer` with `LowerCaseFilter` and `StopFilter`, using a configurable list of stop words.
StandardDirectoryReader
Default implementation of `DirectoryReader`.
StandardTokenizer
A grammar-based tokenizer constructed with JFlex.
StandardTokenizerFactory
Factory for `StandardTokenizer`.
StandardTokenizerImpl
This class implements Word Break rules from the Unicode Text Segmentation algorithm, as specified in Unicode Standard Annex #29.
StatePair
Pair of states.
Stats
BlockTree statistics for a single field returned by `FieldReader.getStats()`.
StopFilter
Removes stop words from a token stream.
StopwordAnalyzerBase
Base class for Analyzers that need to make use of stopword sets.
StoredField
A field whose value is stored so that `IndexSearcher.storedFields()` and `IndexReader.storedFields()` will return the field and its value.
StoredFieldDataInput
A fixed size DataInput which includes the length of the input.
StoredFields
API for reading stored fields.
StoredFieldsFormat
Controls the format of stored fields
StoredFieldsReader
Codec API for reading stored fields.
StoredFieldsWriter
Codec API for writing stored fields: For every document, `StoredFieldsWriter.startDocument()` is called, informing the Codec that a new document has started.
StoredFieldVisitor
Expert: provides a low-level means of accessing the stored field values in an index.
StoredFieldVisitor.Status
Enumeration of possible return values for `StoredFieldVisitor.needsField(org.apache.lucene.index.FieldInfo)`.
StoredValue
Abstraction around a stored value.
StoredValue.Type
Type of a `StoredValue`.
StringField
A field that is indexed but not tokenized: the entire String value is indexed as a single token.
StringHelper
Methods for manipulating strings.
StringSorter
A `BytesRef` sorter tries to use a efficient radix sorter if `StringSorter.cmp` is a `BytesRefComparator`, otherwise fallback to `StringSorter.fallbackSorter(java.util.Comparator<org.apache.lucene.util.BytesRef>)`
SuppressForbidden
Annotation to suppress forbidden-apis errors inside a whole class, a method, or a field.
SynonymQuery
A query that treats multiple terms as synonyms.
SynonymQuery.Builder
A builder for `SynonymQuery`.
TaskExecutor
Executor wrapper responsible for the execution of concurrent tasks.
TemporalMergePolicy
A merge policy that groups segments by time windows and merges segments within the same window, This policy is designed for time-series data where documents contain a timestamp field indexed as a `LongPoint`.
Term
A Term represents a word from text.
TermAndVector
Word2Vec unit composed by a term with the associated vector
TermFrequencyAttribute
Sets the custom term frequency of a term within one document.
TermFrequencyAttributeImpl
Default implementation of `TermFrequencyAttribute`.
TermInSetQuery
Specialization for a disjunction over many terms that, by default, behaves like a `ConstantScoreQuery` over a `BooleanQuery` containing only `BooleanClause.Occur.SHOULD` clauses.
TermOrdValComparator
Sorts by field's natural Term sort order, using ordinals.
TermQuery
A Query that matches documents containing a term.
TermRangeQuery
A Query that matches documents within an range of terms.
Terms
Access to the terms in a specific field.
TermScorer
Expert: A `Scorer` for documents matching a `Term`.
TermsEnum
Iterator to seek (`TermsEnum.seekCeil(BytesRef)`, `TermsEnum.seekExact(BytesRef)`) or step through (`BytesRefIterator.next()` terms to obtain frequency information (`TermsEnum.docFreq()`), `PostingsEnum` or `PostingsEnum` for the current term (`TermsEnum.postings(org.apache.lucene.index.PostingsEnum)`.
TermsEnum.SeekStatus
Represents returned result from `TermsEnum.seekCeil(org.apache.lucene.util.BytesRef)`.
TermState
Encapsulates all required internal state to position the associated `TermsEnum` without re-seeking.
TermStates
Maintains a `IndexReader` `TermState` view over `IndexReader` instances containing a single term.
TermStatistics
Contains statistics for a specific term
TermStats
Holder for per-term statistics.
TermToBytesRefAttribute
This attribute is requested by TermsHashPerField to index the contents.
TermVectors
API for reading term vectors.
TermVectorsFormat
Controls the format of term vectors
TermVectorsReader
Codec API for reading term vectors:
TermVectorsWriter
Codec API for writing term vectors: For every document, `TermVectorsWriter.startDocument(int)` is called, informing the Codec how many fields will be written.
TernaryLongHeap
A ternary min heap that stores longs; a primitive priority queue that like all priority queues maintains a partial ordering of its elements such that the least element can always be found in constant time.
Tessellator
Computes a triangular mesh tessellation for a given polygon.
Tessellator.Monitor
Implementation of this interface will receive calls with internal data at each step of the triangulation algorithm.
Tessellator.Triangle
Triangle in the tessellated mesh
TestSecrets
A set of static methods returning accessors for internal, package-private functionality in Lucene.
TextField
A field that is indexed and tokenized, without term vectors.
TFIDFSimilarity
Implementation of `Similarity` with the Vector Space Model.
ThreadInterruptedException
Thrown by lucene on detecting that Thread.interrupt() had been called.
TieredMergePolicy
Merges segments of approximately equal size, subject to an allowed number of segments per tier.
TieredMergePolicy.MergeScore
Holds score and explanation for a single candidate merge.
TimeLimitingKnnCollectorManager
A `KnnCollectorManager` that collects results with a timeout.
TimSorter
`Sorter` implementation based on the TimSort algorithm.
TokenFilter
A TokenFilter is a TokenStream whose input is another TokenStream.
TokenFilterFactory
Abstract parent class for analysis factories that create `TokenFilter` instances.
Tokenizer
A Tokenizer is a TokenStream whose input is a Reader.
TokenizerFactory
Abstract parent class for analysis factories that create `Tokenizer` instances.
TokenStream
A `TokenStream` enumerates the sequence of tokens, either from `Field`s of a `Document` or from query text.
TokenStreamColumn
A `Column` that provides caller-supplied `TokenStream`s for term inversion.
TokenStreamToAutomaton
Consumes a TokenStream and creates an `Automaton` where the transition labels are UTF8 bytes (or Unicode code points if unicodeArcs is true) from the `TermToBytesRefAttribute`.
TooComplexToDeterminizeException
This exception is thrown when determinizing an automaton would require too much work.
TopDocs
Represents hits returned by `IndexSearcher.search(Query,int)`.
TopDocsCollector<T>
A base class for all collectors that return a `TopDocs` output.
TopFieldCollector
A `Collector` that sorts by `SortField` using `FieldComparator`s.
TopFieldCollectorManager
Create a TopFieldCollectorManager which uses a shared hit counter to maintain number of hits and a shared `MaxScoreAccumulator` to propagate the minimum score across segments if the primary sort is by relevancy.
TopFieldDocs
Represents hits returned by `IndexSearcher.search(Query,int,Sort)`.
TopKnnCollector
TopKnnCollector is a specific KnnCollector.
TopKnnCollectorManager
TopKnnCollectorManager responsible for creating `TopKnnCollector` instances.
TopScoreDocCollector
A `Collector` implementation that collects the top-scoring hits, returning them as a `TopDocs`.
TopScoreDocCollectorManager
Create a TopScoreDocCollectorManager which uses a shared hit counter to maintain number of hits and a shared `MaxScoreAccumulator` to propagate the minimum score across segments
TopTermsRewrite<B>
Base rewrite method for collecting only the top terms via a priority queue.
ToStringUtils
Helper methods to ease implementing `Object.toString()`.
TotalHitCountCollector
Just counts the total number of hits.
TotalHitCountCollectorManager
Collector manager based on `TotalHitCountCollector` that allows users to parallelize counting the number of hits, expected to be used mostly wrapped in `MultiCollectorManager`.
TotalHits
Description of the total number of hits of a query.
TotalHits.Relation
How the `TotalHits.value` should be interpreted.
TrackingDirectoryWrapper
A delegating Directory that records which files were written to and deleted.
Transition
Holds one transition from an `Automaton`.
TransitionAccessor
Interface accessing the transitions of an automaton
TwoPhaseCommit
An interface for implementations that support 2-phase commit.
TwoPhaseCommitTool
A utility for executing 2-phase commit on several objects.
TwoPhaseCommitTool.CommitFailException
Thrown by `TwoPhaseCommitTool.execute(TwoPhaseCommit...)` when an object fails to commit().
TwoPhaseCommitTool.PrepareCommitFailException
Thrown by `TwoPhaseCommitTool.execute(TwoPhaseCommit...)` when an object fails to prepareCommit().
TwoPhaseIterator
Returned by `Scorer.twoPhaseIterator()` to expose an approximation of a `DocIdSetIterator`.
TypeAttribute
A Token's lexical type.
TypeAttributeImpl
Default implementation of `TypeAttribute`.
UnicodeUtil
Class to encode java's UTF16 char[] into UTF8 byte[] without always allocating a new byte[] as String.getBytes(StandardCharsets.UTF_8) does.
UnicodeUtil.UTF8CodePoint
Holds a codepoint along with the number of bytes required to represent it in UTF8
Unwrappable<T>
An object with this interface is a wrapper around another object (e.g., a filter with a delegate).
UpdateableRandomVectorScorer
Just like a `RandomVectorScorer` but allows the scoring ordinal to be changed.
UpdateableRandomVectorScorer.AbstractUpdateableRandomVectorScorer
Creates a default scorer for random access vectors.
UpdateGraphsUtils
Utility class for updating a big graph with smaller graphs.
UpgradeIndexMergePolicy
This `MergePolicy` is used for upgrading all existing segments of an index when calling `IndexWriter.forceMerge(int)`.
UsageTrackingQueryCachingPolicy
A `QueryCachingPolicy` that tracks usage statistics of recently-used filters in order to decide on which filters are worth caching.
UTF32ToUTF8
Converts UTF-32 automata to the equivalent UTF-8 representation.
Util
Static helper methods.
Util.FSTPath<T>
Represents a path in TopNSearcher.
Util.Result<T>
Holds a single input (IntsRef) + output, returned by `shortestPaths()`.
Util.TopNSearcher<T>
Utility class to find top N shortest paths from start point(s).
Util.TopResults<T>
Holds the results for a top N search using `Util.TopNSearcher`
VectorColumn<T>
A `Column` that provides KNN vector values via a tuple cursor.
VectorEncoding
The numeric datatype of the vector values.
VectorizationProvider
A provider of vectorization implementations.
VectorScorer
Computes the similarity score between a given query vector and different document vectors.
VectorScorer.Bulk
Bulk scorer interface to score multiple vectors at once
VectorSimilarityFunction
Vector similarity function; used in search to return top K most similar vectors to a target vector.
VectorUtil
Utilities for computations with numeric arrays, especially algebraic operations like vector dot products.
VectorUtilSupport
Interface for implementations of VectorUtil support.
VerifyingLockFactory
A `LockFactory` that wraps another `LockFactory` and verifies that each lock obtain/release is "correct" (never results in two processes holding the lock at the same time).
Version
Use by certain classes to match version compatibility across releases of Lucene.
VirtualMethod<C>
A utility for keeping backwards compatibility on previously abstract methods (or similar replacements).
WeakIdentityMap<K,V>
Implements a combination of `WeakHashMap` and `IdentityHashMap`.
Weight
Expert: Calculate query weights and build query scorers.
Weight.DefaultBulkScorer
Just wraps a Scorer and performs top scoring using it.
Weight.DefaultScorerSupplier
A wrap for default scorer supplier.
WildcardQuery
Implements the wildcard search query.
WordlistLoader
Loader for text files that represent a list of stopwords.
XYCircle
Represents a circle on the XY plane.
XYDocValuesField
An per-document location field.
XYDocValuesPointInGeometryQuery
XYGeometry query for `XYDocValuesField`.
XYEncodingUtils
reusable cartesian geometry encoding methods
XYGeometry
Cartesian Geometry object.
XYLine
Represents a line in cartesian space.
XYPoint
Represents a point on the earth's surface.
XYPointField
An indexed XY position field.
XYPolygon
Represents a polygon in cartesian space.
XYRectangle
Represents a x/y cartesian rectangle.
XYShape
A cartesian shape utility class for indexing and searching geometries whose vertices are unitless x, y values.
XYShapeDocValues
A concrete implementation of `ShapeDocValues` for storing binary doc value representation of `XYShape` geometries in a `XYShapeDocValuesField`
XYShapeDocValuesField
Concrete implementation of a `ShapeDocValuesField` for cartesian geometries.