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

All Implemented Interfaces:

TReadProtocol, TWriteProtocol

Direct Known Subclasses:

TTupleProtocol
```
public 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 Description

static class TCompactProtocol.Factory
TProtocolFactory that produces TCompactProtocols.
- Nested classes/interfaces inherited from class org.apache.thrift.protocol.TProtocol
  TProtocol.ReadCallback<T,R>, TProtocol.ReadCollectionCallback<R>, TProtocol.ReadMapEntryCallback<K,V>, TProtocol.WriteCallback<T>

Field Summary
- Fields inherited from class org.apache.thrift.protocol.TProtocol
  skippedBytes, trans_

Constructor Summary

Constructors
Constructor	Description
`TCompactProtocol(TTransport transport)`	Create a TCompactProtocol.
`TCompactProtocol(TTransport transport, long stringLengthLimit)`	Deprecated. Use constructor specifying both string limit and container limit instead
`TCompactProtocol(TTransport transport, long stringLengthLimit, long containerLengthLimit)`	Create a TCompactProtocol.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`int`	`getMinSerializedSize(byte type)`	Return the minimum number of bytes a type will consume on the wire
`java.nio.ByteBuffer`	`readBinary()`	Read a ByteBuffer 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.
`protected void`	`skipBinary()`
`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
checkReadBytesAvailable, checkReadBytesAvailable, checkReadBytesAvailable, getScheme, getTransport, readField, readFieldBeginData, readList, readList, readList, readMap, readMap, readMap, readMessage, readSet, readSet, readSet, readStruct, skip, skip, skipBool, skipByte, skipBytes, skipDouble, skipI16, skipI32, skipI64, writeField, writeList, writeMap, writeMessage, writeSet, writeStruct

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,
                        long stringLengthLimit,
                        long containerLengthLimit)
```
    Create a TCompactProtocol.
    
    Parameters:
    
    transport - the TTransport object to read from or write to.
    
    stringLengthLimit - the maximum number of bytes to read for variable-length fields.
    
    containerLengthLimit - the maximum number of elements to read for containers.
  - TCompactProtocol
```
@Deprecated
public TCompactProtocol(TTransport transport,
                        long stringLengthLimit)
```
    Deprecated.
    Use constructor specifying both string limit and container limit instead
    
    Create a TCompactProtocol.
    
    Parameters:
    
    transport - the TTransport object to read from or write to.
    
    stringLengthLimit - the maximum number of bytes to read for variable-length fields.
  - 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.
    
    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.
    
    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.
    
    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.
    
    Throws:
    
    TException
  - writeFieldStop
```
public void writeFieldStop()
                    throws TException
```
    Write the STOP symbol so we know there are no more fields in this struct.
    
    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.
    
    Throws:
    
    TException
  - writeListBegin
```
public void writeListBegin(TList list)
                    throws TException
```
    Write a list header.
    
    Throws:
    
    TException
  - writeSetBegin
```
public void writeSetBegin(TSet set)
                   throws TException
```
    Write a set header.
    
    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.
    
    Throws:
    
    TException
  - writeByte
```
public void writeByte(byte b)
               throws TException
```
    Write a byte. Nothing to see here!
    
    Throws:
    
    TException
  - writeI16
```
public void writeI16(short i16)
              throws TException
```
    Write an I16 as a zigzag varint.
    
    Throws:
    
    TException
  - writeI32
```
public void writeI32(int i32)
              throws TException
```
    Write an i32 as a zigzag varint.
    
    Throws:
    
    TException
  - writeI64
```
public void writeI64(long i64)
              throws TException
```
    Write an i64 as a zigzag varint.
    
    Throws:
    
    TException
  - writeDouble
```
public void writeDouble(double dub)
                 throws TException
```
    Write a double to the wire as 8 bytes.
    
    Throws:
    
    TException
  - writeString
```
public void writeString(java.lang.String str)
                 throws TException
```
    Write a string to the wire with a varint size preceding.
    
    Throws:
    
    TException
  - writeBinary
```
public void writeBinary(java.nio.ByteBuffer bin)
                 throws TException
```
    Write a byte array, using a varint for the size.
    
    Throws:
    
    TException
  - writeMessageEnd
```
public void writeMessageEnd()
                     throws TException
```
    Throws:
    
    TException
  - writeMapEnd
```
public void writeMapEnd()
                 throws TException
```
    Throws:
    
    TException
  - writeListEnd
```
public void writeListEnd()
                  throws TException
```
    Throws:
    
    TException
  - writeSetEnd
```
public void writeSetEnd()
                 throws TException
```
    Throws:
    
    TException
  - writeFieldEnd
```
public void writeFieldEnd()
                   throws TException
```
    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.
    
    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.
    
    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.
    
    Throws:
    
    TException
  - readFieldBegin
```
public TField readFieldBegin()
                      throws TException
```
    Read a field header off the wire.
    
    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.
    
    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.
    
    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.
    
    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.
    
    Throws:
    
    TException
  - readByte
```
public byte readByte()
              throws TException
```
    Read a single byte off the wire. Nothing interesting here.
    
    Throws:
    
    TException
  - readI16
```
public short readI16()
              throws TException
```
    Read an i16 from the wire as a zigzag varint.
    
    Throws:
    
    TException
  - readI32
```
public int readI32()
            throws TException
```
    Read an i32 from the wire as a zigzag varint.
    
    Throws:
    
    TException
  - readI64
```
public long readI64()
             throws TException
```
    Read an i64 from the wire as a zigzag varint.
    
    Throws:
    
    TException
  - readDouble
```
public double readDouble()
                  throws TException
```
    No magic here - just read a double off the wire.
    
    Throws:
    
    TException
  - readString
```
public java.lang.String readString()
                            throws TException
```
    Reads a byte[] (via readBinary), and then UTF-8 decodes it.
    
    Throws:
    
    TException
  - readBinary
```
public java.nio.ByteBuffer readBinary()
                               throws TException
```
    Read a ByteBuffer from the wire.
    
    Throws:
    
    TException
  - readMessageEnd
```
public void readMessageEnd()
                    throws TException
```
    Throws:
    
    TException
  - readFieldEnd
```
public void readFieldEnd()
                  throws TException
```
    Throws:
    
    TException
  - readMapEnd
```
public void readMapEnd()
                throws TException
```
    Throws:
    
    TException
  - readListEnd
```
public void readListEnd()
                 throws TException
```
    Throws:
    
    TException
  - readSetEnd
```
public void readSetEnd()
                throws TException
```
    Throws:
    
    TException
  - getMinSerializedSize
```
public int getMinSerializedSize(byte type)
                         throws TTransportException
```
    Return the minimum number of bytes a type will consume on the wire
    
    Specified by:
    
    getMinSerializedSize in class TProtocol
    
    Parameters:
    
    type - Returns the minimum amount of bytes needed to store the smallest possible instance of TType.
    
    Returns:
    
    min serialized size
    
    Throws:
    
    TTransportException
  - skipBinary
```
protected void skipBinary()
                   throws TException
```
    Overrides:
    
    skipBinary in class TProtocol
    
    Throws:
    
    TException

Class TCompactProtocol

Nested Class Summary

Nested classes/interfaces inherited from class org.apache.thrift.protocol.TProtocol

Field Summary

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

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

Constructor Detail

TCompactProtocol

TCompactProtocol

TCompactProtocol

Method Detail

reset

writeMessageBegin

writeStructBegin

writeStructEnd

writeFieldBegin

writeFieldStop

writeMapBegin

writeListBegin

writeSetBegin

writeBool

writeByte

writeI16

writeI32

writeI64

writeDouble

writeString

writeBinary

writeMessageEnd

writeMapEnd

writeListEnd

writeSetEnd

writeFieldEnd

writeCollectionBegin

readMessageBegin

readStructBegin

readStructEnd

readFieldBegin

readMapBegin

readListBegin

readSetBegin

readBool

readByte

readI16

readI32

readI64

readDouble

readString

readBinary

readMessageEnd

readFieldEnd

readMapEnd

readListEnd

readSetEnd

getMinSerializedSize

skipBinary