CodedOutputStream

java.lang.Object
- com.google.protobuf.ByteOutput
- - com.google.protobuf.CodedOutputStream

```
public abstract class CodedOutputStream
extends ByteOutput
```
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.

Nested Class Summary

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

Field Summary

Fields
Modifier and Type Field and Description

static int DEFAULT_BUFFER_SIZE
The buffer size used in newInstance(OutputStream).

Fields
Modifier and Type	Field and Description
`static int`	`DEFAULT_BUFFER_SIZE` The buffer size used in `newInstance(OutputStream)`.

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.
`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 unused)` Compute the number of bytes that would be needed to encode a `bool` field.
`static int`	`computeByteArraySize(int fieldNumber, byte[] value)` Compute the number of bytes that would be needed to encode a `bytes` field, including tag.
`static int`	`computeByteArraySizeNoTag(byte[] value)` Compute the number of bytes that would be needed to encode a `bytes` field.
`static int`	`computeByteBufferSize(int fieldNumber, ByteBuffer value)` Compute the number of bytes that would be needed to encode a `bytes` field, including tag.
`static int`	`computeByteBufferSizeNoTag(ByteBuffer value)` Compute the number of bytes that would be needed to encode a `bytes` field.
`static int`	`computeBytesSize(int fieldNumber, ByteString value)` Compute the number of bytes that would be needed to encode a `bytes` field, including tag.
`static int`	`computeBytesSizeNoTag(ByteString value)` Compute the number of bytes that would be needed to encode a `bytes` field.
`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 unused)` 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 unused)` 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 unused)` 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 unused)` Compute the number of bytes that would be needed to encode a `float` field, including tag.
`static int`	`computeGroupSizeNoTag(MessageLite value)` Deprecated.
`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`	`computeLazyFieldMessageSetExtensionSize(int fieldNumber, LazyFieldLite value)` Compute the number of bytes that would be needed to encode an lazily parsed MessageSet extension field to the stream.
`static int`	`computeLazyFieldSize(int fieldNumber, LazyFieldLite value)` Compute the number of bytes that would be needed to encode an embedded message in lazy field, including tag.
`static int`	`computeLazyFieldSizeNoTag(LazyFieldLite value)` Compute the number of bytes that would be needed to encode an embedded message stored in lazy field.
`static int`	`computeMessageSetExtensionSize(int fieldNumber, MessageLite value)` Compute the number of bytes that would be needed to encode a MessageSet extension to the stream.
`static int`	`computeMessageSize(int fieldNumber, MessageLite value)` Compute the number of bytes that would be needed to encode an embedded message field, including tag.
`static int`	`computeMessageSizeNoTag(MessageLite value)` Compute the number of bytes that would be needed to encode an embedded message field.
`static int`	`computeRawMessageSetExtensionSize(int fieldNumber, ByteString value)` Compute the number of bytes that would be needed to encode an unparsed MessageSet extension field to the stream.
`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 unused)` 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 unused)` 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, String value)` Compute the number of bytes that would be needed to encode a `string` field, including tag.
`static int`	`computeStringSizeNoTag(String 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 void`	`flush()` Flushes the stream and forces any buffered bytes to be written.
`abstract int`	`getTotalBytesWritten()` Get the total number of bytes successfully written to this stream.
`static CodedOutputStream`	`newInstance(byte[] flatArray)` Create a new `CodedOutputStream` that writes directly to the given byte array.
`static CodedOutputStream`	`newInstance(byte[] flatArray, int offset, int length)` Create a new `CodedOutputStream` that writes directly to the given byte array slice.
`static CodedOutputStream`	`newInstance(ByteBuffer byteBuffer)` Create a new `CodedOutputStream` that writes to the given `ByteBuffer`.
`static CodedOutputStream`	`newInstance(OutputStream output)` Create a new `CodedOutputStream` wrapping the given `OutputStream`.
`static CodedOutputStream`	`newInstance(OutputStream output, int bufferSize)` Create a new `CodedOutputStream` wrapping the given `OutputStream` with a given buffer size.
`abstract int`	`spaceLeft()` If writing to a flat array, return the space left in the array.
`abstract void`	`write(byte value)` Writes a single byte.
`abstract void`	`write(byte[] value, int offset, int length)` Writes a sequence of bytes.
`abstract void`	`write(ByteBuffer value)` Writes a sequence of bytes.
`abstract void`	`writeBool(int fieldNumber, boolean value)` Write a `bool` field, including tag, to the stream.
`void`	`writeBoolNoTag(boolean value)` Write a `bool` field to the stream.
`abstract void`	`writeByteArray(int fieldNumber, byte[] value)` Write a `bytes` field, including tag, to the stream.
`abstract void`	`writeByteArray(int fieldNumber, byte[] value, int offset, int length)` Write a `bytes` field, including tag, to the stream.
`void`	`writeByteArrayNoTag(byte[] value)` Write a `bytes` field to the stream.
`abstract void`	`writeByteBuffer(int fieldNumber, ByteBuffer value)` Write a `bytes` field, including tag, to the stream.
`abstract void`	`writeBytes(int fieldNumber, ByteString value)` Write a `bytes` field, including tag, to the stream.
`abstract void`	`writeBytesNoTag(ByteString value)` Write a `bytes` field to the stream.
`void`	`writeDouble(int fieldNumber, double value)` Write a `double` field, including tag, to the stream.
`void`	`writeDoubleNoTag(double value)` Write a `double` field to the stream.
`void`	`writeEnum(int fieldNumber, int value)` Write an enum field, including tag, to the stream.
`void`	`writeEnumNoTag(int value)` Write an enum field to the stream.
`abstract void`	`writeFixed32(int fieldNumber, int value)` Write a `fixed32` field, including tag, to the stream.
`abstract void`	`writeFixed32NoTag(int value)` Write a `fixed32` field to the stream.
`abstract void`	`writeFixed64(int fieldNumber, long value)` Write a `fixed64` field, including tag, to the stream.
`abstract void`	`writeFixed64NoTag(long value)` Write a `fixed64` field to the stream.
`void`	`writeFloat(int fieldNumber, float value)` Write a `float` field, including tag, to the stream.
`void`	`writeFloatNoTag(float value)` Write a `float` field to the stream.
`abstract void`	`writeInt32(int fieldNumber, int value)` Write an `int32` field, including tag, to the stream.
`abstract void`	`writeInt32NoTag(int value)` Write an `int32` field to the stream.
`void`	`writeInt64(int fieldNumber, long value)` Write an `int64` field, including tag, to the stream.
`void`	`writeInt64NoTag(long value)` Write an `int64` field to the stream.
`abstract void`	`writeLazy(byte[] value, int offset, int length)` Writes a sequence of bytes.
`abstract void`	`writeLazy(ByteBuffer value)` Writes a sequence of bytes.
`abstract void`	`writeMessage(int fieldNumber, MessageLite value)` Write an embedded message field, including tag, to the stream.
`abstract void`	`writeMessageNoTag(MessageLite value)` Write an embedded message field to the stream.
`abstract void`	`writeMessageSetExtension(int fieldNumber, MessageLite value)` Write a MessageSet extension field to the stream.
`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.
`abstract void`	`writeRawBytes(ByteBuffer value)` Write a ByteBuffer.
`void`	`writeRawBytes(ByteString value)` Write a byte string.
`abstract void`	`writeRawMessageSetExtension(int fieldNumber, ByteString value)` Write an unparsed MessageSet extension field to the stream.
`void`	`writeSFixed32(int fieldNumber, int value)` Write an `sfixed32` field, including tag, to the stream.
`void`	`writeSFixed32NoTag(int value)` Write a `sfixed32` field to the stream.
`void`	`writeSFixed64(int fieldNumber, long value)` Write an `sfixed64` field, including tag, to the stream.
`void`	`writeSFixed64NoTag(long value)` Write a `sfixed64` field to the stream.
`void`	`writeSInt32(int fieldNumber, int value)` Write a `sint32` field, including tag, to the stream.
`void`	`writeSInt32NoTag(int value)` Write a `sint32` field to the stream.
`void`	`writeSInt64(int fieldNumber, long value)` Write an `sint64` field, including tag, to the stream.
`void`	`writeSInt64NoTag(long value)` Write a `sint64` field to the stream.
`abstract void`	`writeString(int fieldNumber, String value)` Write a `string` field, including tag, to the stream.
`abstract void`	`writeStringNoTag(String value)` Write a `string` field to the stream.
`abstract void`	`writeTag(int fieldNumber, int wireType)` Encode and write a tag.
`abstract void`	`writeUInt32(int fieldNumber, int value)` Write a `uint32` field, including tag, to the stream.
`abstract void`	`writeUInt32NoTag(int value)` Write a `uint32` field to the stream.
`abstract void`	`writeUInt64(int fieldNumber, long value)` Write a `uint64` field, including tag, to the stream.
`abstract void`	`writeUInt64NoTag(long value)` Write a `uint64` field to the stream.

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

- Field Detail
  - DEFAULT_BUFFER_SIZE
```
public static final int DEFAULT_BUFFER_SIZE
```
    The buffer size used in newInstance(OutputStream).
    
    See Also:
    
    Constant Field Values
- Method Detail
  - checkNoSpaceLeft
```
public final 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 CodedOutputStream. Calling checkNoSpaceLeft() after writing verifies that the message was actually as big as expected, which can help catch bugs.
  - 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.
  - computeBoolSizeNoTag
```
public static int computeBoolSizeNoTag(boolean unused)
```
    Compute the number of bytes that would be needed to encode a bool field.
  - computeByteArraySize
```
public static int computeByteArraySize(int fieldNumber,
                                       byte[] value)
```
    Compute the number of bytes that would be needed to encode a bytes field, including tag.
  - computeByteArraySizeNoTag
```
public static int computeByteArraySizeNoTag(byte[] value)
```
    Compute the number of bytes that would be needed to encode a bytes field.
  - computeByteBufferSize
```
public static int computeByteBufferSize(int fieldNumber,
                                        ByteBuffer value)
```
    Compute the number of bytes that would be needed to encode a bytes field, including tag.
  - computeByteBufferSizeNoTag
```
public static int computeByteBufferSizeNoTag(ByteBuffer value)
```
    Compute the number of bytes that would be needed to encode a bytes field.
  - computeBytesSize
```
public static int computeBytesSize(int fieldNumber,
                                   ByteString value)
```
    Compute the number of bytes that would be needed to encode a bytes field, including tag.
  - computeBytesSizeNoTag
```
public static int computeBytesSizeNoTag(ByteString value)
```
    Compute the number of bytes that would be needed to encode a bytes field.
  - 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.
  - computeDoubleSizeNoTag
```
public static int computeDoubleSizeNoTag(double unused)
```
    Compute the number of bytes that would be needed to encode a double 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. The provided value is the numeric value used to represent the enum value on the wire (not the enum ordinal value).
  - computeEnumSizeNoTag
```
public static int computeEnumSizeNoTag(int value)
```
    Compute the number of bytes that would be needed to encode an enum field. The provided value is the numeric value used to represent the enum value on the wire (not the enum ordinal value).
  - 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.
  - computeFixed32SizeNoTag
```
public static int computeFixed32SizeNoTag(int unused)
```
    Compute the number of bytes that would be needed to encode a fixed32 field.
  - 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.
  - computeFixed64SizeNoTag
```
public static int computeFixed64SizeNoTag(long unused)
```
    Compute the number of bytes that would be needed to encode a fixed64 field.
  - 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.
  - computeFloatSizeNoTag
```
public static int computeFloatSizeNoTag(float unused)
```
    Compute the number of bytes that would be needed to encode a float field, including tag.
  - computeGroupSizeNoTag
```
@Deprecated
public static int computeGroupSizeNoTag(MessageLite value)
```
    Deprecated.
    
    Compute the number of bytes that would be needed to encode a group field.
  - 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.
  - computeInt32SizeNoTag
```
public static int computeInt32SizeNoTag(int value)
```
    Compute the number of bytes that would be needed to encode an int32 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.
  - computeInt64SizeNoTag
```
public static int computeInt64SizeNoTag(long value)
```
    Compute the number of bytes that would be needed to encode an int64 field, including tag.
  - computeLazyFieldMessageSetExtensionSize
```
public static int computeLazyFieldMessageSetExtensionSize(int fieldNumber,
                                                          LazyFieldLite value)
```
    Compute the number of bytes that would be needed to encode an lazily parsed MessageSet extension field to the stream. For historical reasons, the wire format differs from normal fields.
  - computeLazyFieldSize
```
public static int computeLazyFieldSize(int fieldNumber,
                                       LazyFieldLite value)
```
    Compute the number of bytes that would be needed to encode an embedded message in lazy field, including tag.
  - computeLazyFieldSizeNoTag
```
public static int computeLazyFieldSizeNoTag(LazyFieldLite value)
```
    Compute the number of bytes that would be needed to encode an embedded message stored in lazy field.
  - computeMessageSetExtensionSize
```
public static int computeMessageSetExtensionSize(int fieldNumber,
                                                 MessageLite value)
```
    Compute the number of bytes that would be needed to encode a MessageSet extension to the stream. For historical reasons, the wire format differs from normal fields.
  - computeMessageSize
```
public static int computeMessageSize(int fieldNumber,
                                     MessageLite value)
```
    Compute the number of bytes that would be needed to encode an embedded message field, including tag.
  - computeMessageSizeNoTag
```
public static int computeMessageSizeNoTag(MessageLite value)
```
    Compute the number of bytes that would be needed to encode an embedded message field.
  - computeRawMessageSetExtensionSize
```
public static int computeRawMessageSetExtensionSize(int fieldNumber,
                                                    ByteString value)
```
    Compute the number of bytes that would be needed to encode an unparsed MessageSet extension field to the stream. For historical reasons, the wire format differs from normal fields.
  - 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.
  - computeSFixed32SizeNoTag
```
public static int computeSFixed32SizeNoTag(int unused)
```
    Compute the number of bytes that would be needed to encode an sfixed32 field.
  - 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.
  - computeSFixed64SizeNoTag
```
public static int computeSFixed64SizeNoTag(long unused)
```
    Compute the number of bytes that would be needed to encode an sfixed64 field.
  - 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.
  - computeSInt32SizeNoTag
```
public static int computeSInt32SizeNoTag(int value)
```
    Compute the number of bytes that would be needed to encode an sint32 field.
  - 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.
  - computeSInt64SizeNoTag
```
public static int computeSInt64SizeNoTag(long value)
```
    Compute the number of bytes that would be needed to encode an sint64 field.
  - computeStringSize
```
public static int computeStringSize(int fieldNumber,
                                    String value)
```
    Compute the number of bytes that would be needed to encode a string field, including tag.
  - computeStringSizeNoTag
```
public static int computeStringSizeNoTag(String value)
```
    Compute the number of bytes that would be needed to encode a string field.
  - computeTagSize
```
public static int computeTagSize(int fieldNumber)
```
    Compute the number of bytes that would be needed to encode a 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.
  - computeUInt32SizeNoTag
```
public static int computeUInt32SizeNoTag(int value)
```
    Compute the number of bytes that would be needed to encode a uint32 field.
  - 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.
  - computeUInt64SizeNoTag
```
public static int computeUInt64SizeNoTag(long value)
```
    Compute the number of bytes that would be needed to encode a uint64 field, including tag.
  - 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.
  - flush
```
public abstract void flush()
                    throws IOException
```
    Flushes the stream and forces any buffered bytes to be written. This does not flush the underlying OutputStream.
    
    Throws:
    
    IOException
  - getTotalBytesWritten
```
public abstract int getTotalBytesWritten()
```
    Get the total number of bytes successfully written to this stream. The returned value is not guaranteed to be accurate if exceptions have been found in the middle of writing.
  - newInstance
```
public static CodedOutputStream newInstance(byte[] flatArray)
```
    Create a new CodedOutputStream that writes directly to the given byte array. If more bytes are written than fit in the array, CodedOutputStream.OutOfSpaceException will be thrown. Writing directly to a flat array is faster than writing to an OutputStream. See also ByteString.newCodedBuilder(int).
    
    Parameters:
    
    flatArray - the array.
    
    Returns:
    
    the CodedOutputStream instance.
  - newInstance
```
public static CodedOutputStream newInstance(byte[] flatArray,
                                            int offset,
                                            int length)
```
    Create a new CodedOutputStream that writes directly to the given byte array slice. If more bytes are written than fit in the slice, CodedOutputStream.OutOfSpaceException will be thrown. Writing directly to a flat array is faster than writing to an OutputStream. See also ByteString.newCodedBuilder(int).
    
    Parameters:
    
    flatArray - the array.
    
    offset - the offset.
    
    length - the length
    
    Returns:
    
    the CodedOutputStream instance.
  - newInstance
```
public static CodedOutputStream newInstance(ByteBuffer byteBuffer)
```
    Create a new CodedOutputStream that writes to the given ByteBuffer.
    
    Parameters:
    
    byteBuffer - the buffer.
    
    Returns:
    
    the CodedOutputStream instance.
  - newInstance
```
public static CodedOutputStream newInstance(OutputStream output)
```
    Create a new CodedOutputStream wrapping the given OutputStream.
    NOTE: The provided OutputStream MUST NOT retain access or modify the provided byte arrays. Doing so may result in corrupted data, which would be difficult to debug.
    
    Parameters:
    
    output - the OutputStream from which the CodedOutputStream will be instantiated.
    
    Returns:
    
    the CodedOutputStream instance.
  - newInstance
```
public static CodedOutputStream newInstance(OutputStream output,
                                            int bufferSize)
```
    Create a new CodedOutputStream wrapping the given OutputStream with a given buffer size.
    NOTE: The provided OutputStream MUST NOT retain access or modify the provided byte arrays. Doing so may result in corrupted data, which would be difficult to debug.
    
    Parameters:
    
    output - the OutputStream from which the CodedOutputStream will be instantiated.
    
    bufferSize - the buffer.
    
    Returns:
    
    the CodedOutputStream instance.
  - spaceLeft
```
public abstract int spaceLeft()
```
    If writing to a flat array, return the space left in the array. Otherwise, throws UnsupportedOperationException.
  - write
```
@ExperimentalApi
public abstract void write(byte value)
                                     throws IOException
```
    Description copied from class: ByteOutput
    
    Writes a single byte.
    
    Specified by:
    
    write in class ByteOutput
    
    Parameters:
    
    value - the byte to be written
    
    Throws:
    
    IOException - thrown if an error occurred while writing
  - write
```
@ExperimentalApi
public abstract void write(byte[] value,
                                            int offset,
                                            int length)
                                     throws IOException
```
    Description copied from class: ByteOutput
    
    Writes a sequence of bytes. The ByteOutput must copy value if it will not be processed prior to the return of this method call, since value may be reused/altered by the caller.
    NOTE: This method MUST NOT modify the value. Doing so is a programming error and will lead to data corruption which will be difficult to debug.
    
    Specified by:
    
    write in class ByteOutput
    
    Parameters:
    
    value - the bytes to be written
    
    offset - the offset of the start of the writable range
    
    length - the number of bytes to write starting from offset
    
    Throws:
    
    IOException - thrown if an error occurred while writing
  - write
```
public abstract void write(ByteBuffer value)
                    throws IOException
```
    Description copied from class: ByteOutput
    
    Writes a sequence of bytes. The ByteOutput must copy value if it will not be processed prior to the return of this method call, since value may be reused/altered by the caller.
    NOTE: This method MUST NOT modify the value. Doing so is a programming error and will lead to data corruption which will be difficult to debug.
    
    Specified by:
    
    write in class ByteOutput
    
    Parameters:
    
    value - the bytes to be written. Upon returning from this call, the position of this buffer will be set to the limit
    
    Throws:
    
    IOException - thrown if an error occurred while writing
  - writeBool
```
public abstract void writeBool(int fieldNumber,
                               boolean value)
                        throws IOException
```
    Write a bool field, including tag, to the stream.
    
    Throws:
    
    IOException
  - writeBoolNoTag
```
public final void writeBoolNoTag(boolean value)
                          throws IOException
```
    Write a bool field to the stream.
    
    Throws:
    
    IOException
  - writeByteArray
```
public abstract void writeByteArray(int fieldNumber,
                                    byte[] value)
                             throws IOException
```
    Write a bytes field, including tag, to the stream.
    
    Throws:
    
    IOException
  - writeByteArray
```
public abstract void writeByteArray(int fieldNumber,
                                    byte[] value,
                                    int offset,
                                    int length)
                             throws IOException
```
    Write a bytes field, including tag, to the stream.
    
    Throws:
    
    IOException
  - writeByteArrayNoTag
```
public final void writeByteArrayNoTag(byte[] value)
                               throws IOException
```
    Write a bytes field to the stream.
    
    Throws:
    
    IOException
  - writeByteBuffer
```
public abstract void writeByteBuffer(int fieldNumber,
                                     ByteBuffer value)
                              throws IOException
```
    Write a bytes field, including tag, to the stream. This method will write all content of the ByteBuffer regardless of the current position and limit (i.e., the number of bytes to be written is value.capacity(), not value.remaining()). Furthermore, this method doesn't alter the state of the passed-in ByteBuffer. Its position, limit, mark, etc. will remain unchanged. If you only want to write the remaining bytes of a ByteBuffer, you can call writeByteBuffer(fieldNumber, byteBuffer.slice()).
    
    Throws:
    
    IOException
  - writeBytes
```
public abstract void writeBytes(int fieldNumber,
                                ByteString value)
                         throws IOException
```
    Write a bytes field, including tag, to the stream.
    
    Throws:
    
    IOException
  - writeBytesNoTag
```
public abstract void writeBytesNoTag(ByteString value)
                              throws IOException
```
    Write a bytes field to the stream.
    
    Throws:
    
    IOException
  - writeDouble
```
public final void writeDouble(int fieldNumber,
                              double value)
                       throws IOException
```
    Write a double field, including tag, to the stream.
    
    Throws:
    
    IOException
  - writeDoubleNoTag
```
public final void writeDoubleNoTag(double value)
                            throws IOException
```
    Write a double field to the stream.
    
    Throws:
    
    IOException
  - writeEnum
```
public final void writeEnum(int fieldNumber,
                            int value)
                     throws IOException
```
    Write an enum field, including tag, to the stream. The provided value is the numeric value used to represent the enum value on the wire (not the enum ordinal value).
    
    Throws:
    
    IOException
  - writeEnumNoTag
```
public final void writeEnumNoTag(int value)
                          throws IOException
```
    Write an enum field to the stream. The provided value is the numeric value used to represent the enum value on the wire (not the enum ordinal value).
    
    Throws:
    
    IOException
  - writeFixed32
```
public abstract void writeFixed32(int fieldNumber,
                                  int value)
                           throws IOException
```
    Write a fixed32 field, including tag, to the stream.
    
    Throws:
    
    IOException
  - writeFixed32NoTag
```
public abstract void writeFixed32NoTag(int value)
                                throws IOException
```
    Write a fixed32 field to the stream.
    
    Throws:
    
    IOException
  - writeFixed64
```
public abstract void writeFixed64(int fieldNumber,
                                  long value)
                           throws IOException
```
    Write a fixed64 field, including tag, to the stream.
    
    Throws:
    
    IOException
  - writeFixed64NoTag
```
public abstract void writeFixed64NoTag(long value)
                                throws IOException
```
    Write a fixed64 field to the stream.
    
    Throws:
    
    IOException
  - writeFloat
```
public final void writeFloat(int fieldNumber,
                             float value)
                      throws IOException
```
    Write a float field, including tag, to the stream.
    
    Throws:
    
    IOException
  - writeFloatNoTag
```
public final void writeFloatNoTag(float value)
                           throws IOException
```
    Write a float field to the stream.
    
    Throws:
    
    IOException
  - writeInt32
```
public abstract void writeInt32(int fieldNumber,
                                int value)
                         throws IOException
```
    Write an int32 field, including tag, to the stream.
    
    Throws:
    
    IOException
  - writeInt32NoTag
```
public abstract void writeInt32NoTag(int value)
                              throws IOException
```
    Write an int32 field to the stream.
    
    Throws:
    
    IOException
  - writeInt64
```
public final void writeInt64(int fieldNumber,
                             long value)
                      throws IOException
```
    Write an int64 field, including tag, to the stream.
    
    Throws:
    
    IOException
  - writeInt64NoTag
```
public final void writeInt64NoTag(long value)
                           throws IOException
```
    Write an int64 field to the stream.
    
    Throws:
    
    IOException
  - writeLazy
```
@ExperimentalApi
public abstract void writeLazy(byte[] value,
                                                int offset,
                                                int length)
                                         throws IOException
```
    Description copied from class: ByteOutput
    
    Writes a sequence of bytes. The ByteOutput is free to retain a reference to the value beyond the scope of this method call (e.g. write later) since it is considered immutable and is guaranteed not to change by the caller.
    NOTE: This method MUST NOT modify the value. Doing so is a programming error and will lead to data corruption which will be difficult to debug.
    
    Specified by:
    
    writeLazy in class ByteOutput
    
    Parameters:
    
    value - the bytes to be written
    
    offset - the offset of the start of the writable range
    
    length - the number of bytes to write starting from offset
    
    Throws:
    
    IOException - thrown if an error occurred while writing
  - writeLazy
```
@ExperimentalApi
public abstract void writeLazy(ByteBuffer value)
                                         throws IOException
```
    Description copied from class: ByteOutput
    
    Writes a sequence of bytes. The ByteOutput is free to retain a reference to the value beyond the scope of this method call (e.g. write later) since it is considered immutable and is guaranteed not to change by the caller.
    NOTE: This method MUST NOT modify the value. Doing so is a programming error and will lead to data corruption which will be difficult to debug.
    
    Specified by:
    
    writeLazy in class ByteOutput
    
    Parameters:
    
    value - the bytes to be written. Upon returning from this call, the position of this buffer will be set to the limit
    
    Throws:
    
    IOException - thrown if an error occurred while writing
  - writeMessage
```
public abstract void writeMessage(int fieldNumber,
                                  MessageLite value)
                           throws IOException
```
    Write an embedded message field, including tag, to the stream.
    
    Throws:
    
    IOException
  - writeMessageNoTag
```
public abstract void writeMessageNoTag(MessageLite value)
                                throws IOException
```
    Write an embedded message field to the stream.
    
    Throws:
    
    IOException
  - writeMessageSetExtension
```
public abstract void writeMessageSetExtension(int fieldNumber,
                                              MessageLite value)
                                       throws IOException
```
    Write a MessageSet extension field to the stream. For historical reasons, the wire format differs from normal fields.
    
    Throws:
    
    IOException
  - writeRawByte
```
public final void writeRawByte(byte value)
                        throws IOException
```
    Write a single byte.
    
    Throws:
    
    IOException
  - writeRawByte
```
public final void writeRawByte(int value)
                        throws IOException
```
    Write a single byte, represented by an integer value.
    
    Throws:
    
    IOException
  - writeRawBytes
```
public final void writeRawBytes(byte[] value)
                         throws IOException
```
    Write an array of bytes.
    
    Throws:
    
    IOException
  - writeRawBytes
```
public final void writeRawBytes(byte[] value,
                                int offset,
                                int length)
                         throws IOException
```
    Write part of an array of bytes.
    
    Throws:
    
    IOException
  - writeRawBytes
```
public abstract void writeRawBytes(ByteBuffer value)
                            throws IOException
```
    Write a ByteBuffer. This method will write all content of the ByteBuffer regardless of the current position and limit (i.e., the number of bytes to be written is value.capacity(), not value.remaining()). Furthermore, this method doesn't alter the state of the passed-in ByteBuffer. Its position, limit, mark, etc. will remain unchanged. If you only want to write the remaining bytes of a ByteBuffer, you can call writeRawBytes(byteBuffer.slice()).
    
    Throws:
    
    IOException
  - writeRawBytes
```
public final void writeRawBytes(ByteString value)
                         throws IOException
```
    Write a byte string.
    
    Throws:
    
    IOException
  - writeRawMessageSetExtension
```
public abstract void writeRawMessageSetExtension(int fieldNumber,
                                                 ByteString value)
                                          throws IOException
```
    Write an unparsed MessageSet extension field to the stream. For historical reasons, the wire format differs from normal fields.
    
    Throws:
    
    IOException
  - writeSFixed32
```
public final void writeSFixed32(int fieldNumber,
                                int value)
                         throws IOException
```
    Write an sfixed32 field, including tag, to the stream.
    
    Throws:
    
    IOException
  - writeSFixed32NoTag
```
public final void writeSFixed32NoTag(int value)
                              throws IOException
```
    Write a sfixed32 field to the stream.
    
    Throws:
    
    IOException
  - writeSFixed64
```
public final void writeSFixed64(int fieldNumber,
                                long value)
                         throws IOException
```
    Write an sfixed64 field, including tag, to the stream.
    
    Throws:
    
    IOException
  - writeSFixed64NoTag
```
public final void writeSFixed64NoTag(long value)
                              throws IOException
```
    Write a sfixed64 field to the stream.
    
    Throws:
    
    IOException
  - writeSInt32
```
public final void writeSInt32(int fieldNumber,
                              int value)
                       throws IOException
```
    Write a sint32 field, including tag, to the stream.
    
    Throws:
    
    IOException
  - writeSInt32NoTag
```
public final void writeSInt32NoTag(int value)
                            throws IOException
```
    Write a sint32 field to the stream.
    
    Throws:
    
    IOException
  - writeSInt64
```
public final void writeSInt64(int fieldNumber,
                              long value)
                       throws IOException
```
    Write an sint64 field, including tag, to the stream.
    
    Throws:
    
    IOException
  - writeSInt64NoTag
```
public final void writeSInt64NoTag(long value)
                            throws IOException
```
    Write a sint64 field to the stream.
    
    Throws:
    
    IOException
  - writeString
```
public abstract void writeString(int fieldNumber,
                                 String value)
                          throws IOException
```
    Write a string field, including tag, to the stream.
    
    Throws:
    
    IOException
  - writeStringNoTag
```
public abstract void writeStringNoTag(String value)
                               throws IOException
```
    Write a string field to the stream.
    
    Throws:
    
    IOException
  - writeTag
```
public abstract void writeTag(int fieldNumber,
                              int wireType)
                       throws IOException
```
    Encode and write a tag.
    
    Throws:
    
    IOException
  - writeUInt32
```
public abstract void writeUInt32(int fieldNumber,
                                 int value)
                          throws IOException
```
    Write a uint32 field, including tag, to the stream.
    
    Throws:
    
    IOException
  - writeUInt32NoTag
```
public abstract void writeUInt32NoTag(int value)
                               throws IOException
```
    Write a uint32 field to the stream.
    
    Throws:
    
    IOException
  - writeUInt64
```
public abstract void writeUInt64(int fieldNumber,
                                 long value)
                          throws IOException
```
    Write a uint64 field, including tag, to the stream.
    
    Throws:
    
    IOException
  - writeUInt64NoTag
```
public abstract void writeUInt64NoTag(long value)
                               throws IOException
```
    Write a uint64 field to the stream.
    
    Throws:
    
    IOException

Class CodedOutputStream

Nested Class Summary

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DEFAULT_BUFFER_SIZE

Method Detail

checkNoSpaceLeft

computeBoolSize

computeBoolSizeNoTag

computeByteArraySize

computeByteArraySizeNoTag

computeByteBufferSize

computeByteBufferSizeNoTag

computeBytesSize

computeBytesSizeNoTag

computeDoubleSize

computeDoubleSizeNoTag

computeEnumSize

computeEnumSizeNoTag

computeFixed32Size

computeFixed32SizeNoTag

computeFixed64Size

computeFixed64SizeNoTag

computeFloatSize

computeFloatSizeNoTag

computeGroupSizeNoTag

computeInt32Size

computeInt32SizeNoTag

computeInt64Size

computeInt64SizeNoTag

computeLazyFieldMessageSetExtensionSize

computeLazyFieldSize

computeLazyFieldSizeNoTag

computeMessageSetExtensionSize

computeMessageSize

computeMessageSizeNoTag

computeRawMessageSetExtensionSize

computeSFixed32Size

computeSFixed32SizeNoTag

computeSFixed64Size

computeSFixed64SizeNoTag

computeSInt32Size

computeSInt32SizeNoTag

computeSInt64Size

computeSInt64SizeNoTag

computeStringSize

computeStringSizeNoTag

computeTagSize

computeUInt32Size

computeUInt32SizeNoTag

computeUInt64Size

computeUInt64SizeNoTag

encodeZigZag32

encodeZigZag64

flush

getTotalBytesWritten

newInstance

newInstance

newInstance

newInstance

newInstance

spaceLeft

write

write

write

writeBool

writeBoolNoTag

writeByteArray

writeByteArray

writeByteArrayNoTag

writeByteBuffer

writeBytes

writeBytesNoTag

writeDouble

writeDoubleNoTag

writeEnum

writeEnumNoTag

writeFixed32