Class DataOutput

    • Constructor Detail

      • DataOutput

        public DataOutput()
    • Method Detail

      • writeByte

        public abstract void writeByte​(byte b)
                                throws IOException
        Writes a single byte.

        The most primitive data type is an eight-bit byte. Files are accessed as sequences of bytes. All other data types are defined as sequences of bytes, so file formats are byte-order independent.

        Throws:
        IOException
        See Also:
        DataInput.readByte()
      • writeBytes

        public abstract void writeBytes​(byte[] b,
                                        int offset,
                                        int length)
                                 throws IOException
        Writes an array of bytes.
        Parameters:
        b - the bytes to write
        offset - the offset in the byte array
        length - the number of bytes to write
        Throws:
        IOException
        See Also:
        DataInput.readBytes(byte[],int,int)
      • writeVInt

        public final void writeVInt​(int i)
                             throws IOException
        Writes an int in a variable-length format. Writes between one and five bytes. Smaller values take fewer bytes. Negative numbers are supported, but should be avoided.

        VByte is a variable-length format for positive integers is defined where the high-order bit of each byte indicates whether more bytes remain to be read. The low-order seven bits are appended as increasingly more significant bits in the resulting integer value. Thus values from zero to 127 may be stored in a single byte, values from 128 to 16,383 may be stored in two bytes, and so on.

        VByte Encoding Example

        variable length encoding examples
        Value Byte 1 Byte 2 Byte 3
        0 00000000
        1 00000001
        2 00000010
        ...
        127 01111111
        128 10000000 00000001
        129 10000001 00000001
        130 10000010 00000001
        ...
        16,383 11111111 01111111
        16,384 10000000 10000000 00000001
        16,385 10000001 10000000 00000001
        ...

        This provides compression while still being efficient to decode.

        Parameters:
        i - Smaller values take fewer bytes. Negative numbers are supported, but should be avoided.
        Throws:
        IOException - If there is an I/O error writing to the underlying medium.
        See Also:
        DataInput.readVInt()
      • writeVLong

        public final void writeVLong​(long i)
                              throws IOException
        Writes an long in a variable-length format. Writes between one and nine bytes. Smaller values take fewer bytes. Negative numbers are not supported.

        The format is described further in writeVInt(int).

        Throws:
        IOException
        See Also:
        DataInput.readVLong()
      • writeGroupVInts

        public void writeGroupVInts​(long[] values,
                                    int limit)
                             throws IOException
        Encode integers using group-varint. It uses VInt to encode tail values that are not enough for a group. we need a long[] because this is what postings are using, all longs are actually required to be integers.
        Parameters:
        values - the values to write
        limit - the number of values to write.
        Throws:
        IOException
        WARNING: This API is experimental and might change in incompatible ways in the next release.