ProtoSink (quickbuf-runtime 1.4 API)

java.lang.Object
- us.hebi.quickbuf.ProtoSink

```
public abstract class ProtoSink
extends Object
```
NOTE: the code was modified from Javanano's CodedOutputByteBufferNano Encodes and writes protocol message fields.
This class contains two kinds of methods: methods that write specific protocol message constructs and field types (e.g. writeTag(int, int) and writeInt32(int, int)) and methods that write low-level values (e.g. writeRawVarint32(int) and writeRawBytes(byte[])). If you are writing encoded protocol messages, you should use the former methods, but if you are writing some other format of your own design, use the latter.
This class is totally unsynchronized.

Author:

kneton@google.com Kenton Varda, Florian Enner

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`ProtoSink.OutOfSpaceException` If you create a ProtoSink around a simple flat array, you must not attempt to write more bytes than the array has space.

Constructor Summary

Constructors
Modifier Constructor and Description

protected ProtoSink()

Constructors
Modifier	Constructor and Description
`protected`	`ProtoSink()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`checkNoSpaceLeft()` Verifies that `spaceLeft()` returns zero.
`abstract ProtoSink`	`clear()` Clears internal state and removes any references to previous outputs.
`static int`	`computeBoolSize(int fieldNumber, boolean value)` Compute the number of bytes that would be needed to encode a `bool` field, including tag.
`static int`	`computeBoolSizeNoTag(boolean value)` Compute the number of bytes that would be needed to encode a `bool` field.
`static int`	`computeBytesSize(int fieldNumber, RepeatedByte value)` Compute the number of bytes that would be needed to encode a `bytes` field, including tag.
`static int`	`computeBytesSizeNoTag(RepeatedByte value)` Compute the number of bytes that would be needed to encode a `bytes` field.
`static int`	`computeDelimitedSize(int length)` Compute the number of bytes that would be needed to encode length bytes and a length delimiter.
`static int`	`computeDoubleSize(int fieldNumber, double value)` Compute the number of bytes that would be needed to encode a `double` field, including tag.
`static int`	`computeDoubleSizeNoTag(double value)` Compute the number of bytes that would be needed to encode a `double` field, including tag.
`static int`	`computeEnumSize(int fieldNumber, int value)` Compute the number of bytes that would be needed to encode an enum field, including tag.
`static int`	`computeEnumSizeNoTag(int value)` Compute the number of bytes that would be needed to encode an enum field.
`static int`	`computeFixed32Size(int fieldNumber, int value)` Compute the number of bytes that would be needed to encode a `fixed32` field, including tag.
`static int`	`computeFixed32SizeNoTag(int value)` Compute the number of bytes that would be needed to encode a `fixed32` field.
`static int`	`computeFixed64Size(int fieldNumber, long value)` Compute the number of bytes that would be needed to encode a `fixed64` field, including tag.
`static int`	`computeFixed64SizeNoTag(long value)` Compute the number of bytes that would be needed to encode a `fixed64` field.
`static int`	`computeFloatSize(int fieldNumber, float value)` Compute the number of bytes that would be needed to encode a `float` field, including tag.
`static int`	`computeFloatSizeNoTag(float value)` Compute the number of bytes that would be needed to encode a `float` field, including tag.
`static int`	`computeGroupSize(int fieldNumber, ProtoMessage<?> value)` Compute the number of bytes that would be needed to encode a `group` field, including tag.
`static int`	`computeGroupSizeNoTag(ProtoMessage value)` Compute the number of bytes that would be needed to encode a `group` field.
`static int`	`computeInt32Size(int fieldNumber, int value)` Compute the number of bytes that would be needed to encode an `int32` field, including tag.
`static int`	`computeInt32SizeNoTag(int value)` Compute the number of bytes that would be needed to encode an `int32` field, including tag.
`static int`	`computeInt64Size(int fieldNumber, long value)` Compute the number of bytes that would be needed to encode an `int64` field, including tag.
`static int`	`computeInt64SizeNoTag(long value)` Compute the number of bytes that would be needed to encode an `int64` field, including tag.
`static int`	`computeMessageSize(int fieldNumber, ProtoMessage<?> value)` Compute the number of bytes that would be needed to encode an embedded message field, including tag.
`static int`	`computeMessageSizeNoTag(ProtoMessage value)` Compute the number of bytes that would be needed to encode an embedded message field.
`static int`	`computeRawVarint32Size(int value)` Compute the number of bytes that would be needed to encode a varint.
`static int`	`computeRawVarint64Size(long value)` Compute the number of bytes that would be needed to encode a varint.
`static int`	`computeRepeatedBytesSizeNoTag(RepeatedBytes values)` Compute the number of bytes needed to encode all contained `bytes` values
`static int`	`computeRepeatedEnumSizeNoTag(RepeatedEnum<?> values)` Compute the number of bytes needed to encode all contained `enum` values
`static int`	`computeRepeatedGroupSizeNoTag(RepeatedMessage<?> values)` Compute the number of bytes needed to encode all contained `message` values
`static int`	`computeRepeatedInt32SizeNoTag(RepeatedInt values)` Compute the number of bytes needed to encode all contained `int32` values
`static int`	`computeRepeatedInt64SizeNoTag(RepeatedLong values)` Compute the number of bytes needed to encode all contained `int32` values
`static int`	`computeRepeatedMessageSizeNoTag(RepeatedMessage<?> values)` Compute the number of bytes needed to encode all contained `message` values
`static int`	`computeRepeatedSInt32SizeNoTag(RepeatedInt values)` Compute the number of bytes needed to encode all contained `sint32` values
`static int`	`computeRepeatedSInt64SizeNoTag(RepeatedLong values)` Compute the number of bytes needed to encode all contained `sint64` values
`static int`	`computeRepeatedStringSizeNoTag(RepeatedString values)` Compute the number of bytes needed to encode all contained `string` values
`static int`	`computeRepeatedUInt32SizeNoTag(RepeatedInt values)` Compute the number of bytes needed to encode all contained `uint32` values
`static int`	`computeRepeatedUInt64SizeNoTag(RepeatedLong values)` Compute the number of bytes needed to encode all contained `uint64` values
`static int`	`computeSFixed32Size(int fieldNumber, int value)` Compute the number of bytes that would be needed to encode an `sfixed32` field, including tag.
`static int`	`computeSFixed32SizeNoTag(int value)` Compute the number of bytes that would be needed to encode an `sfixed32` field.
`static int`	`computeSFixed64Size(int fieldNumber, long value)` Compute the number of bytes that would be needed to encode an `sfixed64` field, including tag.
`static int`	`computeSFixed64SizeNoTag(long value)` Compute the number of bytes that would be needed to encode an `sfixed64` field.
`static int`	`computeSInt32Size(int fieldNumber, int value)` Compute the number of bytes that would be needed to encode an `sint32` field, including tag.
`static int`	`computeSInt32SizeNoTag(int value)` Compute the number of bytes that would be needed to encode an `sint32` field.
`static int`	`computeSInt64Size(int fieldNumber, long value)` Compute the number of bytes that would be needed to encode an `sint64` field, including tag.
`static int`	`computeSInt64SizeNoTag(long value)` Compute the number of bytes that would be needed to encode an `sint64` field.
`static int`	`computeStringSize(int fieldNumber, CharSequence value)` Compute the number of bytes that would be needed to encode a `string` field, including tag.
`static int`	`computeStringSizeNoTag(CharSequence value)` Compute the number of bytes that would be needed to encode a `string` field.
`static int`	`computeStringSizeNoTag(Utf8String value)` Compute the number of bytes that would be needed to encode a `string` field.
`static int`	`computeTagSize(int fieldNumber)` Compute the number of bytes that would be needed to encode a tag.
`static int`	`computeUInt32Size(int fieldNumber, int value)` Compute the number of bytes that would be needed to encode a `uint32` field, including tag.
`static int`	`computeUInt32SizeNoTag(int value)` Compute the number of bytes that would be needed to encode a `uint32` field.
`static int`	`computeUInt64Size(int fieldNumber, long value)` Compute the number of bytes that would be needed to encode a `uint64` field, including tag.
`static int`	`computeUInt64SizeNoTag(long value)` Compute the number of bytes that would be needed to encode a `uint64` field, including tag.
`static int`	`encodeZigZag32(int n)` Encode a ZigZag-encoded 32-bit value.
`static long`	`encodeZigZag64(long n)` Encode a ZigZag-encoded 64-bit value.
`abstract int`	`getTotalBytesWritten()` Get the total number of bytes successfully written to this sink.
`static ProtoSink`	`newArraySink()` Creates a new `ProtoSink` that writes directly to a byte array.
`static ProtoSink`	`newBufferSink()` Creates a new `ProtoSink` that writes directly to a `ByteBuffer`.
`static ProtoSink`	`newBytesSink()` Creates a new `ProtoSink` that writes to a `RepeatedByte`.
`static ProtoSink`	`newDirectSink()` Creates a new `ProtoSink` that writes directly to a byte array or direct memory.
`static ProtoSink`	`newInstance(byte[] flatArray)` Create a new `ProtoSink` that writes directly to the given byte array.
`static ProtoSink`	`newInstance(byte[] flatArray, int offset, int length)` Create a new `ProtoSink` that writes directly to the given byte array slice.
`static ProtoSink`	`newInstance(ByteBuffer buffer)` Create a new ProtoSink writing to the given `ByteBuffer`.
`static ProtoSink`	`newInstance(OutputStream stream)` Create a new ProtoSink writing to the given `OutputStream`.
`static ProtoSink`	`newInstance(RepeatedByte bytes)` Create a new ProtoSink writing to the given `RepeatedByte`.
`static ProtoSink`	`newStreamSink()` Creates a new `ProtoSink` that writes directly to an `OutputStream`.
`abstract ProtoSink`	`reset()` Resets the position within the internal buffer to zero.
`ProtoSink`	`setOutput(byte[] buffer)` Changes the output to the given array.
`ProtoSink`	`setOutput(byte[] buffer, long offset, int length)` Changes the output to the given array.
`ProtoSink`	`setOutput(ByteBuffer buffer)` Changes the output to the given buffer.
`ProtoSink`	`setOutput(OutputStream stream)` Changes the output to the given stream.
`ProtoSink`	`setOutput(RepeatedByte bytes)` Changes the output to the given bytes.
`int`	`spaceLeft()` Returns remaining space when there is a known limit.
`void`	`writeBool(int fieldNumber, boolean value)` Write a `bool` field, including tag, to the sink.
`void`	`writeBoolNoTag(boolean value)` Write a `bool` field to the sink.
`void`	`writeBytes(int fieldNumber, RepeatedByte value)` Write a `bytes` field, including tag, to the sink.
`void`	`writeBytesNoTag(RepeatedByte value)` Write a `bytes` field to the sink.
`void`	`writeDouble(int fieldNumber, double value)` Write a `double` field, including tag, to the sink.
`void`	`writeDoubleNoTag(double value)` Write a `double` field to the sink.
`void`	`writeEnum(int fieldNumber, int value)` Write an enum field, including tag, to the sink.
`void`	`writeEnumNoTag(int value)` Write an enum field to the sink.
`void`	`writeFixed32(int fieldNumber, int value)` Write a `fixed32` field, including tag, to the sink.
`void`	`writeFixed32NoTag(int value)` Write a `fixed32` field to the sink.
`void`	`writeFixed64(int fieldNumber, long value)` Write a `fixed64` field, including tag, to the sink.
`void`	`writeFixed64NoTag(long value)` Write a `fixed64` field to the sink.
`void`	`writeFloat(int fieldNumber, float value)` Write a `float` field, including tag, to the sink.
`void`	`writeFloatNoTag(float value)` Write a `float` field to the sink.
`void`	`writeGroup(int fieldNumber, ProtoMessage value)` Write a `group` field, including tag, to the sink.
`void`	`writeGroupNoTag(ProtoMessage<?> value)` Write a `group` field to the sink.
`void`	`writeInt32(int fieldNumber, int value)` Write an `int32` field, including tag, to the sink.
`void`	`writeInt32NoTag(int value)` Write an `int32` field to the sink.
`void`	`writeInt64(int fieldNumber, long value)` Write an `int64` field, including tag, to the sink.
`void`	`writeInt64NoTag(long value)` Write an `int64` field to the sink.
`void`	`writeLength(int length)` Write a length delimiter to the sink
`void`	`writeMessage(int fieldNumber, ProtoMessage value)` Write an embedded message field, including tag, to the sink.
`void`	`writeMessageNoTag(ProtoMessage<?> value)` Write an embedded message field to the sink.
`protected void`	`writeNegativeVarint32(int value)` write a negative `int32` that must be sign-extended to 10 bytes
`protected void`	`writeNegativeVarint64(long value)` write a negative `int64` that must be sign-extended to 10 bytes
`void`	`writePackedBoolNoTag(RepeatedBoolean values)` Write a repeated (non-packed)`bool` field, excluding tag, to the sink.
`void`	`writePackedDoubleNoTag(RepeatedDouble values)` Write a repeated (packed) `double` field, excluding tag, to the sink.
`void`	`writePackedEnumNoTag(RepeatedEnum<?> values)` Write a repeated (packed) `enum` field to the sink.
`void`	`writePackedFixed32NoTag(RepeatedInt values)` Write a repeated (packed)`fixed32` field, excluding tag, to the sink.
`void`	`writePackedFixed64NoTag(RepeatedLong values)` Write a repeated (packed)`fixed64` field, excluding tag, to the sink.
`void`	`writePackedFloatNoTag(RepeatedFloat values)` Write a repeated (packed) `float` field, excluding tag, to the sink.
`void`	`writePackedInt32NoTag(RepeatedInt values)` Write a repeated (packed) `int32` field to the sink.
`void`	`writePackedInt64NoTag(RepeatedLong values)` Write a repeated (packed) `int32` field to the sink.
`void`	`writePackedSFixed32NoTag(RepeatedInt values)` Write a repeated (packed) `sfixed32` field, excluding tag, to the sink.
`void`	`writePackedSFixed64NoTag(RepeatedLong values)` Write a repeated (packed) `sfixed64` field, excluding tag, to the sink.
`void`	`writePackedSInt32NoTag(RepeatedInt values)` Write a repeated (packed) `sint32` field to the sink.
`void`	`writePackedSInt64NoTag(RepeatedLong values)` Write a repeated (packed) `sint64` field to the sink.
`void`	`writePackedTag(int fieldNumber)` Encode and write a packed tag for the given field number.
`void`	`writePackedUInt32NoTag(RepeatedInt values)` Write a repeated (packed) `uint32` field to the sink.
`void`	`writePackedUInt64NoTag(RepeatedLong values)` Write a repeated (packed) `uint32` field to the sink.
`protected void`	`writeRawBooleans(boolean[] values, int length)`
`abstract void`	`writeRawByte(byte value)` Write a single byte.
`void`	`writeRawByte(int value)` Write a single byte, represented by an integer value.
`void`	`writeRawBytes(byte[] value)` Write an array of bytes.
`void`	`writeRawBytes(byte[] value, int offset, int length)` Write part of an array of bytes.
`void`	`writeRawBytes(RepeatedByte bytes)` Writes the contents as an array of bytes
`protected void`	`writeRawDoubles(double[] values, int length)`
`protected void`	`writeRawFixed32s(int[] values, int length)`
`protected void`	`writeRawFixed64s(long[] values, int length)`
`protected void`	`writeRawFloats(float[] values, int length)`
`void`	`writeRawLittleEndian16(short value)` Write a little-endian 16-bit integer.
`void`	`writeRawLittleEndian32(int value)` Write a little-endian 32-bit integer.
`void`	`writeRawLittleEndian64(long value)` Write a little-endian 64-bit integer.
`void`	`writeRawVarint32(int value)` Deprecated.
`void`	`writeRawVarint64(long value)` Deprecated.
`void`	`writeSFixed32(int fieldNumber, int value)` Write an `sfixed32` field, including tag, to the sink.
`void`	`writeSFixed32NoTag(int value)` Write an `sfixed32` field to the sink.
`void`	`writeSFixed64(int fieldNumber, long value)` Write an `sfixed64` field, including tag, to the sink.
`void`	`writeSFixed64NoTag(long value)` Write an `sfixed64` field to the sink.
`void`	`writeSInt32(int fieldNumber, int value)` Write an `sint32` field, including tag, to the sink.
`void`	`writeSInt32NoTag(int value)` Write an `sint32` field to the sink.
`void`	`writeSInt64(int fieldNumber, long value)` Write an `sint64` field, including tag, to the sink.
`void`	`writeSInt64NoTag(long value)` Write an `sint64` field to the sink.
`void`	`writeString(int fieldNumber, CharSequence value)` Write a `string` field, including tag, to the sink.
`void`	`writeStringNoTag(CharSequence value)` Write a `string` field to the sink.
`void`	`writeStringNoTag(Utf8String value)` Write a `string` field to the sink.
`void`	`writeTag(int fieldNumber, int wireType)` Encode and write a tag.
`void`	`writeUInt32(int fieldNumber, int value)` Write a `uint32` field, including tag, to the sink.
`static int`	`writeUInt32(OutputStream output, int value)` Encode and write a varint32 to an `OutputStream`.
`void`	`writeUInt32NoTag(int value)` Write a `uint32` field to the sink.
`void`	`writeUInt64(int fieldNumber, long value)` Write a `uint64` field, including tag, to the sink.
`void`	`writeUInt64NoTag(long value)` Write a `uint64` field to the sink.

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

- Constructor Detail
  - ProtoSink
```
protected ProtoSink()
```
- Method Detail
  - newInstance
```
public static ProtoSink newInstance(byte[] flatArray)
```
    Create a new ProtoSink that writes directly to the given byte array. If more bytes are written than fit in the array, ProtoSink.OutOfSpaceException will be thrown.
  - newInstance
```
public static ProtoSink newInstance(byte[] flatArray,
                                    int offset,
                                    int length)
```
    Create a new ProtoSink that writes directly to the given byte array slice. If more bytes are written than fit in the slice, ProtoSink.OutOfSpaceException will be thrown.
  - newInstance
```
public static ProtoSink newInstance(RepeatedByte bytes)
```
    Create a new ProtoSink writing to the given RepeatedByte.
  - newInstance
```
public static ProtoSink newInstance(OutputStream stream)
```
    Create a new ProtoSink writing to the given OutputStream.
  - newInstance
```
public static ProtoSink newInstance(ByteBuffer buffer)
```
    Create a new ProtoSink writing to the given ByteBuffer.
  - newArraySink
```
public static ProtoSink newArraySink()
```
    Creates a new ProtoSink that writes directly to a byte array. If more bytes are written than fit in the array, ProtoSink.OutOfSpaceException will be thrown. This method will return the fastest implementation available for the current platform and may leverage features from sun.misc.Unsafe if available.
  - newDirectSink
```
public static ProtoSink newDirectSink()
```
    Creates a new ProtoSink that writes directly to a byte array or direct memory. If more bytes are written than fit in the array, an ProtoSink.OutOfSpaceException will be thrown. It is similar to ArraySink, but it allows null buffers to support raw memory addresses. This sink requires availability of sun.misc.Unsafe. Be aware that passing incorrect memory addresses may cause the entire runtime to segfault.
  - newBytesSink
```
public static ProtoSink newBytesSink()
```
    Creates a new ProtoSink that writes to a RepeatedByte. The size of the output grows automatically as more bytes are written.
  - newStreamSink
```
public static ProtoSink newStreamSink()
```
    Creates a new ProtoSink that writes directly to an OutputStream. The implementation is lightweight and writes byte-by-byte without any internal buffering. This is slower than writing to an array, but it does not require extra memory.
  - newBufferSink
```
public static ProtoSink newBufferSink()
```
    Creates a new ProtoSink that writes directly to a ByteBuffer. The current implementation is a very lightweight wrapper that writes individual bytes. This is slower than writing to an array, but it works on all platforms.
  - setOutput
```
public final ProtoSink setOutput(byte[] buffer)
```
    Changes the output to the given array. This resets any existing internal state such as position and is equivalent to creating a new instance.
  - setOutput
```
public ProtoSink setOutput(byte[] buffer,
                           long offset,
                           int length)
```
    Changes the output to the given array. This resets any existing internal state such as position and is equivalent to creating a new instance.
  - setOutput
```
public ProtoSink setOutput(RepeatedByte bytes)
```
    Changes the output to the given bytes. This resets any existing internal state such as position and is equivalent to creating a new instance.
  - setOutput
```
public ProtoSink setOutput(OutputStream stream)
```
    Changes the output to the given stream. This resets any existing internal state such as position and is equivalent to creating a new instance.
  - setOutput
```
public ProtoSink setOutput(ByteBuffer buffer)
```
    Changes the output to the given buffer. This resets any existing internal state such as position and is equivalent to creating a new instance. A BufferSink wraps the buffer directly and modifies the buffer state. ArraySink and DirectSink wrap the backing memory and do not modify the buffer state.
  - clear
```
public abstract ProtoSink clear()
```
    Clears internal state and removes any references to previous outputs.
  - writeTag
```
public void writeTag(int fieldNumber,
                     int wireType)
              throws IOException
```
    Encode and write a tag.
    
    Throws:
    
    IOException
  - writePackedTag
```
public void writePackedTag(int fieldNumber)
                    throws IOException
```
    Encode and write a packed tag for the given field number.
    
    Throws:
    
    IOException
  - writeDouble
```
public void writeDouble(int fieldNumber,
                        double value)
                 throws IOException
```
    Write a double field, including tag, to the sink.
    
    Throws:
    
    IOException
  - writeFloat
```
public void writeFloat(int fieldNumber,
                       float value)
                throws IOException
```
    Write a float field, including tag, to the sink.
    
    Throws:
    
    IOException
  - writeUInt64
```
public void writeUInt64(int fieldNumber,
                        long value)
                 throws IOException
```
    Write a uint64 field, including tag, to the sink.
    
    Throws:
    
    IOException
  - writeInt64
```
public void writeInt64(int fieldNumber,
                       long value)
                throws IOException
```
    Write an int64 field, including tag, to the sink.
    
    Throws:
    
    IOException
  - writeInt32
```
public void writeInt32(int fieldNumber,
                       int value)
                throws IOException
```
    Write an int32 field, including tag, to the sink.
    
    Throws:
    
    IOException
  - writeFixed64
```
public void writeFixed64(int fieldNumber,
                         long value)
                  throws IOException
```
    Write a fixed64 field, including tag, to the sink.
    
    Throws:
    
    IOException
  - writeFixed32
```
public void writeFixed32(int fieldNumber,
                         int value)
                  throws IOException
```
    Write a fixed32 field, including tag, to the sink.
    
    Throws:
    
    IOException
  - writeBool
```
public void writeBool(int fieldNumber,
                      boolean value)
               throws IOException
```
    Write a bool field, including tag, to the sink.
    
    Throws:
    
    IOException
  - writeString
```
public void writeString(int fieldNumber,
                        CharSequence value)
                 throws IOException
```
    Write a string field, including tag, to the sink.
    
    Throws:
    
    IOException
  - writeGroup
```
public void writeGroup(int fieldNumber,
                       ProtoMessage value)
                throws IOException
```
    Write a group field, including tag, to the sink.
    
    Throws:
    
    IOException
  - writeMessage
```
public void writeMessage(int fieldNumber,
                         ProtoMessage value)
                  throws IOException
```
    Write an embedded message field, including tag, to the sink.
    
    Throws:
    
    IOException
  - writeBytes
```
public void writeBytes(int fieldNumber,
                       RepeatedByte value)
                throws IOException
```
    Write a bytes field, including tag, to the sink.
    
    Throws:
    
    IOException
  - writeUInt32
```
public void writeUInt32(int fieldNumber,
                        int value)
                 throws IOException
```
    Write a uint32 field, including tag, to the sink.
    
    Throws:
    
    IOException
  - writeEnum
```
public void writeEnum(int fieldNumber,
                      int value)
               throws IOException
```
    Write an enum field, including tag, to the sink. Caller is responsible for converting the enum value to its numeric value.
    
    Throws:
    
    IOException
  - writeSFixed32
```
public void writeSFixed32(int fieldNumber,
                          int value)
                   throws IOException
```
    Write an sfixed32 field, including tag, to the sink.
    
    Throws:
    
    IOException
  - writeSFixed64
```
public void writeSFixed64(int fieldNumber,
                          long value)
                   throws IOException
```
    Write an sfixed64 field, including tag, to the sink.
    
    Throws:
    
    IOException
  - writeSInt32
```
public void writeSInt32(int fieldNumber,
                        int value)
                 throws IOException
```
    Write an sint32 field, including tag, to the sink.
    
    Throws:
    
    IOException
  - writeSInt64
```
public void writeSInt64(int fieldNumber,
                        long value)
                 throws IOException
```
    Write an sint64 field, including tag, to the sink.
    
    Throws:
    
    IOException
  - writePackedDoubleNoTag
```
public void writePackedDoubleNoTag(RepeatedDouble values)
                            throws IOException
```
    Write a repeated (packed) double field, excluding tag, to the sink.
    
    Throws:
    
    IOException
  - writePackedFloatNoTag
```
public void writePackedFloatNoTag(RepeatedFloat values)
                           throws IOException
```
    Write a repeated (packed) float field, excluding tag, to the sink.
    
    Throws:
    
    IOException
  - writePackedFixed64NoTag
```
public void writePackedFixed64NoTag(RepeatedLong values)
                             throws IOException
```
    Write a repeated (packed)fixed64 field, excluding tag, to the sink.
    
    Throws:
    
    IOException
  - writePackedFixed32NoTag
```
public void writePackedFixed32NoTag(RepeatedInt values)
                             throws IOException
```
    Write a repeated (packed)fixed32 field, excluding tag, to the sink.
    
    Throws:
    
    IOException
  - writePackedSFixed32NoTag
```
public void writePackedSFixed32NoTag(RepeatedInt values)
                              throws IOException
```
    Write a repeated (packed) sfixed32 field, excluding tag, to the sink.
    
    Throws:
    
    IOException
  - writePackedSFixed64NoTag
```
public void writePackedSFixed64NoTag(RepeatedLong values)
                              throws IOException
```
    Write a repeated (packed) sfixed64 field, excluding tag, to the sink.
    
    Throws:
    
    IOException
  - writePackedBoolNoTag
```
public void writePackedBoolNoTag(RepeatedBoolean values)
                          throws IOException
```
    Write a repeated (non-packed)bool field, excluding tag, to the sink.
    
    Throws:
    
    IOException
  - writeRawDoubles
```
protected void writeRawDoubles(double[] values,
                               int length)
                        throws IOException
```
    Throws:
    
    IOException
  - writeRawFloats
```
protected void writeRawFloats(float[] values,
                              int length)
                       throws IOException
```
    Throws:
    
    IOException
  - writeRawFixed64s
```
protected void writeRawFixed64s(long[] values,
                                int length)
                         throws IOException
```
    Throws:
    
    IOException
  - writeRawFixed32s
```
protected void writeRawFixed32s(int[] values,
                                int length)
                         throws IOException
```
    Throws:
    
    IOException
  - writeRawBooleans
```
protected void writeRawBooleans(boolean[] values,
                                int length)
                         throws IOException
```
    Throws:
    
    IOException
  - computeRepeatedEnumSizeNoTag
```
public static int computeRepeatedEnumSizeNoTag(RepeatedEnum<?> values)
```
    Compute the number of bytes needed to encode all contained enum values
  - writePackedEnumNoTag
```
public void writePackedEnumNoTag(RepeatedEnum<?> values)
                          throws IOException
```
    Write a repeated (packed) enum field to the sink.
    
    Throws:
    
    IOException
  - computeRepeatedInt32SizeNoTag
```
public static int computeRepeatedInt32SizeNoTag(RepeatedInt values)
```
    Compute the number of bytes needed to encode all contained int32 values
  - writePackedInt32NoTag
```
public void writePackedInt32NoTag(RepeatedInt values)
                           throws IOException
```
    Write a repeated (packed) int32 field to the sink.
    
    Throws:
    
    IOException
  - computeRepeatedUInt32SizeNoTag
```
public static int computeRepeatedUInt32SizeNoTag(RepeatedInt values)
```
    Compute the number of bytes needed to encode all contained uint32 values
  - writePackedUInt32NoTag
```
public void writePackedUInt32NoTag(RepeatedInt values)
                            throws IOException
```
    Write a repeated (packed) uint32 field to the sink.
    
    Throws:
    
    IOException
  - computeRepeatedSInt32SizeNoTag
```
public static int computeRepeatedSInt32SizeNoTag(RepeatedInt values)
```
    Compute the number of bytes needed to encode all contained sint32 values
  - writePackedSInt32NoTag
```
public void writePackedSInt32NoTag(RepeatedInt values)
                            throws IOException
```
    Write a repeated (packed) sint32 field to the sink.
    
    Throws:
    
    IOException
  - computeRepeatedInt64SizeNoTag
```
public static int computeRepeatedInt64SizeNoTag(RepeatedLong values)
```
    Compute the number of bytes needed to encode all contained int32 values
  - writePackedInt64NoTag
```
public void writePackedInt64NoTag(RepeatedLong values)
                           throws IOException
```
    Write a repeated (packed) int32 field to the sink.
    
    Throws:
    
    IOException
  - computeRepeatedUInt64SizeNoTag
```
public static int computeRepeatedUInt64SizeNoTag(RepeatedLong values)
```
    Compute the number of bytes needed to encode all contained uint64 values
  - writePackedUInt64NoTag
```
public void writePackedUInt64NoTag(RepeatedLong values)
                            throws IOException
```
    Write a repeated (packed) uint32 field to the sink.
    
    Throws:
    
    IOException
  - computeRepeatedSInt64SizeNoTag
```
public static int computeRepeatedSInt64SizeNoTag(RepeatedLong values)
```
    Compute the number of bytes needed to encode all contained sint64 values
  - writePackedSInt64NoTag
```
public void writePackedSInt64NoTag(RepeatedLong values)
                            throws IOException
```
    Write a repeated (packed) sint64 field to the sink.
    
    Throws:
    
    IOException
  - computeRepeatedMessageSizeNoTag
```
public static int computeRepeatedMessageSizeNoTag(RepeatedMessage<?> values)
```
    Compute the number of bytes needed to encode all contained message values
  - computeRepeatedGroupSizeNoTag
```
public static int computeRepeatedGroupSizeNoTag(RepeatedMessage<?> values)
```
    Compute the number of bytes needed to encode all contained message values
  - computeRepeatedStringSizeNoTag
```
public static int computeRepeatedStringSizeNoTag(RepeatedString values)
```
    Compute the number of bytes needed to encode all contained string values
  - computeRepeatedBytesSizeNoTag
```
public static int computeRepeatedBytesSizeNoTag(RepeatedBytes values)
```
    Compute the number of bytes needed to encode all contained bytes values
  - writeLength
```
public void writeLength(int length)
                 throws IOException
```
    Write a length delimiter to the sink
    
    Throws:
    
    IOException
  - writeDoubleNoTag
```
public void writeDoubleNoTag(double value)
                      throws IOException
```
    Write a double field to the sink.
    
    Throws:
    
    IOException
  - writeFloatNoTag
```
public void writeFloatNoTag(float value)
                     throws IOException
```
    Write a float field to the sink.
    
    Throws:
    
    IOException
  - writeInt64NoTag
```
public void writeInt64NoTag(long value)
                     throws IOException
```
    Write an int64 field to the sink.
    
    Throws:
    
    IOException
  - writeInt32NoTag
```
public void writeInt32NoTag(int value)
                     throws IOException
```
    Write an int32 field to the sink.
    
    Throws:
    
    IOException
  - writeFixed64NoTag
```
public void writeFixed64NoTag(long value)
                       throws IOException
```
    Write a fixed64 field to the sink.
    
    Throws:
    
    IOException
  - writeFixed32NoTag
```
public void writeFixed32NoTag(int value)
                       throws IOException
```
    Write a fixed32 field to the sink.
    
    Throws:
    
    IOException
  - writeBoolNoTag
```
public void writeBoolNoTag(boolean value)
                    throws IOException
```
    Write a bool field to the sink.
    
    Throws:
    
    IOException
  - writeStringNoTag
```
public void writeStringNoTag(Utf8String value)
                      throws IOException
```
    Write a string field to the sink.
    
    Throws:
    
    IOException
  - writeStringNoTag
```
public void writeStringNoTag(CharSequence value)
                      throws IOException
```
    Write a string field to the sink.
    
    Throws:
    
    IOException
  - writeGroupNoTag
```
public void writeGroupNoTag(ProtoMessage<?> value)
                     throws IOException
```
    Write a group field to the sink.
    
    Throws:
    
    IOException
  - writeMessageNoTag
```
public void writeMessageNoTag(ProtoMessage<?> value)
                       throws IOException
```
    Write an embedded message field to the sink.
    
    Throws:
    
    IOException
  - writeBytesNoTag
```
public void writeBytesNoTag(RepeatedByte value)
                     throws IOException
```
    Write a bytes field to the sink.
    
    Throws:
    
    IOException
  - writeEnumNoTag
```
public void writeEnumNoTag(int value)
                    throws IOException
```
    Write an enum field to the sink. Caller is responsible for converting the enum value to its numeric value.
    
    Throws:
    
    IOException
  - writeSFixed32NoTag
```
public void writeSFixed32NoTag(int value)
                        throws IOException
```
    Write an sfixed32 field to the sink.
    
    Throws:
    
    IOException
  - writeSFixed64NoTag
```
public void writeSFixed64NoTag(long value)
                        throws IOException
```
    Write an sfixed64 field to the sink.
    
    Throws:
    
    IOException
  - writeSInt32NoTag
```
public void writeSInt32NoTag(int value)
                      throws IOException
```
    Write an sint32 field to the sink.
    
    Throws:
    
    IOException
  - writeSInt64NoTag
```
public void writeSInt64NoTag(long value)
                      throws IOException
```
    Write an sint64 field to the sink.
    
    Throws:
    
    IOException
  - computeDoubleSize
```
public static int computeDoubleSize(int fieldNumber,
                                    double value)
```
    Compute the number of bytes that would be needed to encode a double field, including tag.
  - computeFloatSize
```
public static int computeFloatSize(int fieldNumber,
                                   float value)
```
    Compute the number of bytes that would be needed to encode a float field, including tag.
  - computeUInt64Size
```
public static int computeUInt64Size(int fieldNumber,
                                    long value)
```
    Compute the number of bytes that would be needed to encode a uint64 field, including tag.
  - computeInt64Size
```
public static int computeInt64Size(int fieldNumber,
                                   long value)
```
    Compute the number of bytes that would be needed to encode an int64 field, including tag.
  - computeInt32Size
```
public static int computeInt32Size(int fieldNumber,
                                   int value)
```
    Compute the number of bytes that would be needed to encode an int32 field, including tag.
  - computeFixed64Size
```
public static int computeFixed64Size(int fieldNumber,
                                     long value)
```
    Compute the number of bytes that would be needed to encode a fixed64 field, including tag.
  - computeFixed32Size
```
public static int computeFixed32Size(int fieldNumber,
                                     int value)
```
    Compute the number of bytes that would be needed to encode a fixed32 field, including tag.
  - computeBoolSize
```
public static int computeBoolSize(int fieldNumber,
                                  boolean value)
```
    Compute the number of bytes that would be needed to encode a bool field, including tag.
  - computeStringSize
```
public static int computeStringSize(int fieldNumber,
                                    CharSequence value)
```
    Compute the number of bytes that would be needed to encode a string field, including tag.
  - computeGroupSize
```
public static int computeGroupSize(int fieldNumber,
                                   ProtoMessage<?> value)
```
    Compute the number of bytes that would be needed to encode a group field, including tag.
  - computeMessageSize
```
public static int computeMessageSize(int fieldNumber,
                                     ProtoMessage<?> value)
```
    Compute the number of bytes that would be needed to encode an embedded message field, including tag.
  - computeBytesSize
```
public static int computeBytesSize(int fieldNumber,
                                   RepeatedByte value)
```
    Compute the number of bytes that would be needed to encode a bytes field, including tag.
  - computeUInt32Size
```
public static int computeUInt32Size(int fieldNumber,
                                    int value)
```
    Compute the number of bytes that would be needed to encode a uint32 field, including tag.
  - computeEnumSize
```
public static int computeEnumSize(int fieldNumber,
                                  int value)
```
    Compute the number of bytes that would be needed to encode an enum field, including tag. Caller is responsible for converting the enum value to its numeric value.
  - computeSFixed32Size
```
public static int computeSFixed32Size(int fieldNumber,
                                      int value)
```
    Compute the number of bytes that would be needed to encode an sfixed32 field, including tag.
  - computeSFixed64Size
```
public static int computeSFixed64Size(int fieldNumber,
                                      long value)
```
    Compute the number of bytes that would be needed to encode an sfixed64 field, including tag.
  - computeSInt32Size
```
public static int computeSInt32Size(int fieldNumber,
                                    int value)
```
    Compute the number of bytes that would be needed to encode an sint32 field, including tag.
  - computeSInt64Size
```
public static int computeSInt64Size(int fieldNumber,
                                    long value)
```
    Compute the number of bytes that would be needed to encode an sint64 field, including tag.
  - computeDoubleSizeNoTag
```
public static int computeDoubleSizeNoTag(double value)
```
    Compute the number of bytes that would be needed to encode a double field, including tag.
  - computeFloatSizeNoTag
```
public static int computeFloatSizeNoTag(float value)
```
    Compute the number of bytes that would be needed to encode a float field, including tag.
  - computeUInt64SizeNoTag
```
public static int computeUInt64SizeNoTag(long value)
```
    Compute the number of bytes that would be needed to encode a uint64 field, including tag.
  - computeInt64SizeNoTag
```
public static int computeInt64SizeNoTag(long value)
```
    Compute the number of bytes that would be needed to encode an int64 field, including tag.
  - computeInt32SizeNoTag
```
public static int computeInt32SizeNoTag(int value)
```
    Compute the number of bytes that would be needed to encode an int32 field, including tag.
  - computeFixed64SizeNoTag
```
public static int computeFixed64SizeNoTag(long value)
```
    Compute the number of bytes that would be needed to encode a fixed64 field.
  - computeFixed32SizeNoTag
```
public static int computeFixed32SizeNoTag(int value)
```
    Compute the number of bytes that would be needed to encode a fixed32 field.
  - computeBoolSizeNoTag
```
public static int computeBoolSizeNoTag(boolean value)
```
    Compute the number of bytes that would be needed to encode a bool field.
  - computeStringSizeNoTag
```
public static int computeStringSizeNoTag(Utf8String value)
```
    Compute the number of bytes that would be needed to encode a string field.
  - computeStringSizeNoTag
```
public static int computeStringSizeNoTag(CharSequence value)
```
    Compute the number of bytes that would be needed to encode a string field.
  - computeGroupSizeNoTag
```
public static int computeGroupSizeNoTag(ProtoMessage value)
```
    Compute the number of bytes that would be needed to encode a group field.
  - computeMessageSizeNoTag
```
public static int computeMessageSizeNoTag(ProtoMessage value)
```
    Compute the number of bytes that would be needed to encode an embedded message field.
  - computeBytesSizeNoTag
```
public static int computeBytesSizeNoTag(RepeatedByte value)
```
    Compute the number of bytes that would be needed to encode a bytes field.
  - computeUInt32SizeNoTag
```
public static int computeUInt32SizeNoTag(int value)
```
    Compute the number of bytes that would be needed to encode a uint32 field.
  - computeEnumSizeNoTag
```
public static int computeEnumSizeNoTag(int value)
```
    Compute the number of bytes that would be needed to encode an enum field. Caller is responsible for converting the enum value to its numeric value.
  - computeSFixed32SizeNoTag
```
public static int computeSFixed32SizeNoTag(int value)
```
    Compute the number of bytes that would be needed to encode an sfixed32 field.
  - computeSFixed64SizeNoTag
```
public static int computeSFixed64SizeNoTag(long value)
```
    Compute the number of bytes that would be needed to encode an sfixed64 field.
  - computeSInt32SizeNoTag
```
public static int computeSInt32SizeNoTag(int value)
```
    Compute the number of bytes that would be needed to encode an sint32 field.
  - computeSInt64SizeNoTag
```
public static int computeSInt64SizeNoTag(long value)
```
    Compute the number of bytes that would be needed to encode an sint64 field.
  - computeDelimitedSize
```
public static int computeDelimitedSize(int length)
```
    Compute the number of bytes that would be needed to encode length bytes and a length delimiter.
  - spaceLeft
```
public int spaceLeft()
```
    Returns remaining space when there is a known limit. Otherwise, throws UnsupportedOperationException.
  - checkNoSpaceLeft
```
public void checkNoSpaceLeft()
```
    Verifies that spaceLeft() returns zero. It's common to create a byte array that is exactly big enough to hold a message, then write to it with a ProtoSink. Calling checkNoSpaceLeft() after writing verifies that the message was actually as big as expected, which can help catch bugs.
  - getTotalBytesWritten
```
public abstract int getTotalBytesWritten()
```
    Get the total number of bytes successfully written to this sink. The returned value is not guaranteed to be accurate if exceptions have been found in the middle of writing.
  - reset
```
public abstract ProtoSink reset()
```
    Resets the position within the internal buffer to zero.
    
    See Also:
    
    getTotalBytesWritten(), spaceLeft()
  - writeRawByte
```
public abstract void writeRawByte(byte value)
                           throws IOException
```
    Write a single byte.
    
    Throws:
    
    IOException
  - writeRawByte
```
public void writeRawByte(int value)
                  throws IOException
```
    Write a single byte, represented by an integer value.
    
    Throws:
    
    IOException
  - writeRawBytes
```
public void writeRawBytes(byte[] value)
                   throws IOException
```
    Write an array of bytes.
    
    Throws:
    
    IOException
  - writeRawBytes
```
public void writeRawBytes(RepeatedByte bytes)
                   throws IOException
```
    Writes the contents as an array of bytes
    
    Throws:
    
    IOException
  - writeRawBytes
```
public void writeRawBytes(byte[] value,
                          int offset,
                          int length)
                   throws IOException
```
    Write part of an array of bytes.
    
    Throws:
    
    IOException
  - computeTagSize
```
public static int computeTagSize(int fieldNumber)
```
    Compute the number of bytes that would be needed to encode a tag.
  - writeUInt32NoTag
```
public void writeUInt32NoTag(int value)
                      throws IOException
```
    Write a uint32 field to the sink.
    
    Throws:
    
    IOException
  - computeRawVarint32Size
```
public static int computeRawVarint32Size(int value)
```
    Compute the number of bytes that would be needed to encode a varint. value is treated as unsigned, so it won't be sign-extended if negative.
  - writeUInt64NoTag
```
public void writeUInt64NoTag(long value)
                      throws IOException
```
    Write a uint64 field to the sink.
    
    Throws:
    
    IOException
  - computeRawVarint64Size
```
public static int computeRawVarint64Size(long value)
```
    Compute the number of bytes that would be needed to encode a varint.
  - writeNegativeVarint32
```
protected void writeNegativeVarint32(int value)
                              throws IOException
```
    write a negative int32 that must be sign-extended to 10 bytes
    
    Throws:
    
    IOException
  - writeNegativeVarint64
```
protected void writeNegativeVarint64(long value)
                              throws IOException
```
    write a negative int64 that must be sign-extended to 10 bytes
    
    Throws:
    
    IOException
  - writeRawLittleEndian16
```
public void writeRawLittleEndian16(short value)
                            throws IOException
```
    Write a little-endian 16-bit integer.
    
    Throws:
    
    IOException
  - writeRawLittleEndian32
```
public void writeRawLittleEndian32(int value)
                            throws IOException
```
    Write a little-endian 32-bit integer.
    
    Throws:
    
    IOException
  - writeRawLittleEndian64
```
public void writeRawLittleEndian64(long value)
                            throws IOException
```
    Write a little-endian 64-bit integer.
    
    Throws:
    
    IOException
  - encodeZigZag32
```
public static int encodeZigZag32(int n)
```
    Encode a ZigZag-encoded 32-bit value. ZigZag encodes signed integers into values that can be efficiently encoded with varint. (Otherwise, negative values must be sign-extended to 64 bits to be varint encoded, thus always taking 10 bytes on the wire.)
    
    Parameters:
    
    n - A signed 32-bit integer.
    
    Returns:
    
    An unsigned 32-bit integer, stored in a signed int because Java has no explicit unsigned support.
  - encodeZigZag64
```
public static long encodeZigZag64(long n)
```
    Encode a ZigZag-encoded 64-bit value. ZigZag encodes signed integers into values that can be efficiently encoded with varint. (Otherwise, negative values must be sign-extended to 64 bits to be varint encoded, thus always taking 10 bytes on the wire.)
    
    Parameters:
    
    n - A signed 64-bit integer.
    
    Returns:
    
    An unsigned 64-bit integer, stored in a signed int because Java has no explicit unsigned support.
  - writeRawVarint32
```
@Deprecated
public void writeRawVarint32(int value)
                                  throws IOException
```
    Deprecated.
    
    Encode and write a varint. value is treated as unsigned, so it won't be sign-extended if negative.
    
    Throws:
    
    IOException
  - writeRawVarint64
```
@Deprecated
public void writeRawVarint64(long value)
                                  throws IOException
```
    Deprecated.
    
    Encode and write a varint.
    
    Throws:
    
    IOException
  - writeUInt32
```
public static int writeUInt32(OutputStream output,
                              int value)
                       throws IOException
```
    Encode and write a varint32 to an OutputStream. value is treated as unsigned, so it won't be sign-extended if negative. This can be used to write length delimiters before writing messages.
    
    Parameters:
    
    value - uint32 value to be encoded as varint
    
    output - target stream
    
    Returns:
    
    number of written bytes
    
    Throws:
    
    IOException

Class ProtoSink

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ProtoSink

Method Detail

newInstance

newInstance

newInstance

newInstance

newInstance

newArraySink

newDirectSink

newBytesSink

newStreamSink

newBufferSink

setOutput

setOutput

setOutput

setOutput

setOutput

clear

writeTag

writePackedTag

writeDouble

writeFloat

writeUInt64

writeInt64

writeInt32

writeFixed64

writeFixed32

writeBool

writeString

writeGroup

writeMessage

writeBytes

writeUInt32

writeEnum

writeSFixed32

writeSFixed64

writeSInt32

writeSInt64

writePackedDoubleNoTag

writePackedFloatNoTag

writePackedFixed64NoTag

writePackedFixed32NoTag

writePackedSFixed32NoTag

writePackedSFixed64NoTag

writePackedBoolNoTag

writeRawDoubles

writeRawFloats

writeRawFixed64s

writeRawFixed32s

writeRawBooleans

computeRepeatedEnumSizeNoTag

writePackedEnumNoTag

computeRepeatedInt32SizeNoTag

writePackedInt32NoTag

computeRepeatedUInt32SizeNoTag

writePackedUInt32NoTag

computeRepeatedSInt32SizeNoTag

writePackedSInt32NoTag

computeRepeatedInt64SizeNoTag

writePackedInt64NoTag

computeRepeatedUInt64SizeNoTag

writePackedUInt64NoTag

computeRepeatedSInt64SizeNoTag

writePackedSInt64NoTag

computeRepeatedMessageSizeNoTag

computeRepeatedGroupSizeNoTag

computeRepeatedStringSizeNoTag

computeRepeatedBytesSizeNoTag

writeLength

writeDoubleNoTag

writeFloatNoTag

writeInt64NoTag

writeInt32NoTag

writeFixed64NoTag