org.apache.thrift.protocol

## Class TCompactProtocol

- java.lang.Object
- - org.apache.thrift.protocol.TProtocol
  - - org.apache.thrift.protocol.TCompactProtocol

-     public final class TCompactProtocol
      extends TProtocol

  TCompactProtocol2 is the Java implementation of the compact protocol specified in THRIFT-110. The fundamental approach to reducing the overhead of structures is a) use variable-length integers all over the place and b) make use of unused bits wherever possible. Your savings will obviously vary based on the specific makeup of your structs, but in general, the more fields, nested structures, short strings and collections, and low-value i32 and i64 fields you have, the more benefit you'll see.

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `TCompactProtocol.Factory` TProtocolFactory that produces TCompactProtocols.

  - ### Field Summary

    - ### Fields inherited from class org.apache.thrift.protocol.TProtocol

      `trans_`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `TCompactProtocol(TTransport transport)` Create a TCompactProtocol.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `java.nio.ByteBuffer` | `readBinary()` Read a byte[] from the wire.
    `boolean` | `readBool()` Read a boolean off the wire.
    `byte` | `readByte()` Read a single byte off the wire.
    `double` | `readDouble()` No magic here - just read a double off the wire.
    `TField` | `readFieldBegin()` Read a field header off the wire.
    `void` | `readFieldEnd()`
    `short` | `readI16()` Read an i16 from the wire as a zigzag varint.
    `int` | `readI32()` Read an i32 from the wire as a zigzag varint.
    `long` | `readI64()` Read an i64 from the wire as a zigzag varint.
    `TList` | `readListBegin()` Read a list header off the wire.
    `void` | `readListEnd()`
    `TMap` | `readMapBegin()` Read a map header off the wire.
    `void` | `readMapEnd()`
    `TMessage` | `readMessageBegin()` Read a message header.
    `void` | `readMessageEnd()`
    `TSet` | `readSetBegin()` Read a set header off the wire.
    `void` | `readSetEnd()`
    `java.lang.String` | `readString()` Reads a byte[] (via readBinary), and then UTF-8 decodes it.
    `TStruct` | `readStructBegin()` Read a struct begin.
    `void` | `readStructEnd()` Doesn't actually consume any wire data, just removes the last field for this struct from the field stack.
    `void` | `reset()` Reset any internal state back to a blank slate.
    `void` | `writeBinary(java.nio.ByteBuffer bin)` Write a byte array, using a varint for the size.
    `void` | `writeBool(boolean b)` Write a boolean value.
    `void` | `writeByte(byte b)` Write a byte.
    `protected void` | `writeCollectionBegin(byte elemType, int size)` Abstract method for writing the start of lists and sets.
    `void` | `writeDouble(double dub)` Write a double to the wire as 8 bytes.
    `void` | `writeFieldBegin(TField field)` Write a field header containing the field id and field type.
    `void` | `writeFieldEnd()`
    `void` | `writeFieldStop()` Write the STOP symbol so we know there are no more fields in this struct.
    `void` | `writeI16(short i16)` Write an I16 as a zigzag varint.
    `void` | `writeI32(int i32)` Write an i32 as a zigzag varint.
    `void` | `writeI64(long i64)` Write an i64 as a zigzag varint.
    `void` | `writeListBegin(TList list)` Write a list header.
    `void` | `writeListEnd()`
    `void` | `writeMapBegin(TMap map)` Write a map header.
    `void` | `writeMapEnd()`
    `void` | `writeMessageBegin(TMessage message)` Write a message header to the wire.
    `void` | `writeMessageEnd()`
    `void` | `writeSetBegin(TSet set)` Write a set header.
    `void` | `writeSetEnd()`
    `void` | `writeString(java.lang.String str)` Write a string to the wire with a varint size preceding.
    `void` | `writeStructBegin(TStruct struct)` Write a struct begin.
    `void` | `writeStructEnd()` Write a struct end.

    - ### Methods inherited from class org.apache.thrift.protocol.TProtocol

      `getTransport`

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

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

- - ### Constructor Detail

    - #### TCompactProtocol

          public TCompactProtocol(TTransport transport)

      Create a TCompactProtocol.
      Parameters:
        `transport` - the TTransport object to read from or write to.

  - ### Method Detail

    - #### reset

          public void reset()

      Description copied from class: `TProtocol`
      Reset any internal state back to a blank slate. This method only needs to be implemented for stateful protocols.
      Overrides:
        `reset` in class `TProtocol`

    - #### writeMessageBegin

          public void writeMessageBegin(TMessage message)
                                 throws TException

      Write a message header to the wire. Compact Protocol messages contain the protocol version so we can migrate forwards in the future if need be.
      Specified by:
        `writeMessageBegin` in class `TProtocol`
      Throws:
        `TException`

    - #### writeStructBegin

          public void writeStructBegin(TStruct struct)
                                throws TException

      Write a struct begin. This doesn't actually put anything on the wire. We use it as an opportunity to put special placeholder markers on the field stack so we can get the field id deltas correct.
      Specified by:
        `writeStructBegin` in class `TProtocol`
      Throws:
        `TException`

    - #### writeStructEnd

          public void writeStructEnd()
                              throws TException

      Write a struct end. This doesn't actually put anything on the wire. We use this as an opportunity to pop the last field from the current struct off of the field stack.
      Specified by:
        `writeStructEnd` in class `TProtocol`
      Throws:
        `TException`

    - #### writeFieldBegin

          public void writeFieldBegin(TField field)
                               throws TException

      Write a field header containing the field id and field type. If the difference between the current field id and the last one is small (< 15), then the field id will be encoded in the 4 MSB as a delta. Otherwise, the field id will follow the type header as a zigzag varint.
      Specified by:
        `writeFieldBegin` in class `TProtocol`
      Throws:
        `TException`

    - #### writeFieldStop

          public void writeFieldStop()
                              throws TException

      Write the STOP symbol so we know there are no more fields in this struct.
      Specified by:
        `writeFieldStop` in class `TProtocol`
      Throws:
        `TException`

    - #### writeMapBegin

          public void writeMapBegin(TMap map)
                             throws TException

      Write a map header. If the map is empty, omit the key and value type headers, as we don't need any additional information to skip it.
      Specified by:
        `writeMapBegin` in class `TProtocol`
      Throws:
        `TException`

    - #### writeListBegin

          public void writeListBegin(TList list)
                              throws TException

      Write a list header.
      Specified by:
        `writeListBegin` in class `TProtocol`
      Throws:
        `TException`

    - #### writeSetBegin

          public void writeSetBegin(TSet set)
                             throws TException

      Write a set header.
      Specified by:
        `writeSetBegin` in class `TProtocol`
      Throws:
        `TException`

    - #### writeBool

          public void writeBool(boolean b)
                         throws TException

      Write a boolean value. Potentially, this could be a boolean field, in which case the field header info isn't written yet. If so, decide what the right type header is for the value and then write the field header. Otherwise, write a single byte.
      Specified by:
        `writeBool` in class `TProtocol`
      Throws:
        `TException`

    - #### writeByte

          public void writeByte(byte b)
                         throws TException

      Write a byte. Nothing to see here!
      Specified by:
        `writeByte` in class `TProtocol`
      Throws:
        `TException`

    - #### writeI16

          public void writeI16(short i16)
                        throws TException

      Write an I16 as a zigzag varint.
      Specified by:
        `writeI16` in class `TProtocol`
      Throws:
        `TException`

    - #### writeI32

          public void writeI32(int i32)
                        throws TException

      Write an i32 as a zigzag varint.
      Specified by:
        `writeI32` in class `TProtocol`
      Throws:
        `TException`

    - #### writeI64

          public void writeI64(long i64)
                        throws TException

      Write an i64 as a zigzag varint.
      Specified by:
        `writeI64` in class `TProtocol`
      Throws:
        `TException`

    - #### writeDouble

          public void writeDouble(double dub)
                           throws TException

      Write a double to the wire as 8 bytes.
      Specified by:
        `writeDouble` in class `TProtocol`
      Throws:
        `TException`

    - #### writeString

          public void writeString(java.lang.String str)
                           throws TException

      Write a string to the wire with a varint size preceding.
      Specified by:
        `writeString` in class `TProtocol`
      Throws:
        `TException`

    - #### writeBinary

          public void writeBinary(java.nio.ByteBuffer bin)
                           throws TException

      Write a byte array, using a varint for the size.
      Specified by:
        `writeBinary` in class `TProtocol`
      Throws:
        `TException`

    - #### writeMessageEnd

          public void writeMessageEnd()
                               throws TException

      Specified by:
        `writeMessageEnd` in class `TProtocol`
      Throws:
        `TException`

    - #### writeMapEnd

          public void writeMapEnd()
                           throws TException

      Specified by:
        `writeMapEnd` in class `TProtocol`
      Throws:
        `TException`

    - #### writeListEnd

          public void writeListEnd()
                            throws TException

      Specified by:
        `writeListEnd` in class `TProtocol`
      Throws:
        `TException`

    - #### writeSetEnd

          public void writeSetEnd()
                           throws TException

      Specified by:
        `writeSetEnd` in class `TProtocol`
      Throws:
        `TException`

    - #### writeFieldEnd

          public void writeFieldEnd()
                             throws TException

      Specified by:
        `writeFieldEnd` in class `TProtocol`
      Throws:
        `TException`

    - #### writeCollectionBegin

          protected void writeCollectionBegin(byte elemType,
                                  int size)
                                       throws TException

      Abstract method for writing the start of lists and sets. List and sets on the wire differ only by the type indicator.
      Throws:
        `TException`

    - #### readMessageBegin

          public TMessage readMessageBegin()
                                    throws TException

      Read a message header.
      Specified by:
        `readMessageBegin` in class `TProtocol`
      Throws:
        `TException`

    - #### readStructBegin

          public TStruct readStructBegin()
                                  throws TException

      Read a struct begin. There's nothing on the wire for this, but it is our opportunity to push a new struct begin marker onto the field stack.
      Specified by:
        `readStructBegin` in class `TProtocol`
      Throws:
        `TException`

    - #### readStructEnd

          public void readStructEnd()
                             throws TException

      Doesn't actually consume any wire data, just removes the last field for this struct from the field stack.
      Specified by:
        `readStructEnd` in class `TProtocol`
      Throws:
        `TException`

    - #### readFieldBegin

          public TField readFieldBegin()
                                throws TException

      Read a field header off the wire.
      Specified by:
        `readFieldBegin` in class `TProtocol`
      Throws:
        `TException`

    - #### readMapBegin

          public TMap readMapBegin()
                            throws TException

      Read a map header off the wire. If the size is zero, skip reading the key and value type. This means that 0-length maps will yield TMaps without the "correct" types.
      Specified by:
        `readMapBegin` in class `TProtocol`
      Throws:
        `TException`

    - #### readListBegin

          public TList readListBegin()
                              throws TException

      Read a list header off the wire. If the list size is 0-14, the size will be packed into the element type header. If it's a longer list, the 4 MSB of the element type header will be 0xF, and a varint will follow with the true size.
      Specified by:
        `readListBegin` in class `TProtocol`
      Throws:
        `TException`

    - #### readSetBegin

          public TSet readSetBegin()
                            throws TException

      Read a set header off the wire. If the set size is 0-14, the size will be packed into the element type header. If it's a longer set, the 4 MSB of the element type header will be 0xF, and a varint will follow with the true size.
      Specified by:
        `readSetBegin` in class `TProtocol`
      Throws:
        `TException`

    - #### readBool

          public boolean readBool()
                           throws TException

      Read a boolean off the wire. If this is a boolean field, the value should already have been read during readFieldBegin, so we'll just consume the pre-stored value. Otherwise, read a byte.
      Specified by:
        `readBool` in class `TProtocol`
      Throws:
        `TException`

    - #### readByte

          public byte readByte()
                        throws TException

      Read a single byte off the wire. Nothing interesting here.
      Specified by:
        `readByte` in class `TProtocol`
      Throws:
        `TException`

    - #### readI16

          public short readI16()
                        throws TException

      Read an i16 from the wire as a zigzag varint.
      Specified by:
        `readI16` in class `TProtocol`
      Throws:
        `TException`

    - #### readI32

          public int readI32()
                      throws TException

      Read an i32 from the wire as a zigzag varint.
      Specified by:
        `readI32` in class `TProtocol`
      Throws:
        `TException`

    - #### readI64

          public long readI64()
                       throws TException

      Read an i64 from the wire as a zigzag varint.
      Specified by:
        `readI64` in class `TProtocol`
      Throws:
        `TException`

    - #### readDouble

          public double readDouble()
                            throws TException

      No magic here - just read a double off the wire.
      Specified by:
        `readDouble` in class `TProtocol`
      Throws:
        `TException`

    - #### readString

          public java.lang.String readString()
                                      throws TException

      Reads a byte[] (via readBinary), and then UTF-8 decodes it.
      Specified by:
        `readString` in class `TProtocol`
      Throws:
        `TException`

    - #### readBinary

          public java.nio.ByteBuffer readBinary()
                                         throws TException

      Read a byte[] from the wire.
      Specified by:
        `readBinary` in class `TProtocol`
      Throws:
        `TException`

    - #### readMessageEnd

          public void readMessageEnd()
                              throws TException

      Specified by:
        `readMessageEnd` in class `TProtocol`
      Throws:
        `TException`

    - #### readFieldEnd

          public void readFieldEnd()
                            throws TException

      Specified by:
        `readFieldEnd` in class `TProtocol`
      Throws:
        `TException`

    - #### readMapEnd

          public void readMapEnd()
                          throws TException

      Specified by:
        `readMapEnd` in class `TProtocol`
      Throws:
        `TException`

    - #### readListEnd

          public void readListEnd()
                           throws TException

      Specified by:
        `readListEnd` in class `TProtocol`
      Throws:
        `TException`

    - #### readSetEnd

          public void readSetEnd()
                          throws TException

      Specified by:
        `readSetEnd` in class `TProtocol`
      Throws:
        `TException`