MonotonicBlockPackedWriter (Lucene 10.5.1 core API)
Description: declaration: package: org.apache.lucene.util.packed, class: MonotonicBlockPackedWriter

Package org.apache.lucene.util.packed

# Class MonotonicBlockPackedWriter

java.lang.Object
org.apache.lucene.util.packed.MonotonicBlockPackedWriter

public final class MonotonicBlockPackedWriter extends Object
A writer for large monotonically increasing sequences of positive longs.

The sequence is divided into fixed-size blocks and for each block, values are modeled after a linear function f: x → A × x + B. The block encodes deltas from the expected values computed from this function using as few bits as possible.

Format:

- <BLock>BlockCount
- BlockCount: ⌈ ValueCount / BlockSize ⌉
- Block: <Header, (Ints)>
- Header: <B, A, BitsPerValue>
- B: the B from f: x → A × x + B using a `zig-zag encoded` `vLong`
- A: the A from f: x → A × x + B encoded using `Float.floatToIntBits(float)` on `4 bytes`
- BitsPerValue: a `variable-length int`
- Ints: if BitsPerValue is `0`, then there is nothing to read and all values perfectly match the result of the function. Otherwise, these are the `packed` deltas from the expected value (computed from the function) using exactly BitsPerValue bits per value.

See Also:
  - `MonotonicBlockPackedReader`
NOTE: This API is for internal purposes only and might change in incompatible ways in the next release.

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `protected byte[]`
  `blocks`
  `protected boolean`
  `finished`
  `protected int`
  `off`
  `protected long`
  `ord`
  `protected DataOutput`
  `out`
  `protected final long[]`
  `values`

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `MonotonicBlockPackedWriter(DataOutput out, int blockSize)`
  Sole constructor.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `void`
  `add(long l)`
  Append a new long.
  `void`
  `finish()`
  Flush all buffered data to disk.
  `protected void`
  `flush()`
  `long`
  `ord()`
  Return the number of values which have been added.
  `void`
  `reset(DataOutput out)`
  Reset this writer to wrap `out`.
  `protected final void`
  `writeValues(int bitsRequired)`

  ### Methods inherited from class java.lang.Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- ## Field Details

  - ### out

    protected DataOutput out

  - ### values

    protected final long[] values

  - ### blocks

    protected byte[] blocks

  - ### off

    protected int off

  - ### ord

    protected long ord

  - ### finished

    protected boolean finished

- ## Constructor Details

  - ### MonotonicBlockPackedWriter

    public MonotonicBlockPackedWriter(DataOutput out, int blockSize)
    Sole constructor.
    Parameters:
      `blockSize` - the number of values of a single block, must be a power of 2

- ## Method Details

  - ### add

    public void add(long l) throws IOException
    Append a new long.
    Throws:
      `IOException`

  - ### flush

    protected void flush() throws IOException
    Throws:
      `IOException`

  - ### reset

    public void reset(DataOutput out)
    Reset this writer to wrap `out`. The block size remains unchanged.

  - ### finish

    public void finish() throws IOException
    Flush all buffered data to disk. This instance is not usable anymore after this method has been called until `reset(DataOutput)` has been called.
    Throws:
      `IOException`

  - ### ord

    public long ord()
    Return the number of values which have been added.

  - ### writeValues

    protected final void writeValues(int bitsRequired) throws IOException
    Throws:
      `IOException`