# Uses of Interface
org.apache.lucene.util.Accountable

Packages that use Accountable
Package
Description
org.apache.lucene.codecs
Codecs API: API for customization of the encoding and structure of the index.
org.apache.lucene.codecs.hnsw
HNSW vector helper classes.
org.apache.lucene.codecs.lucene90.compressing
Lucene 9.0 compressing format.
org.apache.lucene.codecs.lucene99
Lucene 9.9 file format.
org.apache.lucene.index
Code to maintain and access indices.
org.apache.lucene.internal.hppc
Internal copy of a subset of classes from the HPPC library.
org.apache.lucene.search
Code to search indices.
org.apache.lucene.store
Binary i/o API, used for all index data.
org.apache.lucene.util
Some utility classes.
org.apache.lucene.util.automaton
Finite-state automaton for regular expressions.
org.apache.lucene.util.fst
Finite state transducers
org.apache.lucene.util.hnsw
Navigable Small-World graph, nominally Hierarchical but currently only has a single layer.
org.apache.lucene.util.packed
Packed integer arrays and streams.
org.apache.lucene.util.quantization
Provides quantization methods for scaling vector values to smaller data types and possibly fewer dimensions

## Uses of Accountable in org.apache.lucene.codecs

Classes in org.apache.lucene.codecs that implement Accountable
Modifier and Type
Class
Description
`class`
`BufferingKnnVectorsWriter`
Buffers up pending vector value(s) per doc, then flushes when segment flushes.
`class`
`KnnFieldVectorsWriter<T>`
Vectors' writer for a field
`class`
`KnnVectorsWriter`
Writes vectors to an index.
`class`
`StoredFieldsWriter`
Codec API for writing stored fields: For every document, `StoredFieldsWriter.startDocument()` is called, informing the Codec that a new document has started.
`class`
`TermVectorsWriter`
Codec API for writing term vectors: For every document, `TermVectorsWriter.startDocument(int)` is called, informing the Codec how many fields will be written.

## Uses of Accountable in org.apache.lucene.codecs.hnsw

Classes in org.apache.lucene.codecs.hnsw that implement Accountable
Modifier and Type
Class
Description
`class`
`FlatFieldVectorsWriter<T>`
Vectors' writer for a field
`class`
`FlatVectorsReader`
Reads vectors from an index.
`class`
`FlatVectorsWriter`
Vectors' writer for a field that allows additional indexing logic to be implemented by the caller

## Uses of Accountable in org.apache.lucene.codecs.lucene90.compressing

Classes in org.apache.lucene.codecs.lucene90.compressing that implement Accountable
Modifier and Type
Class
Description
`final class`
`Lucene90CompressingStoredFieldsWriter`
`StoredFieldsWriter` impl for `Lucene90CompressingStoredFieldsFormat`.
`final class`
`Lucene90CompressingTermVectorsWriter`
`TermVectorsWriter` for `Lucene90CompressingTermVectorsFormat`.
Methods in org.apache.lucene.codecs.lucene90.compressing that return types with arguments of type Accountable
Modifier and Type
Method
Description
`Collection<Accountable>`
Lucene90CompressingTermVectorsWriter.`getChildResources()`

## Uses of Accountable in org.apache.lucene.codecs.lucene99

Classes in org.apache.lucene.codecs.lucene99 that implement Accountable
Modifier and Type
Class
Description
`final class`
`Lucene99FlatVectorsReader`
Reads vectors from the index segments.
`final class`
`Lucene99FlatVectorsWriter`
Writes vector values to index segments.
`final class`
`Lucene99HnswVectorsReader`
Reads vectors from the index segments along with index data structures supporting KNN search.
`final class`
`Lucene99HnswVectorsWriter`
Writes vector values and knn graphs to index segments.
`final class`
`Lucene99ScalarQuantizedVectorsReader`
Reads Scalar Quantized vectors from the index segments along with index data structures.
`final class`
`Lucene99ScalarQuantizedVectorsWriter`
Writes quantized vector values and metadata to index segments.

## Uses of Accountable in org.apache.lucene.index

Classes in org.apache.lucene.index that implement Accountable
Modifier and Type
Class
Description
`final class`
`DocsWithFieldSet`
Accumulator for documents that have a value for a field.
`class`
`IndexWriter`
An `IndexWriter` creates and maintains an index.
`class`
`OrdinalMap`
Maps per-segment ordinals to/from global ordinal space, using a compact packed-ints representation.
`class`
`PrefixCodedTerms`
Prefix codes term instances (prefixes are shared).
`final class`
`Term`
A Term represents a word from text.
Methods in org.apache.lucene.index that return types with arguments of type Accountable
Modifier and Type
Method
Description
`Collection<Accountable>`
OrdinalMap.`getChildResources()`

## Uses of Accountable in org.apache.lucene.internal.hppc

Classes in org.apache.lucene.internal.hppc that implement Accountable
Modifier and Type
Class
Description
`class`
`CharHashSet`
A hash set of `char`s, implemented using open addressing with linear probing for collision resolution.
`class`
`CharObjectHashMap<VType>`
A hash map of `char` to `Object`, implemented using open addressing with linear probing for collision resolution.
`class`
`FloatArrayList`
An array-backed list of `float`.
`class`
`IntArrayList`
An array-backed list of `int`.
`class`
`IntDoubleHashMap`
A hash map of `int` to `double`, implemented using open addressing with linear probing for collision resolution.
`class`
`IntFloatHashMap`
A hash map of `int` to `float`, implemented using open addressing with linear probing for collision resolution.
`class`
`IntHashSet`
A hash set of `int`s, implemented using open addressing with linear probing for collision resolution.
`class`
`IntIntHashMap`
A hash map of `int` to `int`, implemented using open addressing with linear probing for collision resolution.
`class`
`IntLongHashMap`
A hash map of `int` to `long`, implemented using open addressing with linear probing for collision resolution.
`class`
`IntObjectHashMap<VType>`
A hash map of `int` to `Object`, implemented using open addressing with linear probing for collision resolution.
`class`
`LongArrayList`
An array-backed list of `long`.
`class`
`LongFloatHashMap`
A hash map of `long` to `float`, implemented using open addressing with linear probing for collision resolution.
`class`
`LongHashSet`
A hash set of `long`s, implemented using open addressing with linear probing for collision resolution.
`class`
`LongIntHashMap`
A hash map of `long` to `int`, implemented using open addressing with linear probing for collision resolution.
`class`
`LongObjectHashMap<VType>`
A hash map of `long` to `Object`, implemented using open addressing with linear probing for collision resolution.

## Uses of Accountable in org.apache.lucene.search

Classes in org.apache.lucene.search that implement Accountable
Modifier and Type
Class
Description
`class`
`AutomatonQuery`
A `Query` that will match terms against a finite-state machine.
`class`
`DocIdSet`
A DocIdSet contains a set of doc ids.
`class`
`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.
`protected static class`
`LRUQueryCache.CacheAndCount`
Cache of doc ids with a count.
`class`
`PointInSetQuery`
Abstract query class to find all documents whose single or multi-dimensional point values, previously indexed with e.g.
`class`
`PrefixQuery`
A Query that matches documents containing terms with a specified prefix.
`class`
`RegexpQuery`
A fast regular expression query based on the `org.apache.lucene.util.automaton` package.
`class`
`TermInSetQuery`
Specialization for a disjunction over many terms that, by default, behaves like a `ConstantScoreQuery` over a `BooleanQuery` containing only `BooleanClause.Occur.SHOULD` clauses.
`class`
`TermRangeQuery`
A Query that matches documents within an range of terms.
`class`
`WildcardQuery`
Implements the wildcard search query.
Methods in org.apache.lucene.search that return types with arguments of type Accountable
Modifier and Type
Method
Description
`Collection<Accountable>`
LRUQueryCache.`getChildResources()`
`Collection<Accountable>`
TermInSetQuery.`getChildResources()`

## Uses of Accountable in org.apache.lucene.store

Classes in org.apache.lucene.store that implement Accountable
Modifier and Type
Class
Description
`final class`
`ByteBuffersDataInput`
A `DataInput` implementing `RandomAccessInput` and reading data from a list of `ByteBuffer`s.
`final class`
`ByteBuffersDataOutput`
A `DataOutput` storing data in a list of `ByteBuffer`s.
`class`
`NRTCachingDirectory`
Wraps a RAM-resident directory around any provided delegate directory, to be used during NRT search.

## Uses of Accountable in org.apache.lucene.util

Classes in org.apache.lucene.util that implement Accountable
Modifier and Type
Class
Description
`class`
`BitDocIdSet`
Implementation of the `DocIdSet` interface on top of a `BitSet`.
`class`
`BitSet`
Base implementation for a bit set.
`final class`
`ByteBlockPool`
This class enables the allocation of fixed-size buffers and their management as part of a buffer array.
`static final class`
`BytesRefArray.SortState`
Used to iterate the elements of an array in a given order.
`class`
`BytesRefBlockPool`
Represents a logical list of ByteRef backed by a `ByteBlockPool`.
`final class`
`BytesRefHash`
`BytesRefHash` is a special purpose hash-map like data-structure optimized for `BytesRef` instances.
`final class`
`FixedBitSet`
BitSet of fixed length (numBits), backed by accessible (`FixedBitSet.getBits()`) long[], accessed with an int index, implementing `Bits` and `DocIdSet`.
`final class`
`FrequencyTrackingRingBuffer`
A ring buffer that tracks the frequency of the integers that it contains.
`final class`
`LongBitSet`
BitSet of fixed length (numBits), backed by accessible (`LongBitSet.getBits()`) long[], accessed with a long index.
`final class`
`NotDocIdSet`
This `DocIdSet` encodes the negation of another `DocIdSet`.
`final class`
`PagedBytes`
Represents a logical byte[] as a series of pages.
`static final class`
`PagedBytes.Reader`
Provides methods to read BytesRefs from a frozen PagedBytes.
`class`
`RoaringDocIdSet`
`DocIdSet` implementation inspired from http://roaringbitmap.org/
`class`
`SparseFixedBitSet`
A bit set that only stores longs that have at least one bit which is set.
Fields in org.apache.lucene.util declared as Accountable
Modifier and Type
Field
Description
`static final Accountable`
Accountable.`NULL_ACCOUNTABLE`
An accountable that always returns 0
Methods in org.apache.lucene.util that return Accountable
Modifier and Type
Method
Description
`static Accountable`
Accountables.`namedAccountable(String description, long bytes)`
Returns an accountable with the provided description and bytes.
`static Accountable`
Accountables.`namedAccountable(String description, Collection<Accountable> children, long bytes)`
Returns an accountable with the provided description, children and bytes.
`static Accountable`
Accountables.`namedAccountable(String description, Accountable in)`
Augments an existing accountable with the provided description.
Methods in org.apache.lucene.util that return types with arguments of type Accountable
Modifier and Type
Method
Description
`default Collection<Accountable>`
Accountable.`getChildResources()`
Returns nested resources of this class.
`static Collection<Accountable>`
Accountables.`namedAccountables(String prefix, Map<?,? extends Accountable> in)`
Converts a map of resources to a collection.
Methods in org.apache.lucene.util with parameters of type Accountable
Modifier and Type
Method
Description
`static Accountable`
Accountables.`namedAccountable(String description, Accountable in)`
Augments an existing accountable with the provided description.
`static long`
RamUsageEstimator.`sizeOf(Accountable accountable)`
Returns the size in bytes of the `Accountable` object, using its `ramBytesUsed()` method.
`static long`
RamUsageEstimator.`sizeOf(Accountable[] accountables)`
Return the size of the provided array of `Accountable`s by summing up the shallow size of the array and the `memory usage` reported by each `Accountable`.
`static String`
Accountables.`toString(Accountable a)`
Returns a String description of an Accountable and any nested resources.
Method parameters in org.apache.lucene.util with type arguments of type Accountable
Modifier and Type
Method
Description
`static Accountable`
Accountables.`namedAccountable(String description, Collection<Accountable> children, long bytes)`
Returns an accountable with the provided description, children and bytes.
`static Collection<Accountable>`
Accountables.`namedAccountables(String prefix, Map<?,? extends Accountable> in)`
Converts a map of resources to a collection.

## Uses of Accountable in org.apache.lucene.util.automaton

Classes in org.apache.lucene.util.automaton that implement Accountable
Modifier and Type
Class
Description
`class`
`Automaton`
Represents an automaton and all its states and transitions.
`class`
`ByteRunAutomaton`
Automaton representation for matching UTF-8 byte[].
`class`
`CharacterRunAutomaton`
Automaton representation for matching char[].
`class`
`CompiledAutomaton`
Immutable class holding compiled details for a given Automaton.
`class`
`NFARunAutomaton`
A RunAutomaton that does not require DFA.
`class`
`RunAutomaton`
Finite-state automaton with fast run operation.
`class`
`Transition`
Holds one transition from an `Automaton`.

## Uses of Accountable in org.apache.lucene.util.fst

Subinterfaces of Accountable in org.apache.lucene.util.fst
Modifier and Type
Interface
Description
`interface`
`FSTReader`
Abstraction for reading bytes necessary for FST.
Classes in org.apache.lucene.util.fst that implement Accountable
Modifier and Type
Class
Description
`final class`
`FST<T>`
Represents an finite state machine (FST), using a compact byte[] format.
`final class`
`OffHeapFSTStore`
Provides off heap storage of finite state machine (FST), using underlying index input instead of byte store on heap
`final class`
`OnHeapFSTStore`
Provides storage of finite state machine (FST), using byte array or byte store allocated on heap.

## Uses of Accountable in org.apache.lucene.util.hnsw

Classes in org.apache.lucene.util.hnsw that implement Accountable
Modifier and Type
Class
Description
`final class`
`OnHeapHnswGraph`
An `HnswGraph` where all nodes and connections are held in memory.

## Uses of Accountable in org.apache.lucene.util.packed

Classes in org.apache.lucene.util.packed that implement Accountable
Modifier and Type
Class
Description
`class`
`AbstractPagedMutable<T extends AbstractPagedMutable<T>>`
Base implementation for `PagedMutable` and `PagedGrowableWriter`.
`class`
`GrowableWriter`
Implements `PackedInts.Mutable`, but grows the bit count of the underlying packed ints on-demand.
`class`
`MonotonicBlockPackedReader`
Provides random access to a stream written with `MonotonicBlockPackedWriter`.
`static class`
`PackedInts.Mutable`
A packed integer array that can be modified.
`static final class`
`PackedInts.NullReader`
A `PackedInts.Reader` which has all its values equal to 0 (bitsPerValue = 0).
`static class`
`PackedInts.Reader`
A read-only random access array of positive integers.
`class`
`PackedLongValues`
Utility class to compress integers into a `LongValues` instance.
`static class`
`PackedLongValues.Builder`
A Builder for a `PackedLongValues` instance.
`final class`
`PagedGrowableWriter`
A `PagedGrowableWriter`.
`final class`
`PagedMutable`
A `PagedMutable`.

## Uses of Accountable in org.apache.lucene.util.quantization

Subinterfaces of Accountable in org.apache.lucene.util.quantization
Modifier and Type
Interface
Description
`interface`
`QuantizedVectorsReader`
Quantized vector reader