Class PackedInt32s

No memory overhead at all, but the returned implementation may be slow.

At most 20% memory overhead.

Default amount of memory to use for bulk operations.

At most 50% memory overhead, always select a reasonably fast implementation.

At most 700% memory overhead, always select a direct implementation.

Returns how many bits are required to hold values up to and including maxValue.

@lucene.internal

Check the validity of a version number.

Copy src[srcPos:srcPos+len] into dest[destPos:destPos+len] using at most mem bytes.

Try to find the PackedInt32s.Format and number of bits per value that would restore from disk the fastest reader whose overhead is less than acceptableOverheadRatio.

The acceptableOverheadRatio parameter makes sense for random-access PackedInt32s.Readers. In case you only plan to perform sequential access on this stream later on, you should probably use COMPACT.

If you don't know how many values you are going to write, use valueCount = -1.

Get a PackedInt32s.IDecoder.

Construct a direct PackedInt32s.Reader from an IndexInput. this method is useful to restore data from streams which have been created using GetWriter(DataOutput, Int32, Int32, Single).

The returned reader will have very little memory overhead, but every call to Get(Int32) is likely to perform a disk seek.

@lucene.internal

Expert: Construct a direct PackedInt32s.Reader from a stream without reading metadata at the beginning of the stream. This method is useful to restore data from streams which have been created using GetWriterNoHeader(DataOutput, PackedInt32s.Format, Int32, Int32, Int32).

The returned reader will have very little memory overhead, but every call to Get(Int32) is likely to perform a disk seek.

@lucene.internal

Expert: Construct a direct PackedInt32s.Reader from an IndexInput without reading metadata at the beginning of the stream. this method is useful to restore data when metadata has been previously read using ReadHeader(DataInput).

@lucene.internal

Get an PackedInt32s.IEncoder.

Same as GetMutable(Int32, Int32, Single) with a pre-computed number of bits per value and format.

@lucene.internal

Create a packed integer array with the given amount of values initialized to 0. The valueCount and the bitsPerValue cannot be changed after creation. All Mutables known by this factory are kept fully in RAM.

Positive values of acceptableOverheadRatio will trade space for speed by selecting a faster but potentially less memory-efficient implementation. An acceptableOverheadRatio of COMPACT will make sure that the most memory-efficient implementation is selected whereas FASTEST will make sure that the fastest implementation is selected.

@lucene.internal

Restore a PackedInt32s.Reader from a stream.

@lucene.internal

Retrieve PackedInt32s as a PackedInt32s.IReaderIterator.

@lucene.internal

Expert: Restore a PackedInt32s.IReaderIterator from a stream without reading metadata at the beginning of the stream. This method is useful to restore data from streams which have been created using GetWriterNoHeader(DataOutput, PackedInt32s.Format, Int32, Int32, Int32).

@lucene.internal

Expert: Restore a PackedInt32s.Reader from a stream without reading metadata at the beginning of the stream. This method is useful to restore data from streams which have been created using GetWriterNoHeader(DataOutput, PackedInt32s.Format, Int32, Int32, Int32).

@lucene.internal

Expert: Restore a PackedInt32s.Reader from a stream without reading metadata at the beginning of the stream. this method is useful to restore data when metadata has been previously read using ReadHeader(DataInput).

@lucene.internal

Create a packed integer array writer for the given output, format, value count, and number of bits per value.

The resulting stream will be long-aligned. this means that depending on the format which is used under the hoods, up to 63 bits will be wasted. An easy way to make sure that no space is lost is to always use a valueCount that is a multiple of 64.

This method writes metadata to the stream, so that the resulting stream is sufficient to restore a PackedInt32s.Reader from it. You don't need to track valueCount or bitsPerValue by yourself. In case this is a problem, you should probably look at GetWriterNoHeader(DataOutput, PackedInt32s.Format, Int32, Int32, Int32).

The acceptableOverheadRatio parameter controls how readers that will be restored from this stream trade space for speed by selecting a faster but potentially less memory-efficient implementation. An acceptableOverheadRatio of COMPACT will make sure that the most memory-efficient implementation is selected whereas FASTEST will make sure that the fastest implementation is selected. In case you are only interested in reading this stream sequentially later on, you should probably use COMPACT.

@lucene.internal

Expert: Create a packed integer array writer for the given output, format, value count, and number of bits per value.

The resulting stream will be long-aligned. this means that depending on the format which is used, up to 63 bits will be wasted. An easy way to make sure that no space is lost is to always use a valueCount that is a multiple of 64.

This method does not write any metadata to the stream, meaning that it is your responsibility to store it somewhere else in order to be able to recover data from the stream later on:

• format (using Id),
• valueCount,
• bitsPerValue,
• VERSION_CURRENT.

It is possible to start writing values without knowing how many of them you are actually going to write. To do this, just pass -1 as valueCount. On the other hand, for any positive value of valueCount, the returned writer will make sure that you don't write more values than expected and pad the end of stream with zeros in case you have written less than valueCount when calling Finish().

The mem parameter lets you control how much memory can be used to buffer changes in memory before flushing to disk. High values of mem are likely to improve throughput. On the other hand, if speed is not that important to you, a value of 0 will use as little memory as possible and should already offer reasonable throughput.

@lucene.internal

Calculates the maximum unsigned long that can be expressed with the given number of bits.

@lucene.internal

Expert: reads only the metadata from a stream. This is useful to later restore a stream or open a direct reader via GetReaderNoHeader(DataInput, PackedInt32s.Header) or GetDirectReaderNoHeader(IndexInput, PackedInt32s.Header).