| // Protocol Buffers - Google's data interchange format |
| // Copyright 2008 Google Inc. All rights reserved. |
| // http://code.google.com/p/protobuf/ |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are |
| // met: |
| // |
| // * Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // * Redistributions in binary form must reproduce the above |
| // copyright notice, this list of conditions and the following disclaimer |
| // in the documentation and/or other materials provided with the |
| // distribution. |
| // * Neither the name of Google Inc. nor the names of its |
| // contributors may be used to endorse or promote products derived from |
| // this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| package com.google.protobuf; |
| |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.io.UnsupportedEncodingException; |
| |
| /** |
| * Encodes and writes protocol message fields. |
| * |
| * <p>This class contains two kinds of methods: methods that write specific |
| * protocol message constructs and field types (e.g. {@link #writeTag} and |
| * {@link #writeInt32}) and methods that write low-level values (e.g. |
| * {@link #writeRawVarint32} and {@link #writeRawBytes}). 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. |
| * |
| * <p>This class is totally unsynchronized. |
| * |
| * @author kneton@google.com Kenton Varda |
| */ |
| public final class CodedOutputStream { |
| private final byte[] buffer; |
| private final int limit; |
| private int position; |
| |
| private final OutputStream output; |
| |
| /** |
| * The buffer size used in {@link #newInstance(OutputStream)}. |
| */ |
| public static final int DEFAULT_BUFFER_SIZE = 4096; |
| |
| /** |
| * Returns the buffer size to efficiently write dataLength bytes to this |
| * CodedOutputStream. Used by AbstractMessageLite. |
| * |
| * @return the buffer size to efficiently write dataLength bytes to this |
| * CodedOutputStream. |
| */ |
| static int computePreferredBufferSize(int dataLength) { |
| if (dataLength > DEFAULT_BUFFER_SIZE) return DEFAULT_BUFFER_SIZE; |
| return dataLength; |
| } |
| |
| private CodedOutputStream(final byte[] buffer, final int offset, |
| final int length) { |
| output = null; |
| this.buffer = buffer; |
| position = offset; |
| limit = offset + length; |
| } |
| |
| private CodedOutputStream(final OutputStream output, final byte[] buffer) { |
| this.output = output; |
| this.buffer = buffer; |
| position = 0; |
| limit = buffer.length; |
| } |
| |
| /** |
| * Create a new {@code CodedOutputStream} wrapping the given |
| * {@code OutputStream}. |
| */ |
| public static CodedOutputStream newInstance(final OutputStream output) { |
| return newInstance(output, DEFAULT_BUFFER_SIZE); |
| } |
| |
| /** |
| * Create a new {@code CodedOutputStream} wrapping the given |
| * {@code OutputStream} with a given buffer size. |
| */ |
| public static CodedOutputStream newInstance(final OutputStream output, |
| final int bufferSize) { |
| return new CodedOutputStream(output, new byte[bufferSize]); |
| } |
| |
| /** |
| * Create a new {@code CodedOutputStream} that writes directly to the given |
| * byte array. If more bytes are written than fit in the array, |
| * {@link OutOfSpaceException} will be thrown. Writing directly to a flat |
| * array is faster than writing to an {@code OutputStream}. See also |
| * {@link ByteString#newCodedBuilder}. |
| */ |
| public static CodedOutputStream newInstance(final byte[] flatArray) { |
| return newInstance(flatArray, 0, flatArray.length); |
| } |
| |
| /** |
| * Create a new {@code CodedOutputStream} that writes directly to the given |
| * byte array slice. If more bytes are written than fit in the slice, |
| * {@link OutOfSpaceException} will be thrown. Writing directly to a flat |
| * array is faster than writing to an {@code OutputStream}. See also |
| * {@link ByteString#newCodedBuilder}. |
| */ |
| public static CodedOutputStream newInstance(final byte[] flatArray, |
| final int offset, |
| final int length) { |
| return new CodedOutputStream(flatArray, offset, length); |
| } |
| |
| // ----------------------------------------------------------------- |
| |
| /** Write a {@code double} field, including tag, to the stream. */ |
| public void writeDouble(final int fieldNumber, final double value) |
| throws IOException { |
| writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED64); |
| writeDoubleNoTag(value); |
| } |
| |
| /** Write a {@code float} field, including tag, to the stream. */ |
| public void writeFloat(final int fieldNumber, final float value) |
| throws IOException { |
| writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED32); |
| writeFloatNoTag(value); |
| } |
| |
| /** Write a {@code uint64} field, including tag, to the stream. */ |
| public void writeUInt64(final int fieldNumber, final long value) |
| throws IOException { |
| writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT); |
| writeUInt64NoTag(value); |
| } |
| |
| /** Write an {@code int64} field, including tag, to the stream. */ |
| public void writeInt64(final int fieldNumber, final long value) |
| throws IOException { |
| writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT); |
| writeInt64NoTag(value); |
| } |
| |
| /** Write an {@code int32} field, including tag, to the stream. */ |
| public void writeInt32(final int fieldNumber, final int value) |
| throws IOException { |
| writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT); |
| writeInt32NoTag(value); |
| } |
| |
| /** Write a {@code fixed64} field, including tag, to the stream. */ |
| public void writeFixed64(final int fieldNumber, final long value) |
| throws IOException { |
| writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED64); |
| writeFixed64NoTag(value); |
| } |
| |
| /** Write a {@code fixed32} field, including tag, to the stream. */ |
| public void writeFixed32(final int fieldNumber, final int value) |
| throws IOException { |
| writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED32); |
| writeFixed32NoTag(value); |
| } |
| |
| /** Write a {@code bool} field, including tag, to the stream. */ |
| public void writeBool(final int fieldNumber, final boolean value) |
| throws IOException { |
| writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT); |
| writeBoolNoTag(value); |
| } |
| |
| /** Write a {@code string} field, including tag, to the stream. */ |
| public void writeString(final int fieldNumber, final String value) |
| throws IOException { |
| writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED); |
| writeStringNoTag(value); |
| } |
| |
| /** Write a {@code group} field, including tag, to the stream. */ |
| public void writeGroup(final int fieldNumber, final MessageLite value) |
| throws IOException { |
| writeTag(fieldNumber, WireFormat.WIRETYPE_START_GROUP); |
| writeGroupNoTag(value); |
| writeTag(fieldNumber, WireFormat.WIRETYPE_END_GROUP); |
| } |
| |
| /** |
| * Write a group represented by an {@link UnknownFieldSet}. |
| * |
| * @deprecated UnknownFieldSet now implements MessageLite, so you can just |
| * call {@link #writeGroup}. |
| */ |
| @Deprecated |
| public void writeUnknownGroup(final int fieldNumber, |
| final MessageLite value) |
| throws IOException { |
| writeGroup(fieldNumber, value); |
| } |
| |
| /** Write an embedded message field, including tag, to the stream. */ |
| public void writeMessage(final int fieldNumber, final MessageLite value) |
| throws IOException { |
| writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED); |
| writeMessageNoTag(value); |
| } |
| |
| /** Write a {@code bytes} field, including tag, to the stream. */ |
| public void writeBytes(final int fieldNumber, final ByteString value) |
| throws IOException { |
| writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED); |
| writeBytesNoTag(value); |
| } |
| |
| /** Write a {@code uint32} field, including tag, to the stream. */ |
| public void writeUInt32(final int fieldNumber, final int value) |
| throws IOException { |
| writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT); |
| writeUInt32NoTag(value); |
| } |
| |
| /** |
| * Write an enum field, including tag, to the stream. Caller is responsible |
| * for converting the enum value to its numeric value. |
| */ |
| public void writeEnum(final int fieldNumber, final int value) |
| throws IOException { |
| writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT); |
| writeEnumNoTag(value); |
| } |
| |
| /** Write an {@code sfixed32} field, including tag, to the stream. */ |
| public void writeSFixed32(final int fieldNumber, final int value) |
| throws IOException { |
| writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED32); |
| writeSFixed32NoTag(value); |
| } |
| |
| /** Write an {@code sfixed64} field, including tag, to the stream. */ |
| public void writeSFixed64(final int fieldNumber, final long value) |
| throws IOException { |
| writeTag(fieldNumber, WireFormat.WIRETYPE_FIXED64); |
| writeSFixed64NoTag(value); |
| } |
| |
| /** Write an {@code sint32} field, including tag, to the stream. */ |
| public void writeSInt32(final int fieldNumber, final int value) |
| throws IOException { |
| writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT); |
| writeSInt32NoTag(value); |
| } |
| |
| /** Write an {@code sint64} field, including tag, to the stream. */ |
| public void writeSInt64(final int fieldNumber, final long value) |
| throws IOException { |
| writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT); |
| writeSInt64NoTag(value); |
| } |
| |
| /** |
| * Write a MessageSet extension field to the stream. For historical reasons, |
| * the wire format differs from normal fields. |
| */ |
| public void writeMessageSetExtension(final int fieldNumber, |
| final MessageLite value) |
| throws IOException { |
| writeTag(WireFormat.MESSAGE_SET_ITEM, WireFormat.WIRETYPE_START_GROUP); |
| writeUInt32(WireFormat.MESSAGE_SET_TYPE_ID, fieldNumber); |
| writeMessage(WireFormat.MESSAGE_SET_MESSAGE, value); |
| writeTag(WireFormat.MESSAGE_SET_ITEM, WireFormat.WIRETYPE_END_GROUP); |
| } |
| |
| /** |
| * Write an unparsed MessageSet extension field to the stream. For |
| * historical reasons, the wire format differs from normal fields. |
| */ |
| public void writeRawMessageSetExtension(final int fieldNumber, |
| final ByteString value) |
| throws IOException { |
| writeTag(WireFormat.MESSAGE_SET_ITEM, WireFormat.WIRETYPE_START_GROUP); |
| writeUInt32(WireFormat.MESSAGE_SET_TYPE_ID, fieldNumber); |
| writeBytes(WireFormat.MESSAGE_SET_MESSAGE, value); |
| writeTag(WireFormat.MESSAGE_SET_ITEM, WireFormat.WIRETYPE_END_GROUP); |
| } |
| |
| // ----------------------------------------------------------------- |
| |
| /** Write a {@code double} field to the stream. */ |
| public void writeDoubleNoTag(final double value) throws IOException { |
| writeRawLittleEndian64(Double.doubleToRawLongBits(value)); |
| } |
| |
| /** Write a {@code float} field to the stream. */ |
| public void writeFloatNoTag(final float value) throws IOException { |
| writeRawLittleEndian32(Float.floatToRawIntBits(value)); |
| } |
| |
| /** Write a {@code uint64} field to the stream. */ |
| public void writeUInt64NoTag(final long value) throws IOException { |
| writeRawVarint64(value); |
| } |
| |
| /** Write an {@code int64} field to the stream. */ |
| public void writeInt64NoTag(final long value) throws IOException { |
| writeRawVarint64(value); |
| } |
| |
| /** Write an {@code int32} field to the stream. */ |
| public void writeInt32NoTag(final int value) throws IOException { |
| if (value >= 0) { |
| writeRawVarint32(value); |
| } else { |
| // Must sign-extend. |
| writeRawVarint64(value); |
| } |
| } |
| |
| /** Write a {@code fixed64} field to the stream. */ |
| public void writeFixed64NoTag(final long value) throws IOException { |
| writeRawLittleEndian64(value); |
| } |
| |
| /** Write a {@code fixed32} field to the stream. */ |
| public void writeFixed32NoTag(final int value) throws IOException { |
| writeRawLittleEndian32(value); |
| } |
| |
| /** Write a {@code bool} field to the stream. */ |
| public void writeBoolNoTag(final boolean value) throws IOException { |
| writeRawByte(value ? 1 : 0); |
| } |
| |
| /** Write a {@code string} field to the stream. */ |
| public void writeStringNoTag(final String value) throws IOException { |
| // Unfortunately there does not appear to be any way to tell Java to encode |
| // UTF-8 directly into our buffer, so we have to let it create its own byte |
| // array and then copy. |
| final byte[] bytes = value.getBytes("UTF-8"); |
| writeRawVarint32(bytes.length); |
| writeRawBytes(bytes); |
| } |
| |
| /** Write a {@code group} field to the stream. */ |
| public void writeGroupNoTag(final MessageLite value) throws IOException { |
| value.writeTo(this); |
| } |
| |
| /** |
| * Write a group represented by an {@link UnknownFieldSet}. |
| * |
| * @deprecated UnknownFieldSet now implements MessageLite, so you can just |
| * call {@link #writeGroupNoTag}. |
| */ |
| @Deprecated |
| public void writeUnknownGroupNoTag(final MessageLite value) |
| throws IOException { |
| writeGroupNoTag(value); |
| } |
| |
| /** Write an embedded message field to the stream. */ |
| public void writeMessageNoTag(final MessageLite value) throws IOException { |
| writeRawVarint32(value.getSerializedSize()); |
| value.writeTo(this); |
| } |
| |
| /** Write a {@code bytes} field to the stream. */ |
| public void writeBytesNoTag(final ByteString value) throws IOException { |
| writeRawVarint32(value.size()); |
| writeRawBytes(value); |
| } |
| |
| /** Write a {@code uint32} field to the stream. */ |
| public void writeUInt32NoTag(final int value) throws IOException { |
| writeRawVarint32(value); |
| } |
| |
| /** |
| * Write an enum field to the stream. Caller is responsible |
| * for converting the enum value to its numeric value. |
| */ |
| public void writeEnumNoTag(final int value) throws IOException { |
| writeInt32NoTag(value); |
| } |
| |
| /** Write an {@code sfixed32} field to the stream. */ |
| public void writeSFixed32NoTag(final int value) throws IOException { |
| writeRawLittleEndian32(value); |
| } |
| |
| /** Write an {@code sfixed64} field to the stream. */ |
| public void writeSFixed64NoTag(final long value) throws IOException { |
| writeRawLittleEndian64(value); |
| } |
| |
| /** Write an {@code sint32} field to the stream. */ |
| public void writeSInt32NoTag(final int value) throws IOException { |
| writeRawVarint32(encodeZigZag32(value)); |
| } |
| |
| /** Write an {@code sint64} field to the stream. */ |
| public void writeSInt64NoTag(final long value) throws IOException { |
| writeRawVarint64(encodeZigZag64(value)); |
| } |
| |
| // ================================================================= |
| |
| /** |
| * Compute the number of bytes that would be needed to encode a |
| * {@code double} field, including tag. |
| */ |
| public static int computeDoubleSize(final int fieldNumber, |
| final double value) { |
| return computeTagSize(fieldNumber) + computeDoubleSizeNoTag(value); |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode a |
| * {@code float} field, including tag. |
| */ |
| public static int computeFloatSize(final int fieldNumber, final float value) { |
| return computeTagSize(fieldNumber) + computeFloatSizeNoTag(value); |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode a |
| * {@code uint64} field, including tag. |
| */ |
| public static int computeUInt64Size(final int fieldNumber, final long value) { |
| return computeTagSize(fieldNumber) + computeUInt64SizeNoTag(value); |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode an |
| * {@code int64} field, including tag. |
| */ |
| public static int computeInt64Size(final int fieldNumber, final long value) { |
| return computeTagSize(fieldNumber) + computeInt64SizeNoTag(value); |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode an |
| * {@code int32} field, including tag. |
| */ |
| public static int computeInt32Size(final int fieldNumber, final int value) { |
| return computeTagSize(fieldNumber) + computeInt32SizeNoTag(value); |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode a |
| * {@code fixed64} field, including tag. |
| */ |
| public static int computeFixed64Size(final int fieldNumber, |
| final long value) { |
| return computeTagSize(fieldNumber) + computeFixed64SizeNoTag(value); |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode a |
| * {@code fixed32} field, including tag. |
| */ |
| public static int computeFixed32Size(final int fieldNumber, |
| final int value) { |
| return computeTagSize(fieldNumber) + computeFixed32SizeNoTag(value); |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode a |
| * {@code bool} field, including tag. |
| */ |
| public static int computeBoolSize(final int fieldNumber, |
| final boolean value) { |
| return computeTagSize(fieldNumber) + computeBoolSizeNoTag(value); |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode a |
| * {@code string} field, including tag. |
| */ |
| public static int computeStringSize(final int fieldNumber, |
| final String value) { |
| return computeTagSize(fieldNumber) + computeStringSizeNoTag(value); |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode a |
| * {@code group} field, including tag. |
| */ |
| public static int computeGroupSize(final int fieldNumber, |
| final MessageLite value) { |
| return computeTagSize(fieldNumber) * 2 + computeGroupSizeNoTag(value); |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode a |
| * {@code group} field represented by an {@code UnknownFieldSet}, including |
| * tag. |
| * |
| * @deprecated UnknownFieldSet now implements MessageLite, so you can just |
| * call {@link #computeGroupSize}. |
| */ |
| @Deprecated |
| public static int computeUnknownGroupSize(final int fieldNumber, |
| final MessageLite value) { |
| return computeGroupSize(fieldNumber, value); |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode an |
| * embedded message field, including tag. |
| */ |
| public static int computeMessageSize(final int fieldNumber, |
| final MessageLite value) { |
| return computeTagSize(fieldNumber) + computeMessageSizeNoTag(value); |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode a |
| * {@code bytes} field, including tag. |
| */ |
| public static int computeBytesSize(final int fieldNumber, |
| final ByteString value) { |
| return computeTagSize(fieldNumber) + computeBytesSizeNoTag(value); |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode an |
| * embedded message in lazy field, including tag. |
| */ |
| public static int computeLazyFieldSize(final int fieldNumber, |
| final LazyField value) { |
| return computeTagSize(fieldNumber) + computeLazyFieldSizeNoTag(value); |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode a |
| * {@code uint32} field, including tag. |
| */ |
| public static int computeUInt32Size(final int fieldNumber, final int value) { |
| return computeTagSize(fieldNumber) + computeUInt32SizeNoTag(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. |
| */ |
| public static int computeEnumSize(final int fieldNumber, final int value) { |
| return computeTagSize(fieldNumber) + computeEnumSizeNoTag(value); |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode an |
| * {@code sfixed32} field, including tag. |
| */ |
| public static int computeSFixed32Size(final int fieldNumber, |
| final int value) { |
| return computeTagSize(fieldNumber) + computeSFixed32SizeNoTag(value); |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode an |
| * {@code sfixed64} field, including tag. |
| */ |
| public static int computeSFixed64Size(final int fieldNumber, |
| final long value) { |
| return computeTagSize(fieldNumber) + computeSFixed64SizeNoTag(value); |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode an |
| * {@code sint32} field, including tag. |
| */ |
| public static int computeSInt32Size(final int fieldNumber, final int value) { |
| return computeTagSize(fieldNumber) + computeSInt32SizeNoTag(value); |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode an |
| * {@code sint64} field, including tag. |
| */ |
| public static int computeSInt64Size(final int fieldNumber, final long value) { |
| return computeTagSize(fieldNumber) + computeSInt64SizeNoTag(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. |
| */ |
| public static int computeMessageSetExtensionSize( |
| final int fieldNumber, final MessageLite value) { |
| return computeTagSize(WireFormat.MESSAGE_SET_ITEM) * 2 + |
| computeUInt32Size(WireFormat.MESSAGE_SET_TYPE_ID, fieldNumber) + |
| computeMessageSize(WireFormat.MESSAGE_SET_MESSAGE, 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. |
| */ |
| public static int computeRawMessageSetExtensionSize( |
| final int fieldNumber, final ByteString value) { |
| return computeTagSize(WireFormat.MESSAGE_SET_ITEM) * 2 + |
| computeUInt32Size(WireFormat.MESSAGE_SET_TYPE_ID, fieldNumber) + |
| computeBytesSize(WireFormat.MESSAGE_SET_MESSAGE, 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. |
| */ |
| public static int computeLazyFieldMessageSetExtensionSize( |
| final int fieldNumber, final LazyField value) { |
| return computeTagSize(WireFormat.MESSAGE_SET_ITEM) * 2 + |
| computeUInt32Size(WireFormat.MESSAGE_SET_TYPE_ID, fieldNumber) + |
| computeLazyFieldSize(WireFormat.MESSAGE_SET_MESSAGE, value); |
| } |
| |
| // ----------------------------------------------------------------- |
| |
| /** |
| * Compute the number of bytes that would be needed to encode a |
| * {@code double} field, including tag. |
| */ |
| public static int computeDoubleSizeNoTag(final double value) { |
| return LITTLE_ENDIAN_64_SIZE; |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode a |
| * {@code float} field, including tag. |
| */ |
| public static int computeFloatSizeNoTag(final float value) { |
| return LITTLE_ENDIAN_32_SIZE; |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode a |
| * {@code uint64} field, including tag. |
| */ |
| public static int computeUInt64SizeNoTag(final long value) { |
| return computeRawVarint64Size(value); |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode an |
| * {@code int64} field, including tag. |
| */ |
| public static int computeInt64SizeNoTag(final long value) { |
| return computeRawVarint64Size(value); |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode an |
| * {@code int32} field, including tag. |
| */ |
| public static int computeInt32SizeNoTag(final int value) { |
| if (value >= 0) { |
| return computeRawVarint32Size(value); |
| } else { |
| // Must sign-extend. |
| return 10; |
| } |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode a |
| * {@code fixed64} field. |
| */ |
| public static int computeFixed64SizeNoTag(final long value) { |
| return LITTLE_ENDIAN_64_SIZE; |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode a |
| * {@code fixed32} field. |
| */ |
| public static int computeFixed32SizeNoTag(final int value) { |
| return LITTLE_ENDIAN_32_SIZE; |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode a |
| * {@code bool} field. |
| */ |
| public static int computeBoolSizeNoTag(final boolean value) { |
| return 1; |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode a |
| * {@code string} field. |
| */ |
| public static int computeStringSizeNoTag(final String value) { |
| try { |
| final byte[] bytes = value.getBytes("UTF-8"); |
| return computeRawVarint32Size(bytes.length) + |
| bytes.length; |
| } catch (UnsupportedEncodingException e) { |
| throw new RuntimeException("UTF-8 not supported.", e); |
| } |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode a |
| * {@code group} field. |
| */ |
| public static int computeGroupSizeNoTag(final MessageLite value) { |
| return value.getSerializedSize(); |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode a |
| * {@code group} field represented by an {@code UnknownFieldSet}, including |
| * tag. |
| * |
| * @deprecated UnknownFieldSet now implements MessageLite, so you can just |
| * call {@link #computeUnknownGroupSizeNoTag}. |
| */ |
| @Deprecated |
| public static int computeUnknownGroupSizeNoTag(final MessageLite value) { |
| return computeGroupSizeNoTag(value); |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode an embedded |
| * message field. |
| */ |
| public static int computeMessageSizeNoTag(final MessageLite value) { |
| final int size = value.getSerializedSize(); |
| return computeRawVarint32Size(size) + size; |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode an embedded |
| * message stored in lazy field. |
| */ |
| public static int computeLazyFieldSizeNoTag(final LazyField value) { |
| final int size = value.getSerializedSize(); |
| return computeRawVarint32Size(size) + size; |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode a |
| * {@code bytes} field. |
| */ |
| public static int computeBytesSizeNoTag(final ByteString value) { |
| return computeRawVarint32Size(value.size()) + |
| value.size(); |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode a |
| * {@code uint32} field. |
| */ |
| public static int computeUInt32SizeNoTag(final int value) { |
| return computeRawVarint32Size(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. |
| */ |
| public static int computeEnumSizeNoTag(final int value) { |
| return computeInt32SizeNoTag(value); |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode an |
| * {@code sfixed32} field. |
| */ |
| public static int computeSFixed32SizeNoTag(final int value) { |
| return LITTLE_ENDIAN_32_SIZE; |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode an |
| * {@code sfixed64} field. |
| */ |
| public static int computeSFixed64SizeNoTag(final long value) { |
| return LITTLE_ENDIAN_64_SIZE; |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode an |
| * {@code sint32} field. |
| */ |
| public static int computeSInt32SizeNoTag(final int value) { |
| return computeRawVarint32Size(encodeZigZag32(value)); |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode an |
| * {@code sint64} field. |
| */ |
| public static int computeSInt64SizeNoTag(final long value) { |
| return computeRawVarint64Size(encodeZigZag64(value)); |
| } |
| |
| // ================================================================= |
| |
| /** |
| * Internal helper that writes the current buffer to the output. The |
| * buffer position is reset to its initial value when this returns. |
| */ |
| private void refreshBuffer() throws IOException { |
| if (output == null) { |
| // We're writing to a single buffer. |
| throw new OutOfSpaceException(); |
| } |
| |
| // Since we have an output stream, this is our buffer |
| // and buffer offset == 0 |
| output.write(buffer, 0, position); |
| position = 0; |
| } |
| |
| /** |
| * Flushes the stream and forces any buffered bytes to be written. This |
| * does not flush the underlying OutputStream. |
| */ |
| public void flush() throws IOException { |
| if (output != null) { |
| refreshBuffer(); |
| } |
| } |
| |
| /** |
| * If writing to a flat array, return the space left in the array. |
| * Otherwise, throws {@code UnsupportedOperationException}. |
| */ |
| public int spaceLeft() { |
| if (output == null) { |
| return limit - position; |
| } else { |
| throw new UnsupportedOperationException( |
| "spaceLeft() can only be called on CodedOutputStreams that are " + |
| "writing to a flat array."); |
| } |
| } |
| |
| /** |
| * Verifies that {@link #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 {@code CodedOutputStream}. Calling {@code checkNoSpaceLeft()} |
| * after writing verifies that the message was actually as big as expected, |
| * which can help catch bugs. |
| */ |
| public void checkNoSpaceLeft() { |
| if (spaceLeft() != 0) { |
| throw new IllegalStateException( |
| "Did not write as much data as expected."); |
| } |
| } |
| |
| /** |
| * If you create a CodedOutputStream around a simple flat array, you must |
| * not attempt to write more bytes than the array has space. Otherwise, |
| * this exception will be thrown. |
| */ |
| public static class OutOfSpaceException extends IOException { |
| private static final long serialVersionUID = -6947486886997889499L; |
| |
| OutOfSpaceException() { |
| super("CodedOutputStream was writing to a flat byte array and ran " + |
| "out of space."); |
| } |
| } |
| |
| /** Write a single byte. */ |
| public void writeRawByte(final byte value) throws IOException { |
| if (position == limit) { |
| refreshBuffer(); |
| } |
| |
| buffer[position++] = value; |
| } |
| |
| /** Write a single byte, represented by an integer value. */ |
| public void writeRawByte(final int value) throws IOException { |
| writeRawByte((byte) value); |
| } |
| |
| /** Write a byte string. */ |
| public void writeRawBytes(final ByteString value) throws IOException { |
| writeRawBytes(value, 0, value.size()); |
| } |
| |
| /** Write an array of bytes. */ |
| public void writeRawBytes(final byte[] value) throws IOException { |
| writeRawBytes(value, 0, value.length); |
| } |
| |
| /** Write part of an array of bytes. */ |
| public void writeRawBytes(final byte[] value, int offset, int length) |
| throws IOException { |
| if (limit - position >= length) { |
| // We have room in the current buffer. |
| System.arraycopy(value, offset, buffer, position, length); |
| position += length; |
| } else { |
| // Write extends past current buffer. Fill the rest of this buffer and |
| // flush. |
| final int bytesWritten = limit - position; |
| System.arraycopy(value, offset, buffer, position, bytesWritten); |
| offset += bytesWritten; |
| length -= bytesWritten; |
| position = limit; |
| refreshBuffer(); |
| |
| // Now deal with the rest. |
| // Since we have an output stream, this is our buffer |
| // and buffer offset == 0 |
| if (length <= limit) { |
| // Fits in new buffer. |
| System.arraycopy(value, offset, buffer, 0, length); |
| position = length; |
| } else { |
| // Write is very big. Let's do it all at once. |
| output.write(value, offset, length); |
| } |
| } |
| } |
| |
| /** Write part of a byte string. */ |
| public void writeRawBytes(final ByteString value, int offset, int length) |
| throws IOException { |
| if (limit - position >= length) { |
| // We have room in the current buffer. |
| value.copyTo(buffer, offset, position, length); |
| position += length; |
| } else { |
| // Write extends past current buffer. Fill the rest of this buffer and |
| // flush. |
| final int bytesWritten = limit - position; |
| value.copyTo(buffer, offset, position, bytesWritten); |
| offset += bytesWritten; |
| length -= bytesWritten; |
| position = limit; |
| refreshBuffer(); |
| |
| // Now deal with the rest. |
| // Since we have an output stream, this is our buffer |
| // and buffer offset == 0 |
| if (length <= limit) { |
| // Fits in new buffer. |
| value.copyTo(buffer, offset, 0, length); |
| position = length; |
| } else { |
| // Write is very big, but we can't do it all at once without allocating |
| // an a copy of the byte array since ByteString does not give us access |
| // to the underlying bytes. Use the InputStream interface on the |
| // ByteString and our buffer to copy between the two. |
| InputStream inputStreamFrom = value.newInput(); |
| if (offset != inputStreamFrom.skip(offset)) { |
| throw new IllegalStateException("Skip failed? Should never happen."); |
| } |
| // Use the buffer as the temporary buffer to avoid allocating memory. |
| while (length > 0) { |
| int bytesToRead = Math.min(length, limit); |
| int bytesRead = inputStreamFrom.read(buffer, 0, bytesToRead); |
| if (bytesRead != bytesToRead) { |
| throw new IllegalStateException("Read failed? Should never happen"); |
| } |
| output.write(buffer, 0, bytesRead); |
| length -= bytesRead; |
| } |
| } |
| } |
| } |
| |
| /** Encode and write a tag. */ |
| public void writeTag(final int fieldNumber, final int wireType) |
| throws IOException { |
| writeRawVarint32(WireFormat.makeTag(fieldNumber, wireType)); |
| } |
| |
| /** Compute the number of bytes that would be needed to encode a tag. */ |
| public static int computeTagSize(final int fieldNumber) { |
| return computeRawVarint32Size(WireFormat.makeTag(fieldNumber, 0)); |
| } |
| |
| /** |
| * Encode and write a varint. {@code value} is treated as |
| * unsigned, so it won't be sign-extended if negative. |
| */ |
| public void writeRawVarint32(int value) throws IOException { |
| while (true) { |
| if ((value & ~0x7F) == 0) { |
| writeRawByte(value); |
| return; |
| } else { |
| writeRawByte((value & 0x7F) | 0x80); |
| value >>>= 7; |
| } |
| } |
| } |
| |
| /** |
| * Compute the number of bytes that would be needed to encode a varint. |
| * {@code value} is treated as unsigned, so it won't be sign-extended if |
| * negative. |
| */ |
| public static int computeRawVarint32Size(final int value) { |
| if ((value & (0xffffffff << 7)) == 0) return 1; |
| if ((value & (0xffffffff << 14)) == 0) return 2; |
| if ((value & (0xffffffff << 21)) == 0) return 3; |
| if ((value & (0xffffffff << 28)) == 0) return 4; |
| return 5; |
| } |
| |
| /** Encode and write a varint. */ |
| public void writeRawVarint64(long value) throws IOException { |
| while (true) { |
| if ((value & ~0x7FL) == 0) { |
| writeRawByte((int)value); |
| return; |
| } else { |
| writeRawByte(((int)value & 0x7F) | 0x80); |
| value >>>= 7; |
| } |
| } |
| } |
| |
| /** Compute the number of bytes that would be needed to encode a varint. */ |
| public static int computeRawVarint64Size(final long value) { |
| if ((value & (0xffffffffffffffffL << 7)) == 0) return 1; |
| if ((value & (0xffffffffffffffffL << 14)) == 0) return 2; |
| if ((value & (0xffffffffffffffffL << 21)) == 0) return 3; |
| if ((value & (0xffffffffffffffffL << 28)) == 0) return 4; |
| if ((value & (0xffffffffffffffffL << 35)) == 0) return 5; |
| if ((value & (0xffffffffffffffffL << 42)) == 0) return 6; |
| if ((value & (0xffffffffffffffffL << 49)) == 0) return 7; |
| if ((value & (0xffffffffffffffffL << 56)) == 0) return 8; |
| if ((value & (0xffffffffffffffffL << 63)) == 0) return 9; |
| return 10; |
| } |
| |
| /** Write a little-endian 32-bit integer. */ |
| public void writeRawLittleEndian32(final int value) throws IOException { |
| writeRawByte((value ) & 0xFF); |
| writeRawByte((value >> 8) & 0xFF); |
| writeRawByte((value >> 16) & 0xFF); |
| writeRawByte((value >> 24) & 0xFF); |
| } |
| |
| public static final int LITTLE_ENDIAN_32_SIZE = 4; |
| |
| /** Write a little-endian 64-bit integer. */ |
| public void writeRawLittleEndian64(final long value) throws IOException { |
| writeRawByte((int)(value ) & 0xFF); |
| writeRawByte((int)(value >> 8) & 0xFF); |
| writeRawByte((int)(value >> 16) & 0xFF); |
| writeRawByte((int)(value >> 24) & 0xFF); |
| writeRawByte((int)(value >> 32) & 0xFF); |
| writeRawByte((int)(value >> 40) & 0xFF); |
| writeRawByte((int)(value >> 48) & 0xFF); |
| writeRawByte((int)(value >> 56) & 0xFF); |
| } |
| |
| public static final int LITTLE_ENDIAN_64_SIZE = 8; |
| |
| /** |
| * 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.) |
| * |
| * @param n A signed 32-bit integer. |
| * @return An unsigned 32-bit integer, stored in a signed int because |
| * Java has no explicit unsigned support. |
| */ |
| public static int encodeZigZag32(final int n) { |
| // Note: the right-shift must be arithmetic |
| return (n << 1) ^ (n >> 31); |
| } |
| |
| /** |
| * 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.) |
| * |
| * @param n A signed 64-bit integer. |
| * @return An unsigned 64-bit integer, stored in a signed int because |
| * Java has no explicit unsigned support. |
| */ |
| public static long encodeZigZag64(final long n) { |
| // Note: the right-shift must be arithmetic |
| return (n << 1) ^ (n >> 63); |
| } |
| } |
