InputBitStream (Blazegraph Database Platform 2.1.5 API)

java.lang.Object
- it.unimi.dsi.fastutil.booleans.AbstractBooleanIterator
- - it.unimi.dsi.io.InputBitStream

All Implemented Interfaces:

it.unimi.dsi.fastutil.booleans.BooleanIterator, Closeable, Flushable, AutoCloseable, Iterator<Boolean>

Direct Known Subclasses:

DebugInputBitStream
```
public class InputBitStream
extends it.unimi.dsi.fastutil.booleans.AbstractBooleanIterator
implements Flushable, Closeable
```
Bit-level input stream.
This class wraps any InputStream so that you can treat it as bit stream. Constructors and methods closely resemble those of InputStream. Data can be read from such a stream in several ways: reading an integer or long in fixed-width, unary, γ, shifted γ, δ, ζ and (skewed) Golomb coding, or reading a number of bits that will be stored in a vector of bytes. There is limited support for mark(int)/reset() operations.
This class can also wrap a byte array; this is much more lightweight than wrapping a FastByteArrayInputStream wrapping the array. Overflowing the array will cause an EOFException.
Note that when reading using a vector of bytes bits are read in the stream format (see OutputBitStream): the first bit is bit 7 of the first byte, the eighth bit is bit 0 of the first byte, the ninth bit is bit 7 of the second byte and so on. When reading integers using some coding, instead, they are stored in the standard way, that is, in the lower bits.
Additional features:
- This class provides an internal buffer. By setting a buffer of length 0 at creation time, you can actually bypass the buffering system: Note, however, that several classes providing buffering have synchronised methods, so using a wrapper instead of the internal buffer is likely to lead to a performance drop.
- To work around the schizophrenic relationship between streams and random access files in java.io, this class provides a flush() method that resets the internal state. At this point, you can safely reposition the underlying stream and read again afterwards. For instance, this is safe and will perform as expected:
```
 FileInputStream fis = new FileInputStream( ... );
 InputBitStream ibs = new InputBitStream( fis );
 ... read operations on ibs ...
 ibs.flush();
 fis.getChannel().position( ... );
 ... other read operations on ibs ...
 
```
  As a commodity, an instance of this class will try to cast the underlying byte stream to a RepositionableStream and to fetch by reflection the FileChannel underlying the given input stream, in this order. If either reference can be successfully fetched, you can use directly the position() method with argument pos with the same semantics of a flush(), followed by a call to position(pos / 8) (where the latter method belongs either to the underlying stream or to its underlying file channel), followed by a skip(pos % 8). However, since the reflective checks are quite heavy they can be disabled using a suitable constructor.
- Finally, this class implements partially the interface of a boolean iterator. More precisely, nextBoolean() will return the same bit as readBit(), and also the same exceptions, whereas hasNext() will always return true: you must be prepared to catch a RuntimeException wrapping an IOException in case the file ends. It is very difficult to implement completely an eager operator using a input-stream based model.
This class is not synchronised. If multiple threads access an instance of this class concurrently, they must be synchronised externally.
Since:

0.1

Author:

Sebastiano Vigna

See Also:
InputStream, OutputBitStream

Field Summary

Fields
Modifier and Type	Field and Description
`protected int`	`avail` Current number of bytes available in the byte buffer.
`protected byte[]`	`buffer` The stream buffer.
`static int`	`DEFAULT_BUFFER_SIZE` The default size of the byte buffer in bytes (8Ki).
`static int[]`	`DELTA`
`protected FileChannel`	`fileChannel` The cached file channel underlying `is`, if any.
`protected int`	`fill` Current number of bits in the bit buffer (stored low).
`static int[]`	`GAMMA`
`protected InputStream`	`is` The underlying `InputStream`.
`protected int`	`pos` Current position in the byte buffer.
`protected long`	`position` Current position of the first byte in the byte buffer.
`protected it.unimi.dsi.fastutil.io.RepositionableStream`	`repositionableStream` `is` cast to a positionable stream, if possible.
`static int[]`	`SHIFTED_GAMMA`
`protected boolean`	`wrapping` True if we are wrapping an array.
`static int[]`	`ZETA_3`

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`InputBitStream()` This (non-public) constructor exists just to provide fake initialisation for classes such as `DebugInputBitStream`.
	`InputBitStream(byte[] a)` Creates a new input bit stream wrapping a given byte array.
	`InputBitStream(byte[] a, int off, int len)` Creates a new input bit stream wrapping a slice of a given byte array (BBT 8/30/2009).
	`InputBitStream(File file)` Creates a new input bit stream reading from a file.
	`InputBitStream(FileInputStream is)` Creates a new input bit stream wrapping a given file input stream using a buffer of size `DEFAULT_BUFFER_SIZE`.
	`InputBitStream(FileInputStream is, int bufSize)` Creates a new input bit stream wrapping a given file input stream with a specified buffer size.
	`InputBitStream(File file, int bufSize)` Creates a new input bit stream reading from a file.
	`InputBitStream(InputStream is)` Creates a new input bit stream wrapping a given input stream using a buffer of size `DEFAULT_BUFFER_SIZE`.
	`InputBitStream(InputStream is, boolean testForPosition)` Creates a new input bit stream wrapping a given input stream using a buffer of size `DEFAULT_BUFFER_SIZE`.
	`InputBitStream(InputStream is, int bufSize)` Creates a new input bit stream wrapping a given input stream with a specified buffer size.
	`InputBitStream(InputStream is, int bufSize, boolean testForPosition)` Creates a new input bit stream wrapping a given input stream with a specified buffer size.
	`InputBitStream(String name)` Creates a new input bit stream reading from a file.
	`InputBitStream(String name, int bufSize)` Creates a new input bit stream reading from a file.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`align()` Aligns the stream.
`long`	`available()` Returns the number of bits that can be read (or skipped over) from this bit stream without blocking by the next caller of a method.
`void`	`close()` Closes the bit stream.
`void`	`flush()` Flushes the bit stream.
`boolean`	`hasNext()`
`void`	`mark(int readLimit)` Marks the current position in this input stream.
`boolean`	`markSupported()` Tests if this stream supports the `mark(int)` and `reset()` methods.
`boolean`	`nextBoolean()`
`void`	`position(long position)` Sets this stream bit position, if it is based on a `RepositionableStream` or on a `FileChannel`.
`void`	`read(byte[] bits, int len)` Reads a sequence of bits.
`int`	`readBit()` Reads a bit.
`long`	`readBits()` Returns the number of bits read from this bit stream.
`void`	`readBits(long readBits)` Sets the number of bits read from this bit stream.
`int`	`readDelta()` Reads a natural number in δ coding.
`void`	`readDeltas(int[] a, int count)` Reads a given number of δ-coded integers.
`int`	`readGamma()` Reads a natural number in γ coding.
`void`	`readGammas(int[] a, int count)` Reads a given number of γ-coded integers.
`int`	`readGolomb(int b)` Reads a natural number in Golomb coding.
`int`	`readGolomb(int b, int log2b)` Reads a natural number in Golomb coding.
`int`	`readInt(int len)` Reads a fixed number of bits into an integer.
`long`	`readLong(int len)` Reads a fixed number of bits into a long.
`long`	`readLongDelta()` Reads a long natural number in δ coding.
`long`	`readLongGamma()` Reads a long natural number in γ coding.
`long`	`readLongGolomb(long b)` Reads a long natural number in Golomb coding.
`long`	`readLongGolomb(long b, int log2b)` Reads a long natural number in Golomb coding.
`long`	`readLongMinimalBinary(long b)` Reads a long natural number in a limited range using a minimal binary coding.
`long`	`readLongMinimalBinary(long b, int log2b)` Reads a long natural number in a limited range using a minimal binary coding.
`long`	`readLongNibble()` Reads a long natural number in variable-length nibble coding.
`long`	`readLongShiftedGamma()` Reads a natural number in shifted γ coding.
`long`	`readLongSkewedGolomb(long b)` Reads a long natural number in skewed Golomb coding.
`long`	`readLongUnary()` Reads a long natural number in unary coding.
`long`	`readLongZeta(int k)` Reads a long natural number in ζ coding.
`int`	`readMinimalBinary(int b)` Reads a natural number in a limited range using a minimal binary coding.
`int`	`readMinimalBinary(int b, int log2b)` Reads a natural number in a limited range using a minimal binary coding.
`int`	`readNibble()` Reads a natural number in variable-length nibble coding.
`int`	`readShiftedGamma()` Reads a natural number in shifted γ coding.
`void`	`readShiftedGammas(int[] a, int count)` Reads a given number of shifted-γ-coded integers.
`int`	`readSkewedGolomb(int b)` Reads a natural number in skewed Golomb coding.
`int`	`readUnary()` Reads a natural number in unary coding.
`int`	`readZeta(int k)` Reads a natural number in ζ coding.
`void`	`readZetas(int k, int[] a, int count)` Reads a given number of γ-coded integers.
`void`	`reset()` Repositions this bit stream to the position at the time the `mark(int)` method was last called.
`int`	`skip(int n)` Deprecated. This method is simply an expensive, try/catch-surrounded version of `skip(long)` that is made necessary by the interface by `BooleanIterator`.
`long`	`skip(long n)` Skips the given number of bits.
`void`	`skipDeltas(int n)` Skips a given number of δ-coded integers.
`void`	`skipGammas(int n)` Skips a given number of γ-coded integers.
`void`	`skipShiftedGammas(int n)` Skips a given number of shited-γ-coded integers.
`void`	`skipZetas(int k, int n)` Skips a given number of ζ-coded integers.

Methods inherited from class it.unimi.dsi.fastutil.booleans.AbstractBooleanIterator
next, remove

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

- Field Detail
  - GAMMA
```
public static final int[] GAMMA
```
  - DELTA
```
public static final int[] DELTA
```
  - ZETA_3
```
public static final int[] ZETA_3
```
  - SHIFTED_GAMMA
```
public static final int[] SHIFTED_GAMMA
```
  - DEFAULT_BUFFER_SIZE
```
public static final int DEFAULT_BUFFER_SIZE
```
    The default size of the byte buffer in bytes (8Ki).
    
    See Also:
    Constant Field Values
  - is
```
protected final InputStream is
```
    The underlying InputStream.
  - fileChannel
```
protected final FileChannel fileChannel
```
    The cached file channel underlying is, if any.
  - repositionableStream
```
protected final it.unimi.dsi.fastutil.io.RepositionableStream repositionableStream
```
    is cast to a positionable stream, if possible.
  - wrapping
```
protected final boolean wrapping
```
    True if we are wrapping an array.
  - buffer
```
protected byte[] buffer
```
    The stream buffer.
  - fill
```
protected int fill
```
    Current number of bits in the bit buffer (stored low).
  - pos
```
protected int pos
```
    Current position in the byte buffer.
  - avail
```
protected int avail
```
    Current number of bytes available in the byte buffer.
  - position
```
protected long position
```
    Current position of the first byte in the byte buffer.
- Constructor Detail
  - InputBitStream
```
protected InputBitStream()
```
    This (non-public) constructor exists just to provide fake initialisation for classes such as DebugInputBitStream.
  - InputBitStream
```
public InputBitStream(InputStream is)
```
    Creates a new input bit stream wrapping a given input stream using a buffer of size DEFAULT_BUFFER_SIZE.
    This constructor performs the reflective tests that are necessary to support position(long).
    
    Parameters:
    is - the input stream to wrap.
  - InputBitStream
```
public InputBitStream(InputStream is,
              boolean testForPosition)
```
    Creates a new input bit stream wrapping a given input stream using a buffer of size DEFAULT_BUFFER_SIZE.
    
    Parameters:
    is - the input stream to wrap.
    testForPosition - if false, the reflective tests that are necessary to support position(long) will not be performed.
  - InputBitStream
```
public InputBitStream(InputStream is,
              int bufSize)
```
    Creates a new input bit stream wrapping a given input stream with a specified buffer size.
    This constructor performs the reflective tests that are necessary to support position(long).
    
    Parameters:
    is - the input stream to wrap.
    bufSize - the size in byte of the buffer; it may be 0, denoting no buffering.
  - InputBitStream
```
public InputBitStream(InputStream is,
              int bufSize,
              boolean testForPosition)
```
    Creates a new input bit stream wrapping a given input stream with a specified buffer size.
    
    Parameters:
    is - the input stream to wrap.
    bufSize - the size in byte of the buffer; it may be 0, denoting no buffering.
    testForPosition - if false, the reflective tests that are necessary to support position(long) will not be performed.
  - InputBitStream
```
public InputBitStream(FileInputStream is)
```
    Creates a new input bit stream wrapping a given file input stream using a buffer of size DEFAULT_BUFFER_SIZE.
    This constructor invokes directly FileInputStream.getChannel() to support position(long).
    
    Parameters:
    is - the file input stream to wrap.
  - InputBitStream
```
public InputBitStream(FileInputStream is,
              int bufSize)
```
    Creates a new input bit stream wrapping a given file input stream with a specified buffer size.
    This constructor invokes directly FileInputStream.getChannel() to support position(long).
    
    Parameters:
    is - the file input stream to wrap.
    bufSize - the size in byte of the buffer; it may be 0, denoting no buffering.
  - InputBitStream
```
public InputBitStream(byte[] a)
```
    Creates a new input bit stream wrapping a given byte array.
    
    Parameters:
    a - the byte array to wrap.
  - InputBitStream
```
public InputBitStream(byte[] a,
              int off,
              int len)
```
    Creates a new input bit stream wrapping a slice of a given byte array (BBT 8/30/2009).
    
    Parameters:
    a - the byte array to wrap.
    off - the byte offset of the first addressable byte in the array.
    len - the #of addressable bytes in the array.
  - InputBitStream
```
public InputBitStream(String name,
              int bufSize)
               throws FileNotFoundException
```
    Creates a new input bit stream reading from a file.
    This constructor invokes directly FileInputStream.getChannel() to support position(long).
    
    Parameters:
    name - the name of the file.
    bufSize - the size in byte of the buffer; it may be 0, denoting no buffering.
    
    Throws:
    
    FileNotFoundException
  - InputBitStream
```
public InputBitStream(String name)
               throws FileNotFoundException
```
    Creates a new input bit stream reading from a file.
    This constructor invokes directly FileInputStream.getChannel() to support position(long).
    
    Parameters:
    name - the name of the file.
    
    Throws:
    
    FileNotFoundException
  - InputBitStream
```
public InputBitStream(File file)
               throws FileNotFoundException
```
    Creates a new input bit stream reading from a file.
    This constructor invokes directly FileInputStream.getChannel() to support position(long).
    
    Parameters:
    file - the file.
    
    Throws:
    
    FileNotFoundException
  - InputBitStream
```
public InputBitStream(File file,
              int bufSize)
               throws FileNotFoundException
```
    Creates a new input bit stream reading from a file.
    This constructor invokes directly FileInputStream.getChannel() to support position(long).
    
    Parameters:
    file - the file.
    bufSize - the size in byte of the buffer; it may be 0, denoting no buffering.
    
    Throws:
    
    FileNotFoundException
- Method Detail
  - flush
```
public void flush()
```
    Flushes the bit stream. All state information associated to the stream is reset. This includes bytes prefetched from the stream, bits in the bit buffer and unget'd bits.
    This method is provided so that users of this class can easily wrap repositionable streams (for instance, file-based streams, which can be repositioned using the underlying FileChannel). It is guaranteed that after calling this method the underlying stream can be repositioned, and that the next read will draw data from the stream.
    
    Specified by:
    
    flush in interface Flushable
  - close
```
public void close()
           throws IOException
```
    Closes the bit stream. All resources associated to the stream are released.
    
    Specified by:
    
    close in interface Closeable
    
    Specified by:
    
    close in interface AutoCloseable
    
    Throws:
    
    IOException
  - available
```
public long available()
               throws IOException
```
    Returns the number of bits that can be read (or skipped over) from this bit stream without blocking by the next caller of a method.
    
    Returns:
    the number of bits that can be read from this bit stream without blocking.
    
    Throws:
    
    IOException
  - readBits
```
public long readBits()
```
    Returns the number of bits read from this bit stream.
    
    Returns:
    the number of bits read so far.
  - readBits
```
public void readBits(long readBits)
```
    Sets the number of bits read from this bit stream.
    This method is provided so that, for instance, the user can reset via readBits(0) the read-bits count after a flush().
    
    Parameters:
    readBits - the new value for the number of bits read so far.
  - align
```
public void align()
```
    Aligns the stream. After a call to this function, the stream is byte aligned. Bits that have been read to align are discarded.
  - read
```
public void read(byte[] bits,
        int len)
          throws IOException
```
    Reads a sequence of bits. Bits will be read in the natural way: the first bit is bit 7 of the first byte, the eightth bit is bit 0 of the first byte, the ninth bit is bit 7 of the second byte and so on.
    
    Parameters:
    bits - an array of bytes to store the result.
    len - the number of bits to read.
    
    Throws:
    
    IOException
  - readBit
```
public int readBit()
            throws IOException
```
    Reads a bit.
    
    Returns:
    the next bit from the stream.
    
    Throws:
    
    IOException
  - readInt
```
public int readInt(int len)
            throws IOException
```
    Reads a fixed number of bits into an integer.
    
    Parameters:
    len - a bit length.
    
    Returns:
    an integer whose lower len bits are taken from the stream; the rest is zeroed.
    
    Throws:
    
    IOException
  - readLong
```
public long readLong(int len)
              throws IOException
```
    Reads a fixed number of bits into a long.
    
    Parameters:
    len - a bit length.
    
    Returns:
    a long whose lower len bits are taken from the stream; the rest is zeroed.
    
    Throws:
    
    IOException
  - skip
```
public long skip(long n)
          throws IOException
```
    Skips the given number of bits.
    
    Parameters:
    n - the number of bits to skip.
    
    Returns:
    the actual number of skipped bits.
    
    Throws:
    
    IOException
  - position
```
public void position(long position)
              throws IOException
```
    Sets this stream bit position, if it is based on a RepositionableStream or on a FileChannel.
    Given an underlying stream that implements RepositionableStream or that can provide a FileChannel via the getChannel() method, a call to this method has the same semantics of a flush(), followed by a call to position(position / 8) on the byte stream, followed by a skip(position % 8).
    
    Parameters:
    position - the new position expressed as a bit offset.
    
    Throws:
    
    UnsupportedOperationException - if the underlying byte stream does not implement RepositionableStream and if the channel it returns is not a FileChannel.
    
    IOException
    See Also:
    FileChannel.position(long)
  - markSupported
```
public boolean markSupported()
```
    Tests if this stream supports the mark(int) and reset() methods.
    This method will just delegate the test to the underlying InputStream.
    
    Returns:
    whether this stream supports mark(int)/reset().
  - mark
```
public void mark(int readLimit)
          throws IOException
```
    Marks the current position in this input stream. A subsequent call to the reset() method repositions this stream at the last marked position so that subsequent reads re-read the same bits.
    This method will just delegate the mark to the underlying InputStream. Moreover, it will throw an exception if you try to mark outsite byte boundaries.
    
    Parameters:
    readLimit - the maximum limit of bytes that can be read before the mark position becomes invalid.
    
    Throws:
    
    IOException - if you try to mark outside byte boundaries.
  - reset
```
public void reset()
           throws IOException
```
    Repositions this bit stream to the position at the time the mark(int) method was last called.
    This method will just flush the stream and delegate the reset to the underlying InputStream.
    
    Throws:
    
    IOException
  - readUnary
```
public int readUnary()
              throws IOException
```
    Reads a natural number in unary coding.
    
    Returns:
    the next unary-encoded natural number.
    
    Throws:
    
    IOException
    See Also:
    OutputBitStream.writeUnary(int)
  - readLongUnary
```
public long readLongUnary()
                   throws IOException
```
    Reads a long natural number in unary coding. Note that by unary coding we mean that 1 encodes 0, 01 encodes 1 and so on.
    
    Returns:
    the next unary-encoded long natural number.
    
    Throws:
    
    IOException
    See Also:
    OutputBitStream.writeUnary(int)
  - readGamma
```
public int readGamma()
              throws IOException
```
    Reads a natural number in γ coding.
    
    Returns:
    the next γ-encoded natural number.
    
    Throws:
    
    IOException
    See Also:
    OutputBitStream.writeGamma(int), skipGammas(int)
  - readLongGamma
```
public long readLongGamma()
                   throws IOException
```
    Reads a long natural number in γ coding.
    
    Returns:
    the next γ-encoded long natural number.
    
    Throws:
    
    IOException
    See Also:
    OutputBitStream.writeGamma(int), skipGammas(int)
  - skipGammas
```
public void skipGammas(int n)
                throws IOException
```
    Skips a given number of γ-coded integers.
    This method should be significantly quicker than iterating n times on readGamma() or readLongGamma(), as precomputed tables are used directly, so the number of method calls is greatly reduced, and the result is discarded, so skip(long) can be invoked instead of more specific decoding methods.
    
    Parameters:
    n - the number of γ-coded integers to be skipped.
    
    Throws:
    
    IOException
    See Also:
    readGamma()
  - readGammas
```
public void readGammas(int[] a,
              int count)
                throws IOException
```
    Reads a given number of γ-coded integers.
    This method should be significantly quicker than iterating n times on readGamma(), as precomputed tables are used directly, so the number of method calls is greatly reduced.
    
    Parameters:
    a - an array of at least count integers where the result wil be written starting at the first position.
    count - the number of γ-coded integers to be read.
    
    Throws:
    
    IOException
    See Also:
    readGamma()
  - readShiftedGamma
```
public int readShiftedGamma()
                     throws IOException
```
    Reads a natural number in shifted γ coding.
    
    Returns:
    the next shifted-γ–encoded natural number.
    
    Throws:
    
    IOException
    See Also:
    OutputBitStream.writeShiftedGamma(int), skipShiftedGammas(int)
  - readLongShiftedGamma
```
public long readLongShiftedGamma()
                          throws IOException
```
    Reads a natural number in shifted γ coding.
    
    Returns:
    the next shifted-γ–encoded natural number.
    
    Throws:
    
    IOException
    See Also:
    OutputBitStream.writeShiftedGamma(int), skipShiftedGammas(int)
  - skipShiftedGammas
```
public void skipShiftedGammas(int n)
                       throws IOException
```
    Skips a given number of shited-γ-coded integers.
    This method should be significantly quicker than iterating n times on readShiftedGamma() or readLongShiftedGamma(), as precomputed tables are used directly, so the number of method calls is greatly reduced, and the result is discarded, so skip(long) can be invoked instead of more specific decoding methods.
    
    Parameters:
    n - the number of shited-γ-coded integers to be skipped.
    
    Throws:
    
    IOException
    See Also:
    readShiftedGamma()
  - readShiftedGammas
```
public void readShiftedGammas(int[] a,
                     int count)
                       throws IOException
```
    Reads a given number of shifted-γ-coded integers.
    This method should be significantly quicker than iterating n times on readShiftedGamma(), as precomputed tables are used directly, so the number of method calls is greatly reduced.
    
    Parameters:
    a - an array of at least count integers where the result wil be written starting at the first position.
    count - the number of shifted-γ-coded integers to be read.
    
    Throws:
    
    IOException
    See Also:
    readShiftedGamma()
  - readDelta
```
public int readDelta()
              throws IOException
```
    Reads a natural number in δ coding.
    
    Returns:
    the next δ-encoded natural number.
    
    Throws:
    
    IOException
    See Also:
    OutputBitStream.writeDelta(int), skipDeltas(int)
  - readLongDelta
```
public long readLongDelta()
                   throws IOException
```
    Reads a long natural number in δ coding.
    
    Returns:
    the next δ-encoded long natural number.
    
    Throws:
    
    IOException
    See Also:
    OutputBitStream.writeDelta(int), skipDeltas(int)
  - skipDeltas
```
public void skipDeltas(int n)
                throws IOException
```
    Skips a given number of δ-coded integers.
    This method should be significantly quicker than iterating n times on readDelta() or readLongDelta(), as precomputed tables are used directly, so the number of method calls is greatly reduced, and the result is discarded, so skip(long) can be invoked instead of more specific decoding methods.
    
    Parameters:
    n - the number of δ-coded integers to be skipped.
    
    Throws:
    
    IOException
    See Also:
    readDelta()
  - readDeltas
```
public void readDeltas(int[] a,
              int count)
                throws IOException
```
    Reads a given number of δ-coded integers.
    This method should be significantly quicker than iterating n times on readDelta(), as precomputed tables are used directly, so the number of method calls is greatly reduced.
    
    Parameters:
    a - an array of at least count integers where the result wil be written starting at the first position.
    count - the number of δ-coded integers to be read.
    
    Throws:
    
    IOException
    See Also:
    readDelta()
  - readMinimalBinary
```
public int readMinimalBinary(int b)
                      throws IOException
```
    Reads a natural number in a limited range using a minimal binary coding.
    
    Parameters:
    b - a strict upper bound.
    
    Returns:
    the next minimally binary encoded natural number.
    
    Throws:
    
    IllegalArgumentException - if you try to read a negative number or use a nonpositive base.
    
    IOException
    See Also:
    OutputBitStream.writeMinimalBinary(int, int)
  - readMinimalBinary
```
public int readMinimalBinary(int b,
                    int log2b)
                      throws IOException
```
    Reads a natural number in a limited range using a minimal binary coding. This method is faster than readMinimalBinary(int) because it does not have to compute log2b.
    
    Parameters:
    b - a strict upper bound.
    log2b - the floor of the base-2 logarithm of the bound.
    
    Returns:
    the next minimally binary encoded natural number.
    
    Throws:
    
    IllegalArgumentException - if you try to read a negative number or use a nonpositive base.
    
    IOException
    See Also:
    OutputBitStream.writeMinimalBinary(int, int)
  - readLongMinimalBinary
```
public long readLongMinimalBinary(long b)
                           throws IOException
```
    Reads a long natural number in a limited range using a minimal binary coding.
    
    Parameters:
    b - a strict upper bound.
    
    Returns:
    the next minimally binary encoded long natural number.
    
    Throws:
    
    IllegalArgumentException - if you try to read a negative number or use a nonpositive base.
    
    IOException
    See Also:
    OutputBitStream.writeMinimalBinary(int, int)
  - readLongMinimalBinary
```
public long readLongMinimalBinary(long b,
                         int log2b)
                           throws IOException
```
    Reads a long natural number in a limited range using a minimal binary coding. This method is faster than readLongMinimalBinary(long) because it does not have to compute log2b.
    
    Parameters:
    b - a strict upper bound.
    log2b - the floor of the base-2 logarithm of the bound.
    
    Returns:
    the next minimally binary encoded long natural number.
    
    Throws:
    
    IllegalArgumentException - if you try to read a negative number or use a nonpositive base.
    
    IOException
    See Also:
    OutputBitStream.writeMinimalBinary(int, int)
  - readGolomb
```
public int readGolomb(int b)
               throws IOException
```
    Reads a natural number in Golomb coding.
    This method implements also the case in which b is 0: in this case, nothing will be read, and 0 will be returned.
    
    Parameters:
    b - the modulus for the coding.
    
    Returns:
    the next Golomb-encoded natural number.
    
    Throws:
    
    IllegalArgumentException - if you use a nonpositive modulus.
    
    IOException
    See Also:
    OutputBitStream.writeGolomb(int, int)
  - readGolomb
```
public int readGolomb(int b,
             int log2b)
               throws IOException
```
    Reads a natural number in Golomb coding. This method is faster than readGolomb(int) because it does not have to compute log2b.
    This method implements also the case in which b is 0: in this case, nothing will be read, and 0 will be returned.
    
    Parameters:
    b - the modulus for the coding.
    log2b - the floor of the base-2 logarithm of the coding modulus.
    
    Returns:
    the next Golomb-encoded natural number.
    
    Throws:
    
    IllegalArgumentException - if you use a nonpositive modulus.
    
    IOException
    See Also:
    OutputBitStream.writeGolomb(int, int)
  - readLongGolomb
```
public long readLongGolomb(long b)
                    throws IOException
```
    Reads a long natural number in Golomb coding.
    This method implements also the case in which b is 0: in this case, nothing will be read, and 0 will be returned.
    
    Parameters:
    b - the modulus for the coding.
    
    Returns:
    the next Golomb-encoded long natural number.
    
    Throws:
    
    IllegalArgumentException - if you use a nonpositive modulus.
    
    IOException
    See Also:
    OutputBitStream.writeGolomb(int, int)
  - readLongGolomb
```
public long readLongGolomb(long b,
                  int log2b)
                    throws IOException
```
    Reads a long natural number in Golomb coding. This method is faster than readLongGolomb(long) because it does not have to compute log2b.
    This method implements also the case in which b is 0: in this case, nothing will be read, and 0 will be returned.
    
    Parameters:
    b - the modulus for the coding.
    log2b - the floor of the base-2 logarithm of the coding modulus.
    
    Returns:
    the next Golomb-encoded long natural number.
    
    Throws:
    
    IllegalArgumentException - if you use a nonpositive modulus.
    
    IOException
    See Also:
    OutputBitStream.writeGolomb(int, int)
  - readSkewedGolomb
```
public int readSkewedGolomb(int b)
                     throws IOException
```
    Reads a natural number in skewed Golomb coding.
    This method implements also the case in which b is 0: in this case, nothing will be read, and 0 will be returned.
    
    Parameters:
    b - the modulus for the coding.
    
    Returns:
    the next skewed Golomb-encoded natural number.
    
    Throws:
    
    IllegalArgumentException - if you use a negative modulus.
    
    IOException
    See Also:
    OutputBitStream.writeSkewedGolomb(int, int)
  - readLongSkewedGolomb
```
public long readLongSkewedGolomb(long b)
                          throws IOException
```
    Reads a long natural number in skewed Golomb coding.
    This method implements also the case in which b is 0: in this case, nothing will be read, and 0 will be returned.
    
    Parameters:
    b - the modulus for the coding.
    
    Returns:
    the next skewed Golomb-encoded long natural number.
    
    Throws:
    
    IllegalArgumentException - if you use a negative modulus.
    
    IOException
    See Also:
    OutputBitStream.writeSkewedGolomb(int, int)
  - readZeta
```
public int readZeta(int k)
             throws IOException
```
    Reads a natural number in ζ coding.
    
    Parameters:
    k - the shrinking factor.
    
    Returns:
    the next ζ-encoded natural number.
    
    Throws:
    
    IllegalArgumentException - if you use a nonpositive shrinking factor.
    
    IOException
    See Also:
    OutputBitStream.writeZeta(int, int)
  - readLongZeta
```
public long readLongZeta(int k)
                  throws IOException
```
    Reads a long natural number in ζ coding.
    
    Parameters:
    k - the shrinking factor.
    
    Returns:
    the next ζ-encoded long natural number.
    
    Throws:
    
    IllegalArgumentException - if you use a nonpositive shrinking factor.
    
    IOException
    See Also:
    OutputBitStream.writeZeta(int, int)
  - skipZetas
```
public void skipZetas(int k,
             int n)
               throws IOException
```
    Skips a given number of ζ-coded integers.
    This method should be significantly quicker than iterating n times on readZeta(int) or readLongZeta(int), as precomputed tables are used directly, so the number of method calls is greatly reduced, and the result is discarded, so skip(long) can be invoked instead of more specific decoding methods.
    
    Parameters:
    k - the shrinking factor.
    n - the number of ζ-coded integers to be skipped.
    
    Throws:
    
    IOException
    See Also:
    readZeta(int)
  - readZetas
```
public void readZetas(int k,
             int[] a,
             int count)
               throws IOException
```
    Reads a given number of γ-coded integers.
    This method should be significantly quicker than iterating n times on readGamma(), as precomputed tables are used directly, so the number of method calls is greatly reduced.
    
    Parameters:
    k - the shrinking factor.
    a - an array of at least count integers where the result wil be written starting at the first position.
    count - the number of ζ-coded integers to be read.
    
    Throws:
    
    IOException
    See Also:
    readGamma()
  - readNibble
```
public int readNibble()
               throws IOException
```
    Reads a natural number in variable-length nibble coding.
    
    Returns:
    the next variable-length nibble-encoded natural number.
    
    Throws:
    
    IOException
    See Also:
    OutputBitStream.writeNibble(int)
  - readLongNibble
```
public long readLongNibble()
                    throws IOException
```
    Reads a long natural number in variable-length nibble coding.
    
    Returns:
    the next variable-length nibble-encoded long natural number.
    
    Throws:
    
    IOException
    See Also:
    OutputBitStream.writeNibble(int)
  - hasNext
```
public boolean hasNext()
```
    Specified by:
    
    hasNext in interface Iterator<Boolean>
  - nextBoolean
```
public boolean nextBoolean()
```
    Specified by:
    
    nextBoolean in interface it.unimi.dsi.fastutil.booleans.BooleanIterator
    
    Overrides:
    
    nextBoolean in class it.unimi.dsi.fastutil.booleans.AbstractBooleanIterator
  - skip
```
@Deprecated
public int skip(int n)
```
    Deprecated. This method is simply an expensive, try/catch-surrounded version of skip(long) that is made necessary by the interface by BooleanIterator.
    
    Skips over the given number of bits.
    
    Specified by:
    
    skip in interface it.unimi.dsi.fastutil.booleans.BooleanIterator
    
    Overrides:
    
    skip in class it.unimi.dsi.fastutil.booleans.AbstractBooleanIterator
    
    Parameters:
    n - the number of bits to skip.
    
    Returns:
    the number of bits actually skipped.

Class InputBitStream

Field Summary

Constructor Summary

Method Summary

Methods inherited from class it.unimi.dsi.fastutil.booleans.AbstractBooleanIterator

Methods inherited from class java.lang.Object

Field Detail

GAMMA

DELTA

ZETA_3

SHIFTED_GAMMA

DEFAULT_BUFFER_SIZE

is

fileChannel

repositionableStream

wrapping

buffer

fill

pos

avail

position

Constructor Detail

InputBitStream

InputBitStream

InputBitStream

InputBitStream

InputBitStream

InputBitStream

InputBitStream

InputBitStream

InputBitStream

InputBitStream

InputBitStream

InputBitStream

InputBitStream

Method Detail

flush

close

available

readBits

readBits

align

read

readBit

readInt

readLong

skip

position

markSupported

mark

reset

readUnary

readLongUnary

readGamma

readLongGamma

skipGammas

readGammas

readShiftedGamma

readLongShiftedGamma

skipShiftedGammas

readShiftedGammas

readDelta

readLongDelta

skipDeltas

readDeltas

readMinimalBinary

readMinimalBinary

readLongMinimalBinary

readLongMinimalBinary

readGolomb

readGolomb

readLongGolomb

readLongGolomb

readSkewedGolomb

readLongSkewedGolomb

readZeta

readLongZeta

skipZetas

readZetas

readNibble