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

Packages that use Accountable
org.apache.lucene.codecs: Codecs API: API for customization of the encoding and structure of the index.
org.apache.lucene.codecs.blocktree: BlockTree terms dictionary.
org.apache.lucene.codecs.compressing: StoredFieldsFormat that allows cross-document and cross-field compression of stored fields.
org.apache.lucene.codecs.lucene84: Components from the Lucene 8.4 index format.
org.apache.lucene.codecs.lucene86: Lucene 8.6 file format.
org.apache.lucene.index: Code to maintain and access indices.
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.packed: Packed integer arrays and streams.

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

Classes in org.apache.lucene.codecs that implement Accountable
`class` `DocValuesProducer` Abstract API that produces numeric, binary, sorted, sortedset, and sortednumeric docvalues.
`class` `FieldsProducer` Abstract API that produces terms, doc, freq, prox, offset and payloads postings.
`class` `NormsProducer` Abstract API that produces field normalization values
`class` `PointsReader` Abstract API to visit point values.
`class` `PostingsReaderBase` The core terms dictionaries (BlockTermsReader, BlockTreeTermsReader) interact with a single instance of this class to manage creation of `PostingsEnum` and `PostingsEnum` instances.
`class` `StoredFieldsReader` Codec API for reading stored fields.
`class` `TermVectorsReader` Codec API for reading term vectors:

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

Classes in org.apache.lucene.codecs.blocktree that implement Accountable
`class` `BlockTreeTermsReader` A block-based terms index and dictionary that assigns terms to variable length blocks according to how they share prefixes.
`class` `FieldReader` BlockTree's implementation of `Terms`.

Methods in org.apache.lucene.codecs.blocktree that return types with arguments of type Accountable
`Collection<Accountable>` FieldReader.`getChildResources()`
`Collection<Accountable>` BlockTreeTermsReader.`getChildResources()`

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

Classes in org.apache.lucene.codecs.compressing that implement Accountable
`class` `CompressingStoredFieldsReader` `StoredFieldsReader` impl for `CompressingStoredFieldsFormat`.
`class` `CompressingTermVectorsReader` `TermVectorsReader` for `CompressingTermVectorsFormat`.

Methods in org.apache.lucene.codecs.compressing that return types with arguments of type Accountable
`Collection<Accountable>` CompressingStoredFieldsReader.`getChildResources()`
`Collection<Accountable>` CompressingTermVectorsReader.`getChildResources()`

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

Classes in org.apache.lucene.codecs.lucene84 that implement Accountable
`class` `Lucene84PostingsReader` Concrete class that reads docId(maybe frq,pos,offset,payloads) list with postings format.

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

Classes in org.apache.lucene.codecs.lucene86 that implement Accountable
`class` `Lucene86PointsReader` Reads point values previously written with `Lucene86PointsWriter`

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

Classes in org.apache.lucene.index that implement Accountable
`class` `CodecReader` LeafReader implemented by codec APIs.
`class` `EmptyDocValuesProducer` Abstract base class implementing a `DocValuesProducer` that has no doc values.
`class` `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.
`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).
`class` `SegmentReader` IndexReader implementation over a single segment.
`class` `Term` A Term represents a word from text.

Methods in org.apache.lucene.index that return types with arguments of type Accountable
`Collection<Accountable>` CodecReader.`getChildResources()`
`Collection<Accountable>` OrdinalMap.`getChildResources()`
`Collection<Accountable>` FilterCodecReader.`getChildResources()`

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

Classes in org.apache.lucene.search that implement Accountable
`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.
`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 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
`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
`class` `ByteBuffersDataInput` A `DataInput` implementing `RandomAccessInput` and reading data from a list of `ByteBuffer`s.
`class` `ByteBuffersDataOutput` A `DataOutput` storing data in a list of `ByteBuffer`s.
`class` `NRTCachingDirectory` Wraps a `RAMDirectory` around any provided delegate directory, to be used during NRT search.
`class` `RAMDirectory` Deprecated. This class uses inefficient synchronization and is discouraged in favor of `MMapDirectory`. It will be removed in future versions of Lucene.
`class` `RAMFile` Deprecated. This class uses inefficient synchronization and is discouraged in favor of `MMapDirectory`. It will be removed in future versions of Lucene.
`class` `RAMOutputStream` Deprecated. This class uses inefficient synchronization and is discouraged in favor of `MMapDirectory`. It will be removed in future versions of Lucene.

Methods in org.apache.lucene.store that return types with arguments of type Accountable
`Collection<Accountable>` RAMDirectory.`getChildResources()` Deprecated.
`Collection<Accountable>` NRTCachingDirectory.`getChildResources()`
`Collection<Accountable>` RAMOutputStream.`getChildResources()` Deprecated.

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

Classes in org.apache.lucene.util that implement Accountable
`class` `BitDocIdSet` Implementation of the `DocIdSet` interface on top of a `BitSet`.
`class` `BitSet` Base implementation for a bit set.
`class` `ByteBlockPool` Class that Posting and PostingVector use to write byte streams into shared fixed-size byte[] arrays.
`static class` `BytesRefArray.SortState` Used to iterate the elements of an array in a given order.
`class` `BytesRefHash` `BytesRefHash` is a special purpose hash-map like data-structure optimized for `BytesRef` instances.
`class` `FixedBitSet` BitSet of fixed length (numBits), backed by accessible (`FixedBitSet.getBits()`) long[], accessed with an int index, implementing `Bits` and `DocIdSet`.
`class` `FrequencyTrackingRingBuffer` A ring buffer that tracks the frequency of the integers that it contains.
`class` `LongBitSet` BitSet of fixed length (numBits), backed by accessible (`LongBitSet.getBits()`) long[], accessed with a long index.
`class` `NotDocIdSet` This `DocIdSet` encodes the negation of another `DocIdSet`.
`class` `PagedBytes` Represents a logical byte[] as a series of pages.
`static class` `PagedBytes.Reader` Provides methods to read BytesRefs from a frozen PagedBytes.
`class` `RoaringDocIdSet` `DocIdSet` implementation inspired from http://roaringbitmap.org/ The space is divided into blocks of 2^16 bits and each block is encoded independently.
`class` `SparseFixedBitSet` A bit set that only stores longs that have at least one bit which is set.

Methods in org.apache.lucene.util that return Accountable
`static Accountable` Accountables.`namedAccountable(String description, Accountable in)` Augments an existing accountable with the provided description.
`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, long bytes)` Returns an accountable with the provided description and bytes.

Methods in org.apache.lucene.util that return types with arguments of type Accountable
`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
`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
`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
`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` `RunAutomaton` Finite-state automaton with fast run operation.

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

Subinterfaces of Accountable in org.apache.lucene.util.fst
`interface` `FSTStore` Abstraction for reading/writing bytes necessary for FST.

Classes in org.apache.lucene.util.fst that implement Accountable
`class` `FST<T>` Represents an finite state machine (FST), using a compact byte[] format.
`class` `OffHeapFSTStore` Provides off heap storage of finite state machine (FST), using underlying index input instead of byte store on heap
`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.packed

Classes in org.apache.lucene.util.packed that implement Accountable
`class` `AbstractPagedMutable<T extends AbstractPagedMutable<T>>` Base implementation for `PagedMutable` and `PagedGrowableWriter`.
`class` `BlockPackedReader` Provides random access to a stream written with `BlockPackedWriter`.
`class` `DirectMonotonicReader` Retrieves an instance previously written by `DirectMonotonicWriter`.
`static class` `DirectMonotonicReader.Meta` In-memory metadata that needs to be kept around for `DirectMonotonicReader` to read data from disk.
`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 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.
`class` `PagedGrowableWriter` A `PagedGrowableWriter`.
`class` `PagedMutable` A `PagedMutable`.