## org.apache.lucene.util.encoding
Class FourFlagsIntEncoder

    java.lang.Object
      org.apache.lucene.util.encoding.IntEncoder
          org.apache.lucene.util.encoding.ChunksIntEncoder
              org.apache.lucene.util.encoding.FourFlagsIntEncoder

Direct Known Subclasses:
  NOnesIntEncoder

    public class FourFlagsIntEncoder

extends ChunksIntEncoder

A `ChunksIntEncoder` which encodes values in chunks of 4. Every group starts with a single byte (called indicator) which represents 4 - 2 bit flags, where the values:

- 1, 2 or 3 mean the encoded value is '1', '2' or '3' respectively.
- 0 means the value is encoded using `VInt8IntEncoder`, and the encoded bytes follow the indicator.
  Since value 0 is illegal, and 1-3 are encoded in the indicator, the actual value that is encoded is `value-4`, which saves some more bits.

Encoding example:

- Original values: 6, 16, 5, 9, 7, 1, 11
- After sorting: 1, 5, 6, 7, 9, 11, 16
- D-Gap computing: 1, 4, 1, 1, 2, 5 (so far - done by `DGapIntEncoder`)
- Encoding: 1,0,1,1 as the first indicator, followed by 0 (4-4), than 2,0,0,0 as the second indicator, followed by 1 (5-4) encoded with.
- Binary encode: 01 | 01 | 00 | 01 00000000 00 | 00 | 00 | 10 00000001 (indicators are underlined).
  NOTE: the order of the values in the indicator is lsb ⇒ msb, which allows for more efficient decoding.

WARNING: This API is experimental and might change in incompatible ways in the next release.

Field Summary

Fields inherited from class org.apache.lucene.util.encoding.ChunksIntEncoder
`encodeQueue, encodeQueueSize, encoder, indicator, ordinal`

Fields inherited from class org.apache.lucene.util.encoding.IntEncoder
`out`

Constructor Summary
`FourFlagsIntEncoder()`

Method Summary
`IntDecoder` `createMatchingDecoder()` Returns an `IntDecoder` which matches this encoder.
`void` `encode(int data)` Small values (<=3) are stored in the `indicator` while larger values are saved for later encoding in the `ChunksIntEncoder.encodeQueue`.
`String` `toString()`

Methods inherited from class org.apache.lucene.util.encoding.ChunksIntEncoder
`close, encodeChunk, reInit`

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

Constructor Detail

### FourFlagsIntEncoder

    public FourFlagsIntEncoder()

Method Detail

### encode

    public void encode(int data)
                throws IOException

  Small values (<=3) are stored in the `indicator` while larger values are saved for later encoding in the `ChunksIntEncoder.encodeQueue`. Since Vint8 will only encode values larger or equal to 4, the values saves for encoded are transformed to (value - 4).
  When a chunk is ready (got 4 values), the `ChunksIntEncoder.encodeChunk()` takes control.

  Specified by:
    `encode` in class `IntEncoder`
  Throws:
    `IOException`

### createMatchingDecoder

    public IntDecoder createMatchingDecoder()

  Description copied from class: `IntEncoder`
  Returns an `IntDecoder` which matches this encoder. Every encoder must return an `IntDecoder` and `null` is not a valid value. If an encoder is just a filter, it should at least return its wrapped encoder's matching decoder.

  NOTE: this method should create a new instance of the matching decoder and leave the instance sharing to the caller. Returning the same instance over and over is risky because encoders and decoders are not thread safe.

  Specified by:
    `createMatchingDecoder` in class `IntEncoder`

### toString

    public String toString()

  Overrides:
    `toString` in class `Object`