## 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. Each block has an overhead between 6 and 14 bytes.

Format:

- <BLock>BlockCount
- BlockCount: ⌈ ValueCount / BlockSize ⌉
- Block: <Header, (Ints)>
- Header: <B, A, BitsPerValue>
- B: the B from f: x → A × x + B using a `variable-length long`
- 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 zigzag-encoded `packed` deltas from the expected value (computed from the function) using exaclty 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
`protected byte[]` `blocks`
`protected boolean` `finished`
`protected int` `off`
`protected long` `ord`
`protected DataOutput` `out`
`protected long[]` `values`

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

Method Summary
`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 void` `writeValues(int bitsRequired)`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### 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 Detail

### 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 Detail

### 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`

Copyright © 2000-2013 Apache Software Foundation. All Rights Reserved.