diff --git a/Makefile.am b/Makefile.am index 83f1043d..fac76c43 100644 --- a/Makefile.am +++ b/Makefile.am @@ -187,6 +187,44 @@ csharp_EXTRA_DIST= \ csharp/src/packages/repositories.config java_EXTRA_DIST= \ + java/core/src/main/java/com/google/protobuf/AllocatedBuffer.java \ + java/core/src/main/java/com/google/protobuf/BinaryProtocolUtil.java \ + java/core/src/main/java/com/google/protobuf/BinaryReader.java \ + java/core/src/main/java/com/google/protobuf/BinaryWriter.java \ + java/core/src/main/java/com/google/protobuf/BufferAllocator.java \ + java/core/src/main/java/com/google/protobuf/FieldInfo.java \ + java/core/src/main/java/com/google/protobuf/Int2ObjectHashMap.java \ + java/core/src/main/java/com/google/protobuf/MessageInfo.java \ + java/core/src/main/java/com/google/protobuf/MessageInfoFactory.java \ + java/core/src/main/java/com/google/protobuf/Protobuf.java \ + java/core/src/main/java/com/google/protobuf/ProtobufLists.java \ + java/core/src/main/java/com/google/protobuf/Reader.java \ + java/core/src/main/java/com/google/protobuf/Schema.java \ + java/core/src/main/java/com/google/protobuf/SchemaFactory.java \ + java/core/src/main/java/com/google/protobuf/SchemaUtil.java \ + java/core/src/main/java/com/google/protobuf/Writer.java \ + java/core/src/main/java/com/google/protobuf/DescriptorMessageInfoFactory.java \ + java/core/src/main/java/com/google/protobuf/AbstractProto2LiteSchema.java \ + java/core/src/main/java/com/google/protobuf/AbstractProto2Schema.java \ + java/core/src/main/java/com/google/protobuf/AbstractProto2StandardSchema.java \ + java/core/src/main/java/com/google/protobuf/AbstractProto3LiteSchema.java \ + java/core/src/main/java/com/google/protobuf/AbstractProto3Schema.java \ + java/core/src/main/java/com/google/protobuf/AbstractProto3StandardSchema.java \ + java/core/src/main/java/com/google/protobuf/Proto2LiteLookupSchema.java \ + java/core/src/main/java/com/google/protobuf/Proto2LiteTableSchema.java \ + java/core/src/main/java/com/google/protobuf/Proto2LookupSchema.java \ + java/core/src/main/java/com/google/protobuf/Proto2Manifest.java \ + java/core/src/main/java/com/google/protobuf/Proto2SchemaFactory.java \ + java/core/src/main/java/com/google/protobuf/Proto2TableSchema.java \ + java/core/src/main/java/com/google/protobuf/Proto3LiteLookupSchema.java \ + java/core/src/main/java/com/google/protobuf/Proto3LiteTableSchema.java \ + java/core/src/main/java/com/google/protobuf/Proto3LookupSchema.java \ + java/core/src/main/java/com/google/protobuf/Proto3Manifest.java \ + java/core/src/main/java/com/google/protobuf/Proto3SchemaFactory.java \ + java/core/src/main/java/com/google/protobuf/Proto3TableSchema.java \ + java/core/src/main/java/com/google/protobuf/ProtoSyntax.java \ + java/core/src/main/java/com/google/protobuf/FieldType.java \ + java/core/src/main/java/com/google/protobuf/JavaType.java \ java/README.md \ java/core/generate-sources-build.xml \ java/core/generate-test-sources-build.xml \ diff --git a/java/core/src/main/java/com/google/protobuf/AbstractProto2LiteSchema.java b/java/core/src/main/java/com/google/protobuf/AbstractProto2LiteSchema.java new file mode 100644 index 00000000..d23fe978 --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/AbstractProto2LiteSchema.java @@ -0,0 +1,183 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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 static com.google.protobuf.Proto2Manifest.FIELD_LENGTH; +import static com.google.protobuf.Proto2Manifest.offset; +import static com.google.protobuf.Proto2Manifest.type; + +/** Base class for all proto2-lite-based schemas. */ +abstract class AbstractProto2LiteSchema extends AbstractProto2Schema { + final Class messageClass; + + public AbstractProto2LiteSchema(Class messageClass, Proto2Manifest manifest) { + super(manifest); + this.messageClass = messageClass; + } + + @SuppressWarnings("unchecked") + @Override + public final T newInstance() { + T msg = (T) UnsafeUtil.allocateInstance(messageClass); + for (long pos = manifest.address; pos < manifest.limit; pos += FIELD_LENGTH) { + final int typeAndOffset = manifest.typeAndOffsetAt(pos); + switch (type(typeAndOffset)) { + case 0: //DOUBLE: + case 1: //FLOAT: + case 2: //INT64: + case 3: //UINT64: + case 4: //INT32: + case 5: //FIXED64: + case 6: //FIXED32: + case 7: //BOOL: + case 9: //MESSAGE: + case 11: //UINT32: + case 12: //ENUM: + case 13: //SFIXED32: + case 14: //SFIXED64: + case 15: //SINT32: + case 16: //SINT64: + // Do nothing, just use default values. + break; + case 8: //STRING: + UnsafeUtil.putObject(msg, offset(typeAndOffset), ""); + break; + case 10: //BYTES: + UnsafeUtil.putObject(msg, offset(typeAndOffset), ByteString.EMPTY); + break; + case 17: //DOUBLE_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), DoubleArrayList.emptyList()); + break; + case 18: //FLOAT_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), FloatArrayList.emptyList()); + break; + case 19: //INT64_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), LongArrayList.emptyList()); + break; + case 20: //UINT64_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), LongArrayList.emptyList()); + break; + case 21: //INT32_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), IntArrayList.emptyList()); + break; + case 22: //FIXED64_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), LongArrayList.emptyList()); + break; + case 23: //FIXED32_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), IntArrayList.emptyList()); + break; + case 24: //BOOL_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), BooleanArrayList.emptyList()); + break; + case 25: //STRING_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), LazyStringArrayList.EMPTY); + break; + case 26: //MESSAGE_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), ProtobufArrayList.emptyList()); + break; + case 27: //BYTES_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), ProtobufArrayList.emptyList()); + break; + case 28: //UINT32_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), IntArrayList.emptyList()); + break; + case 29: //ENUM_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), IntArrayList.emptyList()); + break; + case 30: //SFIXED32_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), IntArrayList.emptyList()); + break; + case 31: //SFIXED64_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), LongArrayList.emptyList()); + break; + case 32: //SINT32_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), IntArrayList.emptyList()); + break; + case 33: //SINT64_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), LongArrayList.emptyList()); + break; + case 34: //DOUBLE_LIST_PACKED: + UnsafeUtil.putObject(msg, offset(typeAndOffset), DoubleArrayList.emptyList()); + break; + case 35: //FLOAT_LIST_PACKED: + UnsafeUtil.putObject(msg, offset(typeAndOffset), FloatArrayList.emptyList()); + break; + case 36: //INT64_LIST_PACKED: + UnsafeUtil.putObject(msg, offset(typeAndOffset), LongArrayList.emptyList()); + break; + case 37: //UINT64_LIST_PACKED: + UnsafeUtil.putObject(msg, offset(typeAndOffset), LongArrayList.emptyList()); + break; + case 38: //INT32_LIST_PACKED: + UnsafeUtil.putObject(msg, offset(typeAndOffset), IntArrayList.emptyList()); + break; + case 39: //FIXED64_LIST_PACKED: + UnsafeUtil.putObject(msg, offset(typeAndOffset), LongArrayList.emptyList()); + break; + case 40: //FIXED32_LIST_PACKED: + UnsafeUtil.putObject(msg, offset(typeAndOffset), IntArrayList.emptyList()); + break; + case 41: //BOOL_LIST_PACKED: + UnsafeUtil.putObject(msg, offset(typeAndOffset), BooleanArrayList.emptyList()); + break; + case 42: //UINT32_LIST_PACKED: + UnsafeUtil.putObject(msg, offset(typeAndOffset), IntArrayList.emptyList()); + break; + case 43: //ENUM_LIST_PACKED: + UnsafeUtil.putObject(msg, offset(typeAndOffset), IntArrayList.emptyList()); + break; + case 44: //SFIXED32_LIST_PACKED: + UnsafeUtil.putObject(msg, offset(typeAndOffset), IntArrayList.emptyList()); + break; + case 45: //SFIXED64_LIST_PACKED: + UnsafeUtil.putObject(msg, offset(typeAndOffset), LongArrayList.emptyList()); + break; + case 46: //SINT32_LIST_PACKED: + UnsafeUtil.putObject(msg, offset(typeAndOffset), IntArrayList.emptyList()); + break; + case 47: //SINT64_LIST_PACKED: + UnsafeUtil.putObject(msg, offset(typeAndOffset), LongArrayList.emptyList()); + break; + case -4: //GROUP: + break; + case -3: //GROUP_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), ProtobufArrayList.emptyList()); + break; + default: + break; + } + } + + // Initialize the base class fields. + SchemaUtil.initLiteBaseClassFields(msg); + return msg; + } +} diff --git a/java/core/src/main/java/com/google/protobuf/AbstractProto2Schema.java b/java/core/src/main/java/com/google/protobuf/AbstractProto2Schema.java new file mode 100644 index 00000000..fd701682 --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/AbstractProto2Schema.java @@ -0,0 +1,400 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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 static com.google.protobuf.Proto2Manifest.FIELD_LENGTH; +import static com.google.protobuf.Proto2Manifest.offset; +import static com.google.protobuf.Proto2Manifest.type; + +import java.util.List; + +/** Abstract base class for all proto3-based schemas. */ +abstract class AbstractProto2Schema implements Schema { + protected final Proto2Manifest manifest; + + public AbstractProto2Schema(Proto2Manifest manifest) { + this.manifest = manifest; + } + + @SuppressWarnings("unchecked") + @Override + public final void writeTo(T message, Writer writer) { + for (long pos = manifest.address; pos < manifest.limit; pos += FIELD_LENGTH) { + final int typeAndOffset = manifest.typeAndOffsetAt(pos); + + // Benchmarks have shown that switching on a byte is faster than an enum. + switch (type(typeAndOffset)) { + case 0: //DOUBLE: + if (manifest.isFieldPresent(message, pos)) { + writer.writeDouble( + manifest.numberAt(pos), UnsafeUtil.getDouble(message, offset(typeAndOffset))); + } + break; + case 1: //FLOAT: + if (manifest.isFieldPresent(message, pos)) { + writer.writeFloat( + manifest.numberAt(pos), UnsafeUtil.getFloat(message, offset(typeAndOffset))); + } + break; + case 2: //INT64: + if (manifest.isFieldPresent(message, pos)) { + writer.writeInt64( + manifest.numberAt(pos), UnsafeUtil.getLong(message, offset(typeAndOffset))); + } + break; + case 3: //UINT64: + if (manifest.isFieldPresent(message, pos)) { + writer.writeUInt64( + manifest.numberAt(pos), UnsafeUtil.getLong(message, offset(typeAndOffset))); + } + break; + case 4: //INT32: + if (manifest.isFieldPresent(message, pos)) { + writer.writeInt32( + manifest.numberAt(pos), UnsafeUtil.getInt(message, offset(typeAndOffset))); + } + break; + case 5: //FIXED64: + if (manifest.isFieldPresent(message, pos)) { + writer.writeFixed64( + manifest.numberAt(pos), UnsafeUtil.getLong(message, offset(typeAndOffset))); + } + break; + case 6: //FIXED32: + if (manifest.isFieldPresent(message, pos)) { + writer.writeFixed32( + manifest.numberAt(pos), UnsafeUtil.getInt(message, offset(typeAndOffset))); + } + break; + case 7: //BOOL: + if (manifest.isFieldPresent(message, pos)) { + writer.writeBool( + manifest.numberAt(pos), UnsafeUtil.getBoolean(message, offset(typeAndOffset))); + } + break; + case 8: //STRING: + if (manifest.isFieldPresent(message, pos)) { + writeString( + manifest.numberAt(pos), + UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer); + } + break; + case 9: //MESSAGE: + if (manifest.isFieldPresent(message, pos)) { + writer.writeMessage( + manifest.numberAt(pos), UnsafeUtil.getObject(message, offset(typeAndOffset))); + } + break; + case 10: //BYTES: + if (manifest.isFieldPresent(message, pos)) { + writer.writeBytes( + manifest.numberAt(pos), + (ByteString) UnsafeUtil.getObject(message, offset(typeAndOffset))); + } + break; + case 11: //UINT32: + if (manifest.isFieldPresent(message, pos)) { + writer.writeUInt32( + manifest.numberAt(pos), UnsafeUtil.getInt(message, offset(typeAndOffset))); + } + break; + case 12: //ENUM: + if (manifest.isFieldPresent(message, pos)) { + writer.writeEnum( + manifest.numberAt(pos), UnsafeUtil.getInt(message, offset(typeAndOffset))); + } + break; + case 13: //SFIXED32: + if (manifest.isFieldPresent(message, pos)) { + writer.writeSFixed32( + manifest.numberAt(pos), UnsafeUtil.getInt(message, offset(typeAndOffset))); + } + break; + case 14: //SFIXED64: + if (manifest.isFieldPresent(message, pos)) { + writer.writeSFixed64( + manifest.numberAt(pos), UnsafeUtil.getLong(message, offset(typeAndOffset))); + } + break; + case 15: //SINT32: + if (manifest.isFieldPresent(message, pos)) { + writer.writeSInt32( + manifest.numberAt(pos), UnsafeUtil.getInt(message, offset(typeAndOffset))); + } + break; + case 16: //SINT64: + if (manifest.isFieldPresent(message, pos)) { + writer.writeSInt64( + manifest.numberAt(pos), UnsafeUtil.getLong(message, offset(typeAndOffset))); + } + break; + case 17: //DOUBLE_LIST: + SchemaUtil.writeDoubleList( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + false); + break; + case 18: //FLOAT_LIST: + SchemaUtil.writeFloatList( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + false); + break; + case 19: //INT64_LIST: + SchemaUtil.writeInt64List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + false); + break; + case 20: //UINT64_LIST: + SchemaUtil.writeUInt64List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + false); + break; + case 21: //INT32_LIST: + SchemaUtil.writeInt32List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + false); + break; + case 22: //FIXED64_LIST: + SchemaUtil.writeFixed64List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + false); + break; + case 23: //FIXED32_LIST: + SchemaUtil.writeFixed32List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + false); + break; + case 24: //BOOL_LIST: + SchemaUtil.writeBoolList( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + false); + break; + case 25: //STRING_LIST: + SchemaUtil.writeStringList( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer); + break; + case 26: //MESSAGE_LIST: + SchemaUtil.writeMessageList( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer); + break; + case 27: //BYTES_LIST: + SchemaUtil.writeBytesList( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer); + break; + case 28: //UINT32_LIST: + SchemaUtil.writeUInt32List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + false); + break; + case 29: //ENUM_LIST: + SchemaUtil.writeEnumList( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + false); + break; + case 30: //SFIXED32_LIST: + SchemaUtil.writeSFixed32List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + false); + break; + case 31: //SFIXED64_LIST: + SchemaUtil.writeSFixed64List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + false); + break; + case 32: //SINT32_LIST: + SchemaUtil.writeSInt32List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + false); + break; + case 33: //SINT64_LIST: + SchemaUtil.writeSInt64List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + false); + break; + case 34: //DOUBLE_LIST_PACKED: + SchemaUtil.writeDoubleList( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + true); + break; + case 35: //FLOAT_LIST_PACKED: + SchemaUtil.writeFloatList( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + true); + break; + case 36: //INT64_LIST_PACKED: + SchemaUtil.writeInt64List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + true); + break; + case 37: //UINT64_LIST_PACKED: + SchemaUtil.writeUInt64List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + true); + break; + case 38: //INT32_LIST_PACKED: + SchemaUtil.writeInt32List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + true); + break; + case 39: //FIXED64_LIST_PACKED: + SchemaUtil.writeFixed64List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + true); + break; + case 40: //FIXED32_LIST_PACKED: + SchemaUtil.writeFixed32List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + true); + break; + case 41: //BOOL_LIST_PACKED: + SchemaUtil.writeBoolList( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + true); + break; + case 42: //UINT32_LIST_PACKED: + SchemaUtil.writeUInt32List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + true); + break; + case 43: //ENUM_LIST_PACKED: + SchemaUtil.writeEnumList( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + true); + break; + case 44: //SFIXED32_LIST_PACKED: + SchemaUtil.writeSFixed32List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + true); + break; + case 45: //SFIXED64_LIST_PACKED: + SchemaUtil.writeSFixed64List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + true); + break; + case 46: //SINT32_LIST_PACKED: + SchemaUtil.writeSInt32List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + true); + break; + case 47: //SINT64_LIST_PACKED: + SchemaUtil.writeSInt64List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + true); + break; + case -4: //GROUP: + if (manifest.isFieldPresent(message, pos)) { + writer.writeGroup( + manifest.numberAt(pos), UnsafeUtil.getObject(message, offset(typeAndOffset))); + } + break; + case -3: //GROUP_LIST: + SchemaUtil.writeGroupList( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer); + break; + default: + // Assume it's an empty entry - just go to the next entry. + break; + } + } + } + + private void writeString(int fieldNumber, Object value, Writer writer) { + if (value instanceof String) { + writer.writeString(fieldNumber, (String) value); + } else { + writer.writeBytes(fieldNumber, (ByteString) value); + } + } +} diff --git a/java/core/src/main/java/com/google/protobuf/AbstractProto2StandardSchema.java b/java/core/src/main/java/com/google/protobuf/AbstractProto2StandardSchema.java new file mode 100644 index 00000000..46a58a7b --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/AbstractProto2StandardSchema.java @@ -0,0 +1,127 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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 static com.google.protobuf.Proto2Manifest.FIELD_LENGTH; +import static com.google.protobuf.Proto2Manifest.offset; +import static com.google.protobuf.Proto2Manifest.type; + +import java.util.Collections; + +/** Abtract base class for standard (i.e. non-lite) proto2 schemas. */ +abstract class AbstractProto2StandardSchema extends AbstractProto2Schema { + final Class messageClass; + + public AbstractProto2StandardSchema(Class messageClass, Proto2Manifest manifest) { + super(manifest); + this.messageClass = messageClass; + } + + @SuppressWarnings("unchecked") + @Override + public final T newInstance() { + T msg = (T) UnsafeUtil.allocateInstance(messageClass); + for (long pos = manifest.address; pos < manifest.limit; pos += FIELD_LENGTH) { + final int typeAndOffset = manifest.typeAndOffsetAt(pos); + switch (type(typeAndOffset)) { + case 0: //DOUBLE: + case 1: //FLOAT: + case 2: //INT64: + case 3: //UINT64: + case 4: //INT32: + case 5: //FIXED64: + case 6: //FIXED32: + case 7: //BOOL: + case 9: //MESSAGE: + case 11: //UINT32: + case 12: //ENUM: + case 13: //SFIXED32: + case 14: //SFIXED64: + case 15: //SINT32: + case 16: //SINT64: + // Do nothing, just use default values. + break; + case 8: //STRING: + UnsafeUtil.putObject(msg, offset(typeAndOffset), ""); + break; + case 10: //BYTES: + UnsafeUtil.putObject(msg, offset(typeAndOffset), ByteString.EMPTY); + break; + case 17: //DOUBLE_LIST: + case 18: //FLOAT_LIST: + case 19: //INT64_LIST: + case 20: //UINT64_LIST: + case 21: //INT32_LIST: + case 22: //FIXED64_LIST: + case 23: //FIXED32_LIST: + case 24: //BOOL_LIST: + case 26: //MESSAGE_LIST: + case 27: //BYTES_LIST: + case 28: //UINT32_LIST: + case 29: //ENUM_LIST: + case 30: //SFIXED32_LIST: + case 31: //SFIXED64_LIST: + case 32: //SINT32_LIST: + case 33: //SINT64_LIST: + case 34: //DOUBLE_LIST_PACKED: + case 35: //FLOAT_LIST_PACKED: + case 36: //INT64_LIST_PACKED: + case 37: //UINT64_LIST_PACKED: + case 38: //INT32_LIST_PACKED: + case 39: //FIXED64_LIST_PACKED: + case 40: //FIXED32_LIST_PACKED: + case 41: //BOOL_LIST_PACKED: + case 42: //UINT32_LIST_PACKED: + case 43: //ENUM_LIST_PACKED: + case 44: //SFIXED32_LIST_PACKED: + case 45: //SFIXED64_LIST_PACKED: + case 46: //SINT32_LIST_PACKED: + case 47: //SINT64_LIST_PACKED: + UnsafeUtil.putObject(msg, offset(typeAndOffset), Collections.emptyList()); + break; + case 25: //STRING_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), LazyStringArrayList.EMPTY); + break; + case -4: //GROUP + break; + case -3: //GROUP_LIST + UnsafeUtil.putObject(msg, offset(typeAndOffset), Collections.emptyList()); + break; + default: + break; + } + } + + // Initialize the base class fields. + SchemaUtil.initBaseClassFields(msg); + return msg; + } +} diff --git a/java/core/src/main/java/com/google/protobuf/AbstractProto3LiteSchema.java b/java/core/src/main/java/com/google/protobuf/AbstractProto3LiteSchema.java new file mode 100644 index 00000000..ebb62ef9 --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/AbstractProto3LiteSchema.java @@ -0,0 +1,178 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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 static com.google.protobuf.Proto3Manifest.FIELD_LENGTH; +import static com.google.protobuf.Proto3Manifest.offset; +import static com.google.protobuf.Proto3Manifest.type; + +/** Base class for all proto3-lite-based schemas. */ +abstract class AbstractProto3LiteSchema extends AbstractProto3Schema { + final Class messageClass; + + public AbstractProto3LiteSchema(Class messageClass, Proto3Manifest manifest) { + super(manifest); + this.messageClass = messageClass; + } + + @SuppressWarnings("unchecked") + @Override + public final T newInstance() { + T msg = (T) UnsafeUtil.allocateInstance(messageClass); + for (long pos = manifest.address; pos < manifest.limit; pos += FIELD_LENGTH) { + final int typeAndOffset = manifest.typeAndOffsetAt(pos); + switch (type(typeAndOffset)) { + case 0: //DOUBLE: + case 1: //FLOAT: + case 2: //INT64: + case 3: //UINT64: + case 4: //INT32: + case 5: //FIXED64: + case 6: //FIXED32: + case 7: //BOOL: + case 9: //MESSAGE: + case 11: //UINT32: + case 12: //ENUM: + case 13: //SFIXED32: + case 14: //SFIXED64: + case 15: //SINT32: + case 16: //SINT64: + // Do nothing, just use default values. + break; + case 8: //STRING: + UnsafeUtil.putObject(msg, offset(typeAndOffset), ""); + break; + case 10: //BYTES: + UnsafeUtil.putObject(msg, offset(typeAndOffset), ByteString.EMPTY); + break; + case 17: //DOUBLE_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), DoubleArrayList.emptyList()); + break; + case 18: //FLOAT_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), FloatArrayList.emptyList()); + break; + case 19: //INT64_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), LongArrayList.emptyList()); + break; + case 20: //UINT64_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), LongArrayList.emptyList()); + break; + case 21: //INT32_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), IntArrayList.emptyList()); + break; + case 22: //FIXED64_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), LongArrayList.emptyList()); + break; + case 23: //FIXED32_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), IntArrayList.emptyList()); + break; + case 24: //BOOL_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), BooleanArrayList.emptyList()); + break; + case 25: //STRING_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), LazyStringArrayList.EMPTY); + break; + case 26: //MESSAGE_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), ProtobufArrayList.emptyList()); + break; + case 27: //BYTES_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), ProtobufArrayList.emptyList()); + break; + case 28: //UINT32_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), IntArrayList.emptyList()); + break; + case 29: //ENUM_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), IntArrayList.emptyList()); + break; + case 30: //SFIXED32_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), IntArrayList.emptyList()); + break; + case 31: //SFIXED64_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), LongArrayList.emptyList()); + break; + case 32: //SINT32_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), IntArrayList.emptyList()); + break; + case 33: //SINT64_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), LongArrayList.emptyList()); + break; + case 34: //DOUBLE_LIST_PACKED: + UnsafeUtil.putObject(msg, offset(typeAndOffset), DoubleArrayList.emptyList()); + break; + case 35: //FLOAT_LIST_PACKED: + UnsafeUtil.putObject(msg, offset(typeAndOffset), FloatArrayList.emptyList()); + break; + case 36: //INT64_LIST_PACKED: + UnsafeUtil.putObject(msg, offset(typeAndOffset), LongArrayList.emptyList()); + break; + case 37: //UINT64_LIST_PACKED: + UnsafeUtil.putObject(msg, offset(typeAndOffset), LongArrayList.emptyList()); + break; + case 38: //INT32_LIST_PACKED: + UnsafeUtil.putObject(msg, offset(typeAndOffset), IntArrayList.emptyList()); + break; + case 39: //FIXED64_LIST_PACKED: + UnsafeUtil.putObject(msg, offset(typeAndOffset), LongArrayList.emptyList()); + break; + case 40: //FIXED32_LIST_PACKED: + UnsafeUtil.putObject(msg, offset(typeAndOffset), IntArrayList.emptyList()); + break; + case 41: //BOOL_LIST_PACKED: + UnsafeUtil.putObject(msg, offset(typeAndOffset), BooleanArrayList.emptyList()); + break; + case 42: //UINT32_LIST_PACKED: + UnsafeUtil.putObject(msg, offset(typeAndOffset), IntArrayList.emptyList()); + break; + case 43: //ENUM_LIST_PACKED: + UnsafeUtil.putObject(msg, offset(typeAndOffset), IntArrayList.emptyList()); + break; + case 44: //SFIXED32_LIST_PACKED: + UnsafeUtil.putObject(msg, offset(typeAndOffset), IntArrayList.emptyList()); + break; + case 45: //SFIXED64_LIST_PACKED: + UnsafeUtil.putObject(msg, offset(typeAndOffset), LongArrayList.emptyList()); + break; + case 46: //SINT32_LIST_PACKED: + UnsafeUtil.putObject(msg, offset(typeAndOffset), IntArrayList.emptyList()); + break; + case 47: //SINT64_LIST_PACKED: + UnsafeUtil.putObject(msg, offset(typeAndOffset), LongArrayList.emptyList()); + break; + default: + break; + } + } + + // Initialize the base class fields. + SchemaUtil.initLiteBaseClassFields(msg); + return msg; + } +} diff --git a/java/core/src/main/java/com/google/protobuf/AbstractProto3Schema.java b/java/core/src/main/java/com/google/protobuf/AbstractProto3Schema.java new file mode 100644 index 00000000..e52b28f0 --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/AbstractProto3Schema.java @@ -0,0 +1,347 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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 static com.google.protobuf.Proto3Manifest.FIELD_LENGTH; +import static com.google.protobuf.Proto3Manifest.offset; +import static com.google.protobuf.Proto3Manifest.type; + +import java.util.List; + +/** Abstract base class for all proto3-based schemas. */ +abstract class AbstractProto3Schema implements Schema { + protected final Proto3Manifest manifest; + + public AbstractProto3Schema(Proto3Manifest manifest) { + this.manifest = manifest; + } + + @SuppressWarnings("unchecked") + @Override + public final void writeTo(T message, Writer writer) { + for (long pos = manifest.address; pos < manifest.limit; pos += FIELD_LENGTH) { + final int typeAndOffset = manifest.typeAndOffsetAt(pos); + + // Benchmarks have shown that switching on a byte is faster than an enum. + switch (type(typeAndOffset)) { + case 0: //DOUBLE: + SchemaUtil.writeDouble( + manifest.numberAt(pos), UnsafeUtil.getDouble(message, offset(typeAndOffset)), writer); + break; + case 1: //FLOAT: + SchemaUtil.writeFloat( + manifest.numberAt(pos), UnsafeUtil.getFloat(message, offset(typeAndOffset)), writer); + break; + case 2: //INT64: + SchemaUtil.writeInt64( + manifest.numberAt(pos), UnsafeUtil.getLong(message, offset(typeAndOffset)), writer); + break; + case 3: //UINT64: + SchemaUtil.writeUInt64( + manifest.numberAt(pos), UnsafeUtil.getLong(message, offset(typeAndOffset)), writer); + break; + case 4: //INT32: + SchemaUtil.writeInt32( + manifest.numberAt(pos), UnsafeUtil.getInt(message, offset(typeAndOffset)), writer); + break; + case 5: //FIXED64: + SchemaUtil.writeFixed64( + manifest.numberAt(pos), UnsafeUtil.getLong(message, offset(typeAndOffset)), writer); + break; + case 6: //FIXED32: + SchemaUtil.writeFixed32( + manifest.numberAt(pos), UnsafeUtil.getInt(message, offset(typeAndOffset)), writer); + break; + case 7: //BOOL: + SchemaUtil.writeBool( + manifest.numberAt(pos), + UnsafeUtil.getBoolean(message, offset(typeAndOffset)), + writer); + break; + case 8: //STRING: + SchemaUtil.writeString( + manifest.numberAt(pos), UnsafeUtil.getObject(message, offset(typeAndOffset)), writer); + break; + case 9: //MESSAGE: + SchemaUtil.writeMessage( + manifest.numberAt(pos), UnsafeUtil.getObject(message, offset(typeAndOffset)), writer); + break; + case 10: //BYTES: + SchemaUtil.writeBytes( + manifest.numberAt(pos), + (ByteString) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer); + break; + case 11: //UINT32: + SchemaUtil.writeUInt32( + manifest.numberAt(pos), UnsafeUtil.getInt(message, offset(typeAndOffset)), writer); + break; + case 12: //ENUM: + SchemaUtil.writeEnum( + manifest.numberAt(pos), UnsafeUtil.getInt(message, offset(typeAndOffset)), writer); + break; + case 13: //SFIXED32: + SchemaUtil.writeSFixed32( + manifest.numberAt(pos), UnsafeUtil.getInt(message, offset(typeAndOffset)), writer); + break; + case 14: //SFIXED64: + SchemaUtil.writeSFixed64( + manifest.numberAt(pos), UnsafeUtil.getLong(message, offset(typeAndOffset)), writer); + break; + case 15: //SINT32: + SchemaUtil.writeSInt32( + manifest.numberAt(pos), UnsafeUtil.getInt(message, offset(typeAndOffset)), writer); + break; + case 16: //SINT64: + SchemaUtil.writeSInt64( + manifest.numberAt(pos), UnsafeUtil.getLong(message, offset(typeAndOffset)), writer); + break; + case 17: //DOUBLE_LIST: + SchemaUtil.writeDoubleList( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + false); + break; + case 18: //FLOAT_LIST: + SchemaUtil.writeFloatList( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + false); + break; + case 19: //INT64_LIST: + SchemaUtil.writeInt64List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + false); + break; + case 20: //UINT64_LIST: + SchemaUtil.writeUInt64List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + false); + break; + case 21: //INT32_LIST: + SchemaUtil.writeInt32List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + false); + break; + case 22: //FIXED64_LIST: + SchemaUtil.writeFixed64List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + false); + break; + case 23: //FIXED32_LIST: + SchemaUtil.writeFixed32List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + false); + break; + case 24: //BOOL_LIST: + SchemaUtil.writeBoolList( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + false); + break; + case 25: //STRING_LIST: + SchemaUtil.writeStringList( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer); + break; + case 26: //MESSAGE_LIST: + SchemaUtil.writeMessageList( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer); + break; + case 27: //BYTES_LIST: + SchemaUtil.writeBytesList( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer); + break; + case 28: //UINT32_LIST: + SchemaUtil.writeUInt32List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + false); + break; + case 29: //ENUM_LIST: + SchemaUtil.writeEnumList( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + false); + break; + case 30: //SFIXED32_LIST: + SchemaUtil.writeSFixed32List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + false); + break; + case 31: //SFIXED64_LIST: + SchemaUtil.writeSFixed64List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + false); + break; + case 32: //SINT32_LIST: + SchemaUtil.writeSInt32List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + false); + break; + case 33: //SINT64_LIST: + SchemaUtil.writeSInt64List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + false); + break; + case 34: //DOUBLE_LIST_PACKED: + SchemaUtil.writeDoubleList( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + true); + break; + case 35: //FLOAT_LIST_PACKED: + SchemaUtil.writeFloatList( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + true); + break; + case 36: //INT64_LIST_PACKED: + SchemaUtil.writeInt64List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + true); + break; + case 37: //UINT64_LIST_PACKED: + SchemaUtil.writeUInt64List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + true); + break; + case 38: //INT32_LIST_PACKED: + SchemaUtil.writeInt32List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + true); + break; + case 39: //FIXED64_LIST_PACKED: + SchemaUtil.writeFixed64List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + true); + break; + case 40: //FIXED32_LIST_PACKED: + SchemaUtil.writeFixed32List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + true); + break; + case 41: //BOOL_LIST_PACKED: + SchemaUtil.writeBoolList( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + true); + break; + case 42: //UINT32_LIST_PACKED: + SchemaUtil.writeUInt32List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + true); + break; + case 43: //ENUM_LIST_PACKED: + SchemaUtil.writeEnumList( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + true); + break; + case 44: //SFIXED32_LIST_PACKED: + SchemaUtil.writeSFixed32List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + true); + break; + case 45: //SFIXED64_LIST_PACKED: + SchemaUtil.writeSFixed64List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + true); + break; + case 46: //SINT32_LIST_PACKED: + SchemaUtil.writeSInt32List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + true); + break; + case 47: //SINT64_LIST_PACKED: + SchemaUtil.writeSInt64List( + manifest.numberAt(pos), + (List) UnsafeUtil.getObject(message, offset(typeAndOffset)), + writer, + true); + break; + default: + // Assume it's an empty entry - just go to the next entry. + break; + } + } + } +} diff --git a/java/core/src/main/java/com/google/protobuf/AbstractProto3StandardSchema.java b/java/core/src/main/java/com/google/protobuf/AbstractProto3StandardSchema.java new file mode 100644 index 00000000..3c4f5072 --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/AbstractProto3StandardSchema.java @@ -0,0 +1,124 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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 static com.google.protobuf.Proto3Manifest.FIELD_LENGTH; +import static com.google.protobuf.Proto3Manifest.offset; +import static com.google.protobuf.Proto3Manifest.type; + +import java.util.Collections; + +/** + * Abtract base class for standard (i.e. non-lite) proto3 schemas. + */ +abstract class AbstractProto3StandardSchema extends AbstractProto3Schema { + final Class messageClass; + + public AbstractProto3StandardSchema(Class messageClass, Proto3Manifest manifest) { + super(manifest); + this.messageClass = messageClass; + } + + @SuppressWarnings("unchecked") + @Override + public final T newInstance() { + T msg = (T) UnsafeUtil.allocateInstance(messageClass); + for (long pos = manifest.address; pos < manifest.limit; pos += FIELD_LENGTH) { + final int typeAndOffset = manifest.typeAndOffsetAt(pos); + switch (type(typeAndOffset)) { + case 0: //DOUBLE: + case 1: //FLOAT: + case 2: //INT64: + case 3: //UINT64: + case 4: //INT32: + case 5: //FIXED64: + case 6: //FIXED32: + case 7: //BOOL: + case 9: //MESSAGE: + case 11: //UINT32: + case 12: //ENUM: + case 13: //SFIXED32: + case 14: //SFIXED64: + case 15: //SINT32: + case 16: //SINT64: + // Do nothing, just use default values. + break; + case 8: //STRING: + UnsafeUtil.putObject(msg, offset(typeAndOffset), ""); + break; + case 10: //BYTES: + UnsafeUtil.putObject(msg, offset(typeAndOffset), ByteString.EMPTY); + break; + case 17: //DOUBLE_LIST: + case 18: //FLOAT_LIST: + case 19: //INT64_LIST: + case 20: //UINT64_LIST: + case 21: //INT32_LIST: + case 22: //FIXED64_LIST: + case 23: //FIXED32_LIST: + case 24: //BOOL_LIST: + case 26: //MESSAGE_LIST: + case 27: //BYTES_LIST: + case 28: //UINT32_LIST: + case 29: //ENUM_LIST: + case 30: //SFIXED32_LIST: + case 31: //SFIXED64_LIST: + case 32: //SINT32_LIST: + case 33: //SINT64_LIST: + case 34: //DOUBLE_LIST_PACKED: + case 35: //FLOAT_LIST_PACKED: + case 36: //INT64_LIST_PACKED: + case 37: //UINT64_LIST_PACKED: + case 38: //INT32_LIST_PACKED: + case 39: //FIXED64_LIST_PACKED: + case 40: //FIXED32_LIST_PACKED: + case 41: //BOOL_LIST_PACKED: + case 42: //UINT32_LIST_PACKED: + case 43: //ENUM_LIST_PACKED: + case 44: //SFIXED32_LIST_PACKED: + case 45: //SFIXED64_LIST_PACKED: + case 46: //SINT32_LIST_PACKED: + case 47: //SINT64_LIST_PACKED: + UnsafeUtil.putObject(msg, offset(typeAndOffset), Collections.emptyList()); + break; + case 25: //STRING_LIST: + UnsafeUtil.putObject(msg, offset(typeAndOffset), LazyStringArrayList.EMPTY); + break; + default: + break; + } + } + + // Initialize the base class fields. + SchemaUtil.initBaseClassFields(msg); + return msg; + } +} diff --git a/java/core/src/main/java/com/google/protobuf/AllocatedBuffer.java b/java/core/src/main/java/com/google/protobuf/AllocatedBuffer.java new file mode 100644 index 00000000..4c822348 --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/AllocatedBuffer.java @@ -0,0 +1,263 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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 static com.google.protobuf.Internal.checkNotNull; + +import java.nio.ByteBuffer; + +/** + * A buffer that was allocated by a {@link BufferAllocator}. For every buffer, it is guaranteed that + * at least one of {@link #hasArray()} or {@link #hasNioBuffer()} will be {@code true}. + */ +@ExperimentalApi +public abstract class AllocatedBuffer { + /** + * Indicates whether this buffer contains a backing {@link ByteBuffer} (i.e. it is safe to call + * {@link #nioBuffer()}). + */ + public abstract boolean hasNioBuffer(); + + /** + * Indicates whether this buffer contains a backing array (i.e. it is safe to call {@link + * #array()}). + */ + public abstract boolean hasArray(); + + /** + * Returns the {@link ByteBuffer} that backs this buffer (optional operation). + * + *

Call {@link #hasNioBuffer()} before invoking this method in order to ensure that this buffer + * has a backing {@link ByteBuffer}. + * + * @return The {@link ByteBuffer} that backs this buffer + * @throws UnsupportedOperationException If this buffer is not backed by a {@link ByteBuffer}. + */ + public abstract ByteBuffer nioBuffer(); + + /** + * Returns the byte array that backs this buffer (optional operation). + * + *

Call {@link #hasArray()} before invoking this method in order to ensure that this buffer has + * an accessible backing array. + * + * @return The array that backs this buffer + * @throws java.nio.ReadOnlyBufferException If this buffer is backed by an array but is read-only + * @throws UnsupportedOperationException If this buffer is not backed by an accessible array + */ + public abstract byte[] array(); + + /** + * Returns the offset within this buffer's backing array of the first element of the buffer + * (optional operation). + * + *

If this buffer is backed by an array then {@link #position()} corresponds to the array index + * {@link #position()} {@code +} {@link #arrayOffset()}. + * + *

Invoke the {@link #hasArray hasArray} method before invoking this method in order to ensure + * that this buffer has an accessible backing array. + * + * @return The offset within this buffer's array of the first element of the buffer + * @throws java.nio.ReadOnlyBufferException If this buffer is backed by an array but is read-only + * @throws UnsupportedOperationException If this buffer is not backed by an accessible array + */ + public abstract int arrayOffset(); + + /** + * Returns this buffer's position. + * + * @return The position of this buffer + */ + public abstract int position(); + + /** + * Sets this buffer's position. + * + * @param position The new position value; must be non-negative and no larger than the current + * limit + * @return This buffer + * @throws IllegalArgumentException If the preconditions on {@code position} do not hold + */ + public abstract AllocatedBuffer position(int position); + + /** + * Returns this buffer's limit. + * + * @return The limit of this buffer + */ + public abstract int limit(); + + /** + * Returns the number of elements between the current {@link #position()} and the {@link #limit()} + * . + * + * @return The number of elements remaining in this buffer + */ + public abstract int remaining(); + + /** + * Creates a new {@link AllocatedBuffer} that is backed by the given array. The returned buffer + * will have {@link #hasArray} == {@code true}, {@link #arrayOffset()} == {@code 0}, {@link + * #position()} == {@code 0} and {@link #limit()} equal to the length of {@code bytes}. + */ + public static AllocatedBuffer wrap(byte[] bytes) { + return wrapNoCheck(bytes, 0, bytes.length); + } + + /** + * Creates a new {@link AllocatedBuffer} that is backed by the given array. The returned buffer + * will have {@link #hasArray} == {@code true}, {@link #arrayOffset()} == {@code offset}, {@link + * #position()} == {@code 0} and {@link #limit()} == {@code length}. + */ + public static AllocatedBuffer wrap(final byte[] bytes, final int offset, final int length) { + if (offset < 0 || length < 0 || (offset + length) > bytes.length) { + throw new IndexOutOfBoundsException( + String.format("bytes.length=%d, offset=%d, lenght=%d", bytes.length, offset, length)); + } + + return wrapNoCheck(bytes, offset, length); + } + + /** + * Creates a new {@link AllocatedBuffer} that is backed by the given {@link ByteBuffer}. The + * returned buffer will have {@link #hasNioBuffer} == {@code true}. + */ + public static AllocatedBuffer wrap(final ByteBuffer buffer) { + checkNotNull(buffer, "buffer"); + + return new AllocatedBuffer() { + + @Override + public boolean hasNioBuffer() { + return true; + } + + @Override + public ByteBuffer nioBuffer() { + return buffer; + } + + @Override + public boolean hasArray() { + return buffer.hasArray(); + } + + @Override + public byte[] array() { + return buffer.array(); + } + + @Override + public int arrayOffset() { + return buffer.arrayOffset(); + } + + @Override + public int position() { + return buffer.position(); + } + + @Override + public AllocatedBuffer position(int position) { + buffer.position(position); + return this; + } + + @Override + public int limit() { + return buffer.limit(); + } + + @Override + public int remaining() { + return buffer.remaining(); + } + }; + } + + private static AllocatedBuffer wrapNoCheck( + final byte[] bytes, final int offset, final int length) { + return new AllocatedBuffer() { + // Relative to offset. + private int position; + + @Override + public boolean hasNioBuffer() { + return false; + } + + @Override + public ByteBuffer nioBuffer() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean hasArray() { + return true; + } + + @Override + public byte[] array() { + return bytes; + } + + @Override + public int arrayOffset() { + return offset; + } + + @Override + public int position() { + return position; + } + + @Override + public AllocatedBuffer position(int position) { + if (position < 0 || position > length) { + throw new IllegalArgumentException("Invalid position: " + position); + } + this.position = position; + return this; + } + + @Override + public int limit() { + // Relative to offset. + return length; + } + + @Override + public int remaining() { + return length - position; + } + }; + } +} diff --git a/java/core/src/main/java/com/google/protobuf/BinaryProtocolUtil.java b/java/core/src/main/java/com/google/protobuf/BinaryProtocolUtil.java new file mode 100644 index 00000000..8143785e --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/BinaryProtocolUtil.java @@ -0,0 +1,117 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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; + +/** Common methods and constants for the binary protobuf protocol. */ +@ExperimentalApi +final class BinaryProtocolUtil { + private BinaryProtocolUtil() {} + + private static final int TAG_TYPE_BITS = 3; + private static final int TAG_TYPE_MASK = (1 << TAG_TYPE_BITS) - 1; + + static final byte WIRETYPE_VARINT = 0; + static final byte WIRETYPE_FIXED64 = 1; + static final byte WIRETYPE_LENGTH_DELIMITED = 2; + static final byte WIRETYPE_START_GROUP = 3; + static final byte WIRETYPE_END_GROUP = 4; + static final byte WIRETYPE_FIXED32 = 5; + static final byte MAX_VARINT32_SIZE = 5; + static final byte MAX_VARINT64_SIZE = 10; + static final byte FIXED32_SIZE = 4; + static final byte FIXED64_SIZE = 8; + + static int tagFor(int fieldNumber, byte wireType) { + return (fieldNumber << TAG_TYPE_BITS) | wireType; + } + + static int getFieldNumber(final int tag) { + return tag >>> TAG_TYPE_BITS; + } + + static int getWireType(final int tag) { + return tag & TAG_TYPE_MASK; + } + + /** + * Decode 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 An unsigned 32-bit integer, stored in a signed int because Java has no explicit + * unsigned support. + * @return A signed 32-bit integer. + */ + static int decodeZigZag32(final int n) { + return (n >>> 1) ^ -(n & 1); + } + + /** + * Decode 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 An unsigned 64-bit integer, stored in a signed int because Java has no explicit + * unsigned support. + * @return A signed 64-bit integer. + */ + static long decodeZigZag64(final long n) { + return (n >>> 1) ^ -(n & 1); + } + + /** + * 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. + */ + 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. + */ + static long encodeZigZag64(final long n) { + // Note: the right-shift must be arithmetic + return (n << 1) ^ (n >> 63); + } +} diff --git a/java/core/src/main/java/com/google/protobuf/BinaryReader.java b/java/core/src/main/java/com/google/protobuf/BinaryReader.java new file mode 100644 index 00000000..ab20c619 --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/BinaryReader.java @@ -0,0 +1,1516 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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 static com.google.protobuf.BinaryProtocolUtil.FIXED32_SIZE; +import static com.google.protobuf.BinaryProtocolUtil.FIXED64_SIZE; +import static com.google.protobuf.BinaryProtocolUtil.WIRETYPE_END_GROUP; +import static com.google.protobuf.BinaryProtocolUtil.WIRETYPE_FIXED32; +import static com.google.protobuf.BinaryProtocolUtil.WIRETYPE_FIXED64; +import static com.google.protobuf.BinaryProtocolUtil.WIRETYPE_LENGTH_DELIMITED; +import static com.google.protobuf.BinaryProtocolUtil.WIRETYPE_START_GROUP; +import static com.google.protobuf.BinaryProtocolUtil.WIRETYPE_VARINT; +import static com.google.protobuf.BinaryProtocolUtil.decodeZigZag32; +import static com.google.protobuf.BinaryProtocolUtil.decodeZigZag64; +import static com.google.protobuf.BinaryProtocolUtil.getWireType; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.List; + +/** + * A {@link Reader} that reads from a buffer containing a message serialized with the binary + * protocol. + */ +@ExperimentalApi +public abstract class BinaryReader implements Reader { + private static final int FIXED32_MULTIPLE_MASK = FIXED32_SIZE - 1; + private static final int FIXED64_MULTIPLE_MASK = FIXED64_SIZE - 1; + + /** + * Creates a new reader using the given {@code buffer} as input. + * + * @param buffer the input buffer. The buffer (including position, limit, etc.) will not be + * modified. To increment the buffer position after the read completes, use the value returned + * by {@link #getTotalBytesRead()}. + * @param bufferIsImmutable if {@code true} the reader assumes that the content of {@code buffer} + * will never change and any allocated {@link ByteString} instances will by directly wrap + * slices of {@code buffer}. + * @return the reader + */ + public static BinaryReader newInstance(ByteBuffer buffer, boolean bufferIsImmutable) { + if (buffer.hasArray()) { + // TODO(nathanmittler): Add support for unsafe operations. + return new SafeHeapReader(buffer, bufferIsImmutable); + } + // TODO(nathanmittler): Add support for direct buffers + throw new IllegalArgumentException("Direct buffers not yet supported"); + } + + /** Only allow subclassing for inner classes. */ + private BinaryReader() {} + + /** Returns the total number of bytes read so far from the input buffer. */ + public abstract int getTotalBytesRead(); + + /** + * A {@link BinaryReader} implementation that operates on a heap {@link ByteBuffer}. Uses only + * safe operations on the underlying array. + */ + private static final class SafeHeapReader extends BinaryReader { + private final boolean bufferIsImmutable; + private final byte[] buffer; + private int pos; + private final int initialPos; + private int limit; + private int tag; + private int endGroupTag; + + public SafeHeapReader(ByteBuffer bytebuf, boolean bufferIsImmutable) { + this.bufferIsImmutable = bufferIsImmutable; + buffer = bytebuf.array(); + initialPos = pos = bytebuf.arrayOffset() + bytebuf.position(); + limit = bytebuf.arrayOffset() + bytebuf.limit(); + } + + private boolean isAtEnd() { + return pos == limit; + } + + @Override + public int getTotalBytesRead() { + return pos - initialPos; + } + + @Override + public int getFieldNumber() throws IOException { + if (isAtEnd()) { + return Reader.READ_DONE; + } + tag = readVarint32(); + if (tag == endGroupTag) { + return Reader.READ_DONE; + } + return BinaryProtocolUtil.getFieldNumber(tag); + } + + @Override + public boolean skipField() throws IOException { + if (isAtEnd() || tag == endGroupTag) { + return false; + } + + switch (getWireType(tag)) { + case WIRETYPE_VARINT: + skipVarint(); + return true; + case WIRETYPE_FIXED64: + skipBytes(FIXED64_SIZE); + return true; + case WIRETYPE_LENGTH_DELIMITED: + skipBytes(readVarint32()); + return true; + case WIRETYPE_FIXED32: + skipBytes(FIXED32_SIZE); + return true; + default: + throw InvalidProtocolBufferException.invalidWireType(); + } + } + + @Override + public double readDouble() throws IOException { + requireWireType(WIRETYPE_FIXED64); + return Double.longBitsToDouble(readLittleEndian64()); + } + + @Override + public float readFloat() throws IOException { + requireWireType(WIRETYPE_FIXED32); + return Float.intBitsToFloat(readLittleEndian32()); + } + + @Override + public long readUInt64() throws IOException { + requireWireType(WIRETYPE_VARINT); + return readVarint64(); + } + + @Override + public long readInt64() throws IOException { + requireWireType(WIRETYPE_VARINT); + return readVarint64(); + } + + @Override + public int readInt32() throws IOException { + requireWireType(WIRETYPE_VARINT); + return readVarint32(); + } + + @Override + public long readFixed64() throws IOException { + requireWireType(WIRETYPE_FIXED64); + return readLittleEndian64(); + } + + @Override + public int readFixed32() throws IOException { + requireWireType(WIRETYPE_FIXED32); + return readLittleEndian32(); + } + + @Override + public boolean readBool() throws IOException { + requireWireType(WIRETYPE_VARINT); + return readVarint32() != 0; + } + + @Override + public String readString() throws IOException { + requireWireType(WIRETYPE_LENGTH_DELIMITED); + final int size = readVarint32(); + if (size == 0) { + return ""; + } + + requireBytes(size); + // TODO(nathanmittler): need to make this an option. + if (!Utf8.isValidUtf8(buffer, pos, pos + size)) { + throw InvalidProtocolBufferException.invalidUtf8(); + } + String result = new String(buffer, pos, size, Internal.UTF_8); + pos += size; + return result; + } + + @Override + public T readMessage(Class clazz) throws IOException { + requireWireType(WIRETYPE_LENGTH_DELIMITED); + return readMessage(Protobuf.getInstance().schemaFor(clazz)); + } + + private T readMessage(Schema schema) throws IOException { + int size = readVarint32(); + requireBytes(size); + + // Update the limit. + int prevLimit = limit; + int newLimit = pos + size; + limit = newLimit; + + try { + // Allocate and read the message. + T message = schema.newInstance(); + schema.mergeFrom(message, this); + + if (pos != newLimit) { + throw InvalidProtocolBufferException.parseFailure(); + } + return message; + } finally { + // Restore the limit. + limit = prevLimit; + } + } + + @Override + public T readGroup(Class clazz) throws IOException { + requireWireType(WIRETYPE_START_GROUP); + return readGroup(Protobuf.getInstance().schemaFor(clazz)); + } + + private T readGroup(Schema schema) throws IOException { + int prevEndGroupTag = endGroupTag; + endGroupTag = + BinaryProtocolUtil.tagFor(BinaryProtocolUtil.getFieldNumber(tag), WIRETYPE_END_GROUP); + + try { + // Allocate and read the message. + T message = schema.newInstance(); + schema.mergeFrom(message, this); + + if (tag != endGroupTag) { + throw InvalidProtocolBufferException.parseFailure(); + } + return message; + } finally { + // Restore the old end group tag. + endGroupTag = prevEndGroupTag; + } + } + + @Override + public ByteString readBytes() throws IOException { + requireWireType(WIRETYPE_LENGTH_DELIMITED); + int size = readVarint32(); + if (size == 0) { + return ByteString.EMPTY; + } + + requireBytes(size); + ByteString bytes = + bufferIsImmutable + ? ByteString.wrap(buffer, pos, size) + : ByteString.copyFrom(buffer, pos, size); + pos += size; + return bytes; + } + + @Override + public int readUInt32() throws IOException { + requireWireType(WIRETYPE_VARINT); + return readVarint32(); + } + + @Override + public int readEnum() throws IOException { + requireWireType(WIRETYPE_VARINT); + return readVarint32(); + } + + @Override + public int readSFixed32() throws IOException { + requireWireType(WIRETYPE_FIXED32); + return readLittleEndian32(); + } + + @Override + public long readSFixed64() throws IOException { + requireWireType(WIRETYPE_FIXED64); + return readLittleEndian64(); + } + + @Override + public int readSInt32() throws IOException { + requireWireType(WIRETYPE_VARINT); + return decodeZigZag32(readVarint32()); + } + + @Override + public long readSInt64() throws IOException { + requireWireType(WIRETYPE_VARINT); + return decodeZigZag64(readVarint64()); + } + + @Override + public void readDoubleList(List target) throws IOException { + if (target instanceof DoubleArrayList) { + DoubleArrayList plist = (DoubleArrayList) target; + switch (getWireType(tag)) { + case WIRETYPE_LENGTH_DELIMITED: + final int bytes = readVarint32(); + verifyPackedFixed64Length(bytes); + final int fieldEndPos = pos + bytes; + while (pos < fieldEndPos) { + plist.addDouble(Double.longBitsToDouble(readLittleEndian64_NoCheck())); + } + break; + case WIRETYPE_FIXED64: + while (true) { + plist.addDouble(readDouble()); + + if (isAtEnd()) { + return; + } + int prevPos = pos; + int nextTag = readVarint32(); + if (nextTag != tag) { + // We've reached the end of the repeated field. Rewind the buffer position to before + // the new tag. + pos = prevPos; + return; + } + } + default: + throw InvalidProtocolBufferException.invalidWireType(); + } + } else { + switch (getWireType(tag)) { + case WIRETYPE_LENGTH_DELIMITED: + final int bytes = readVarint32(); + verifyPackedFixed64Length(bytes); + final int fieldEndPos = pos + bytes; + while (pos < fieldEndPos) { + target.add(Double.longBitsToDouble(readLittleEndian64_NoCheck())); + } + break; + case WIRETYPE_FIXED64: + while (true) { + target.add(readDouble()); + + if (isAtEnd()) { + return; + } + int prevPos = pos; + int nextTag = readVarint32(); + if (nextTag != tag) { + // We've reached the end of the repeated field. Rewind the buffer position to before + // the new tag. + pos = prevPos; + return; + } + } + default: + throw InvalidProtocolBufferException.invalidWireType(); + } + } + } + + @Override + public void readFloatList(List target) throws IOException { + if (target instanceof FloatArrayList) { + FloatArrayList plist = (FloatArrayList) target; + switch (getWireType(tag)) { + case WIRETYPE_LENGTH_DELIMITED: + final int bytes = readVarint32(); + verifyPackedFixed32Length(bytes); + final int fieldEndPos = pos + bytes; + while (pos < fieldEndPos) { + plist.addFloat(Float.intBitsToFloat(readLittleEndian32_NoCheck())); + } + break; + case WIRETYPE_FIXED32: + while (true) { + plist.addFloat(readFloat()); + + if (isAtEnd()) { + return; + } + int prevPos = pos; + int nextTag = readVarint32(); + if (nextTag != tag) { + // We've reached the end of the repeated field. Rewind the buffer position to before + // the new tag. + pos = prevPos; + return; + } + } + default: + throw InvalidProtocolBufferException.invalidWireType(); + } + } else { + switch (getWireType(tag)) { + case WIRETYPE_LENGTH_DELIMITED: + final int bytes = readVarint32(); + verifyPackedFixed32Length(bytes); + final int fieldEndPos = pos + bytes; + while (pos < fieldEndPos) { + target.add(Float.intBitsToFloat(readLittleEndian32_NoCheck())); + } + break; + case WIRETYPE_FIXED32: + while (true) { + target.add(readFloat()); + + if (isAtEnd()) { + return; + } + int prevPos = pos; + int nextTag = readVarint32(); + if (nextTag != tag) { + // We've reached the end of the repeated field. Rewind the buffer position to before + // the new tag. + pos = prevPos; + return; + } + } + default: + throw InvalidProtocolBufferException.invalidWireType(); + } + } + } + + @Override + public void readUInt64List(List target) throws IOException { + if (target instanceof LongArrayList) { + LongArrayList plist = (LongArrayList) target; + switch (getWireType(tag)) { + case WIRETYPE_LENGTH_DELIMITED: + final int bytes = readVarint32(); + final int fieldEndPos = pos + bytes; + while (pos < fieldEndPos) { + plist.addLong(readVarint64()); + } + break; + case WIRETYPE_VARINT: + while (true) { + plist.addLong(readUInt64()); + + if (isAtEnd()) { + return; + } + int prevPos = pos; + int nextTag = readVarint32(); + if (nextTag != tag) { + // We've reached the end of the repeated field. Rewind the buffer position to before + // the new tag. + pos = prevPos; + return; + } + } + default: + throw InvalidProtocolBufferException.invalidWireType(); + } + } else { + switch (getWireType(tag)) { + case WIRETYPE_LENGTH_DELIMITED: + final int bytes = readVarint32(); + final int fieldEndPos = pos + bytes; + while (pos < fieldEndPos) { + target.add(readVarint64()); + } + break; + case WIRETYPE_VARINT: + while (true) { + target.add(readUInt64()); + + if (isAtEnd()) { + return; + } + int prevPos = pos; + int nextTag = readVarint32(); + if (nextTag != tag) { + // We've reached the end of the repeated field. Rewind the buffer position to before + // the new tag. + pos = prevPos; + return; + } + } + default: + throw InvalidProtocolBufferException.invalidWireType(); + } + } + } + + @Override + public void readInt64List(List target) throws IOException { + if (target instanceof LongArrayList) { + LongArrayList plist = (LongArrayList) target; + switch (getWireType(tag)) { + case WIRETYPE_LENGTH_DELIMITED: + final int bytes = readVarint32(); + final int fieldEndPos = pos + bytes; + while (pos < fieldEndPos) { + plist.addLong(readVarint64()); + } + break; + case WIRETYPE_VARINT: + while (true) { + plist.addLong(readInt64()); + + if (isAtEnd()) { + return; + } + int prevPos = pos; + int nextTag = readVarint32(); + if (nextTag != tag) { + // We've reached the end of the repeated field. Rewind the buffer position to before + // the new tag. + pos = prevPos; + return; + } + } + default: + throw InvalidProtocolBufferException.invalidWireType(); + } + } else { + switch (getWireType(tag)) { + case WIRETYPE_LENGTH_DELIMITED: + final int bytes = readVarint32(); + final int fieldEndPos = pos + bytes; + while (pos < fieldEndPos) { + target.add(readVarint64()); + } + break; + case WIRETYPE_VARINT: + while (true) { + target.add(readInt64()); + + if (isAtEnd()) { + return; + } + int prevPos = pos; + int nextTag = readVarint32(); + if (nextTag != tag) { + // We've reached the end of the repeated field. Rewind the buffer position to before + // the new tag. + pos = prevPos; + return; + } + } + default: + throw InvalidProtocolBufferException.invalidWireType(); + } + } + } + + @Override + public void readInt32List(List target) throws IOException { + if (target instanceof IntArrayList) { + IntArrayList plist = (IntArrayList) target; + switch (getWireType(tag)) { + case WIRETYPE_LENGTH_DELIMITED: + final int bytes = readVarint32(); + final int fieldEndPos = pos + bytes; + while (pos < fieldEndPos) { + plist.addInt(readVarint32()); + } + break; + case WIRETYPE_VARINT: + while (true) { + plist.addInt(readInt32()); + + if (isAtEnd()) { + return; + } + int prevPos = pos; + int nextTag = readVarint32(); + if (nextTag != tag) { + // We've reached the end of the repeated field. Rewind the buffer position to before + // the new tag. + pos = prevPos; + return; + } + } + default: + throw InvalidProtocolBufferException.invalidWireType(); + } + } else { + switch (getWireType(tag)) { + case WIRETYPE_LENGTH_DELIMITED: + final int bytes = readVarint32(); + final int fieldEndPos = pos + bytes; + while (pos < fieldEndPos) { + target.add(readVarint32()); + } + break; + case WIRETYPE_VARINT: + while (true) { + target.add(readInt32()); + + if (isAtEnd()) { + return; + } + int prevPos = pos; + int nextTag = readVarint32(); + if (nextTag != tag) { + // We've reached the end of the repeated field. Rewind the buffer position to before + // the new tag. + pos = prevPos; + return; + } + } + default: + throw InvalidProtocolBufferException.invalidWireType(); + } + } + } + + @Override + public void readFixed64List(List target) throws IOException { + if (target instanceof LongArrayList) { + LongArrayList plist = (LongArrayList) target; + switch (getWireType(tag)) { + case WIRETYPE_LENGTH_DELIMITED: + final int bytes = readVarint32(); + verifyPackedFixed64Length(bytes); + final int fieldEndPos = pos + bytes; + while (pos < fieldEndPos) { + plist.addLong(readLittleEndian64_NoCheck()); + } + break; + case WIRETYPE_FIXED64: + while (true) { + plist.addLong(readFixed64()); + + if (isAtEnd()) { + return; + } + int prevPos = pos; + int nextTag = readVarint32(); + if (nextTag != tag) { + // We've reached the end of the repeated field. Rewind the buffer position to before + // the new tag. + pos = prevPos; + return; + } + } + default: + throw InvalidProtocolBufferException.invalidWireType(); + } + } else { + switch (getWireType(tag)) { + case WIRETYPE_LENGTH_DELIMITED: + final int bytes = readVarint32(); + verifyPackedFixed64Length(bytes); + final int fieldEndPos = pos + bytes; + while (pos < fieldEndPos) { + target.add(readLittleEndian64_NoCheck()); + } + break; + case WIRETYPE_FIXED64: + while (true) { + target.add(readFixed64()); + + if (isAtEnd()) { + return; + } + int prevPos = pos; + int nextTag = readVarint32(); + if (nextTag != tag) { + // We've reached the end of the repeated field. Rewind the buffer position to before + // the new tag. + pos = prevPos; + return; + } + } + default: + throw InvalidProtocolBufferException.invalidWireType(); + } + } + } + + @Override + public void readFixed32List(List target) throws IOException { + if (target instanceof IntArrayList) { + IntArrayList plist = (IntArrayList) target; + switch (getWireType(tag)) { + case WIRETYPE_LENGTH_DELIMITED: + final int bytes = readVarint32(); + verifyPackedFixed32Length(bytes); + final int fieldEndPos = pos + bytes; + while (pos < fieldEndPos) { + plist.addInt(readLittleEndian32_NoCheck()); + } + break; + case WIRETYPE_FIXED32: + while (true) { + plist.addInt(readFixed32()); + + if (isAtEnd()) { + return; + } + int prevPos = pos; + int nextTag = readVarint32(); + if (nextTag != tag) { + // We've reached the end of the repeated field. Rewind the buffer position to before + // the new tag. + pos = prevPos; + return; + } + } + default: + throw InvalidProtocolBufferException.invalidWireType(); + } + } else { + switch (getWireType(tag)) { + case WIRETYPE_LENGTH_DELIMITED: + final int bytes = readVarint32(); + verifyPackedFixed32Length(bytes); + final int fieldEndPos = pos + bytes; + while (pos < fieldEndPos) { + target.add(readLittleEndian32_NoCheck()); + } + break; + case WIRETYPE_FIXED32: + while (true) { + target.add(readFixed32()); + + if (isAtEnd()) { + return; + } + int prevPos = pos; + int nextTag = readVarint32(); + if (nextTag != tag) { + // We've reached the end of the repeated field. Rewind the buffer position to before + // the new tag. + pos = prevPos; + return; + } + } + default: + throw InvalidProtocolBufferException.invalidWireType(); + } + } + } + + @Override + public void readBoolList(List target) throws IOException { + if (target instanceof BooleanArrayList) { + BooleanArrayList plist = (BooleanArrayList) target; + switch (getWireType(tag)) { + case WIRETYPE_LENGTH_DELIMITED: + final int bytes = readVarint32(); + final int fieldEndPos = pos + bytes; + while (pos < fieldEndPos) { + plist.addBoolean(readVarint32() != 0); + } + break; + case WIRETYPE_VARINT: + while (true) { + plist.addBoolean(readBool()); + + if (isAtEnd()) { + return; + } + int prevPos = pos; + int nextTag = readVarint32(); + if (nextTag != tag) { + // We've reached the end of the repeated field. Rewind the buffer position to before + // the new tag. + pos = prevPos; + return; + } + } + default: + throw InvalidProtocolBufferException.invalidWireType(); + } + } else { + switch (getWireType(tag)) { + case WIRETYPE_LENGTH_DELIMITED: + final int bytes = readVarint32(); + final int fieldEndPos = pos + bytes; + while (pos < fieldEndPos) { + target.add(readVarint32() != 0); + } + break; + case WIRETYPE_VARINT: + while (true) { + target.add(readBool()); + + if (isAtEnd()) { + return; + } + int prevPos = pos; + int nextTag = readVarint32(); + if (nextTag != tag) { + // We've reached the end of the repeated field. Rewind the buffer position to before + // the new tag. + pos = prevPos; + return; + } + } + default: + throw InvalidProtocolBufferException.invalidWireType(); + } + } + } + + @Override + public void readStringList(List target) throws IOException { + if (getWireType(tag) != WIRETYPE_LENGTH_DELIMITED) { + throw InvalidProtocolBufferException.invalidWireType(); + } + + while (true) { + target.add(readString()); + + if (isAtEnd()) { + return; + } + int prevPos = pos; + int nextTag = readVarint32(); + if (nextTag != tag) { + // We've reached the end of the repeated field. Rewind the buffer position to before + // the new tag. + pos = prevPos; + return; + } + } + } + + @Override + public void readMessageList(List target, Class targetType) throws IOException { + if (getWireType(tag) != WIRETYPE_LENGTH_DELIMITED) { + throw InvalidProtocolBufferException.invalidWireType(); + } + + final Schema schema = Protobuf.getInstance().schemaFor(targetType); + final int listTag = tag; + while (true) { + target.add(readMessage(schema)); + + if (isAtEnd()) { + return; + } + int prevPos = pos; + int nextTag = readVarint32(); + if (nextTag != listTag) { + // We've reached the end of the repeated field. Rewind the buffer position to before + // the new tag. + pos = prevPos; + return; + } + } + } + + @Override + public void readGroupList(List target, Class targetType) throws IOException { + if (getWireType(tag) != WIRETYPE_START_GROUP) { + throw InvalidProtocolBufferException.invalidWireType(); + } + + final Schema schema = Protobuf.getInstance().schemaFor(targetType); + final int listTag = tag; + while (true) { + target.add(readGroup(schema)); + + if (isAtEnd()) { + return; + } + int prevPos = pos; + int nextTag = readVarint32(); + if (nextTag != listTag) { + // We've reached the end of the repeated field. Rewind the buffer position to before + // the new tag. + pos = prevPos; + return; + } + } + } + + @Override + public void readBytesList(List target) throws IOException { + if (getWireType(tag) != WIRETYPE_LENGTH_DELIMITED) { + throw InvalidProtocolBufferException.invalidWireType(); + } + + while (true) { + target.add(readBytes()); + + if (isAtEnd()) { + return; + } + int prevPos = pos; + int nextTag = readVarint32(); + if (nextTag != tag) { + // We've reached the end of the repeated field. Rewind the buffer position to before + // the new tag. + pos = prevPos; + return; + } + } + } + + @Override + public void readUInt32List(List target) throws IOException { + if (target instanceof IntArrayList) { + IntArrayList plist = (IntArrayList) target; + switch (getWireType(tag)) { + case WIRETYPE_LENGTH_DELIMITED: + final int bytes = readVarint32(); + final int fieldEndPos = pos + bytes; + while (pos < fieldEndPos) { + plist.addInt(readVarint32()); + } + break; + case WIRETYPE_VARINT: + while (true) { + plist.addInt(readUInt32()); + + if (isAtEnd()) { + return; + } + int prevPos = pos; + int nextTag = readVarint32(); + if (nextTag != tag) { + // We've reached the end of the repeated field. Rewind the buffer position to before + // the new tag. + pos = prevPos; + return; + } + } + default: + throw InvalidProtocolBufferException.invalidWireType(); + } + } else { + switch (getWireType(tag)) { + case WIRETYPE_LENGTH_DELIMITED: + final int bytes = readVarint32(); + final int fieldEndPos = pos + bytes; + while (pos < fieldEndPos) { + target.add(readVarint32()); + } + break; + case WIRETYPE_VARINT: + while (true) { + target.add(readUInt32()); + + if (isAtEnd()) { + return; + } + int prevPos = pos; + int nextTag = readVarint32(); + if (nextTag != tag) { + // We've reached the end of the repeated field. Rewind the buffer position to before + // the new tag. + pos = prevPos; + return; + } + } + default: + throw InvalidProtocolBufferException.invalidWireType(); + } + } + } + + @Override + public void readEnumList(List target) throws IOException { + if (target instanceof IntArrayList) { + IntArrayList plist = (IntArrayList) target; + switch (getWireType(tag)) { + case WIRETYPE_LENGTH_DELIMITED: + final int bytes = readVarint32(); + final int fieldEndPos = pos + bytes; + while (pos < fieldEndPos) { + plist.addInt(readVarint32()); + } + break; + case WIRETYPE_VARINT: + while (true) { + plist.addInt(readEnum()); + + if (isAtEnd()) { + return; + } + int prevPos = pos; + int nextTag = readVarint32(); + if (nextTag != tag) { + // We've reached the end of the repeated field. Rewind the buffer position to before + // the new tag. + pos = prevPos; + return; + } + } + default: + throw InvalidProtocolBufferException.invalidWireType(); + } + } else { + switch (getWireType(tag)) { + case WIRETYPE_LENGTH_DELIMITED: + final int bytes = readVarint32(); + final int fieldEndPos = pos + bytes; + while (pos < fieldEndPos) { + target.add(readVarint32()); + } + break; + case WIRETYPE_VARINT: + while (true) { + target.add(readEnum()); + + if (isAtEnd()) { + return; + } + int prevPos = pos; + int nextTag = readVarint32(); + if (nextTag != tag) { + // We've reached the end of the repeated field. Rewind the buffer position to before + // the new tag. + pos = prevPos; + return; + } + } + default: + throw InvalidProtocolBufferException.invalidWireType(); + } + } + } + + @Override + public void readSFixed32List(List target) throws IOException { + if (target instanceof IntArrayList) { + IntArrayList plist = (IntArrayList) target; + switch (getWireType(tag)) { + case WIRETYPE_LENGTH_DELIMITED: + final int bytes = readVarint32(); + verifyPackedFixed32Length(bytes); + final int fieldEndPos = pos + bytes; + while (pos < fieldEndPos) { + plist.addInt(readLittleEndian32_NoCheck()); + } + break; + case WIRETYPE_FIXED32: + while (true) { + plist.addInt(readSFixed32()); + + if (isAtEnd()) { + return; + } + int prevPos = pos; + int nextTag = readVarint32(); + if (nextTag != tag) { + // We've reached the end of the repeated field. Rewind the buffer position to before + // the new tag. + pos = prevPos; + return; + } + } + default: + throw InvalidProtocolBufferException.invalidWireType(); + } + } else { + switch (getWireType(tag)) { + case WIRETYPE_LENGTH_DELIMITED: + final int bytes = readVarint32(); + verifyPackedFixed32Length(bytes); + final int fieldEndPos = pos + bytes; + while (pos < fieldEndPos) { + target.add(readLittleEndian32_NoCheck()); + } + break; + case WIRETYPE_FIXED32: + while (true) { + target.add(readSFixed32()); + + if (isAtEnd()) { + return; + } + int prevPos = pos; + int nextTag = readVarint32(); + if (nextTag != tag) { + // We've reached the end of the repeated field. Rewind the buffer position to before + // the new tag. + pos = prevPos; + return; + } + } + default: + throw InvalidProtocolBufferException.invalidWireType(); + } + } + } + + @Override + public void readSFixed64List(List target) throws IOException { + if (target instanceof LongArrayList) { + LongArrayList plist = (LongArrayList) target; + switch (getWireType(tag)) { + case WIRETYPE_LENGTH_DELIMITED: + final int bytes = readVarint32(); + verifyPackedFixed64Length(bytes); + final int fieldEndPos = pos + bytes; + while (pos < fieldEndPos) { + plist.addLong(readLittleEndian64_NoCheck()); + } + break; + case WIRETYPE_FIXED64: + while (true) { + plist.addLong(readSFixed64()); + + if (isAtEnd()) { + return; + } + int prevPos = pos; + int nextTag = readVarint32(); + if (nextTag != tag) { + // We've reached the end of the repeated field. Rewind the buffer position to before + // the new tag. + pos = prevPos; + return; + } + } + default: + throw InvalidProtocolBufferException.invalidWireType(); + } + } else { + switch (getWireType(tag)) { + case WIRETYPE_LENGTH_DELIMITED: + final int bytes = readVarint32(); + verifyPackedFixed64Length(bytes); + final int fieldEndPos = pos + bytes; + while (pos < fieldEndPos) { + target.add(readLittleEndian64_NoCheck()); + } + break; + case WIRETYPE_FIXED64: + while (true) { + target.add(readSFixed64()); + + if (isAtEnd()) { + return; + } + int prevPos = pos; + int nextTag = readVarint32(); + if (nextTag != tag) { + // We've reached the end of the repeated field. Rewind the buffer position to before + // the new tag. + pos = prevPos; + return; + } + } + default: + throw InvalidProtocolBufferException.invalidWireType(); + } + } + } + + @Override + public void readSInt32List(List target) throws IOException { + if (target instanceof IntArrayList) { + IntArrayList plist = (IntArrayList) target; + switch (getWireType(tag)) { + case WIRETYPE_LENGTH_DELIMITED: + final int bytes = readVarint32(); + final int fieldEndPos = pos + bytes; + while (pos < fieldEndPos) { + plist.addInt(decodeZigZag32(readVarint32())); + } + break; + case WIRETYPE_VARINT: + while (true) { + plist.addInt(readSInt32()); + + if (isAtEnd()) { + return; + } + int prevPos = pos; + int nextTag = readVarint32(); + if (nextTag != tag) { + // We've reached the end of the repeated field. Rewind the buffer position to before + // the new tag. + pos = prevPos; + return; + } + } + default: + throw InvalidProtocolBufferException.invalidWireType(); + } + } else { + switch (getWireType(tag)) { + case WIRETYPE_LENGTH_DELIMITED: + final int bytes = readVarint32(); + final int fieldEndPos = pos + bytes; + while (pos < fieldEndPos) { + target.add(decodeZigZag32(readVarint32())); + } + break; + case WIRETYPE_VARINT: + while (true) { + target.add(readSInt32()); + + if (isAtEnd()) { + return; + } + int prevPos = pos; + int nextTag = readVarint32(); + if (nextTag != tag) { + // We've reached the end of the repeated field. Rewind the buffer position to before + // the new tag. + pos = prevPos; + return; + } + } + default: + throw InvalidProtocolBufferException.invalidWireType(); + } + } + } + + @Override + public void readSInt64List(List target) throws IOException { + if (target instanceof LongArrayList) { + LongArrayList plist = (LongArrayList) target; + switch (getWireType(tag)) { + case WIRETYPE_LENGTH_DELIMITED: + final int bytes = readVarint32(); + final int fieldEndPos = pos + bytes; + while (pos < fieldEndPos) { + plist.addLong(decodeZigZag64(readVarint64())); + } + break; + case WIRETYPE_VARINT: + while (true) { + plist.addLong(readSInt64()); + + if (isAtEnd()) { + return; + } + int prevPos = pos; + int nextTag = readVarint32(); + if (nextTag != tag) { + // We've reached the end of the repeated field. Rewind the buffer position to before + // the new tag. + pos = prevPos; + return; + } + } + default: + throw InvalidProtocolBufferException.invalidWireType(); + } + } else { + switch (getWireType(tag)) { + case WIRETYPE_LENGTH_DELIMITED: + final int bytes = readVarint32(); + final int fieldEndPos = pos + bytes; + while (pos < fieldEndPos) { + target.add(decodeZigZag64(readVarint64())); + } + break; + case WIRETYPE_VARINT: + while (true) { + target.add(readSInt64()); + + if (isAtEnd()) { + return; + } + int prevPos = pos; + int nextTag = readVarint32(); + if (nextTag != tag) { + // We've reached the end of the repeated field. Rewind the buffer position to before + // the new tag. + pos = prevPos; + return; + } + } + default: + throw InvalidProtocolBufferException.invalidWireType(); + } + } + } + + /** Read a raw Varint from the stream. If larger than 32 bits, discard the upper bits. */ + private int readVarint32() throws IOException { + // See implementation notes for readRawVarint64 + int i = pos; + + if (limit == pos) { + throw InvalidProtocolBufferException.truncatedMessage(); + } + + int x; + if ((x = buffer[i++]) >= 0) { + pos = i; + return x; + } else if (limit - i < 9) { + return (int) readVarint64SlowPath(); + } else if ((x ^= (buffer[i++] << 7)) < 0) { + x ^= (~0 << 7); + } else if ((x ^= (buffer[i++] << 14)) >= 0) { + x ^= (~0 << 7) ^ (~0 << 14); + } else if ((x ^= (buffer[i++] << 21)) < 0) { + x ^= (~0 << 7) ^ (~0 << 14) ^ (~0 << 21); + } else { + int y = buffer[i++]; + x ^= y << 28; + x ^= (~0 << 7) ^ (~0 << 14) ^ (~0 << 21) ^ (~0 << 28); + if (y < 0 + && buffer[i++] < 0 + && buffer[i++] < 0 + && buffer[i++] < 0 + && buffer[i++] < 0 + && buffer[i++] < 0) { + throw InvalidProtocolBufferException.malformedVarint(); + } + } + pos = i; + return x; + } + + public long readVarint64() throws IOException { + // Implementation notes: + // + // Optimized for one-byte values, expected to be common. + // The particular code below was selected from various candidates + // empirically, by winning VarintBenchmark. + // + // Sign extension of (signed) Java bytes is usually a nuisance, but + // we exploit it here to more easily obtain the sign of bytes read. + // Instead of cleaning up the sign extension bits by masking eagerly, + // we delay until we find the final (positive) byte, when we clear all + // accumulated bits with one xor. We depend on javac to constant fold. + int i = pos; + + if (limit == i) { + throw InvalidProtocolBufferException.truncatedMessage(); + } + + final byte[] buffer = this.buffer; + long x; + int y; + if ((y = buffer[i++]) >= 0) { + pos = i; + return y; + } else if (limit - i < 9) { + return readVarint64SlowPath(); + } else if ((y ^= (buffer[i++] << 7)) < 0) { + x = y ^ (~0 << 7); + } else if ((y ^= (buffer[i++] << 14)) >= 0) { + x = y ^ ((~0 << 7) ^ (~0 << 14)); + } else if ((y ^= (buffer[i++] << 21)) < 0) { + x = y ^ ((~0 << 7) ^ (~0 << 14) ^ (~0 << 21)); + } else if ((x = y ^ ((long) buffer[i++] << 28)) >= 0L) { + x ^= (~0L << 7) ^ (~0L << 14) ^ (~0L << 21) ^ (~0L << 28); + } else if ((x ^= ((long) buffer[i++] << 35)) < 0L) { + x ^= (~0L << 7) ^ (~0L << 14) ^ (~0L << 21) ^ (~0L << 28) ^ (~0L << 35); + } else if ((x ^= ((long) buffer[i++] << 42)) >= 0L) { + x ^= (~0L << 7) ^ (~0L << 14) ^ (~0L << 21) ^ (~0L << 28) ^ (~0L << 35) ^ (~0L << 42); + } else if ((x ^= ((long) buffer[i++] << 49)) < 0L) { + x ^= + (~0L << 7) + ^ (~0L << 14) + ^ (~0L << 21) + ^ (~0L << 28) + ^ (~0L << 35) + ^ (~0L << 42) + ^ (~0L << 49); + } else { + x ^= ((long) buffer[i++] << 56); + x ^= + (~0L << 7) + ^ (~0L << 14) + ^ (~0L << 21) + ^ (~0L << 28) + ^ (~0L << 35) + ^ (~0L << 42) + ^ (~0L << 49) + ^ (~0L << 56); + if (x < 0L) { + if (buffer[i++] < 0L) { + throw InvalidProtocolBufferException.malformedVarint(); + } + } + } + pos = i; + return x; + } + + private long readVarint64SlowPath() throws IOException { + long result = 0; + for (int shift = 0; shift < 64; shift += 7) { + final byte b = readByte(); + result |= (long) (b & 0x7F) << shift; + if ((b & 0x80) == 0) { + return result; + } + } + throw InvalidProtocolBufferException.malformedVarint(); + } + + private byte readByte() throws IOException { + if (pos == limit) { + throw InvalidProtocolBufferException.truncatedMessage(); + } + return buffer[pos++]; + } + + private int readLittleEndian32() throws IOException { + requireBytes(FIXED32_SIZE); + return readLittleEndian32_NoCheck(); + } + + private long readLittleEndian64() throws IOException { + requireBytes(FIXED64_SIZE); + return readLittleEndian64_NoCheck(); + } + + private int readLittleEndian32_NoCheck() { + int p = pos; + final byte[] buffer = this.buffer; + pos = p + FIXED32_SIZE; + return (((buffer[p] & 0xff)) + | ((buffer[p + 1] & 0xff) << 8) + | ((buffer[p + 2] & 0xff) << 16) + | ((buffer[p + 3] & 0xff) << 24)); + } + + private long readLittleEndian64_NoCheck() { + int p = pos; + final byte[] buffer = this.buffer; + pos = p + FIXED64_SIZE; + return (((buffer[p] & 0xffL)) + | ((buffer[p + 1] & 0xffL) << 8) + | ((buffer[p + 2] & 0xffL) << 16) + | ((buffer[p + 3] & 0xffL) << 24) + | ((buffer[p + 4] & 0xffL) << 32) + | ((buffer[p + 5] & 0xffL) << 40) + | ((buffer[p + 6] & 0xffL) << 48) + | ((buffer[p + 7] & 0xffL) << 56)); + } + + private void skipVarint() throws IOException { + if (limit - pos >= 10) { + final byte[] buffer = this.buffer; + int p = pos; + for (int i = 0; i < 10; i++) { + if (buffer[p++] >= 0) { + pos = p; + return; + } + } + } + skipVarintSlowPath(); + } + + private void skipVarintSlowPath() throws IOException { + for (int i = 0; i < 10; i++) { + if (readByte() >= 0) { + return; + } + } + throw InvalidProtocolBufferException.malformedVarint(); + } + + private void skipBytes(final int size) throws IOException { + requireBytes(size); + + pos += size; + } + + private void requireBytes(int size) throws IOException { + if (size < 0 || size > (limit - pos)) { + throw InvalidProtocolBufferException.truncatedMessage(); + } + } + + private void requireWireType(int requiredWireType) throws IOException { + if (getWireType(tag) != requiredWireType) { + throw InvalidProtocolBufferException.invalidWireType(); + } + } + + private void verifyPackedFixed64Length(int bytes) throws IOException { + requireBytes(bytes); + if ((bytes & FIXED64_MULTIPLE_MASK) != 0) { + // Require that the number of bytes be a multiple of 8. + throw InvalidProtocolBufferException.parseFailure(); + } + } + + private void verifyPackedFixed32Length(int bytes) throws IOException { + requireBytes(bytes); + if ((bytes & FIXED32_MULTIPLE_MASK) != 0) { + // Require that the number of bytes be a multiple of 4. + throw InvalidProtocolBufferException.parseFailure(); + } + } + } +} diff --git a/java/core/src/main/java/com/google/protobuf/BinaryWriter.java b/java/core/src/main/java/com/google/protobuf/BinaryWriter.java new file mode 100644 index 00000000..2039a556 --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/BinaryWriter.java @@ -0,0 +1,2804 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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 static com.google.protobuf.BinaryProtocolUtil.FIXED32_SIZE; +import static com.google.protobuf.BinaryProtocolUtil.FIXED64_SIZE; +import static com.google.protobuf.BinaryProtocolUtil.MAX_VARINT32_SIZE; +import static com.google.protobuf.BinaryProtocolUtil.MAX_VARINT64_SIZE; +import static com.google.protobuf.BinaryProtocolUtil.WIRETYPE_END_GROUP; +import static com.google.protobuf.BinaryProtocolUtil.WIRETYPE_FIXED32; +import static com.google.protobuf.BinaryProtocolUtil.WIRETYPE_FIXED64; +import static com.google.protobuf.BinaryProtocolUtil.WIRETYPE_LENGTH_DELIMITED; +import static com.google.protobuf.BinaryProtocolUtil.WIRETYPE_START_GROUP; +import static com.google.protobuf.BinaryProtocolUtil.WIRETYPE_VARINT; +import static com.google.protobuf.BinaryProtocolUtil.encodeZigZag32; +import static com.google.protobuf.BinaryProtocolUtil.encodeZigZag64; +import static com.google.protobuf.BinaryProtocolUtil.tagFor; +import static com.google.protobuf.Internal.checkNotNull; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.util.ArrayDeque; +import java.util.List; +import java.util.Queue; + +/** + * A protobuf writer that serializes messages in their binary form. Messages are serialized in + * reverse in order to avoid calculating the serialized size of each nested message. Since the + * message size is not known in advance, the writer employs a strategy of chunking and buffer + * chaining. Buffers are allocated as-needed by a provided {@link BufferAllocator}. Once writing is + * finished, the application can access the buffers in forward-writing order by calling {@link + * #complete()}. + * + *

Once {@link #complete()} has been called, the writer can not be reused for additional writes. + * The {@link #getTotalBytesWritten()} will continue to reflect the total of the write and will not + * be reset. + */ +@ExperimentalApi +public abstract class BinaryWriter extends ByteOutput implements Writer { + public static final int DEFAULT_CHUNK_SIZE = 4096; + + private final BufferAllocator alloc; + private final int chunkSize; + + final ArrayDeque buffers = new ArrayDeque(4); + int totalDoneBytes; + + /** + * Creates a new {@link BinaryWriter} that will allocate heap buffers of {@link + * #DEFAULT_CHUNK_SIZE} as necessary. + */ + public static BinaryWriter newHeapInstance(BufferAllocator alloc) { + return newHeapInstance(alloc, DEFAULT_CHUNK_SIZE); + } + + /** + * Creates a new {@link BinaryWriter} that will allocate heap buffers of {@code chunkSize} as + * necessary. + */ + public static BinaryWriter newHeapInstance(BufferAllocator alloc, int chunkSize) { + return isUnsafeHeapSupported() + ? newUnsafeHeapInstance(alloc, chunkSize) + : newSafeHeapInstance(alloc, chunkSize); + } + + /** + * Creates a new {@link BinaryWriter} that will allocate direct (i.e. non-heap) buffers of {@link + * #DEFAULT_CHUNK_SIZE} as necessary. + */ + public static BinaryWriter newDirectInstance(BufferAllocator alloc) { + return newDirectInstance(alloc, DEFAULT_CHUNK_SIZE); + } + + /** + * Creates a new {@link BinaryWriter} that will allocate direct (i.e. non-heap) buffers of {@code + * chunkSize} as necessary. + */ + public static BinaryWriter newDirectInstance(BufferAllocator alloc, int chunkSize) { + return isUnsafeDirectSupported() + ? newUnsafeDirectInstance(alloc, chunkSize) + : newSafeDirectInstance(alloc, chunkSize); + } + + static boolean isUnsafeHeapSupported() { + return UnsafeHeapWriter.isSupported(); + } + + static boolean isUnsafeDirectSupported() { + return UnsafeDirectWriter.isSupported(); + } + + static BinaryWriter newSafeHeapInstance(BufferAllocator alloc, int chunkSize) { + return new SafeHeapWriter(alloc, chunkSize); + } + + static BinaryWriter newUnsafeHeapInstance(BufferAllocator alloc, int chunkSize) { + if (!isUnsafeHeapSupported()) { + throw new UnsupportedOperationException("Unsafe operations not supported"); + } + return new UnsafeHeapWriter(alloc, chunkSize); + } + + static BinaryWriter newSafeDirectInstance(BufferAllocator alloc, int chunkSize) { + return new SafeDirectWriter(alloc, chunkSize); + } + + static BinaryWriter newUnsafeDirectInstance(BufferAllocator alloc, int chunkSize) { + if (!isUnsafeDirectSupported()) { + throw new UnsupportedOperationException("Unsafe operations not supported"); + } + return new UnsafeDirectWriter(alloc, chunkSize); + } + + /** Only allow subclassing for inner classes. */ + private BinaryWriter(BufferAllocator alloc, int chunkSize) { + if (chunkSize <= 0) { + throw new IllegalArgumentException("chunkSize must be > 0"); + } + this.alloc = checkNotNull(alloc, "alloc"); + this.chunkSize = chunkSize; + } + + /** + * Completes the write operation and returns a queue of {@link AllocatedBuffer} objects in + * forward-writing order. This method should only be called once. + * + *

After calling this method, the writer can not be reused. Create a new writer for future + * writes. + */ + public final Queue complete() { + finishCurrentBuffer(); + return buffers; + } + + @Override + public final void writeSFixed32(int fieldNumber, int value) { + writeFixed32(fieldNumber, value); + } + + @Override + public final void writeInt64(int fieldNumber, long value) { + writeUInt64(fieldNumber, value); + } + + @Override + public final void writeSFixed64(int fieldNumber, long value) { + writeFixed64(fieldNumber, value); + } + + @Override + public final void writeFloat(int fieldNumber, float value) { + writeFixed32(fieldNumber, Float.floatToRawIntBits(value)); + } + + @Override + public final void writeDouble(int fieldNumber, double value) { + writeFixed64(fieldNumber, Double.doubleToRawLongBits(value)); + } + + @Override + public final void writeEnum(int fieldNumber, int value) { + writeInt32(fieldNumber, value); + } + + @Override + public final void writeInt32List(int fieldNumber, List list, boolean packed) { + if (list instanceof IntArrayList) { + writeInt32List_Internal(fieldNumber, (IntArrayList) list, packed); + } else { + writeInt32List_Internal(fieldNumber, list, packed); + } + } + + private final void writeInt32List_Internal(int fieldNumber, List list, boolean packed) { + if (packed) { + requireSpace((MAX_VARINT32_SIZE * 2) + (list.size() * MAX_VARINT64_SIZE)); + int prevBytes = getTotalBytesWritten(); + for (int i = list.size() - 1; i >= 0; --i) { + writeInt32(list.get(i)); + } + int length = getTotalBytesWritten() - prevBytes; + writeVarint32(length); + writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED); + } else { + for (int i = list.size() - 1; i >= 0; --i) { + writeInt32(fieldNumber, list.get(i)); + } + } + } + + private final void writeInt32List_Internal(int fieldNumber, IntArrayList list, boolean packed) { + if (packed) { + requireSpace((MAX_VARINT32_SIZE * 2) + (list.size() * MAX_VARINT64_SIZE)); + int prevBytes = getTotalBytesWritten(); + for (int i = list.size() - 1; i >= 0; --i) { + writeInt32(list.getInt(i)); + } + int length = getTotalBytesWritten() - prevBytes; + writeVarint32(length); + writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED); + } else { + for (int i = list.size() - 1; i >= 0; --i) { + writeInt32(fieldNumber, list.getInt(i)); + } + } + } + + @Override + public final void writeFixed32List(int fieldNumber, List list, boolean packed) { + if (list instanceof IntArrayList) { + writeFixed32List_Internal(fieldNumber, (IntArrayList) list, packed); + } else { + writeFixed32List_Internal(fieldNumber, list, packed); + } + } + + private final void writeFixed32List_Internal( + int fieldNumber, List list, boolean packed) { + if (packed) { + requireSpace((MAX_VARINT32_SIZE * 2) + (list.size() * FIXED32_SIZE)); + int prevBytes = getTotalBytesWritten(); + for (int i = list.size() - 1; i >= 0; --i) { + writeFixed32(list.get(i)); + } + int length = getTotalBytesWritten() - prevBytes; + writeVarint32(length); + writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED); + } else { + for (int i = list.size() - 1; i >= 0; --i) { + writeFixed32(fieldNumber, list.get(i)); + } + } + } + + private final void writeFixed32List_Internal(int fieldNumber, IntArrayList list, boolean packed) { + if (packed) { + requireSpace((MAX_VARINT32_SIZE * 2) + (list.size() * FIXED32_SIZE)); + int prevBytes = getTotalBytesWritten(); + for (int i = list.size() - 1; i >= 0; --i) { + writeFixed32(list.getInt(i)); + } + int length = getTotalBytesWritten() - prevBytes; + writeVarint32(length); + writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED); + } else { + for (int i = list.size() - 1; i >= 0; --i) { + writeFixed32(fieldNumber, list.getInt(i)); + } + } + } + + @Override + public final void writeInt64List(int fieldNumber, List list, boolean packed) { + writeUInt64List(fieldNumber, list, packed); + } + + @Override + public final void writeUInt64List(int fieldNumber, List list, boolean packed) { + if (list instanceof LongArrayList) { + writeUInt64List_Internal(fieldNumber, (LongArrayList) list, packed); + } else { + writeUInt64List_Internal(fieldNumber, list, packed); + } + } + + private final void writeUInt64List_Internal(int fieldNumber, List list, boolean packed) { + if (packed) { + requireSpace((MAX_VARINT32_SIZE * 2) + (list.size() * MAX_VARINT64_SIZE)); + int prevBytes = getTotalBytesWritten(); + for (int i = list.size() - 1; i >= 0; --i) { + writeVarint64(list.get(i)); + } + int length = getTotalBytesWritten() - prevBytes; + writeVarint32(length); + writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED); + } else { + for (int i = list.size() - 1; i >= 0; --i) { + writeUInt64(fieldNumber, list.get(i)); + } + } + } + + private final void writeUInt64List_Internal(int fieldNumber, LongArrayList list, boolean packed) { + if (packed) { + requireSpace((MAX_VARINT32_SIZE * 2) + (list.size() * MAX_VARINT64_SIZE)); + int prevBytes = getTotalBytesWritten(); + for (int i = list.size() - 1; i >= 0; --i) { + writeVarint64(list.getLong(i)); + } + int length = getTotalBytesWritten() - prevBytes; + writeVarint32(length); + writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED); + } else { + for (int i = list.size() - 1; i >= 0; --i) { + writeUInt64(fieldNumber, list.getLong(i)); + } + } + } + + @Override + public final void writeFixed64List(int fieldNumber, List list, boolean packed) { + if (list instanceof LongArrayList) { + writeFixed64List_Internal(fieldNumber, (LongArrayList) list, packed); + } else { + writeFixed64List_Internal(fieldNumber, list, packed); + } + } + + private final void writeFixed64List_Internal(int fieldNumber, List list, boolean packed) { + if (packed) { + requireSpace((MAX_VARINT32_SIZE * 2) + (list.size() * FIXED64_SIZE)); + int prevBytes = getTotalBytesWritten(); + for (int i = list.size() - 1; i >= 0; --i) { + writeFixed64(list.get(i)); + } + int length = getTotalBytesWritten() - prevBytes; + writeVarint32(length); + writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED); + } else { + for (int i = list.size() - 1; i >= 0; --i) { + writeFixed64(fieldNumber, list.get(i)); + } + } + } + + private final void writeFixed64List_Internal( + int fieldNumber, LongArrayList list, boolean packed) { + if (packed) { + requireSpace((MAX_VARINT32_SIZE * 2) + (list.size() * FIXED64_SIZE)); + int prevBytes = getTotalBytesWritten(); + for (int i = list.size() - 1; i >= 0; --i) { + writeFixed64(list.getLong(i)); + } + int length = getTotalBytesWritten() - prevBytes; + writeVarint32(length); + writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED); + } else { + for (int i = list.size() - 1; i >= 0; --i) { + writeFixed64(fieldNumber, list.getLong(i)); + } + } + } + + @Override + public final void writeFloatList(int fieldNumber, List list, boolean packed) { + if (list instanceof FloatArrayList) { + writeFloatList_Internal(fieldNumber, (FloatArrayList) list, packed); + } else { + writeFloatList_Internal(fieldNumber, list, packed); + } + } + + private final void writeFloatList_Internal(int fieldNumber, List list, boolean packed) { + if (packed) { + requireSpace((MAX_VARINT32_SIZE * 2) + (list.size() * FIXED32_SIZE)); + int prevBytes = getTotalBytesWritten(); + for (int i = list.size() - 1; i >= 0; --i) { + writeFixed32(Float.floatToRawIntBits(list.get(i))); + } + int length = getTotalBytesWritten() - prevBytes; + writeVarint32(length); + writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED); + } else { + for (int i = list.size() - 1; i >= 0; --i) { + writeFloat(fieldNumber, list.get(i)); + } + } + } + + private final void writeFloatList_Internal(int fieldNumber, FloatArrayList list, boolean packed) { + if (packed) { + requireSpace((MAX_VARINT32_SIZE * 2) + (list.size() * FIXED32_SIZE)); + int prevBytes = getTotalBytesWritten(); + for (int i = list.size() - 1; i >= 0; --i) { + writeFixed32(Float.floatToRawIntBits(list.getFloat(i))); + } + int length = getTotalBytesWritten() - prevBytes; + writeVarint32(length); + writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED); + } else { + for (int i = list.size() - 1; i >= 0; --i) { + writeFloat(fieldNumber, list.getFloat(i)); + } + } + } + + @Override + public final void writeDoubleList(int fieldNumber, List list, boolean packed) { + if (list instanceof DoubleArrayList) { + writeDoubleList_Internal(fieldNumber, (DoubleArrayList) list, packed); + } else { + writeDoubleList_Internal(fieldNumber, list, packed); + } + } + + private final void writeDoubleList_Internal(int fieldNumber, List list, boolean packed) { + if (packed) { + requireSpace((MAX_VARINT32_SIZE * 2) + (list.size() * FIXED64_SIZE)); + int prevBytes = getTotalBytesWritten(); + for (int i = list.size() - 1; i >= 0; --i) { + writeFixed64(Double.doubleToRawLongBits(list.get(i))); + } + int length = getTotalBytesWritten() - prevBytes; + writeVarint32(length); + writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED); + } else { + for (int i = list.size() - 1; i >= 0; --i) { + writeDouble(fieldNumber, list.get(i)); + } + } + } + + private final void writeDoubleList_Internal( + int fieldNumber, DoubleArrayList list, boolean packed) { + if (packed) { + requireSpace((MAX_VARINT32_SIZE * 2) + (list.size() * FIXED64_SIZE)); + int prevBytes = getTotalBytesWritten(); + for (int i = list.size() - 1; i >= 0; --i) { + writeFixed64(Double.doubleToRawLongBits(list.getDouble(i))); + } + int length = getTotalBytesWritten() - prevBytes; + writeVarint32(length); + writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED); + } else { + for (int i = list.size() - 1; i >= 0; --i) { + writeDouble(fieldNumber, list.getDouble(i)); + } + } + } + + @Override + public final void writeEnumList(int fieldNumber, List list, boolean packed) { + writeInt32List(fieldNumber, list, packed); + } + + @Override + public final void writeBoolList(int fieldNumber, List list, boolean packed) { + if (list instanceof BooleanArrayList) { + writeBoolList_Internal(fieldNumber, (BooleanArrayList) list, packed); + } else { + writeBoolList_Internal(fieldNumber, list, packed); + } + } + + private final void writeBoolList_Internal(int fieldNumber, List list, boolean packed) { + if (packed) { + requireSpace((MAX_VARINT32_SIZE * 2) + list.size()); + int prevBytes = getTotalBytesWritten(); + for (int i = list.size() - 1; i >= 0; --i) { + writeBool(list.get(i)); + } + int length = getTotalBytesWritten() - prevBytes; + writeVarint32(length); + writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED); + } else { + for (int i = list.size() - 1; i >= 0; --i) { + writeBool(fieldNumber, list.get(i)); + } + } + } + + private final void writeBoolList_Internal( + int fieldNumber, BooleanArrayList list, boolean packed) { + if (packed) { + requireSpace((MAX_VARINT32_SIZE * 2) + list.size()); + int prevBytes = getTotalBytesWritten(); + for (int i = list.size() - 1; i >= 0; --i) { + writeBool(list.getBoolean(i)); + } + int length = getTotalBytesWritten() - prevBytes; + writeVarint32(length); + writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED); + } else { + for (int i = list.size() - 1; i >= 0; --i) { + writeBool(fieldNumber, list.getBoolean(i)); + } + } + } + + @Override + public final void writeStringList(int fieldNumber, List list) { + for (int i = list.size() - 1; i >= 0; i--) { + writeString(fieldNumber, list.get(i)); + } + } + + @Override + public final void writeBytesList(int fieldNumber, List list) { + for (int i = list.size() - 1; i >= 0; i--) { + writeBytes(fieldNumber, list.get(i)); + } + } + + @Override + public final void writeUInt32List(int fieldNumber, List list, boolean packed) { + if (list instanceof IntArrayList) { + writeUInt32List_Internal(fieldNumber, (IntArrayList) list, packed); + } else { + writeUInt32List_Internal(fieldNumber, list, packed); + } + } + + private final void writeUInt32List_Internal(int fieldNumber, List list, boolean packed) { + if (packed) { + requireSpace((MAX_VARINT32_SIZE * 2) + (list.size() * MAX_VARINT32_SIZE)); + int prevBytes = getTotalBytesWritten(); + for (int i = list.size() - 1; i >= 0; --i) { + writeVarint32(list.get(i)); + } + int length = getTotalBytesWritten() - prevBytes; + writeVarint32(length); + writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED); + } else { + for (int i = list.size() - 1; i >= 0; --i) { + writeUInt32(fieldNumber, list.get(i)); + } + } + } + + private final void writeUInt32List_Internal(int fieldNumber, IntArrayList list, boolean packed) { + if (packed) { + requireSpace((MAX_VARINT32_SIZE * 2) + (list.size() * MAX_VARINT32_SIZE)); + int prevBytes = getTotalBytesWritten(); + for (int i = list.size() - 1; i >= 0; --i) { + writeVarint32(list.getInt(i)); + } + int length = getTotalBytesWritten() - prevBytes; + writeVarint32(length); + writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED); + } else { + for (int i = list.size() - 1; i >= 0; --i) { + writeUInt32(fieldNumber, list.getInt(i)); + } + } + } + + @Override + public final void writeSFixed32List(int fieldNumber, List list, boolean packed) { + writeFixed32List(fieldNumber, list, packed); + } + + @Override + public final void writeSFixed64List(int fieldNumber, List list, boolean packed) { + writeFixed64List(fieldNumber, list, packed); + } + + @Override + public final void writeSInt32List(int fieldNumber, List list, boolean packed) { + if (list instanceof IntArrayList) { + writeSInt32List_Internal(fieldNumber, (IntArrayList) list, packed); + } else { + writeSInt32List_Internal(fieldNumber, list, packed); + } + } + + private final void writeSInt32List_Internal(int fieldNumber, List list, boolean packed) { + if (packed) { + requireSpace((MAX_VARINT32_SIZE * 2) + (list.size() * MAX_VARINT32_SIZE)); + int prevBytes = getTotalBytesWritten(); + for (int i = list.size() - 1; i >= 0; --i) { + writeSInt32(list.get(i)); + } + int length = getTotalBytesWritten() - prevBytes; + writeVarint32(length); + writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED); + } else { + for (int i = list.size() - 1; i >= 0; --i) { + writeSInt32(fieldNumber, list.get(i)); + } + } + } + + private final void writeSInt32List_Internal(int fieldNumber, IntArrayList list, boolean packed) { + if (packed) { + requireSpace((MAX_VARINT32_SIZE * 2) + (list.size() * MAX_VARINT32_SIZE)); + int prevBytes = getTotalBytesWritten(); + for (int i = list.size() - 1; i >= 0; --i) { + writeSInt32(list.getInt(i)); + } + int length = getTotalBytesWritten() - prevBytes; + writeVarint32(length); + writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED); + } else { + for (int i = list.size() - 1; i >= 0; --i) { + writeSInt32(fieldNumber, list.getInt(i)); + } + } + } + + @Override + public final void writeSInt64List(int fieldNumber, List list, boolean packed) { + if (list instanceof LongArrayList) { + writeSInt64List_Internal(fieldNumber, (LongArrayList) list, packed); + } else { + writeSInt64List_Internal(fieldNumber, list, packed); + } + } + + private final void writeSInt64List_Internal(int fieldNumber, List list, boolean packed) { + if (packed) { + requireSpace((MAX_VARINT32_SIZE * 2) + (list.size() * MAX_VARINT64_SIZE)); + int prevBytes = getTotalBytesWritten(); + for (int i = list.size() - 1; i >= 0; --i) { + writeSInt64(list.get(i)); + } + int length = getTotalBytesWritten() - prevBytes; + writeVarint32(length); + writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED); + } else { + for (int i = list.size() - 1; i >= 0; --i) { + writeSInt64(fieldNumber, list.get(i)); + } + } + } + + private final void writeSInt64List_Internal(int fieldNumber, LongArrayList list, boolean packed) { + if (packed) { + requireSpace((MAX_VARINT32_SIZE * 2) + (list.size() * MAX_VARINT64_SIZE)); + int prevBytes = getTotalBytesWritten(); + for (int i = list.size() - 1; i >= 0; --i) { + writeSInt64(list.getLong(i)); + } + int length = getTotalBytesWritten() - prevBytes; + writeVarint32(length); + writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED); + } else { + for (int i = list.size() - 1; i >= 0; --i) { + writeSInt64(fieldNumber, list.getLong(i)); + } + } + } + + @Override + public final void writeMessageList(int fieldNumber, List list) { + for (int i = list.size() - 1; i >= 0; i--) { + writeMessage(fieldNumber, list.get(i)); + } + } + + @Override + public final void writeGroupList(int fieldNumber, List list) { + for (int i = list.size() - 1; i >= 0; i--) { + writeGroup(fieldNumber, list.get(i)); + } + } + + final AllocatedBuffer newHeapBuffer() { + return alloc.allocateHeapBuffer(chunkSize); + } + + final AllocatedBuffer newHeapBuffer(int capacity) { + return alloc.allocateHeapBuffer(Math.max(capacity, chunkSize)); + } + + final AllocatedBuffer newDirectBuffer() { + return alloc.allocateDirectBuffer(chunkSize); + } + + final AllocatedBuffer newDirectBuffer(int capacity) { + return alloc.allocateDirectBuffer(Math.max(capacity, chunkSize)); + } + + /** + * Gets the total number of bytes that have been written. This will not be reset by a call to + * {@link #complete()}. + */ + public abstract int getTotalBytesWritten(); + + abstract void requireSpace(int size); + + abstract void finishCurrentBuffer(); + + abstract void writeTag(int fieldNumber, byte wireType); + + abstract void writeVarint32(int value); + + abstract void writeInt32(int value); + + abstract void writeSInt32(int value); + + abstract void writeFixed32(int value); + + abstract void writeVarint64(long value); + + abstract void writeSInt64(long value); + + abstract void writeFixed64(long value); + + abstract void writeBool(boolean value); + + abstract void writeString(String in); + + /** + * Not using the version in CodedOutputStream due to the fact that benchmarks have shown a + * performance improvement when returning a byte (rather than an int). + */ + private static byte computeUInt64SizeNoTag(long value) { + // handle two popular special cases up front ... + if ((value & (~0L << 7)) == 0L) { + // Byte 1 + return 1; + } + if (value < 0L) { + // Byte 10 + return 10; + } + // ... leaving us with 8 remaining, which we can divide and conquer + byte n = 2; + if ((value & (~0L << 35)) != 0L) { + // Byte 6-9 + n += 4; // + (value >>> 63); + value >>>= 28; + } + if ((value & (~0L << 21)) != 0L) { + // Byte 4-5 or 8-9 + n += 2; + value >>>= 14; + } + if ((value & (~0L << 14)) != 0L) { + // Byte 3 or 7 + n += 1; + } + return n; + } + + /** Writer that uses safe operations on target array. */ + private static final class SafeHeapWriter extends BinaryWriter { + private AllocatedBuffer allocatedBuffer; + private byte[] buffer; + private int offset; + private int limit; + private int offsetMinusOne; + private int limitMinusOne; + private int pos; + + SafeHeapWriter(BufferAllocator alloc, int chunkSize) { + super(alloc, chunkSize); + nextBuffer(); + } + + @Override + void finishCurrentBuffer() { + if (allocatedBuffer != null) { + totalDoneBytes += bytesWrittenToCurrentBuffer(); + allocatedBuffer.position((pos - allocatedBuffer.arrayOffset()) + 1); + allocatedBuffer = null; + pos = 0; + limitMinusOne = 0; + } + } + + private void nextBuffer() { + nextBuffer(newHeapBuffer()); + } + + private void nextBuffer(int capacity) { + nextBuffer(newHeapBuffer(capacity)); + } + + private void nextBuffer(AllocatedBuffer allocatedBuffer) { + if (!allocatedBuffer.hasArray()) { + throw new RuntimeException("Allocator returned non-heap buffer"); + } + + finishCurrentBuffer(); + + buffers.addFirst(allocatedBuffer); + + this.allocatedBuffer = allocatedBuffer; + this.buffer = allocatedBuffer.array(); + int arrayOffset = allocatedBuffer.arrayOffset(); + this.limit = arrayOffset + allocatedBuffer.limit(); + this.offset = arrayOffset + allocatedBuffer.position(); + this.offsetMinusOne = offset - 1; + this.limitMinusOne = limit - 1; + this.pos = limitMinusOne; + } + + @Override + public int getTotalBytesWritten() { + return totalDoneBytes + bytesWrittenToCurrentBuffer(); + } + + int bytesWrittenToCurrentBuffer() { + return limitMinusOne - pos; + } + + int spaceLeft() { + return pos - offsetMinusOne; + } + + @Override + public void writeUInt32(int fieldNumber, int value) { + requireSpace(MAX_VARINT32_SIZE * 2); + writeVarint32(value); + writeTag(fieldNumber, WIRETYPE_VARINT); + } + + @Override + public void writeInt32(int fieldNumber, int value) { + requireSpace(MAX_VARINT32_SIZE + MAX_VARINT64_SIZE); + writeInt32(value); + writeTag(fieldNumber, WIRETYPE_VARINT); + } + + @Override + public void writeSInt32(int fieldNumber, int value) { + requireSpace(MAX_VARINT32_SIZE * 2); + writeSInt32(value); + writeTag(fieldNumber, WIRETYPE_VARINT); + } + + @Override + public void writeFixed32(int fieldNumber, int value) { + requireSpace(MAX_VARINT32_SIZE + FIXED32_SIZE); + writeFixed32(value); + writeTag(fieldNumber, WIRETYPE_FIXED32); + } + + @Override + public void writeUInt64(int fieldNumber, long value) { + requireSpace(MAX_VARINT32_SIZE + MAX_VARINT64_SIZE); + writeVarint64(value); + writeTag(fieldNumber, WIRETYPE_VARINT); + } + + @Override + public void writeSInt64(int fieldNumber, long value) { + requireSpace(MAX_VARINT32_SIZE + MAX_VARINT64_SIZE); + writeSInt64(value); + writeTag(fieldNumber, WIRETYPE_VARINT); + } + + @Override + public void writeFixed64(int fieldNumber, long value) { + requireSpace(MAX_VARINT32_SIZE + FIXED64_SIZE); + writeFixed64(value); + writeTag(fieldNumber, WIRETYPE_FIXED64); + } + + @Override + public void writeBool(int fieldNumber, boolean value) { + requireSpace(MAX_VARINT32_SIZE + 1); + write((byte) (value ? 1 : 0)); + writeTag(fieldNumber, WIRETYPE_VARINT); + } + + @Override + public void writeString(int fieldNumber, String value) { + int prevBytes = getTotalBytesWritten(); + writeString(value); + int length = getTotalBytesWritten() - prevBytes; + requireSpace(2 * MAX_VARINT32_SIZE); + writeVarint32(length); + writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED); + } + + @Override + public void writeBytes(int fieldNumber, ByteString value) { + try { + value.writeToReverse(this); + } catch (IOException e) { + // Should never happen since the writer does not throw. + throw new RuntimeException(e); + } + + requireSpace(MAX_VARINT32_SIZE * 2); + writeVarint32(value.size()); + writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED); + } + + @Override + public void writeMessage(int fieldNumber, Object value) { + int prevBytes = getTotalBytesWritten(); + Protobuf.getInstance().writeTo(value, this); + int length = getTotalBytesWritten() - prevBytes; + requireSpace(MAX_VARINT32_SIZE * 2); + writeVarint32(length); + writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED); + } + + @Override + public void writeGroup(int fieldNumber, Object value) { + writeTag(fieldNumber, WIRETYPE_END_GROUP); + Protobuf.getInstance().writeTo(value, this); + writeTag(fieldNumber, WIRETYPE_START_GROUP); + } + + @Override + void writeInt32(int value) { + if (value >= 0) { + writeVarint32(value); + } else { + writeVarint64(value); + } + } + + @Override + void writeSInt32(int value) { + writeVarint32(encodeZigZag32(value)); + } + + @Override + void writeSInt64(long value) { + writeVarint64(encodeZigZag64(value)); + } + + @Override + void writeBool(boolean value) { + write((byte) (value ? 1 : 0)); + } + + @Override + void writeTag(int fieldNumber, byte wireType) { + writeVarint32(tagFor(fieldNumber, wireType)); + } + + @Override + void writeVarint32(int value) { + if ((value & (~0 << 7)) == 0) { + writeVarint32OneByte(value); + } else if ((value & (~0 << 14)) == 0) { + writeVarint32TwoBytes(value); + } else if ((value & (~0 << 21)) == 0) { + writeVarint32ThreeBytes(value); + } else if ((value & (~0 << 28)) == 0) { + writeVarint32FourBytes(value); + } else { + writeVarint32FiveBytes(value); + } + } + + private void writeVarint32OneByte(int value) { + buffer[pos--] = (byte) value; + } + + private void writeVarint32TwoBytes(int value) { + buffer[pos--] = (byte) (value >>> 7); + buffer[pos--] = (byte) ((value & 0x7F) | 0x80); + } + + private void writeVarint32ThreeBytes(int value) { + buffer[pos--] = (byte) (value >>> 14); + buffer[pos--] = (byte) (((value >>> 7) & 0x7F) | 0x80); + buffer[pos--] = (byte) ((value & 0x7F) | 0x80); + } + + private void writeVarint32FourBytes(int value) { + buffer[pos--] = (byte) (value >>> 21); + buffer[pos--] = (byte) (((value >>> 14) & 0x7F) | 0x80); + buffer[pos--] = (byte) (((value >>> 7) & 0x7F) | 0x80); + buffer[pos--] = (byte) ((value & 0x7F) | 0x80); + } + + private void writeVarint32FiveBytes(int value) { + buffer[pos--] = (byte) (value >>> 28); + buffer[pos--] = (byte) (((value >>> 21) & 0x7F) | 0x80); + buffer[pos--] = (byte) (((value >>> 14) & 0x7F) | 0x80); + buffer[pos--] = (byte) (((value >>> 7) & 0x7F) | 0x80); + buffer[pos--] = (byte) ((value & 0x7F) | 0x80); + } + + @Override + void writeVarint64(long value) { + switch (computeUInt64SizeNoTag(value)) { + case 1: + writeVarint64OneByte(value); + break; + case 2: + writeVarint64TwoBytes(value); + break; + case 3: + writeVarint64ThreeBytes(value); + break; + case 4: + writeVarint64FourBytes(value); + break; + case 5: + writeVarint64FiveBytes(value); + break; + case 6: + writeVarint64SixBytes(value); + break; + case 7: + writeVarint64SevenBytes(value); + break; + case 8: + writeVarint64EightBytes(value); + break; + case 9: + writeVarint64NineBytes(value); + break; + case 10: + writeVarint64TenBytes(value); + break; + } + } + + private void writeVarint64OneByte(long value) { + buffer[pos--] = (byte) value; + } + + private void writeVarint64TwoBytes(long value) { + buffer[pos--] = (byte) (value >>> 7); + buffer[pos--] = (byte) (((int) value & 0x7F) | 0x80); + } + + private void writeVarint64ThreeBytes(long value) { + buffer[pos--] = (byte) (((int) value) >>> 14); + buffer[pos--] = (byte) (((value >>> 7) & 0x7F) | 0x80); + buffer[pos--] = (byte) ((value & 0x7F) | 0x80); + } + + private void writeVarint64FourBytes(long value) { + buffer[pos--] = (byte) (value >>> 21); + buffer[pos--] = (byte) (((value >>> 14) & 0x7F) | 0x80); + buffer[pos--] = (byte) (((value >>> 7) & 0x7F) | 0x80); + buffer[pos--] = (byte) ((value & 0x7F) | 0x80); + } + + private void writeVarint64FiveBytes(long value) { + buffer[pos--] = (byte) (value >>> 28); + buffer[pos--] = (byte) (((value >>> 21) & 0x7F) | 0x80); + buffer[pos--] = (byte) (((value >>> 14) & 0x7F) | 0x80); + buffer[pos--] = (byte) (((value >>> 7) & 0x7F) | 0x80); + buffer[pos--] = (byte) ((value & 0x7F) | 0x80); + } + + private void writeVarint64SixBytes(long value) { + buffer[pos--] = (byte) (value >>> 35); + buffer[pos--] = (byte) (((value >>> 28) & 0x7F) | 0x80); + buffer[pos--] = (byte) (((value >>> 21) & 0x7F) | 0x80); + buffer[pos--] = (byte) (((value >>> 14) & 0x7F) | 0x80); + buffer[pos--] = (byte) (((value >>> 7) & 0x7F) | 0x80); + buffer[pos--] = (byte) ((value & 0x7F) | 0x80); + } + + private void writeVarint64SevenBytes(long value) { + buffer[pos--] = (byte) (value >>> 42); + buffer[pos--] = (byte) (((value >>> 35) & 0x7F) | 0x80); + buffer[pos--] = (byte) (((value >>> 28) & 0x7F) | 0x80); + buffer[pos--] = (byte) (((value >>> 21) & 0x7F) | 0x80); + buffer[pos--] = (byte) (((value >>> 14) & 0x7F) | 0x80); + buffer[pos--] = (byte) (((value >>> 7) & 0x7F) | 0x80); + buffer[pos--] = (byte) ((value & 0x7F) | 0x80); + } + + private void writeVarint64EightBytes(long value) { + buffer[pos--] = (byte) (value >>> 49); + buffer[pos--] = (byte) (((value >>> 42) & 0x7F) | 0x80); + buffer[pos--] = (byte) (((value >>> 35) & 0x7F) | 0x80); + buffer[pos--] = (byte) (((value >>> 28) & 0x7F) | 0x80); + buffer[pos--] = (byte) (((value >>> 21) & 0x7F) | 0x80); + buffer[pos--] = (byte) (((value >>> 14) & 0x7F) | 0x80); + buffer[pos--] = (byte) (((value >>> 7) & 0x7F) | 0x80); + buffer[pos--] = (byte) ((value & 0x7F) | 0x80); + } + + private void writeVarint64NineBytes(long value) { + buffer[pos--] = (byte) (value >>> 56); + buffer[pos--] = (byte) (((value >>> 49) & 0x7F) | 0x80); + buffer[pos--] = (byte) (((value >>> 42) & 0x7F) | 0x80); + buffer[pos--] = (byte) (((value >>> 35) & 0x7F) | 0x80); + buffer[pos--] = (byte) (((value >>> 28) & 0x7F) | 0x80); + buffer[pos--] = (byte) (((value >>> 21) & 0x7F) | 0x80); + buffer[pos--] = (byte) (((value >>> 14) & 0x7F) | 0x80); + buffer[pos--] = (byte) (((value >>> 7) & 0x7F) | 0x80); + buffer[pos--] = (byte) ((value & 0x7F) | 0x80); + } + + private void writeVarint64TenBytes(long value) { + buffer[pos--] = (byte) (value >>> 63); + buffer[pos--] = (byte) (((value >>> 56) & 0x7F) | 0x80); + buffer[pos--] = (byte) (((value >>> 49) & 0x7F) | 0x80); + buffer[pos--] = (byte) (((value >>> 42) & 0x7F) | 0x80); + buffer[pos--] = (byte) (((value >>> 35) & 0x7F) | 0x80); + buffer[pos--] = (byte) (((value >>> 28) & 0x7F) | 0x80); + buffer[pos--] = (byte) (((value >>> 21) & 0x7F) | 0x80); + buffer[pos--] = (byte) (((value >>> 14) & 0x7F) | 0x80); + buffer[pos--] = (byte) (((value >>> 7) & 0x7F) | 0x80); + buffer[pos--] = (byte) ((value & 0x7F) | 0x80); + } + + @Override + void writeFixed32(int value) { + buffer[pos--] = (byte) ((value >> 24) & 0xFF); + buffer[pos--] = (byte) ((value >> 16) & 0xFF); + buffer[pos--] = (byte) ((value >> 8) & 0xFF); + buffer[pos--] = (byte) (value & 0xFF); + } + + @Override + void writeFixed64(long value) { + buffer[pos--] = (byte) ((int) (value >> 56) & 0xFF); + buffer[pos--] = (byte) ((int) (value >> 48) & 0xFF); + buffer[pos--] = (byte) ((int) (value >> 40) & 0xFF); + buffer[pos--] = (byte) ((int) (value >> 32) & 0xFF); + buffer[pos--] = (byte) ((int) (value >> 24) & 0xFF); + buffer[pos--] = (byte) ((int) (value >> 16) & 0xFF); + buffer[pos--] = (byte) ((int) (value >> 8) & 0xFF); + buffer[pos--] = (byte) ((int) (value) & 0xFF); + } + + @Override + void writeString(String in) { + // Request enough space to write the ASCII string. + requireSpace(in.length()); + + // We know the buffer is big enough... + int i = in.length() - 1; + // Set pos to the start of the ASCII string. + pos -= i; + // Designed to take advantage of + // https://wikis.oracle.com/display/HotSpotInternals/RangeCheckElimination + for (char c; i >= 0 && (c = in.charAt(i)) < 0x80; i--) { + buffer[pos + i] = (byte) c; + } + if (i == -1) { + // Move pos past the String. + pos -= 1; + return; + } + pos += i; + for (char c; i >= 0; i--) { + c = in.charAt(i); + if (c < 0x80 && pos > offsetMinusOne) { + buffer[pos--] = (byte) c; + } else if (c < 0x800 && pos > offset) { // 11 bits, two UTF-8 bytes + buffer[pos--] = (byte) (0x80 | (0x3F & c)); + buffer[pos--] = (byte) ((0xF << 6) | (c >>> 6)); + } else if ((c < Character.MIN_SURROGATE || Character.MAX_SURROGATE < c) + && pos > (offset + 1)) { + // Maximum single-char code point is 0xFFFF, 16 bits, three UTF-8 bytes + buffer[pos--] = (byte) (0x80 | (0x3F & c)); + buffer[pos--] = (byte) (0x80 | (0x3F & (c >>> 6))); + buffer[pos--] = (byte) ((0xF << 5) | (c >>> 12)); + } else if (pos > (offset + 2)) { + // Minimum code point represented by a surrogate pair is 0x10000, 17 bits, + // four UTF-8 bytes + char high = 0; + if (i == 0 || !Character.isSurrogatePair(high = in.charAt(i - 1), c)) { + throw new Utf8.UnpairedSurrogateException(i - 1, i); + } + i--; + int codePoint = Character.toCodePoint(high, c); + buffer[pos--] = (byte) (0x80 | (0x3F & codePoint)); + buffer[pos--] = (byte) (0x80 | (0x3F & (codePoint >>> 6))); + buffer[pos--] = (byte) (0x80 | (0x3F & (codePoint >>> 12))); + buffer[pos--] = (byte) ((0xF << 4) | (codePoint >>> 18)); + } else { + // Buffer is full - allocate a new one and revisit the current character. + requireSpace(i); + i++; + } + } + } + + @Override + public void write(byte value) { + buffer[pos--] = value; + } + + @Override + public void write(byte[] value, int offset, int length) { + if (spaceLeft() < length) { + nextBuffer(length); + } + + pos -= length; + System.arraycopy(value, offset, buffer, pos + 1, length); + } + + @Override + public void writeLazy(byte[] value, int offset, int length) { + if (spaceLeft() < length) { + // We consider the value to be immutable (likely the internals of a ByteString). Just + // wrap it in a Netty buffer and add it to the output buffer. + totalDoneBytes += length; + buffers.addFirst(AllocatedBuffer.wrap(value, offset, length)); + + // Advance the writer to the next buffer. + // TODO(nathanmittler): Consider slicing if space available above some threshold. + nextBuffer(); + return; + } + + pos -= length; + System.arraycopy(value, offset, buffer, pos + 1, length); + } + + @Override + public void write(ByteBuffer value) { + int length = value.remaining(); + if (spaceLeft() < length) { + nextBuffer(length); + } + + pos -= length; + value.get(buffer, pos + 1, length); + } + + @Override + public void writeLazy(ByteBuffer value) { + int length = value.remaining(); + if (spaceLeft() < length) { + // We consider the value to be immutable (likely the internals of a ByteString). Just + // wrap it in a Netty buffer and add it to the output buffer. + totalDoneBytes += length; + buffers.addFirst(AllocatedBuffer.wrap(value)); + + // Advance the writer to the next buffer. + // TODO(nathanmittler): Consider slicing if space available above some threshold. + nextBuffer(); + } + + pos -= length; + value.get(buffer, pos + 1, length); + } + + @Override + void requireSpace(int size) { + if (spaceLeft() < size) { + nextBuffer(size); + } + } + } + + /** Writer that uses unsafe operations on a target array. */ + private static final class UnsafeHeapWriter extends BinaryWriter { + private AllocatedBuffer allocatedBuffer; + private byte[] buffer; + private long offset; + private long limit; + private long offsetMinusOne; + private long limitMinusOne; + private long pos; + + UnsafeHeapWriter(BufferAllocator alloc, int chunkSize) { + super(alloc, chunkSize); + nextBuffer(); + } + + /** Indicates whether the required unsafe operations are supported on this platform. */ + static boolean isSupported() { + return UnsafeUtil.hasUnsafeArrayOperations(); + } + + @Override + void finishCurrentBuffer() { + if (allocatedBuffer != null) { + totalDoneBytes += bytesWrittenToCurrentBuffer(); + allocatedBuffer.position((arrayPos() - allocatedBuffer.arrayOffset()) + 1); + allocatedBuffer = null; + pos = 0; + limitMinusOne = 0; + } + } + + private int arrayPos() { + return (int) (pos - UnsafeUtil.getArrayBaseOffset()); + } + + private void nextBuffer() { + nextBuffer(newHeapBuffer()); + } + + private void nextBuffer(int capacity) { + nextBuffer(newHeapBuffer(capacity)); + } + + private void nextBuffer(AllocatedBuffer allocatedBuffer) { + if (!allocatedBuffer.hasArray()) { + throw new RuntimeException("Allocator returned non-heap buffer"); + } + + finishCurrentBuffer(); + buffers.addFirst(allocatedBuffer); + + this.allocatedBuffer = allocatedBuffer; + this.buffer = allocatedBuffer.array(); + int arrayOffset = allocatedBuffer.arrayOffset(); + long byteArrayOffset = UnsafeUtil.getArrayBaseOffset(); + this.limit = byteArrayOffset + arrayOffset + allocatedBuffer.limit(); + this.offset = byteArrayOffset + arrayOffset + allocatedBuffer.position(); + this.offsetMinusOne = offset - 1; + this.limitMinusOne = limit - 1; + this.pos = limitMinusOne; + } + + @Override + public int getTotalBytesWritten() { + return totalDoneBytes + bytesWrittenToCurrentBuffer(); + } + + int bytesWrittenToCurrentBuffer() { + return (int) (limitMinusOne - pos); + } + + int spaceLeft() { + return (int) (pos - offsetMinusOne); + } + + @Override + public void writeUInt32(int fieldNumber, int value) { + requireSpace(MAX_VARINT32_SIZE * 2); + writeVarint32(value); + writeTag(fieldNumber, WIRETYPE_VARINT); + } + + @Override + public void writeInt32(int fieldNumber, int value) { + requireSpace(MAX_VARINT32_SIZE + MAX_VARINT64_SIZE); + writeInt32(value); + writeTag(fieldNumber, WIRETYPE_VARINT); + } + + @Override + public void writeSInt32(int fieldNumber, int value) { + requireSpace(MAX_VARINT32_SIZE * 2); + writeSInt32(value); + writeTag(fieldNumber, WIRETYPE_VARINT); + } + + @Override + public void writeFixed32(int fieldNumber, int value) { + requireSpace(MAX_VARINT32_SIZE + FIXED32_SIZE); + writeFixed32(value); + writeTag(fieldNumber, WIRETYPE_FIXED32); + } + + @Override + public void writeUInt64(int fieldNumber, long value) { + requireSpace(MAX_VARINT32_SIZE + MAX_VARINT64_SIZE); + writeVarint64(value); + writeTag(fieldNumber, WIRETYPE_VARINT); + } + + @Override + public void writeSInt64(int fieldNumber, long value) { + requireSpace(MAX_VARINT32_SIZE + MAX_VARINT64_SIZE); + writeSInt64(value); + writeTag(fieldNumber, WIRETYPE_VARINT); + } + + @Override + public void writeFixed64(int fieldNumber, long value) { + requireSpace(MAX_VARINT32_SIZE + FIXED64_SIZE); + writeFixed64(value); + writeTag(fieldNumber, WIRETYPE_FIXED64); + } + + @Override + public void writeBool(int fieldNumber, boolean value) { + requireSpace(MAX_VARINT32_SIZE + 1); + write((byte) (value ? 1 : 0)); + writeTag(fieldNumber, WIRETYPE_VARINT); + } + + @Override + public void writeString(int fieldNumber, String value) { + int prevBytes = getTotalBytesWritten(); + writeString(value); + int length = getTotalBytesWritten() - prevBytes; + requireSpace(2 * MAX_VARINT32_SIZE); + writeVarint32(length); + writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED); + } + + @Override + public void writeBytes(int fieldNumber, ByteString value) { + try { + value.writeToReverse(this); + } catch (IOException e) { + // Should never happen since the writer does not throw. + throw new RuntimeException(e); + } + + requireSpace(MAX_VARINT32_SIZE * 2); + writeVarint32(value.size()); + writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED); + } + + @Override + public void writeMessage(int fieldNumber, Object value) { + int prevBytes = getTotalBytesWritten(); + Protobuf.getInstance().writeTo(value, this); + int length = getTotalBytesWritten() - prevBytes; + requireSpace(MAX_VARINT32_SIZE * 2); + writeVarint32(length); + writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED); + } + + @Override + public void writeGroup(int fieldNumber, Object value) { + writeTag(fieldNumber, WIRETYPE_END_GROUP); + Protobuf.getInstance().writeTo(value, this); + writeTag(fieldNumber, WIRETYPE_START_GROUP); + } + + @Override + void writeInt32(int value) { + if (value >= 0) { + writeVarint32(value); + } else { + writeVarint64(value); + } + } + + @Override + void writeSInt32(int value) { + writeVarint32(encodeZigZag32(value)); + } + + @Override + void writeSInt64(long value) { + writeVarint64(encodeZigZag64(value)); + } + + @Override + void writeBool(boolean value) { + write((byte) (value ? 1 : 0)); + } + + @Override + void writeTag(int fieldNumber, byte wireType) { + writeVarint32(tagFor(fieldNumber, wireType)); + } + + @Override + void writeVarint32(int value) { + if ((value & (~0 << 7)) == 0) { + writeVarint32OneByte(value); + } else if ((value & (~0 << 14)) == 0) { + writeVarint32TwoBytes(value); + } else if ((value & (~0 << 21)) == 0) { + writeVarint32ThreeBytes(value); + } else if ((value & (~0 << 28)) == 0) { + writeVarint32FourBytes(value); + } else { + writeVarint32FiveBytes(value); + } + } + + private void writeVarint32OneByte(int value) { + UnsafeUtil.putByte(buffer, pos--, (byte) value); + } + + private void writeVarint32TwoBytes(int value) { + UnsafeUtil.putByte(buffer, pos--, (byte) (value >>> 7)); + UnsafeUtil.putByte(buffer, pos--, (byte) ((value & 0x7F) | 0x80)); + } + + private void writeVarint32ThreeBytes(int value) { + UnsafeUtil.putByte(buffer, pos--, (byte) (value >>> 14)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 7) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) ((value & 0x7F) | 0x80)); + } + + private void writeVarint32FourBytes(int value) { + UnsafeUtil.putByte(buffer, pos--, (byte) (value >>> 21)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 14) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 7) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) ((value & 0x7F) | 0x80)); + } + + private void writeVarint32FiveBytes(int value) { + UnsafeUtil.putByte(buffer, pos--, (byte) (value >>> 28)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 21) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 14) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 7) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) ((value & 0x7F) | 0x80)); + } + + @Override + void writeVarint64(long value) { + switch (computeUInt64SizeNoTag(value)) { + case 1: + writeVarint64OneByte(value); + break; + case 2: + writeVarint64TwoBytes(value); + break; + case 3: + writeVarint64ThreeBytes(value); + break; + case 4: + writeVarint64FourBytes(value); + break; + case 5: + writeVarint64FiveBytes(value); + break; + case 6: + writeVarint64SixBytes(value); + break; + case 7: + writeVarint64SevenBytes(value); + break; + case 8: + writeVarint64EightBytes(value); + break; + case 9: + writeVarint64NineBytes(value); + break; + case 10: + writeVarint64TenBytes(value); + break; + } + } + + private void writeVarint64OneByte(long value) { + UnsafeUtil.putByte(buffer, pos--, (byte) value); + } + + private void writeVarint64TwoBytes(long value) { + UnsafeUtil.putByte(buffer, pos--, (byte) (value >>> 7)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((int) value & 0x7F) | 0x80)); + } + + private void writeVarint64ThreeBytes(long value) { + UnsafeUtil.putByte(buffer, pos--, (byte) (((int) value) >>> 14)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 7) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) ((value & 0x7F) | 0x80)); + } + + private void writeVarint64FourBytes(long value) { + UnsafeUtil.putByte(buffer, pos--, (byte) (value >>> 21)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 14) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 7) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) ((value & 0x7F) | 0x80)); + } + + private void writeVarint64FiveBytes(long value) { + UnsafeUtil.putByte(buffer, pos--, (byte) (value >>> 28)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 21) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 14) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 7) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) ((value & 0x7F) | 0x80)); + } + + private void writeVarint64SixBytes(long value) { + UnsafeUtil.putByte(buffer, pos--, (byte) (value >>> 35)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 28) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 21) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 14) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 7) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) ((value & 0x7F) | 0x80)); + } + + private void writeVarint64SevenBytes(long value) { + UnsafeUtil.putByte(buffer, pos--, (byte) (value >>> 42)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 35) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 28) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 21) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 14) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 7) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) ((value & 0x7F) | 0x80)); + } + + private void writeVarint64EightBytes(long value) { + UnsafeUtil.putByte(buffer, pos--, (byte) (value >>> 49)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 42) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 35) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 28) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 21) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 14) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 7) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) ((value & 0x7F) | 0x80)); + } + + private void writeVarint64NineBytes(long value) { + UnsafeUtil.putByte(buffer, pos--, (byte) (value >>> 56)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 49) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 42) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 35) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 28) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 21) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 14) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 7) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) ((value & 0x7F) | 0x80)); + } + + private void writeVarint64TenBytes(long value) { + UnsafeUtil.putByte(buffer, pos--, (byte) (value >>> 63)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 56) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 49) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 42) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 35) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 28) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 21) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 14) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) (((value >>> 7) & 0x7F) | 0x80)); + UnsafeUtil.putByte(buffer, pos--, (byte) ((value & 0x7F) | 0x80)); + } + + @Override + void writeFixed32(int value) { + UnsafeUtil.putByte(buffer, pos--, (byte) ((value >> 24) & 0xFF)); + UnsafeUtil.putByte(buffer, pos--, (byte) ((value >> 16) & 0xFF)); + UnsafeUtil.putByte(buffer, pos--, (byte) ((value >> 8) & 0xFF)); + UnsafeUtil.putByte(buffer, pos--, (byte) (value & 0xFF)); + } + + @Override + void writeFixed64(long value) { + UnsafeUtil.putByte(buffer, pos--, (byte) ((int) (value >> 56) & 0xFF)); + UnsafeUtil.putByte(buffer, pos--, (byte) ((int) (value >> 48) & 0xFF)); + UnsafeUtil.putByte(buffer, pos--, (byte) ((int) (value >> 40) & 0xFF)); + UnsafeUtil.putByte(buffer, pos--, (byte) ((int) (value >> 32) & 0xFF)); + UnsafeUtil.putByte(buffer, pos--, (byte) ((int) (value >> 24) & 0xFF)); + UnsafeUtil.putByte(buffer, pos--, (byte) ((int) (value >> 16) & 0xFF)); + UnsafeUtil.putByte(buffer, pos--, (byte) ((int) (value >> 8) & 0xFF)); + UnsafeUtil.putByte(buffer, pos--, (byte) ((int) (value) & 0xFF)); + } + + @Override + void writeString(String in) { + // Request enough space to write the ASCII string. + requireSpace(in.length()); + + // We know the buffer is big enough... + int i = in.length() - 1; + // Set pos to the start of the ASCII string. + //pos -= i; + // Designed to take advantage of + // https://wikis.oracle.com/display/HotSpotInternals/RangeCheckElimination + for (char c; i >= 0 && (c = in.charAt(i)) < 0x80; i--) { + UnsafeUtil.putByte(buffer, pos--, (byte) c); + } + if (i == -1) { + // Move pos past the String. + return; + } + for (char c; i >= 0; i--) { + c = in.charAt(i); + if (c < 0x80 && pos > offsetMinusOne) { + UnsafeUtil.putByte(buffer, pos--, (byte) c); + } else if (c < 0x800 && pos > offset) { // 11 bits, two UTF-8 bytes + UnsafeUtil.putByte(buffer, pos--, (byte) (0x80 | (0x3F & c))); + UnsafeUtil.putByte(buffer, pos--, (byte) ((0xF << 6) | (c >>> 6))); + } else if ((c < Character.MIN_SURROGATE || Character.MAX_SURROGATE < c) + && pos > offset + 1) { + // Maximum single-char code point is 0xFFFF, 16 bits, three UTF-8 bytes + UnsafeUtil.putByte(buffer, pos--, (byte) (0x80 | (0x3F & c))); + UnsafeUtil.putByte(buffer, pos--, (byte) (0x80 | (0x3F & (c >>> 6)))); + UnsafeUtil.putByte(buffer, pos--, (byte) ((0xF << 5) | (c >>> 12))); + } else if (pos > offset + 2) { + // Minimum code point represented by a surrogate pair is 0x10000, 17 bits, + // four UTF-8 bytes + final char high; + if (i == 0 || !Character.isSurrogatePair(high = in.charAt(i - 1), c)) { + throw new Utf8.UnpairedSurrogateException(i - 1, i); + } + i--; + int codePoint = Character.toCodePoint(high, c); + UnsafeUtil.putByte(buffer, pos--, (byte) (0x80 | (0x3F & codePoint))); + UnsafeUtil.putByte(buffer, pos--, (byte) (0x80 | (0x3F & (codePoint >>> 6)))); + UnsafeUtil.putByte(buffer, pos--, (byte) (0x80 | (0x3F & (codePoint >>> 12)))); + UnsafeUtil.putByte(buffer, pos--, (byte) ((0xF << 4) | (codePoint >>> 18))); + } else { + // Buffer is full - allocate a new one and revisit the current character. + requireSpace(i); + i++; + } + } + } + + @Override + public void write(byte value) { + UnsafeUtil.putByte(buffer, pos--, value); + } + + @Override + public void write(byte[] value, int offset, int length) { + if (offset < 0 || offset + length > value.length) { + throw new ArrayIndexOutOfBoundsException( + String.format("value.length=%d, offset=%d, length=%d", value.length, offset, length)); + } + requireSpace(length); + + pos -= length; + System.arraycopy(value, offset, buffer, arrayPos() + 1, length); + } + + @Override + public void writeLazy(byte[] value, int offset, int length) { + if (offset < 0 || offset + length > value.length) { + throw new ArrayIndexOutOfBoundsException( + String.format("value.length=%d, offset=%d, length=%d", value.length, offset, length)); + } + if (spaceLeft() < length) { + // We consider the value to be immutable (likely the internals of a ByteString). Just + // wrap it in a Netty buffer and add it to the output buffer. + totalDoneBytes += length; + buffers.addFirst(AllocatedBuffer.wrap(value, offset, length)); + + // Advance the writer to the next buffer. + // TODO(nathanmittler): Consider slicing if space available above some threshold. + nextBuffer(); + return; + } + + pos -= length; + System.arraycopy(value, offset, buffer, arrayPos() + 1, length); + } + + @Override + public void write(ByteBuffer value) { + int length = value.remaining(); + requireSpace(length); + + pos -= length; + value.get(buffer, arrayPos() + 1, length); + } + + @Override + public void writeLazy(ByteBuffer value) { + int length = value.remaining(); + if (spaceLeft() < length) { + // We consider the value to be immutable (likely the internals of a ByteString). Just + // wrap it in a Netty buffer and add it to the output buffer. + totalDoneBytes += length; + buffers.addFirst(AllocatedBuffer.wrap(value)); + + // Advance the writer to the next buffer. + // TODO(nathanmittler): Consider slicing if space available above some threshold. + nextBuffer(); + } + + pos -= length; + value.get(buffer, arrayPos() + 1, length); + } + + @Override + void requireSpace(int size) { + if (spaceLeft() < size) { + nextBuffer(size); + } + } + } + + /** Writer that uses safe operations on a target {@link ByteBuffer}. */ + private static final class SafeDirectWriter extends BinaryWriter { + private ByteBuffer buffer; + private int limitMinusOne; + private int pos; + + SafeDirectWriter(BufferAllocator alloc, int chunkSize) { + super(alloc, chunkSize); + nextBuffer(); + } + + private void nextBuffer() { + nextBuffer(newDirectBuffer()); + } + + private void nextBuffer(int capacity) { + nextBuffer(newDirectBuffer(capacity)); + } + + private void nextBuffer(AllocatedBuffer allocatedBuffer) { + if (!allocatedBuffer.hasNioBuffer()) { + throw new RuntimeException("Allocated buffer does not have NIO buffer"); + } + ByteBuffer nioBuffer = allocatedBuffer.nioBuffer(); + if (!nioBuffer.isDirect()) { + throw new RuntimeException("Allocator returned non-direct buffer"); + } + + finishCurrentBuffer(); + buffers.addFirst(allocatedBuffer); + + buffer = nioBuffer; + buffer.limit(buffer.capacity()); + buffer.position(0); + // Set byte order to little endian for fast writing of fixed 32/64. + buffer.order(ByteOrder.LITTLE_ENDIAN); + + limitMinusOne = buffer.limit() - 1; + pos = limitMinusOne; + } + + @Override + public int getTotalBytesWritten() { + return totalDoneBytes + bytesWrittenToCurrentBuffer(); + } + + private int bytesWrittenToCurrentBuffer() { + return limitMinusOne - pos; + } + + private int spaceLeft() { + return pos + 1; + } + + @Override + void finishCurrentBuffer() { + if (buffer != null) { + totalDoneBytes += bytesWrittenToCurrentBuffer(); + // Update the indices on the netty buffer. + buffer.position(pos + 1); + buffer = null; + pos = 0; + limitMinusOne = 0; + } + } + + @Override + public void writeUInt32(int fieldNumber, int value) { + requireSpace(MAX_VARINT32_SIZE * 2); + writeVarint32(value); + writeTag(fieldNumber, WIRETYPE_VARINT); + } + + @Override + public void writeInt32(int fieldNumber, int value) { + requireSpace(MAX_VARINT32_SIZE + MAX_VARINT64_SIZE); + writeInt32(value); + writeTag(fieldNumber, WIRETYPE_VARINT); + } + + @Override + public void writeSInt32(int fieldNumber, int value) { + requireSpace(MAX_VARINT32_SIZE * 2); + writeSInt32(value); + writeTag(fieldNumber, WIRETYPE_VARINT); + } + + @Override + public void writeFixed32(int fieldNumber, int value) { + requireSpace(MAX_VARINT32_SIZE + FIXED32_SIZE); + writeFixed32(value); + writeTag(fieldNumber, WIRETYPE_FIXED32); + } + + @Override + public void writeUInt64(int fieldNumber, long value) { + requireSpace(MAX_VARINT32_SIZE + MAX_VARINT64_SIZE); + writeVarint64(value); + writeTag(fieldNumber, WIRETYPE_VARINT); + } + + @Override + public void writeSInt64(int fieldNumber, long value) { + requireSpace(MAX_VARINT32_SIZE + MAX_VARINT64_SIZE); + writeSInt64(value); + writeTag(fieldNumber, WIRETYPE_VARINT); + } + + @Override + public void writeFixed64(int fieldNumber, long value) { + requireSpace(MAX_VARINT32_SIZE + FIXED64_SIZE); + writeFixed64(value); + writeTag(fieldNumber, WIRETYPE_FIXED64); + } + + @Override + public void writeBool(int fieldNumber, boolean value) { + requireSpace(MAX_VARINT32_SIZE + 1); + write((byte) (value ? 1 : 0)); + writeTag(fieldNumber, WIRETYPE_VARINT); + } + + @Override + public void writeString(int fieldNumber, String value) { + int prevBytes = getTotalBytesWritten(); + writeString(value); + int length = getTotalBytesWritten() - prevBytes; + requireSpace(2 * MAX_VARINT32_SIZE); + writeVarint32(length); + writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED); + } + + @Override + public void writeBytes(int fieldNumber, ByteString value) { + try { + value.writeToReverse(this); + } catch (IOException e) { + // Should never happen since the writer does not throw. + throw new RuntimeException(e); + } + + requireSpace(MAX_VARINT32_SIZE * 2); + writeVarint32(value.size()); + writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED); + } + + @Override + public void writeMessage(int fieldNumber, Object value) { + int prevBytes = getTotalBytesWritten(); + Protobuf.getInstance().writeTo(value, this); + int length = getTotalBytesWritten() - prevBytes; + requireSpace(MAX_VARINT32_SIZE * 2); + writeVarint32(length); + writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED); + } + + @Override + public void writeGroup(int fieldNumber, Object value) { + writeTag(fieldNumber, WIRETYPE_END_GROUP); + Protobuf.getInstance().writeTo(value, this); + writeTag(fieldNumber, WIRETYPE_START_GROUP); + } + + @Override + void writeInt32(int value) { + if (value >= 0) { + writeVarint32(value); + } else { + writeVarint64(value); + } + } + + @Override + void writeSInt32(int value) { + writeVarint32(encodeZigZag32(value)); + } + + @Override + void writeSInt64(long value) { + writeVarint64(encodeZigZag64(value)); + } + + @Override + void writeBool(boolean value) { + write((byte) (value ? 1 : 0)); + } + + @Override + void writeTag(int fieldNumber, byte wireType) { + writeVarint32(tagFor(fieldNumber, wireType)); + } + + @Override + void writeVarint32(int value) { + if ((value & (~0 << 7)) == 0) { + writeVarint32OneByte(value); + } else if ((value & (~0 << 14)) == 0) { + writeVarint32TwoBytes(value); + } else if ((value & (~0 << 21)) == 0) { + writeVarint32ThreeBytes(value); + } else if ((value & (~0 << 28)) == 0) { + writeVarint32FourBytes(value); + } else { + writeVarint32FiveBytes(value); + } + } + + private void writeVarint32OneByte(int value) { + buffer.put(pos--, (byte) value); + } + + private void writeVarint32TwoBytes(int value) { + // Byte order is little-endian. + pos -= 2; + buffer.putShort(pos + 1, (short) (((value & (0x7F << 7)) << 1) | ((value & 0x7F) | 0x80))); + } + + private void writeVarint32ThreeBytes(int value) { + // Byte order is little-endian. + pos -= 3; + buffer.putInt( + pos, + ((value & (0x7F << 14)) << 10) + | (((value & (0x7F << 7)) | (0x80 << 7)) << 9) + | ((value & 0x7F) | 0x80) << 8); + } + + private void writeVarint32FourBytes(int value) { + // Byte order is little-endian. + pos -= 4; + buffer.putInt( + pos + 1, + ((value & (0x7F << 21)) << 3) + | (((value & (0x7F << 14)) | (0x80 << 14)) << 2) + | (((value & (0x7F << 7)) | (0x80 << 7)) << 1) + | ((value & 0x7F) | 0x80)); + } + + private void writeVarint32FiveBytes(int value) { + // Byte order is little-endian. + buffer.put(pos--, (byte) (value >>> 28)); + pos -= 4; + buffer.putInt( + pos + 1, + ((((value >>> 21) & 0x7F) | 0x80) << 24) + | ((((value >>> 14) & 0x7F) | 0x80) << 16) + | ((((value >>> 7) & 0x7F) | 0x80) << 8) + | ((value & 0x7F) | 0x80)); + } + + @Override + void writeVarint64(long value) { + switch (computeUInt64SizeNoTag(value)) { + case 1: + writeVarint64OneByte(value); + break; + case 2: + writeVarint64TwoBytes(value); + break; + case 3: + writeVarint64ThreeBytes(value); + break; + case 4: + writeVarint64FourBytes(value); + break; + case 5: + writeVarint64FiveBytes(value); + break; + case 6: + writeVarint64SixBytes(value); + break; + case 7: + writeVarint64SevenBytes(value); + break; + case 8: + writeVarint64EightBytes(value); + break; + case 9: + writeVarint64NineBytes(value); + break; + case 10: + writeVarint64TenBytes(value); + break; + } + } + + private void writeVarint64OneByte(long value) { + writeVarint32OneByte((int) value); + } + + private void writeVarint64TwoBytes(long value) { + writeVarint32TwoBytes((int) value); + } + + private void writeVarint64ThreeBytes(long value) { + writeVarint32ThreeBytes((int) value); + } + + private void writeVarint64FourBytes(long value) { + writeVarint32FourBytes((int) value); + } + + private void writeVarint64FiveBytes(long value) { + // Byte order is little-endian. + pos -= 5; + buffer.putLong( + pos - 2, + ((value & (0x7FL << 28)) << 28) + | (((value & (0x7F << 21)) | (0x80 << 21)) << 27) + | (((value & (0x7F << 14)) | (0x80 << 14)) << 26) + | (((value & (0x7F << 7)) | (0x80 << 7)) << 25) + | (((value & 0x7F) | 0x80)) << 24); + } + + private void writeVarint64SixBytes(long value) { + // Byte order is little-endian. + pos -= 6; + buffer.putLong( + pos - 1, + ((value & (0x7FL << 35)) << 21) + | (((value & (0x7FL << 28)) | (0x80L << 28)) << 20) + | (((value & (0x7F << 21)) | (0x80 << 21)) << 19) + | (((value & (0x7F << 14)) | (0x80 << 14)) << 18) + | (((value & (0x7F << 7)) | (0x80 << 7)) << 17) + | (((value & 0x7F) | 0x80)) << 16); + } + + private void writeVarint64SevenBytes(long value) { + // Byte order is little-endian. + pos -= 7; + buffer.putLong( + pos, + ((value & (0x7FL << 42)) << 14) + | (((value & (0x7FL << 35)) | (0x80L << 35)) << 13) + | (((value & (0x7FL << 28)) | (0x80L << 28)) << 12) + | (((value & (0x7F << 21)) | (0x80 << 21)) << 11) + | (((value & (0x7F << 14)) | (0x80 << 14)) << 10) + | (((value & (0x7F << 7)) | (0x80 << 7)) << 9) + | (((value & 0x7F) | 0x80)) << 8); + } + + private void writeVarint64EightBytes(long value) { + // Byte order is little-endian. + pos -= 8; + buffer.putLong( + pos + 1, + ((value & (0x7FL << 49)) << 7) + | (((value & (0x7FL << 42)) | (0x80L << 42)) << 6) + | (((value & (0x7FL << 35)) | (0x80L << 35)) << 5) + | (((value & (0x7FL << 28)) | (0x80L << 28)) << 4) + | (((value & (0x7F << 21)) | (0x80 << 21)) << 3) + | (((value & (0x7F << 14)) | (0x80 << 14)) << 2) + | (((value & (0x7F << 7)) | (0x80 << 7)) << 1) + | ((value & 0x7F) | 0x80)); + } + + private void writeVarint64EightBytesWithSign(long value) { + // Byte order is little-endian. + pos -= 8; + buffer.putLong( + pos + 1, + (((value & (0x7FL << 49)) | (0x80L << 49)) << 7) + | (((value & (0x7FL << 42)) | (0x80L << 42)) << 6) + | (((value & (0x7FL << 35)) | (0x80L << 35)) << 5) + | (((value & (0x7FL << 28)) | (0x80L << 28)) << 4) + | (((value & (0x7F << 21)) | (0x80 << 21)) << 3) + | (((value & (0x7F << 14)) | (0x80 << 14)) << 2) + | (((value & (0x7F << 7)) | (0x80 << 7)) << 1) + | ((value & 0x7F) | 0x80)); + } + + private void writeVarint64NineBytes(long value) { + buffer.put(pos--, (byte) (value >>> 56)); + writeVarint64EightBytesWithSign(value & 0xFFFFFFFFFFFFFFL); + } + + private void writeVarint64TenBytes(long value) { + buffer.put(pos--, (byte) (value >>> 63)); + buffer.put(pos--, (byte) (((value >>> 56) & 0x7F) | 0x80)); + writeVarint64EightBytesWithSign(value & 0xFFFFFFFFFFFFFFL); + } + + @Override + void writeFixed32(int value) { + pos -= 4; + buffer.putInt(pos + 1, value); + } + + @Override + void writeFixed64(long value) { + pos -= 8; + buffer.putLong(pos + 1, value); + } + + @Override + void writeString(String in) { + // Request enough space to write the ASCII string. + requireSpace(in.length()); + + // We know the buffer is big enough... + int i = in.length() - 1; + pos -= i; + // Designed to take advantage of + // https://wikis.oracle.com/display/HotSpotInternals/RangeCheckElimination + for (char c; i >= 0 && (c = in.charAt(i)) < 0x80; i--) { + buffer.put(pos + i, (byte) c); + } + if (i == -1) { + // Move the position past the ASCII string. + pos -= 1; + return; + } + pos += i; + for (char c; i >= 0; i--) { + c = in.charAt(i); + if (c < 0x80 && pos >= 0) { + buffer.put(pos--, (byte) c); + } else if (c < 0x800 && pos > 0) { // 11 bits, two UTF-8 bytes + buffer.put(pos--, (byte) (0x80 | (0x3F & c))); + buffer.put(pos--, (byte) ((0xF << 6) | (c >>> 6))); + } else if ((c < Character.MIN_SURROGATE || Character.MAX_SURROGATE < c) && pos > 1) { + // Maximum single-char code point is 0xFFFF, 16 bits, three UTF-8 bytes + buffer.put(pos--, (byte) (0x80 | (0x3F & c))); + buffer.put(pos--, (byte) (0x80 | (0x3F & (c >>> 6)))); + buffer.put(pos--, (byte) ((0xF << 5) | (c >>> 12))); + } else if (pos > 2) { + // Minimum code point represented by a surrogate pair is 0x10000, 17 bits, + // four UTF-8 bytes + char high = 0; + if (i == 0 || !Character.isSurrogatePair(high = in.charAt(i - 1), c)) { + throw new Utf8.UnpairedSurrogateException(i - 1, i); + } + i--; + int codePoint = Character.toCodePoint(high, c); + buffer.put(pos--, (byte) (0x80 | (0x3F & codePoint))); + buffer.put(pos--, (byte) (0x80 | (0x3F & (codePoint >>> 6)))); + buffer.put(pos--, (byte) (0x80 | (0x3F & (codePoint >>> 12)))); + buffer.put(pos--, (byte) ((0xF << 4) | (codePoint >>> 18))); + } else { + // Buffer is full - allocate a new one and revisit the current character. + requireSpace(i); + i++; + } + } + } + + @Override + public void write(byte value) { + buffer.put(pos--, value); + } + + @Override + public void write(byte[] value, int offset, int length) { + if (spaceLeft() < length) { + nextBuffer(length); + } + + pos -= length; + buffer.position(pos + 1); + buffer.put(value, offset, length); + } + + @Override + public void writeLazy(byte[] value, int offset, int length) { + if (spaceLeft() < length) { + // We consider the value to be immutable (likely the internals of a ByteString). Just + // wrap it in a Netty buffer and add it to the output buffer. + totalDoneBytes += length; + buffers.addFirst(AllocatedBuffer.wrap(value, offset, length)); + + // Advance the writer to the next buffer. + // TODO(nathanmittler): Consider slicing if space available above some threshold. + nextBuffer(); + return; + } + + pos -= length; + buffer.position(pos + 1); + buffer.put(value, offset, length); + } + + @Override + public void write(ByteBuffer value) { + int length = value.remaining(); + if (spaceLeft() < length) { + nextBuffer(length); + } + + pos -= length; + buffer.position(pos + 1); + buffer.put(value); + } + + @Override + public void writeLazy(ByteBuffer value) { + int length = value.remaining(); + if (spaceLeft() < length) { + // We consider the value to be immutable (likely the internals of a ByteString). Just + // wrap it in a Netty buffer and add it to the output buffer. + totalDoneBytes += length; + buffers.addFirst(AllocatedBuffer.wrap(value)); + + // Advance the writer to the next buffer. + // TODO(nathanmittler): Consider slicing if space available above some threshold. + nextBuffer(); + return; + } + + pos -= length; + buffer.position(pos + 1); + buffer.put(value); + } + + @Override + void requireSpace(int size) { + if (spaceLeft() < size) { + nextBuffer(size); + } + } + } + + /** Writer that uses unsafe operations on a target {@link ByteBuffer}. */ + private static final class UnsafeDirectWriter extends BinaryWriter { + private ByteBuffer buffer; + private long bufferOffset; + private long limitMinusOne; + private long pos; + + UnsafeDirectWriter(BufferAllocator alloc, int chunkSize) { + super(alloc, chunkSize); + nextBuffer(); + } + + /** Indicates whether the required unsafe operations are supported on this platform. */ + private static boolean isSupported() { + return UnsafeUtil.hasUnsafeByteBufferOperations(); + } + + private void nextBuffer() { + nextBuffer(newDirectBuffer()); + } + + private void nextBuffer(int capacity) { + nextBuffer(newDirectBuffer(capacity)); + } + + private void nextBuffer(AllocatedBuffer allocatedBuffer) { + if (!allocatedBuffer.hasNioBuffer()) { + throw new RuntimeException("Allocated buffer does not have NIO buffer"); + } + ByteBuffer nioBuffer = allocatedBuffer.nioBuffer(); + if (!nioBuffer.isDirect()) { + throw new RuntimeException("Allocator returned non-direct buffer"); + } + + finishCurrentBuffer(); + buffers.addFirst(allocatedBuffer); + + buffer = nioBuffer; + buffer.limit(buffer.capacity()); + buffer.position(0); + + bufferOffset = UnsafeUtil.addressOffset(buffer); + limitMinusOne = bufferOffset + (buffer.limit() - 1); + pos = limitMinusOne; + } + + @Override + public int getTotalBytesWritten() { + return totalDoneBytes + bytesWrittenToCurrentBuffer(); + } + + private int bytesWrittenToCurrentBuffer() { + return (int) (limitMinusOne - pos); + } + + private int spaceLeft() { + return bufferPos() + 1; + } + + @Override + void finishCurrentBuffer() { + if (buffer != null) { + totalDoneBytes += bytesWrittenToCurrentBuffer(); + // Update the indices on the netty buffer. + buffer.position(bufferPos() + 1); + buffer = null; + pos = 0; + limitMinusOne = 0; + } + } + + private int bufferPos() { + return (int) (pos - bufferOffset); + } + + @Override + public void writeUInt32(int fieldNumber, int value) { + requireSpace(MAX_VARINT32_SIZE * 2); + writeVarint32(value); + writeTag(fieldNumber, WIRETYPE_VARINT); + } + + @Override + public void writeInt32(int fieldNumber, int value) { + requireSpace(MAX_VARINT32_SIZE + MAX_VARINT64_SIZE); + writeInt32(value); + writeTag(fieldNumber, WIRETYPE_VARINT); + } + + @Override + public void writeSInt32(int fieldNumber, int value) { + requireSpace(MAX_VARINT32_SIZE * 2); + writeSInt32(value); + writeTag(fieldNumber, WIRETYPE_VARINT); + } + + @Override + public void writeFixed32(int fieldNumber, int value) { + requireSpace(MAX_VARINT32_SIZE + FIXED32_SIZE); + writeFixed32(value); + writeTag(fieldNumber, WIRETYPE_FIXED32); + } + + @Override + public void writeUInt64(int fieldNumber, long value) { + requireSpace(MAX_VARINT32_SIZE + MAX_VARINT64_SIZE); + writeVarint64(value); + writeTag(fieldNumber, WIRETYPE_VARINT); + } + + @Override + public void writeSInt64(int fieldNumber, long value) { + requireSpace(MAX_VARINT32_SIZE + MAX_VARINT64_SIZE); + writeSInt64(value); + writeTag(fieldNumber, WIRETYPE_VARINT); + } + + @Override + public void writeFixed64(int fieldNumber, long value) { + requireSpace(MAX_VARINT32_SIZE + FIXED64_SIZE); + writeFixed64(value); + writeTag(fieldNumber, WIRETYPE_FIXED64); + } + + @Override + public void writeBool(int fieldNumber, boolean value) { + requireSpace(MAX_VARINT32_SIZE + 1); + write((byte) (value ? 1 : 0)); + writeTag(fieldNumber, WIRETYPE_VARINT); + } + + @Override + public void writeString(int fieldNumber, String value) { + int prevBytes = getTotalBytesWritten(); + writeString(value); + int length = getTotalBytesWritten() - prevBytes; + requireSpace(2 * MAX_VARINT32_SIZE); + writeVarint32(length); + writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED); + } + + @Override + public void writeBytes(int fieldNumber, ByteString value) { + try { + value.writeToReverse(this); + } catch (IOException e) { + // Should never happen since the writer does not throw. + throw new RuntimeException(e); + } + + requireSpace(MAX_VARINT32_SIZE * 2); + writeVarint32(value.size()); + writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED); + } + + @Override + public void writeMessage(int fieldNumber, Object value) { + int prevBytes = getTotalBytesWritten(); + Protobuf.getInstance().writeTo(value, this); + int length = getTotalBytesWritten() - prevBytes; + requireSpace(MAX_VARINT32_SIZE * 2); + writeVarint32(length); + writeTag(fieldNumber, WIRETYPE_LENGTH_DELIMITED); + } + + @Override + public void writeGroup(int fieldNumber, Object value) { + writeTag(fieldNumber, WIRETYPE_END_GROUP); + Protobuf.getInstance().writeTo(value, this); + writeTag(fieldNumber, WIRETYPE_START_GROUP); + } + + @Override + void writeInt32(int value) { + if (value >= 0) { + writeVarint32(value); + } else { + writeVarint64(value); + } + } + + @Override + void writeSInt32(int value) { + writeVarint32(encodeZigZag32(value)); + } + + @Override + void writeSInt64(long value) { + writeVarint64(encodeZigZag64(value)); + } + + @Override + void writeBool(boolean value) { + write((byte) (value ? 1 : 0)); + } + + @Override + void writeTag(int fieldNumber, byte wireType) { + writeVarint32(tagFor(fieldNumber, wireType)); + } + + @Override + void writeVarint32(int value) { + if ((value & (~0 << 7)) == 0) { + writeVarint32OneByte(value); + } else if ((value & (~0 << 14)) == 0) { + writeVarint32TwoBytes(value); + } else if ((value & (~0 << 21)) == 0) { + writeVarint32ThreeBytes(value); + } else if ((value & (~0 << 28)) == 0) { + writeVarint32FourBytes(value); + } else { + writeVarint32FiveBytes(value); + } + } + + private void writeVarint32OneByte(int value) { + UnsafeUtil.putByte(pos--, (byte) value); + } + + private void writeVarint32TwoBytes(int value) { + UnsafeUtil.putByte(pos--, (byte) (value >>> 7)); + UnsafeUtil.putByte(pos--, (byte) ((value & 0x7F) | 0x80)); + } + + private void writeVarint32ThreeBytes(int value) { + UnsafeUtil.putByte(pos--, (byte) (value >>> 14)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 7) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) ((value & 0x7F) | 0x80)); + } + + private void writeVarint32FourBytes(int value) { + UnsafeUtil.putByte(pos--, (byte) (value >>> 21)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 14) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 7) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) ((value & 0x7F) | 0x80)); + } + + private void writeVarint32FiveBytes(int value) { + UnsafeUtil.putByte(pos--, (byte) (value >>> 28)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 21) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 14) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 7) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) ((value & 0x7F) | 0x80)); + } + + @Override + void writeVarint64(long value) { + switch (computeUInt64SizeNoTag(value)) { + case 1: + writeVarint64OneByte(value); + break; + case 2: + writeVarint64TwoBytes(value); + break; + case 3: + writeVarint64ThreeBytes(value); + break; + case 4: + writeVarint64FourBytes(value); + break; + case 5: + writeVarint64FiveBytes(value); + break; + case 6: + writeVarint64SixBytes(value); + break; + case 7: + writeVarint64SevenBytes(value); + break; + case 8: + writeVarint64EightBytes(value); + break; + case 9: + writeVarint64NineBytes(value); + break; + case 10: + writeVarint64TenBytes(value); + break; + } + } + + private void writeVarint64OneByte(long value) { + UnsafeUtil.putByte(pos--, (byte) value); + } + + private void writeVarint64TwoBytes(long value) { + UnsafeUtil.putByte(pos--, (byte) (value >>> 7)); + UnsafeUtil.putByte(pos--, (byte) (((int) value & 0x7F) | 0x80)); + } + + private void writeVarint64ThreeBytes(long value) { + UnsafeUtil.putByte(pos--, (byte) (((int) value) >>> 14)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 7) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) ((value & 0x7F) | 0x80)); + } + + private void writeVarint64FourBytes(long value) { + UnsafeUtil.putByte(pos--, (byte) (value >>> 21)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 14) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 7) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) ((value & 0x7F) | 0x80)); + } + + private void writeVarint64FiveBytes(long value) { + UnsafeUtil.putByte(pos--, (byte) (value >>> 28)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 21) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 14) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 7) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) ((value & 0x7F) | 0x80)); + } + + private void writeVarint64SixBytes(long value) { + UnsafeUtil.putByte(pos--, (byte) (value >>> 35)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 28) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 21) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 14) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 7) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) ((value & 0x7F) | 0x80)); + } + + private void writeVarint64SevenBytes(long value) { + UnsafeUtil.putByte(pos--, (byte) (value >>> 42)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 35) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 28) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 21) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 14) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 7) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) ((value & 0x7F) | 0x80)); + } + + private void writeVarint64EightBytes(long value) { + UnsafeUtil.putByte(pos--, (byte) (value >>> 49)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 42) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 35) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 28) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 21) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 14) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 7) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) ((value & 0x7F) | 0x80)); + } + + private void writeVarint64NineBytes(long value) { + UnsafeUtil.putByte(pos--, (byte) (value >>> 56)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 49) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 42) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 35) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 28) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 21) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 14) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 7) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) ((value & 0x7F) | 0x80)); + } + + private void writeVarint64TenBytes(long value) { + UnsafeUtil.putByte(pos--, (byte) (value >>> 63)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 56) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 49) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 42) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 35) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 28) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 21) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 14) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) (((value >>> 7) & 0x7F) | 0x80)); + UnsafeUtil.putByte(pos--, (byte) ((value & 0x7F) | 0x80)); + } + + @Override + void writeFixed32(int value) { + UnsafeUtil.putByte(pos--, (byte) ((value >> 24) & 0xFF)); + UnsafeUtil.putByte(pos--, (byte) ((value >> 16) & 0xFF)); + UnsafeUtil.putByte(pos--, (byte) ((value >> 8) & 0xFF)); + UnsafeUtil.putByte(pos--, (byte) (value & 0xFF)); + } + + @Override + void writeFixed64(long value) { + UnsafeUtil.putByte(pos--, (byte) ((int) (value >> 56) & 0xFF)); + UnsafeUtil.putByte(pos--, (byte) ((int) (value >> 48) & 0xFF)); + UnsafeUtil.putByte(pos--, (byte) ((int) (value >> 40) & 0xFF)); + UnsafeUtil.putByte(pos--, (byte) ((int) (value >> 32) & 0xFF)); + UnsafeUtil.putByte(pos--, (byte) ((int) (value >> 24) & 0xFF)); + UnsafeUtil.putByte(pos--, (byte) ((int) (value >> 16) & 0xFF)); + UnsafeUtil.putByte(pos--, (byte) ((int) (value >> 8) & 0xFF)); + UnsafeUtil.putByte(pos--, (byte) ((int) (value) & 0xFF)); + } + + @Override + void writeString(String in) { + // Request enough space to write the ASCII string. + requireSpace(in.length()); + + // We know the buffer is big enough... + int i = in.length() - 1; + // Designed to take advantage of + // https://wikis.oracle.com/display/HotSpotInternals/RangeCheckElimination + for (char c; i >= 0 && (c = in.charAt(i)) < 0x80; i--) { + UnsafeUtil.putByte(pos--, (byte) c); + } + if (i == -1) { + // ASCII. + return; + } + for (char c; i >= 0; i--) { + c = in.charAt(i); + if (c < 0x80 && pos >= bufferOffset) { + UnsafeUtil.putByte(pos--, (byte) c); + } else if (c < 0x800 && pos > bufferOffset) { // 11 bits, two UTF-8 bytes + UnsafeUtil.putByte(pos--, (byte) (0x80 | (0x3F & c))); + UnsafeUtil.putByte(pos--, (byte) ((0xF << 6) | (c >>> 6))); + } else if ((c < Character.MIN_SURROGATE || Character.MAX_SURROGATE < c) + && pos > bufferOffset + 1) { + // Maximum single-char code point is 0xFFFF, 16 bits, three UTF-8 bytes + UnsafeUtil.putByte(pos--, (byte) (0x80 | (0x3F & c))); + UnsafeUtil.putByte(pos--, (byte) (0x80 | (0x3F & (c >>> 6)))); + UnsafeUtil.putByte(pos--, (byte) ((0xF << 5) | (c >>> 12))); + } else if (pos > bufferOffset + 2) { + // Minimum code point represented by a surrogate pair is 0x10000, 17 bits, + // four UTF-8 bytes + final char high; + if (i == 0 || !Character.isSurrogatePair(high = in.charAt(i - 1), c)) { + throw new Utf8.UnpairedSurrogateException(i - 1, i); + } + i--; + int codePoint = Character.toCodePoint(high, c); + UnsafeUtil.putByte(pos--, (byte) (0x80 | (0x3F & codePoint))); + UnsafeUtil.putByte(pos--, (byte) (0x80 | (0x3F & (codePoint >>> 6)))); + UnsafeUtil.putByte(pos--, (byte) (0x80 | (0x3F & (codePoint >>> 12)))); + UnsafeUtil.putByte(pos--, (byte) ((0xF << 4) | (codePoint >>> 18))); + } else { + // Buffer is full - allocate a new one and revisit the current character. + requireSpace(i); + i++; + } + } + } + + @Override + public void write(byte value) { + UnsafeUtil.putByte(pos--, value); + } + + @Override + public void write(byte[] value, int offset, int length) { + if (spaceLeft() < length) { + nextBuffer(length); + } + + pos -= length; + buffer.position(bufferPos() + 1); + buffer.put(value, offset, length); + } + + @Override + public void writeLazy(byte[] value, int offset, int length) { + if (spaceLeft() < length) { + // We consider the value to be immutable (likely the internals of a ByteString). Just + // wrap it in a Netty buffer and add it to the output buffer. + totalDoneBytes += length; + buffers.addFirst(AllocatedBuffer.wrap(value, offset, length)); + + // Advance the writer to the next buffer. + // TODO(nathanmittler): Consider slicing if space available above some threshold. + nextBuffer(); + return; + } + + pos -= length; + buffer.position(bufferPos() + 1); + buffer.put(value, offset, length); + } + + @Override + public void write(ByteBuffer value) { + int length = value.remaining(); + if (spaceLeft() < length) { + nextBuffer(length); + } + + pos -= length; + long sourceOffset = UnsafeUtil.addressOffset(value); + long sourcePos = sourceOffset + value.position(); + UnsafeUtil.copyMemory(sourcePos, pos + 1, length); + } + + @Override + public void writeLazy(ByteBuffer value) { + int length = value.remaining(); + if (spaceLeft() < length) { + // We consider the value to be immutable (likely the internals of a ByteString). Just + // wrap it in a Netty buffer and add it to the output buffer. + totalDoneBytes += length; + buffers.addFirst(AllocatedBuffer.wrap(value)); + + // Advance the writer to the next buffer. + // TODO(nathanmittler): Consider slicing if space available above some threshold. + nextBuffer(); + return; + } + + pos -= length; + long sourceOffset = UnsafeUtil.addressOffset(value); + long sourcePos = sourceOffset + value.position(); + UnsafeUtil.copyMemory(sourcePos, pos + 1, length); + } + + @Override + void requireSpace(int size) { + if (spaceLeft() < size) { + nextBuffer(size); + } + } + } +} diff --git a/java/core/src/main/java/com/google/protobuf/BufferAllocator.java b/java/core/src/main/java/com/google/protobuf/BufferAllocator.java new file mode 100644 index 00000000..f8d865d9 --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/BufferAllocator.java @@ -0,0 +1,71 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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.nio.ByteBuffer; + +/** + * An object responsible for allocation of buffers. This is an extension point to enable buffer + * pooling within an application. + */ +@ExperimentalApi +public abstract class BufferAllocator { + private static final BufferAllocator UNPOOLED = + new BufferAllocator() { + @Override + public AllocatedBuffer allocateHeapBuffer(int capacity) { + return AllocatedBuffer.wrap(new byte[capacity]); + } + + @Override + public AllocatedBuffer allocateDirectBuffer(int capacity) { + return AllocatedBuffer.wrap(ByteBuffer.allocateDirect(capacity)); + } + }; + + /** + * Returns an unpooled buffer allocator, which will create a new buffer for each request. + */ + public static BufferAllocator unpooled() { + return UNPOOLED; + } + + /** + * Allocates a buffer with the given capacity that is backed by an array on the heap. + */ + public abstract AllocatedBuffer allocateHeapBuffer(int capacity); + + /** + * Allocates a direct (i.e. non-heap) buffer with the given capacity. + */ + public abstract AllocatedBuffer allocateDirectBuffer(int capacity); +} + diff --git a/java/core/src/main/java/com/google/protobuf/ByteString.java b/java/core/src/main/java/com/google/protobuf/ByteString.java index 5b24976d..9d640385 100644 --- a/java/core/src/main/java/com/google/protobuf/ByteString.java +++ b/java/core/src/main/java/com/google/protobuf/ByteString.java @@ -28,6 +28,7 @@ // (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.ByteArrayInputStream; @@ -52,9 +53,9 @@ import java.util.NoSuchElementException; /** * Immutable sequence of bytes. Substring is supported by sharing the reference - * to the immutable underlying bytes. Concatenation is likewise supported - * without copying (long strings) by building a tree of pieces in - * {@link RopeByteString}. + * to the immutable underlying bytes, as with {@link String}. Concatenation is + * likewise supported without copying (long strings) by building a tree of + * pieces in {@link RopeByteString}. *

* Like {@link String}, the contents of a {@link ByteString} can never be * observed to change, not even in the presence of a data race or incorrect @@ -691,6 +692,16 @@ public abstract class ByteString implements Iterable, Serializable { */ abstract void writeTo(ByteOutput byteOutput) throws IOException; + /** + * This method behaves exactly the same as {@link #writeTo(ByteOutput)} unless the {@link + * ByteString} is a rope. For ropes, the leaf nodes are written in reverse order to the {@code + * byteOutput}. + * + * @param byteOutput the output target to receive the bytes + * @throws IOException if an I/O error occurs + * @see UnsafeByteOperations#unsafeWriteToReverse(ByteString, ByteOutput) + */ + abstract void writeToReverse(ByteOutput byteOutput) throws IOException; /** * Constructs a read-only {@code java.nio.ByteBuffer} whose content @@ -833,6 +844,10 @@ public abstract class ByteString implements Iterable, Serializable { return true; } + @Override + void writeToReverse(ByteOutput byteOutput) throws IOException { + writeTo(byteOutput); + } /** * Check equality of the substring of given length of this object starting at diff --git a/java/core/src/main/java/com/google/protobuf/DescriptorMessageInfoFactory.java b/java/core/src/main/java/com/google/protobuf/DescriptorMessageInfoFactory.java new file mode 100644 index 00000000..92f0470c --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/DescriptorMessageInfoFactory.java @@ -0,0 +1,264 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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 static com.google.protobuf.FieldInfo.forField; +import static com.google.protobuf.FieldInfo.forPresenceCheckedField; + +import com.google.protobuf.Descriptors.Descriptor; +import com.google.protobuf.Descriptors.FieldDescriptor; +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.util.List; + +/** A factory for message info based on protobuf descriptors for a {@link GeneratedMessage}. */ +@ExperimentalApi +public final class DescriptorMessageInfoFactory implements MessageInfoFactory { + private static final String GET_DEFAULT_INSTANCE_METHOD_NAME = "getDefaultInstance"; + private static final DescriptorMessageInfoFactory instance = new DescriptorMessageInfoFactory(); + + // Disallow construction - it's a singleton. + private DescriptorMessageInfoFactory() { + } + + public static DescriptorMessageInfoFactory getInstance() { + return instance; + } + + @Override + public MessageInfo messageInfoFor(Class messageType) { + if (!GeneratedMessage.class.isAssignableFrom(messageType)) { + throw new IllegalArgumentException("Only generated protobuf messages are supported"); + } + + return convert(messageType, descriptorForType(messageType)); + } + + private static Descriptor descriptorForType(Class messageType) { + try { + Method method = messageType.getDeclaredMethod(GET_DEFAULT_INSTANCE_METHOD_NAME); + GeneratedMessage message = (GeneratedMessage) method.invoke(null); + return message.getDescriptorForType(); + } catch (Exception e) { + throw new IllegalArgumentException( + "Unable to get default instance for message class " + messageType.getName(), e); + } + } + + private static MessageInfo convert(Class messageType, Descriptor desc) { + switch (desc.getFile().getSyntax()) { + case PROTO2: + return convertProto2(messageType, desc); + case PROTO3: + return convertProto3(messageType, desc); + default: + throw new IllegalArgumentException("Unsupported syntax: " + desc.getFile().getSyntax()); + } + } + + private static MessageInfo convertProto2(Class messageType, Descriptor desc) { + List fieldDescriptors = desc.getFields(); + MessageInfo.Builder builder = MessageInfo.newBuilder(fieldDescriptors.size()); + builder.withSyntax(ProtoSyntax.PROTO2); + + int bitFieldIndex = 0; + int presenceMask = 1; + Field bitField = bitField(messageType, bitFieldIndex++); + + // Fields in the descriptor are ordered by the index position in which they appear in the + // proto file. This is the same order used to determine the presence mask used in the + // bitFields. So to determine the appropriate presence mask to be used for a field, we simply + // need to shift the presence mask whenever a presence-checked field is encountered. + for (int i = 0; i < fieldDescriptors.size(); ++i) { + FieldDescriptor fd = fieldDescriptors.get(i); + Field field = field(messageType, fd); + int number = fd.getNumber(); + FieldType type = getFieldType(fd); + + if (fd.isRepeated()) { + // Repeated fields are not presence-checked. + builder.add(forField(field, number, type)); + continue; + } + + // It's a presence-checked field. + builder.add(forPresenceCheckedField(field, number, type, bitField, presenceMask)); + + // Update the presence mask/bitfield + presenceMask <<= 1; + if (presenceMask == 0) { + // We've assigned all of the bits in the current bitField. Advance to the next one. + bitField = bitField(messageType, bitFieldIndex++); + } + } + + return builder.build(); + } + + private static MessageInfo convertProto3(Class messageType, Descriptor desc) { + List fieldDescriptors = desc.getFields(); + MessageInfo.Builder builder = MessageInfo.newBuilder(fieldDescriptors.size()); + builder.withSyntax(ProtoSyntax.PROTO3); + for (int i = 0; i < fieldDescriptors.size(); ++i) { + FieldDescriptor fd = fieldDescriptors.get(i); + builder.add(forField(field(messageType, fd), fd.getNumber(), getFieldType(fd))); + } + + return builder.build(); + } + + private static FieldType getFieldType(FieldDescriptor fd) { + switch (fd.getType()) { + case BOOL: + if (!fd.isRepeated()) { + return FieldType.BOOL; + } + return fd.isPacked() ? FieldType.BOOL_LIST_PACKED : FieldType.BOOL_LIST; + case BYTES: + return fd.isRepeated() ? FieldType.BYTES_LIST : FieldType.BYTES; + case DOUBLE: + if (!fd.isRepeated()) { + return FieldType.DOUBLE; + } + return fd.isPacked() ? FieldType.DOUBLE_LIST_PACKED : FieldType.DOUBLE_LIST; + case ENUM: + if (!fd.isRepeated()) { + return FieldType.ENUM; + } + return fd.isPacked() ? FieldType.ENUM_LIST_PACKED : FieldType.ENUM_LIST; + case FIXED32: + if (!fd.isRepeated()) { + return FieldType.FIXED32; + } + return fd.isPacked() ? FieldType.FIXED32_LIST_PACKED : FieldType.FIXED32_LIST; + case FIXED64: + if (!fd.isRepeated()) { + return FieldType.FIXED64; + } + return fd.isPacked() ? FieldType.FIXED64_LIST_PACKED : FieldType.FIXED64_LIST; + case FLOAT: + if (!fd.isRepeated()) { + return FieldType.FLOAT; + } + return fd.isPacked() ? FieldType.FLOAT_LIST_PACKED : FieldType.FLOAT_LIST; + case GROUP: + return fd.isRepeated() ? FieldType.GROUP_LIST : FieldType.GROUP; + case INT32: + if (!fd.isRepeated()) { + return FieldType.INT32; + } + return fd.isPacked() ? FieldType.INT32_LIST_PACKED : FieldType.INT32_LIST; + case INT64: + if (!fd.isRepeated()) { + return FieldType.INT64; + } + return fd.isPacked() ? FieldType.INT64_LIST_PACKED : FieldType.INT64_LIST; + case MESSAGE: + // TODO(nathanmittler): Add support for maps. + return fd.isRepeated() ? FieldType.MESSAGE_LIST : FieldType.MESSAGE; + case SFIXED32: + if (!fd.isRepeated()) { + return FieldType.SFIXED32; + } + return fd.isPacked() ? FieldType.SFIXED32_LIST_PACKED : FieldType.SFIXED32_LIST; + case SFIXED64: + if (!fd.isRepeated()) { + return FieldType.SFIXED64; + } + return fd.isPacked() ? FieldType.SFIXED64_LIST_PACKED : FieldType.SFIXED64_LIST; + case SINT32: + if (!fd.isRepeated()) { + return FieldType.SINT32; + } + return fd.isPacked() ? FieldType.SINT32_LIST_PACKED : FieldType.SINT32_LIST; + case SINT64: + if (!fd.isRepeated()) { + return FieldType.SINT64; + } + return fd.isPacked() ? FieldType.SINT64_LIST_PACKED : FieldType.SINT64_LIST; + case STRING: + return fd.isRepeated() ? FieldType.STRING_LIST : FieldType.STRING; + case UINT32: + if (!fd.isRepeated()) { + return FieldType.UINT32; + } + return fd.isPacked() ? FieldType.UINT32_LIST_PACKED : FieldType.UINT32_LIST; + case UINT64: + if (!fd.isRepeated()) { + return FieldType.UINT64; + } + return fd.isPacked() ? FieldType.UINT64_LIST_PACKED : FieldType.UINT64_LIST; + default: + throw new IllegalArgumentException("Unsupported field type: " + fd.getType()); + } + } + + private static Field bitField(Class messageType, int index) { + return field(messageType, "bitField" + index + "_"); + } + + private static Field field(Class messageType, FieldDescriptor fd) { + return field(messageType, getFieldName(fd)); + } + + private static Field field(Class messageType, String fieldName) { + try { + return messageType.getDeclaredField(fieldName); + } catch (Exception e) { + throw new IllegalArgumentException( + "Unable to find field " + fieldName + " in message class " + messageType.getName()); + } + } + + // This method must match exactly with the corresponding function in protocol compiler. + // See: https://github.com/google/protobuf/blob/v3.0.0/src/google/protobuf/compiler/java/java_helpers.cc#L153 + private static String getFieldName(FieldDescriptor fd) { + String snakeCase = + fd.getType() == FieldDescriptor.Type.GROUP ? fd.getMessageType().getName() : fd.getName(); + StringBuilder sb = new StringBuilder(snakeCase.length() + 1); + boolean capNext = false; + for (int ctr = 0; ctr < snakeCase.length(); ctr++) { + char next = snakeCase.charAt(ctr); + if (next == '_') { + capNext = true; + } else if (capNext) { + sb.append(Character.toUpperCase(next)); + capNext = false; + } else if (ctr == 0) { + sb.append(Character.toLowerCase(next)); + } else { + sb.append(next); + } + } + sb.append('_'); + return sb.toString(); + } +} diff --git a/java/core/src/main/java/com/google/protobuf/FieldInfo.java b/java/core/src/main/java/com/google/protobuf/FieldInfo.java new file mode 100644 index 00000000..37d7b102 --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/FieldInfo.java @@ -0,0 +1,175 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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 static com.google.protobuf.Internal.checkNotNull; + +import java.lang.reflect.Field; +import java.lang.reflect.ParameterizedType; +import java.lang.reflect.Type; + +/** Information for a single field in a protobuf message class. */ +@ExperimentalApi +public final class FieldInfo implements Comparable { + private final Field field; + private final FieldType type; + private final int fieldNumber; + private final Field presenceField; + private final int presenceMask; + + /** Constructs a new descriptor for a field. */ + public static FieldInfo forField(Field field, int fieldNumber, FieldType fieldType) { + return new FieldInfo(field, fieldNumber, fieldType, null, 0); + } + + /** Constructor for a field that uses a presence bit field (i.e. proto2 only). */ + public static FieldInfo forPresenceCheckedField( + Field field, int fieldNumber, FieldType fieldType, Field presenceField, int presenceMask) { + checkNotNull(presenceField, "presenceField"); + return new FieldInfo(field, fieldNumber, fieldType, presenceField, presenceMask); + } + + private FieldInfo( + Field field, int fieldNumber, FieldType type, Field presenceField, int presenceMask) { + if (fieldNumber <= 0) { + throw new IllegalArgumentException("fieldNumber must be positive: " + fieldNumber); + } + if (presenceField != null && !isExactlyOneBitSet(presenceMask)) { + throw new IllegalArgumentException( + "presenceMask must have exactly one bit set: " + presenceMask); + } + this.field = checkNotNull(field, "field"); + this.type = checkNotNull(type, "type"); + this.fieldNumber = fieldNumber; + this.presenceField = presenceField; + this.presenceMask = presenceMask; + } + + /** Gets the subject {@link Field} of this descriptor. */ + public Field getField() { + return field; + } + + /** Gets the type information for the field. */ + public FieldType getType() { + return type; + } + + /** Gets the field number for the field. */ + public int getFieldNumber() { + return fieldNumber; + } + + @Override + public int compareTo(FieldInfo o) { + return fieldNumber - o.fieldNumber; + } + + /** + * For list fields, returns the generic argument that represents the type stored in the list. For + * non-list fields, returns {@code null}. + */ + public Class getListElementType() { + if (!type.isList()) { + return null; + } + + Type genericType = field.getGenericType(); + if (!(genericType instanceof ParameterizedType)) { + throw new IllegalStateException( + "Cannot determine parameterized type for list field " + fieldNumber); + } + + Type type = ((ParameterizedType) field.getGenericType()).getActualTypeArguments()[0]; + return (Class) type; + } + + /** Gets the presence bit field. Only valid for unary fields. For lists, returns {@code null}. */ + public Field getPresenceField() { + return presenceField; + } + + /** + * If {@link #getPresenceField()} is non-{@code null}, returns the mask used to identify the + * presence bit for this field in the message. + */ + public int getPresenceMask() { + return presenceMask; + } + + public static Builder newBuilder() { + return new Builder(); + } + + /** A builder for {@link FieldInfo} instances. */ + public static final class Builder { + private Field field; + private FieldType type; + private int fieldNumber; + private Field presenceField; + private int presenceMask; + + private Builder() {} + + public Builder withField(Field field) { + this.field = field; + return this; + } + + public Builder withType(FieldType type) { + this.type = type; + return this; + } + + public Builder withFieldNumber(int fieldNumber) { + this.fieldNumber = fieldNumber; + return this; + } + + public Builder withPresenceField(Field presenceField) { + this.presenceField = checkNotNull(presenceField, "presenceField"); + return this; + } + + public Builder withPresenceMask(int presenceMask) { + this.presenceMask = presenceMask; + return this; + } + + public FieldInfo build() { + return new FieldInfo(field, fieldNumber, type, presenceField, presenceMask); + } + } + + private static boolean isExactlyOneBitSet(int value) { + return value != 0 && (value & (value - 1)) == 0; + } +} diff --git a/java/core/src/main/java/com/google/protobuf/FieldType.java b/java/core/src/main/java/com/google/protobuf/FieldType.java new file mode 100644 index 00000000..1e368c11 --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/FieldType.java @@ -0,0 +1,535 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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.lang.reflect.Field; +import java.lang.reflect.ParameterizedType; +import java.lang.reflect.Type; +import java.lang.reflect.TypeVariable; +import java.util.List; + +/** + * Enumeration identifying all relevant type information for a protobuf field. + */ +@ExperimentalApi +public enum FieldType { + DOUBLE(0, Collection.SCALAR, JavaType.DOUBLE, JavaType.VOID), + FLOAT(1, Collection.SCALAR, JavaType.FLOAT, JavaType.VOID), + INT64(2, Collection.SCALAR, JavaType.LONG, JavaType.VOID), + UINT64(3, Collection.SCALAR, JavaType.LONG, JavaType.VOID), + INT32(4, Collection.SCALAR, JavaType.INT, JavaType.VOID), + FIXED64(5, Collection.SCALAR, JavaType.LONG, JavaType.VOID), + FIXED32(6, Collection.SCALAR, JavaType.INT, JavaType.VOID), + BOOL(7, Collection.SCALAR, JavaType.BOOLEAN, JavaType.VOID), + STRING(8, Collection.SCALAR, JavaType.STRING, JavaType.VOID), + MESSAGE(9, Collection.SCALAR, JavaType.MESSAGE, JavaType.VOID), + BYTES(10, Collection.SCALAR, JavaType.BYTE_STRING, JavaType.VOID), + UINT32(11, Collection.SCALAR, JavaType.INT, JavaType.VOID), + ENUM(12, Collection.SCALAR, JavaType.ENUM, JavaType.VOID), + SFIXED32(13, Collection.SCALAR, JavaType.INT, JavaType.VOID), + SFIXED64(14, Collection.SCALAR, JavaType.LONG, JavaType.VOID), + SINT32(15, Collection.SCALAR, JavaType.INT, JavaType.VOID), + SINT64(16, Collection.SCALAR, JavaType.LONG, JavaType.VOID), + DOUBLE_LIST(17, Collection.VECTOR, JavaType.DOUBLE, JavaType.VOID), + FLOAT_LIST(18, Collection.VECTOR, JavaType.FLOAT, JavaType.VOID), + INT64_LIST(19, Collection.VECTOR, JavaType.LONG, JavaType.VOID), + UINT64_LIST(20, Collection.VECTOR, JavaType.LONG, JavaType.VOID), + INT32_LIST(21, Collection.VECTOR, JavaType.INT, JavaType.VOID), + FIXED64_LIST(22, Collection.VECTOR, JavaType.LONG, JavaType.VOID), + FIXED32_LIST(23, Collection.VECTOR, JavaType.INT, JavaType.VOID), + BOOL_LIST(24, Collection.VECTOR, JavaType.BOOLEAN, JavaType.VOID), + STRING_LIST(25, Collection.VECTOR, JavaType.STRING, JavaType.VOID), + MESSAGE_LIST(26, Collection.VECTOR, JavaType.MESSAGE, JavaType.VOID), + BYTES_LIST(27, Collection.VECTOR, JavaType.BYTE_STRING, JavaType.VOID), + UINT32_LIST(28, Collection.VECTOR, JavaType.INT, JavaType.VOID), + ENUM_LIST(29, Collection.VECTOR, JavaType.ENUM, JavaType.VOID), + SFIXED32_LIST(30, Collection.VECTOR, JavaType.INT, JavaType.VOID), + SFIXED64_LIST(31, Collection.VECTOR, JavaType.LONG, JavaType.VOID), + SINT32_LIST(32, Collection.VECTOR, JavaType.INT, JavaType.VOID), + SINT64_LIST(33, Collection.VECTOR, JavaType.LONG, JavaType.VOID), + DOUBLE_LIST_PACKED(34, Collection.PACKED_VECTOR, JavaType.DOUBLE, JavaType.VOID), + FLOAT_LIST_PACKED(35, Collection.PACKED_VECTOR, JavaType.FLOAT, JavaType.VOID), + INT64_LIST_PACKED(36, Collection.PACKED_VECTOR, JavaType.LONG, JavaType.VOID), + UINT64_LIST_PACKED(37, Collection.PACKED_VECTOR, JavaType.LONG, JavaType.VOID), + INT32_LIST_PACKED(38, Collection.PACKED_VECTOR, JavaType.INT, JavaType.VOID), + FIXED64_LIST_PACKED(39, Collection.PACKED_VECTOR, JavaType.LONG, JavaType.VOID), + FIXED32_LIST_PACKED(40, Collection.PACKED_VECTOR, JavaType.INT, JavaType.VOID), + BOOL_LIST_PACKED(41, Collection.PACKED_VECTOR, JavaType.BOOLEAN, JavaType.VOID), + UINT32_LIST_PACKED(42, Collection.PACKED_VECTOR, JavaType.INT, JavaType.VOID), + ENUM_LIST_PACKED(43, Collection.PACKED_VECTOR, JavaType.ENUM, JavaType.VOID), + SFIXED32_LIST_PACKED(44, Collection.PACKED_VECTOR, JavaType.INT, JavaType.VOID), + SFIXED64_LIST_PACKED(45, Collection.PACKED_VECTOR, JavaType.LONG, JavaType.VOID), + SINT32_LIST_PACKED(46, Collection.PACKED_VECTOR, JavaType.INT, JavaType.VOID), + SINT64_LIST_PACKED(47, Collection.PACKED_VECTOR, JavaType.LONG, JavaType.VOID), + INT32_TO_INT32_MAP(48, Collection.MAP, JavaType.INT, JavaType.INT), + INT32_TO_INT64_MAP(49, Collection.MAP, JavaType.INT, JavaType.LONG), + INT32_TO_UINT32_MAP(50, Collection.MAP, JavaType.INT, JavaType.INT), + INT32_TO_UINT64_MAP(51, Collection.MAP, JavaType.INT, JavaType.LONG), + INT32_TO_SINT32_MAP(52, Collection.MAP, JavaType.INT, JavaType.INT), + INT32_TO_SINT64_MAP(53, Collection.MAP, JavaType.INT, JavaType.LONG), + INT32_TO_FIXED32_MAP(54, Collection.MAP, JavaType.INT, JavaType.INT), + INT32_TO_FIXED64_MAP(55, Collection.MAP, JavaType.INT, JavaType.LONG), + INT32_TO_SFIXED32_MAP(56, Collection.MAP, JavaType.INT, JavaType.INT), + INT32_TO_SFIXED64_MAP(57, Collection.MAP, JavaType.INT, JavaType.LONG), + INT32_TO_BOOL_MAP(58, Collection.MAP, JavaType.INT, JavaType.BOOLEAN), + INT32_TO_STRING_MAP(59, Collection.MAP, JavaType.INT, JavaType.STRING), + INT32_TO_ENUM_MAP(60, Collection.MAP, JavaType.INT, JavaType.ENUM), + INT32_TO_MESSAGE_MAP(61, Collection.MAP, JavaType.INT, JavaType.MESSAGE), + INT32_TO_BYTES_MAP(62, Collection.MAP, JavaType.INT, JavaType.BYTE_STRING), + INT32_TO_DOUBLE_MAP(63, Collection.MAP, JavaType.INT, JavaType.DOUBLE), + INT32_TO_FLOAT_MAP(64, Collection.MAP, JavaType.INT, JavaType.FLOAT), + INT64_TO_INT32_MAP(65, Collection.MAP, JavaType.LONG, JavaType.INT), + INT64_TO_INT64_MAP(66, Collection.MAP, JavaType.LONG, JavaType.LONG), + INT64_TO_UINT32_MAP(67, Collection.MAP, JavaType.LONG, JavaType.INT), + INT64_TO_UINT64_MAP(68, Collection.MAP, JavaType.LONG, JavaType.LONG), + INT64_TO_SINT32_MAP(69, Collection.MAP, JavaType.LONG, JavaType.INT), + INT64_TO_SINT64_MAP(70, Collection.MAP, JavaType.LONG, JavaType.LONG), + INT64_TO_FIXED32_MAP(71, Collection.MAP, JavaType.LONG, JavaType.INT), + INT64_TO_FIXED64_MAP(72, Collection.MAP, JavaType.LONG, JavaType.LONG), + INT64_TO_SFIXED32_MAP(73, Collection.MAP, JavaType.LONG, JavaType.INT), + INT64_TO_SFIXED64_MAP(74, Collection.MAP, JavaType.LONG, JavaType.LONG), + INT64_TO_BOOL_MAP(75, Collection.MAP, JavaType.LONG, JavaType.BOOLEAN), + INT64_TO_STRING_MAP(76, Collection.MAP, JavaType.LONG, JavaType.STRING), + INT64_TO_ENUM_MAP(77, Collection.MAP, JavaType.LONG, JavaType.ENUM), + INT64_TO_MESSAGE_MAP(78, Collection.MAP, JavaType.LONG, JavaType.MESSAGE), + INT64_TO_BYTES_MAP(79, Collection.MAP, JavaType.LONG, JavaType.BYTE_STRING), + INT64_TO_DOUBLE_MAP(80, Collection.MAP, JavaType.LONG, JavaType.DOUBLE), + INT64_TO_FLOAT_MAP(81, Collection.MAP, JavaType.LONG, JavaType.FLOAT), + UINT32_TO_INT32_MAP(82, Collection.MAP, JavaType.INT, JavaType.INT), + UINT32_TO_INT64_MAP(83, Collection.MAP, JavaType.INT, JavaType.LONG), + UINT32_TO_UINT32_MAP(84, Collection.MAP, JavaType.INT, JavaType.INT), + UINT32_TO_UINT64_MAP(85, Collection.MAP, JavaType.INT, JavaType.LONG), + UINT32_TO_SINT32_MAP(86, Collection.MAP, JavaType.INT, JavaType.INT), + UINT32_TO_SINT64_MAP(87, Collection.MAP, JavaType.INT, JavaType.LONG), + UINT32_TO_FIXED32_MAP(88, Collection.MAP, JavaType.INT, JavaType.INT), + UINT32_TO_FIXED64_MAP(89, Collection.MAP, JavaType.INT, JavaType.LONG), + UINT32_TO_SFIXED32_MAP(90, Collection.MAP, JavaType.INT, JavaType.INT), + UINT32_TO_SFIXED64_MAP(91, Collection.MAP, JavaType.INT, JavaType.LONG), + UINT32_TO_BOOL_MAP(92, Collection.MAP, JavaType.INT, JavaType.BOOLEAN), + UINT32_TO_STRING_MAP(93, Collection.MAP, JavaType.INT, JavaType.STRING), + UINT32_TO_ENUM_MAP(94, Collection.MAP, JavaType.INT, JavaType.ENUM), + UINT32_TO_MESSAGE_MAP(95, Collection.MAP, JavaType.INT, JavaType.MESSAGE), + UINT32_TO_BYTES_MAP(96, Collection.MAP, JavaType.INT, JavaType.BYTE_STRING), + UINT32_TO_DOUBLE_MAP(97, Collection.MAP, JavaType.INT, JavaType.DOUBLE), + UINT32_TO_FLOAT_MAP(98, Collection.MAP, JavaType.INT, JavaType.FLOAT), + UINT64_TO_INT32_MAP(99, Collection.MAP, JavaType.LONG, JavaType.INT), + UINT64_TO_INT64_MAP(100, Collection.MAP, JavaType.LONG, JavaType.LONG), + UINT64_TO_UINT32_MAP(101, Collection.MAP, JavaType.LONG, JavaType.INT), + UINT64_TO_UINT64_MAP(102, Collection.MAP, JavaType.LONG, JavaType.LONG), + UINT64_TO_SINT32_MAP(103, Collection.MAP, JavaType.LONG, JavaType.INT), + UINT64_TO_SINT64_MAP(104, Collection.MAP, JavaType.LONG, JavaType.LONG), + UINT64_TO_FIXED32_MAP(105, Collection.MAP, JavaType.LONG, JavaType.INT), + UINT64_TO_FIXED64_MAP(106, Collection.MAP, JavaType.LONG, JavaType.LONG), + UINT64_TO_SFIXED32_MAP(107, Collection.MAP, JavaType.LONG, JavaType.INT), + UINT64_TO_SFIXED64_MAP(108, Collection.MAP, JavaType.LONG, JavaType.LONG), + UINT64_TO_BOOL_MAP(109, Collection.MAP, JavaType.LONG, JavaType.BOOLEAN), + UINT64_TO_STRING_MAP(110, Collection.MAP, JavaType.LONG, JavaType.STRING), + UINT64_TO_ENUM_MAP(111, Collection.MAP, JavaType.LONG, JavaType.ENUM), + UINT64_TO_MESSAGE_MAP(112, Collection.MAP, JavaType.LONG, JavaType.MESSAGE), + UINT64_TO_BYTES_MAP(113, Collection.MAP, JavaType.LONG, JavaType.BYTE_STRING), + UINT64_TO_DOUBLE_MAP(114, Collection.MAP, JavaType.LONG, JavaType.DOUBLE), + UINT64_TO_FLOAT_MAP(115, Collection.MAP, JavaType.LONG, JavaType.FLOAT), + SINT32_TO_INT32_MAP(116, Collection.MAP, JavaType.INT, JavaType.INT), + SINT32_TO_INT64_MAP(117, Collection.MAP, JavaType.INT, JavaType.LONG), + SINT32_TO_UINT32_MAP(118, Collection.MAP, JavaType.INT, JavaType.INT), + SINT32_TO_UINT64_MAP(119, Collection.MAP, JavaType.INT, JavaType.LONG), + SINT32_TO_SINT32_MAP(120, Collection.MAP, JavaType.INT, JavaType.INT), + SINT32_TO_SINT64_MAP(121, Collection.MAP, JavaType.INT, JavaType.LONG), + SINT32_TO_FIXED32_MAP(122, Collection.MAP, JavaType.INT, JavaType.INT), + SINT32_TO_FIXED64_MAP(123, Collection.MAP, JavaType.INT, JavaType.LONG), + SINT32_TO_SFIXED32_MAP(124, Collection.MAP, JavaType.INT, JavaType.INT), + SINT32_TO_SFIXED64_MAP(125, Collection.MAP, JavaType.INT, JavaType.LONG), + SINT32_TO_BOOL_MAP(126, Collection.MAP, JavaType.INT, JavaType.BOOLEAN), + SINT32_TO_STRING_MAP(127, Collection.MAP, JavaType.INT, JavaType.STRING), + SINT32_TO_ENUM_MAP(128, Collection.MAP, JavaType.INT, JavaType.ENUM), + SINT32_TO_MESSAGE_MAP(129, Collection.MAP, JavaType.INT, JavaType.MESSAGE), + SINT32_TO_BYTES_MAP(130, Collection.MAP, JavaType.INT, JavaType.BYTE_STRING), + SINT32_TO_DOUBLE_MAP(131, Collection.MAP, JavaType.INT, JavaType.DOUBLE), + SINT32_TO_FLOAT_MAP(132, Collection.MAP, JavaType.INT, JavaType.FLOAT), + SINT64_TO_INT32_MAP(133, Collection.MAP, JavaType.LONG, JavaType.INT), + SINT64_TO_INT64_MAP(134, Collection.MAP, JavaType.LONG, JavaType.LONG), + SINT64_TO_UINT32_MAP(135, Collection.MAP, JavaType.LONG, JavaType.INT), + SINT64_TO_UINT64_MAP(136, Collection.MAP, JavaType.LONG, JavaType.LONG), + SINT64_TO_SINT32_MAP(137, Collection.MAP, JavaType.LONG, JavaType.INT), + SINT64_TO_SINT64_MAP(138, Collection.MAP, JavaType.LONG, JavaType.LONG), + SINT64_TO_FIXED32_MAP(139, Collection.MAP, JavaType.LONG, JavaType.INT), + SINT64_TO_FIXED64_MAP(140, Collection.MAP, JavaType.LONG, JavaType.LONG), + SINT64_TO_SFIXED32_MAP(141, Collection.MAP, JavaType.LONG, JavaType.INT), + SINT64_TO_SFIXED64_MAP(142, Collection.MAP, JavaType.LONG, JavaType.LONG), + SINT64_TO_BOOL_MAP(143, Collection.MAP, JavaType.LONG, JavaType.BOOLEAN), + SINT64_TO_STRING_MAP(144, Collection.MAP, JavaType.LONG, JavaType.STRING), + SINT64_TO_ENUM_MAP(145, Collection.MAP, JavaType.LONG, JavaType.ENUM), + SINT64_TO_MESSAGE_MAP(146, Collection.MAP, JavaType.LONG, JavaType.MESSAGE), + SINT64_TO_BYTES_MAP(147, Collection.MAP, JavaType.LONG, JavaType.BYTE_STRING), + SINT64_TO_DOUBLE_MAP(148, Collection.MAP, JavaType.LONG, JavaType.DOUBLE), + SINT64_TO_FLOAT_MAP(149, Collection.MAP, JavaType.LONG, JavaType.FLOAT), + FIXED32_TO_INT32_MAP(150, Collection.MAP, JavaType.INT, JavaType.INT), + FIXED32_TO_INT64_MAP(151, Collection.MAP, JavaType.INT, JavaType.LONG), + FIXED32_TO_UINT32_MAP(152, Collection.MAP, JavaType.INT, JavaType.INT), + FIXED32_TO_UINT64_MAP(153, Collection.MAP, JavaType.INT, JavaType.LONG), + FIXED32_TO_SINT32_MAP(154, Collection.MAP, JavaType.INT, JavaType.INT), + FIXED32_TO_SINT64_MAP(155, Collection.MAP, JavaType.INT, JavaType.LONG), + FIXED32_TO_FIXED32_MAP(156, Collection.MAP, JavaType.INT, JavaType.INT), + FIXED32_TO_FIXED64_MAP(157, Collection.MAP, JavaType.INT, JavaType.LONG), + FIXED32_TO_SFIXED32_MAP(158, Collection.MAP, JavaType.INT, JavaType.INT), + FIXED32_TO_SFIXED64_MAP(159, Collection.MAP, JavaType.INT, JavaType.LONG), + FIXED32_TO_BOOL_MAP(160, Collection.MAP, JavaType.INT, JavaType.BOOLEAN), + FIXED32_TO_STRING_MAP(161, Collection.MAP, JavaType.INT, JavaType.STRING), + FIXED32_TO_ENUM_MAP(162, Collection.MAP, JavaType.INT, JavaType.ENUM), + FIXED32_TO_MESSAGE_MAP(163, Collection.MAP, JavaType.INT, JavaType.MESSAGE), + FIXED32_TO_BYTES_MAP(164, Collection.MAP, JavaType.INT, JavaType.BYTE_STRING), + FIXED32_TO_DOUBLE_MAP(165, Collection.MAP, JavaType.INT, JavaType.DOUBLE), + FIXED32_TO_FLOAT_MAP(166, Collection.MAP, JavaType.INT, JavaType.FLOAT), + FIXED64_TO_INT32_MAP(167, Collection.MAP, JavaType.LONG, JavaType.INT), + FIXED64_TO_INT64_MAP(168, Collection.MAP, JavaType.LONG, JavaType.LONG), + FIXED64_TO_UINT32_MAP(169, Collection.MAP, JavaType.LONG, JavaType.INT), + FIXED64_TO_UINT64_MAP(170, Collection.MAP, JavaType.LONG, JavaType.LONG), + FIXED64_TO_SINT32_MAP(171, Collection.MAP, JavaType.LONG, JavaType.INT), + FIXED64_TO_SINT64_MAP(172, Collection.MAP, JavaType.LONG, JavaType.LONG), + FIXED64_TO_FIXED32_MAP(173, Collection.MAP, JavaType.LONG, JavaType.INT), + FIXED64_TO_FIXED64_MAP(174, Collection.MAP, JavaType.LONG, JavaType.LONG), + FIXED64_TO_SFIXED32_MAP(175, Collection.MAP, JavaType.LONG, JavaType.INT), + FIXED64_TO_SFIXED64_MAP(176, Collection.MAP, JavaType.LONG, JavaType.LONG), + FIXED64_TO_BOOL_MAP(177, Collection.MAP, JavaType.LONG, JavaType.BOOLEAN), + FIXED64_TO_STRING_MAP(178, Collection.MAP, JavaType.LONG, JavaType.STRING), + FIXED64_TO_ENUM_MAP(179, Collection.MAP, JavaType.LONG, JavaType.ENUM), + FIXED64_TO_MESSAGE_MAP(180, Collection.MAP, JavaType.LONG, JavaType.MESSAGE), + FIXED64_TO_BYTES_MAP(181, Collection.MAP, JavaType.LONG, JavaType.BYTE_STRING), + FIXED64_TO_DOUBLE_MAP(182, Collection.MAP, JavaType.LONG, JavaType.DOUBLE), + FIXED64_TO_FLOAT_MAP(183, Collection.MAP, JavaType.LONG, JavaType.FLOAT), + SFIXED32_TO_INT32_MAP(184, Collection.MAP, JavaType.INT, JavaType.INT), + SFIXED32_TO_INT64_MAP(185, Collection.MAP, JavaType.INT, JavaType.LONG), + SFIXED32_TO_UINT32_MAP(186, Collection.MAP, JavaType.INT, JavaType.INT), + SFIXED32_TO_UINT64_MAP(187, Collection.MAP, JavaType.INT, JavaType.LONG), + SFIXED32_TO_SINT32_MAP(188, Collection.MAP, JavaType.INT, JavaType.INT), + SFIXED32_TO_SINT64_MAP(189, Collection.MAP, JavaType.INT, JavaType.LONG), + SFIXED32_TO_FIXED32_MAP(190, Collection.MAP, JavaType.INT, JavaType.INT), + SFIXED32_TO_FIXED64_MAP(191, Collection.MAP, JavaType.INT, JavaType.LONG), + SFIXED32_TO_SFIXED32_MAP(192, Collection.MAP, JavaType.INT, JavaType.INT), + SFIXED32_TO_SFIXED64_MAP(193, Collection.MAP, JavaType.INT, JavaType.LONG), + SFIXED32_TO_BOOL_MAP(194, Collection.MAP, JavaType.INT, JavaType.BOOLEAN), + SFIXED32_TO_STRING_MAP(195, Collection.MAP, JavaType.INT, JavaType.STRING), + SFIXED32_TO_ENUM_MAP(196, Collection.MAP, JavaType.INT, JavaType.ENUM), + SFIXED32_TO_MESSAGE_MAP(197, Collection.MAP, JavaType.INT, JavaType.MESSAGE), + SFIXED32_TO_BYTES_MAP(198, Collection.MAP, JavaType.INT, JavaType.BYTE_STRING), + SFIXED32_TO_DOUBLE_MAP(199, Collection.MAP, JavaType.INT, JavaType.DOUBLE), + SFIXED32_TO_FLOAT_MAP(200, Collection.MAP, JavaType.INT, JavaType.FLOAT), + SFIXED64_TO_INT32_MAP(201, Collection.MAP, JavaType.LONG, JavaType.INT), + SFIXED64_TO_INT64_MAP(202, Collection.MAP, JavaType.LONG, JavaType.LONG), + SFIXED64_TO_UINT32_MAP(203, Collection.MAP, JavaType.LONG, JavaType.INT), + SFIXED64_TO_UINT64_MAP(204, Collection.MAP, JavaType.LONG, JavaType.LONG), + SFIXED64_TO_SINT32_MAP(205, Collection.MAP, JavaType.LONG, JavaType.INT), + SFIXED64_TO_SINT64_MAP(206, Collection.MAP, JavaType.LONG, JavaType.LONG), + SFIXED64_TO_FIXED32_MAP(207, Collection.MAP, JavaType.LONG, JavaType.INT), + SFIXED64_TO_FIXED64_MAP(208, Collection.MAP, JavaType.LONG, JavaType.LONG), + SFIXED64_TO_SFIXED32_MAP(209, Collection.MAP, JavaType.LONG, JavaType.INT), + SFIXED64_TO_SFIXED64_MAP(210, Collection.MAP, JavaType.LONG, JavaType.LONG), + SFIXED64_TO_BOOL_MAP(211, Collection.MAP, JavaType.LONG, JavaType.BOOLEAN), + SFIXED64_TO_STRING_MAP(212, Collection.MAP, JavaType.LONG, JavaType.STRING), + SFIXED64_TO_ENUM_MAP(213, Collection.MAP, JavaType.LONG, JavaType.ENUM), + SFIXED64_TO_MESSAGE_MAP(214, Collection.MAP, JavaType.LONG, JavaType.MESSAGE), + SFIXED64_TO_BYTES_MAP(215, Collection.MAP, JavaType.LONG, JavaType.BYTE_STRING), + SFIXED64_TO_DOUBLE_MAP(216, Collection.MAP, JavaType.LONG, JavaType.DOUBLE), + SFIXED64_TO_FLOAT_MAP(217, Collection.MAP, JavaType.LONG, JavaType.FLOAT), + BOOL_TO_INT32_MAP(218, Collection.MAP, JavaType.BOOLEAN, JavaType.INT), + BOOL_TO_INT64_MAP(219, Collection.MAP, JavaType.BOOLEAN, JavaType.LONG), + BOOL_TO_UINT32_MAP(220, Collection.MAP, JavaType.BOOLEAN, JavaType.INT), + BOOL_TO_UINT64_MAP(221, Collection.MAP, JavaType.BOOLEAN, JavaType.LONG), + BOOL_TO_SINT32_MAP(222, Collection.MAP, JavaType.BOOLEAN, JavaType.INT), + BOOL_TO_SINT64_MAP(223, Collection.MAP, JavaType.BOOLEAN, JavaType.LONG), + BOOL_TO_FIXED32_MAP(224, Collection.MAP, JavaType.BOOLEAN, JavaType.INT), + BOOL_TO_FIXED64_MAP(225, Collection.MAP, JavaType.BOOLEAN, JavaType.LONG), + BOOL_TO_SFIXED32_MAP(226, Collection.MAP, JavaType.BOOLEAN, JavaType.INT), + BOOL_TO_SFIXED64_MAP(227, Collection.MAP, JavaType.BOOLEAN, JavaType.LONG), + BOOL_TO_BOOL_MAP(228, Collection.MAP, JavaType.BOOLEAN, JavaType.BOOLEAN), + BOOL_TO_STRING_MAP(229, Collection.MAP, JavaType.BOOLEAN, JavaType.STRING), + BOOL_TO_ENUM_MAP(230, Collection.MAP, JavaType.BOOLEAN, JavaType.ENUM), + BOOL_TO_MESSAGE_MAP(231, Collection.MAP, JavaType.BOOLEAN, JavaType.MESSAGE), + BOOL_TO_BYTES_MAP(232, Collection.MAP, JavaType.BOOLEAN, JavaType.BYTE_STRING), + BOOL_TO_DOUBLE_MAP(233, Collection.MAP, JavaType.BOOLEAN, JavaType.DOUBLE), + BOOL_TO_FLOAT_MAP(234, Collection.MAP, JavaType.BOOLEAN, JavaType.FLOAT), + STRING_TO_INT32_MAP(235, Collection.MAP, JavaType.STRING, JavaType.INT), + STRING_TO_INT64_MAP(236, Collection.MAP, JavaType.STRING, JavaType.LONG), + STRING_TO_UINT32_MAP(237, Collection.MAP, JavaType.STRING, JavaType.INT), + STRING_TO_UINT64_MAP(238, Collection.MAP, JavaType.STRING, JavaType.LONG), + STRING_TO_SINT32_MAP(239, Collection.MAP, JavaType.STRING, JavaType.INT), + STRING_TO_SINT64_MAP(240, Collection.MAP, JavaType.STRING, JavaType.LONG), + STRING_TO_FIXED32_MAP(241, Collection.MAP, JavaType.STRING, JavaType.INT), + STRING_TO_FIXED64_MAP(242, Collection.MAP, JavaType.STRING, JavaType.LONG), + STRING_TO_SFIXED32_MAP(243, Collection.MAP, JavaType.STRING, JavaType.INT), + STRING_TO_SFIXED64_MAP(244, Collection.MAP, JavaType.STRING, JavaType.LONG), + STRING_TO_BOOL_MAP(245, Collection.MAP, JavaType.STRING, JavaType.BOOLEAN), + STRING_TO_STRING_MAP(246, Collection.MAP, JavaType.STRING, JavaType.STRING), + STRING_TO_ENUM_MAP(247, Collection.MAP, JavaType.STRING, JavaType.ENUM), + STRING_TO_MESSAGE_MAP(248, Collection.MAP, JavaType.STRING, JavaType.MESSAGE), + STRING_TO_BYTES_MAP(249, Collection.MAP, JavaType.STRING, JavaType.BYTE_STRING), + STRING_TO_DOUBLE_MAP(250, Collection.MAP, JavaType.STRING, JavaType.DOUBLE), + STRING_TO_FLOAT_MAP(251, Collection.MAP, JavaType.STRING, JavaType.FLOAT), + GROUP(252, Collection.SCALAR, JavaType.MESSAGE, JavaType.VOID), + GROUP_LIST(253, Collection.VECTOR, JavaType.MESSAGE, JavaType.VOID), + GROUP_LIST_PACKED(254, Collection.PACKED_VECTOR, JavaType.MESSAGE, JavaType.VOID); + + private final JavaType javaType1; + private final JavaType javaType2; + private final int id; + private final Collection collection; + private final Class elementType1; + private final Class elementType2; + + FieldType(int id, Collection collection, JavaType javaType1, JavaType javaType2) { + this.id = id; + this.collection = collection; + this.javaType1 = javaType1; + this.javaType2 = javaType2; + + switch (collection) { + case MAP: + elementType1 = javaType1.getBoxedType(); + elementType2 = javaType2.getBoxedType(); + break; + case VECTOR: + elementType1 = javaType1.getBoxedType(); + elementType2 = null; + break; + case SCALAR: + default: + elementType1 = null; + elementType2 = null; + break; + } + } + + /** + * A reliable unique identifier for this type. + */ + public int id() { + return id; + } + + /** + * Gets the {@link JavaType} for this field. For lists, this identifies the type of the elements + * contained within the list. + */ + public JavaType getJavaType() { + return javaType1; + } + + /** + * Indicates whether a list field should be represented on the wire in packed form. + */ + public boolean isPacked() { + return Collection.PACKED_VECTOR.equals(collection); + } + + /** + * Indicates whether this field represents a list of values. + */ + public boolean isList() { + return collection.isList(); + } + + /** + * Indicates whether or not this {@link FieldType} can be applied to the given {@link Field}. + */ + public boolean isValidForField(Field field) { + if (Collection.VECTOR.equals(collection)) { + return isValidForList(field); + } else { + return javaType1.getType().isAssignableFrom(field.getType()); + } + } + + private boolean isValidForList(Field field) { + Class clazz = field.getType(); + if (!javaType1.getType().isAssignableFrom(clazz)) { + // The field isn't a List type. + return false; + } + Type[] types = EMPTY_TYPES; + Type genericType = field.getGenericType(); + if (genericType instanceof ParameterizedType) { + types = ((ParameterizedType) field.getGenericType()).getActualTypeArguments(); + } + Type listParameter = getListParameter(clazz, types); + if (!(listParameter instanceof Class)) { + // It's a wildcard, we should allow anything in the list. + return true; + } + return elementType1.isAssignableFrom((Class) listParameter); + } + + /** + * Looks up the appropriate {@link FieldType} by it's identifier. + * + * @return the {@link FieldType} or {@code null} if not found. + */ + /* @Nullable */ + public static FieldType forId(byte id) { + if (id < 0 || id >= VALUES.length) { + return null; + } + return VALUES[id]; + } + + private static final FieldType[] VALUES; + private static final Type[] EMPTY_TYPES = new Type[0]; + + static { + FieldType[] values = values(); + VALUES = new FieldType[values.length]; + for (FieldType type : values) { + VALUES[type.id] = type; + } + } + + /** + * Given a class, finds a generic super class or interface that extends {@link List}. + * + * @return the generic super class/interface, or {@code null} if not found. + */ + /* @Nullable */ + private static Type getGenericSuperList(Class clazz) { + // First look at interfaces. + Type[] genericInterfaces = clazz.getGenericInterfaces(); + for (Type genericInterface : genericInterfaces) { + if (genericInterface instanceof ParameterizedType) { + ParameterizedType parameterizedType = (ParameterizedType) genericInterface; + Class rawType = (Class) parameterizedType.getRawType(); + if (List.class.isAssignableFrom(rawType)) { + return genericInterface; + } + } + } + + // Try the subclass + Type type = clazz.getGenericSuperclass(); + if (type instanceof ParameterizedType) { + ParameterizedType parameterizedType = (ParameterizedType) type; + Class rawType = (Class) parameterizedType.getRawType(); + if (List.class.isAssignableFrom(rawType)) { + return type; + } + } + + // No super class/interface extends List. + return null; + } + + /** + * Inspects the inheritance hierarchy for the given class and finds the generic type parameter + * for {@link List}. + * + * @param clazz the class to begin the search. + * @param realTypes the array of actual type parameters for {@code clazz}. These will be used to + * substitute generic parameters up the inheritance hierarchy. If {@code clazz} does not have any + * generic parameters, this list should be empty. + * @return the {@link List} parameter. + */ + private static Type getListParameter(Class clazz, Type[] realTypes) { + top: + while (clazz != List.class) { + // First look at generic subclass and interfaces. + Type genericType = getGenericSuperList(clazz); + if (genericType instanceof ParameterizedType) { + // Replace any generic parameters with the real values. + ParameterizedType parameterizedType = (ParameterizedType) genericType; + Type[] superArgs = parameterizedType.getActualTypeArguments(); + for (int i = 0; i < superArgs.length; ++i) { + Type superArg = superArgs[i]; + if (superArg instanceof TypeVariable) { + // Get the type variables for this class so that we can match them to the variables + // used on the super class. + TypeVariable[] clazzParams = clazz.getTypeParameters(); + if (realTypes.length != clazzParams.length) { + throw new RuntimeException("Type array mismatch"); + } + + // Replace the variable parameter with the real type. + boolean foundReplacement = false; + for (int j = 0; j < clazzParams.length; ++j) { + if (superArg == clazzParams[j]) { + Type realType = realTypes[j]; + superArgs[i] = realType; + foundReplacement = true; + break; + } + } + if (!foundReplacement) { + throw new RuntimeException("Unable to find replacement for " + superArg); + } + } + } + + Class parent = (Class) parameterizedType.getRawType(); + + realTypes = superArgs; + clazz = parent; + continue; + } + + // None of the parameterized types inherit List. Just continue up the inheritance hierarchy + // toward the List interface until we can identify the parameters. + realTypes = EMPTY_TYPES; + for (Class iface : clazz.getInterfaces()) { + if (List.class.isAssignableFrom(iface)) { + clazz = iface; + continue top; + } + } + clazz = clazz.getSuperclass(); + } + + if (realTypes.length != 1) { + throw new RuntimeException("Unable to identify parameter type for List"); + } + return realTypes[0]; + } + + enum Collection { + SCALAR(false), + VECTOR(true), + PACKED_VECTOR(true), + MAP(false); + + private final boolean isList; + + Collection(boolean isList) { + this.isList = isList; + } + + /** + * @return the isList + */ + public boolean isList() { + return isList; + } + } +} diff --git a/java/core/src/main/java/com/google/protobuf/Int2ObjectHashMap.java b/java/core/src/main/java/com/google/protobuf/Int2ObjectHashMap.java new file mode 100644 index 00000000..7909ab28 --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/Int2ObjectHashMap.java @@ -0,0 +1,754 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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.util.AbstractCollection; +import java.util.AbstractSet; +import java.util.Arrays; +import java.util.Collection; +import java.util.Iterator; +import java.util.Map; +import java.util.NoSuchElementException; +import java.util.Set; + +/** + * A hash map that uses primitive integers as keys with open addressing. To minimize the memory + * footprint, this class uses open addressing rather than chaining. Collisions are resolved using + * linear probing. Deletions implement compaction, so cost of remove can approach O(N) for full + * maps, which makes a small loadFactor recommended. + * + * @param The value type stored in the map. + */ +@ExperimentalApi +public final class Int2ObjectHashMap implements Map { + /** + * A primitive entry in the map, provided by the iterator from {@link #entries()} + * + * @param the value type stored in the map. + */ + public interface PrimitiveEntry { + /** Gets the key for this entry. */ + int key(); + + /** Gets the value for this entry. */ + V value(); + + /** Sets the value for this entry. */ + void setValue(V value); + } + + /** Default initial capacity. Used if not specified in the constructor */ + public static final int DEFAULT_CAPACITY = 8; + + /** Default load factor. Used if not specified in the constructor */ + public static final float DEFAULT_LOAD_FACTOR = 0.5f; + + /** + * Placeholder for null values, so we can use the actual null to mean available. (Better than + * using a placeholder for available: less references for GC processing.) + */ + private static final Object NULL_VALUE = new Object(); + + /** The maximum number of elements allowed without allocating more space. */ + private int maxSize; + + /** The load factor for the map. Used to calculate {@link #maxSize}. */ + private final float loadFactor; + + private int[] keys; + private V[] values; + private int size; + private int mask; + + private final Set keySet = new KeySet(); + private final Set> entrySet = new EntrySet(); + private final Iterable> entries = + new Iterable>() { + @Override + public Iterator> iterator() { + return new PrimitiveIterator(); + } + }; + + public Int2ObjectHashMap() { + this(DEFAULT_CAPACITY, DEFAULT_LOAD_FACTOR); + } + + public Int2ObjectHashMap(int initialCapacity) { + this(initialCapacity, DEFAULT_LOAD_FACTOR); + } + + public Int2ObjectHashMap(int initialCapacity, float loadFactor) { + if (initialCapacity < 1) { + throw new IllegalArgumentException("initialCapacity must be >= 1"); + } + if (loadFactor <= 0.0f || loadFactor > 1.0f) { + // Cannot exceed 1 because we can never store more than capacity elements; + // using a bigger loadFactor would trigger rehashing before the desired load is reached. + throw new IllegalArgumentException("loadFactor must be > 0 and <= 1"); + } + + this.loadFactor = loadFactor; + + // Adjust the initial capacity if necessary. + int capacity = findNextPositivePowerOfTwo(initialCapacity); + mask = capacity - 1; + + // Allocate the arrays. + keys = new int[capacity]; + @SuppressWarnings({"unchecked", "SuspiciousArrayCast"}) + V[] temp = (V[]) new Object[capacity]; + values = temp; + + // Initialize the maximum size value. + maxSize = calcMaxSize(capacity); + } + + private static T toExternal(T value) { + return value == NULL_VALUE ? null : value; + } + + @SuppressWarnings("unchecked") + private static T toInternal(T value) { + return value == null ? (T) NULL_VALUE : value; + } + + public V get(int key) { + int index = indexOf(key); + return index == -1 ? null : toExternal(values[index]); + } + + public V put(int key, V value) { + int startIndex = hashIndex(key); + int index = startIndex; + + for (; ; ) { + if (values[index] == null) { + // Found empty slot, use it. + keys[index] = key; + values[index] = toInternal(value); + growSize(); + return null; + } + if (keys[index] == key) { + // Found existing entry with this key, just replace the value. + V previousValue = values[index]; + values[index] = toInternal(value); + return toExternal(previousValue); + } + + // Conflict, keep probing ... + if ((index = probeNext(index)) == startIndex) { + // Can only happen if the map was full at MAX_ARRAY_SIZE and couldn't grow. + throw new IllegalStateException("Unable to insert"); + } + } + } + + @Override + public void putAll(Map sourceMap) { + if (sourceMap instanceof Int2ObjectHashMap) { + // Optimization - iterate through the arrays. + @SuppressWarnings("unchecked") + Int2ObjectHashMap source = (Int2ObjectHashMap) sourceMap; + for (int i = 0; i < source.values.length; ++i) { + V sourceValue = source.values[i]; + if (sourceValue != null) { + put(source.keys[i], sourceValue); + } + } + return; + } + + // Otherwise, just add each entry. + for (Entry entry : sourceMap.entrySet()) { + put(entry.getKey(), entry.getValue()); + } + } + + public V remove(int key) { + int index = indexOf(key); + if (index == -1) { + return null; + } + + V prev = values[index]; + removeAt(index); + return toExternal(prev); + } + + @Override + public int size() { + return size; + } + + @Override + public boolean isEmpty() { + return size == 0; + } + + @Override + public void clear() { + Arrays.fill(keys, 0); + Arrays.fill(values, null); + size = 0; + } + + public boolean containsKey(int key) { + return indexOf(key) >= 0; + } + + @Override + public boolean containsValue(Object value) { + @SuppressWarnings("unchecked") + V v1 = toInternal((V) value); + for (V v2 : values) { + // The map supports null values; this will be matched as NULL_VALUE.equals(NULL_VALUE). + if (v2 != null && v2.equals(v1)) { + return true; + } + } + return false; + } + + public Iterable> entries() { + return entries; + } + + @Override + public Collection values() { + return new AbstractCollection() { + @Override + public Iterator iterator() { + return new Iterator() { + final PrimitiveIterator iter = new PrimitiveIterator(); + + @Override + public boolean hasNext() { + return iter.hasNext(); + } + + @Override + public V next() { + return iter.next().value(); + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + }; + } + + @Override + public int size() { + return size; + } + }; + } + + @Override + public int hashCode() { + // Hashcode is based on all non-zero, valid keys. We have to scan the whole keys + // array, which may have different lengths for two maps of same size(), so the + // capacity cannot be used as input for hashing but the size can. + int hash = size; + for (int key : keys) { + // 0 can be a valid key or unused slot, but won't impact the hashcode in either case. + // This way we can use a cheap loop without conditionals, or hard-to-unroll operations, + // or the devastatingly bad memory locality of visiting value objects. + // Also, it's important to use a hash function that does not depend on the ordering + // of terms, only their values; since the map is an unordered collection and + // entries can end up in different positions in different maps that have the same + // elements, but with different history of puts/removes, due to conflicts. + hash ^= hashCode(key); + } + return hash; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (!(obj instanceof Int2ObjectHashMap)) { + return false; + } + @SuppressWarnings("rawtypes") + Int2ObjectHashMap other = (Int2ObjectHashMap) obj; + if (size != other.size()) { + return false; + } + for (int i = 0; i < values.length; ++i) { + V value = values[i]; + if (value != null) { + int key = keys[i]; + Object otherValue = other.get(key); + if (value == NULL_VALUE) { + if (otherValue != null) { + return false; + } + } else if (!value.equals(otherValue)) { + return false; + } + } + } + return true; + } + + @Override + public boolean containsKey(Object key) { + return containsKey(objectToKey(key)); + } + + @Override + public V get(Object key) { + return get(objectToKey(key)); + } + + @Override + public V put(Integer key, V value) { + return put(objectToKey(key), value); + } + + @Override + public V remove(Object key) { + return remove(objectToKey(key)); + } + + @Override + public Set keySet() { + return keySet; + } + + @Override + public Set> entrySet() { + return entrySet; + } + + private int objectToKey(Object key) { + return ((Integer) key).intValue(); + } + + /** + * Locates the index for the given key. This method probes using double hashing. + * + * @param key the key for an entry in the map. + * @return the index where the key was found, or {@code -1} if no entry is found for that key. + */ + private int indexOf(int key) { + int startIndex = hashIndex(key); + int index = startIndex; + + for (; ; ) { + if (values[index] == null) { + // It's available, so no chance that this value exists anywhere in the map. + return -1; + } + if (key == keys[index]) { + return index; + } + + // Conflict, keep probing ... + if ((index = probeNext(index)) == startIndex) { + return -1; + } + } + } + + /** Returns the hashed index for the given key. */ + private int hashIndex(int key) { + // The array lengths are always a power of two, so we can use a bitmask to stay inside the + // array bounds. + return hashCode(key) & mask; + } + + /** Returns the hash code for the key. */ + private static int hashCode(int key) { + return key; + } + + /** Get the next sequential index after {@code index} and wraps if necessary. */ + private int probeNext(int index) { + // The array lengths are always a power of two, so we can use a bitmask to stay inside the + // array bounds. + return (index + 1) & mask; + } + + /** Grows the map size after an insertion. If necessary, performs a rehash of the map. */ + private void growSize() { + size++; + + if (size > maxSize) { + if (keys.length == Integer.MAX_VALUE) { + throw new IllegalStateException("Max capacity reached at size=" + size); + } + + // Double the capacity. + rehash(keys.length << 1); + } + } + + /** + * Removes entry at the given index position. Also performs opportunistic, incremental rehashing + * if necessary to not break conflict chains. + * + * @param index the index position of the element to remove. + * @return {@code true} if the next item was moved back. {@code false} otherwise. + */ + private boolean removeAt(final int index) { + --size; + // Clearing the key is not strictly necessary (for GC like in a regular collection), + // but recommended for security. The memory location is still fresh in the cache anyway. + keys[index] = 0; + values[index] = null; + + // In the interval from index to the next available entry, the arrays may have entries + // that are displaced from their base position due to prior conflicts. Iterate these + // entries and move them back if possible, optimizing future lookups. + // Knuth Section 6.4 Algorithm R, also used by the JDK's IdentityHashMap. + + boolean movedBack = false; + int nextFree = index; + for (int i = probeNext(index); values[i] != null; i = probeNext(i)) { + int bucket = hashIndex(keys[i]); + if ((i < bucket && (bucket <= nextFree || nextFree <= i)) + || (bucket <= nextFree && nextFree <= i)) { + // Move the displaced entry "back" to the first available position. + keys[nextFree] = keys[i]; + values[nextFree] = values[i]; + movedBack = true; + // Put the first entry after the displaced entry + keys[i] = 0; + values[i] = null; + nextFree = i; + } + } + return movedBack; + } + + /** Calculates the maximum size allowed before rehashing. */ + private int calcMaxSize(int capacity) { + // Clip the upper bound so that there will always be at least one available slot. + int upperBound = capacity - 1; + return Math.min(upperBound, (int) (capacity * loadFactor)); + } + + /** + * Rehashes the map for the given capacity. + * + * @param newCapacity the new capacity for the map. + */ + private void rehash(int newCapacity) { + int[] oldKeys = keys; + V[] oldVals = values; + + keys = new int[newCapacity]; + @SuppressWarnings({"unchecked", "SuspiciousArrayCast"}) + V[] temp = (V[]) new Object[newCapacity]; + values = temp; + + maxSize = calcMaxSize(newCapacity); + mask = newCapacity - 1; + + // Insert to the new arrays. + for (int i = 0; i < oldVals.length; ++i) { + V oldVal = oldVals[i]; + if (oldVal != null) { + // Inlined put(), but much simpler: we don't need to worry about + // duplicated keys, growing/rehashing, or failing to insert. + int oldKey = oldKeys[i]; + int index = hashIndex(oldKey); + + for (; ; ) { + if (values[index] == null) { + keys[index] = oldKey; + values[index] = oldVal; + break; + } + + // Conflict, keep probing. Can wrap around, but never reaches startIndex again. + index = probeNext(index); + } + } + } + } + + @Override + public String toString() { + if (isEmpty()) { + return "{}"; + } + StringBuilder sb = new StringBuilder(4 * size); + sb.append('{'); + boolean first = true; + for (int i = 0; i < values.length; ++i) { + V value = values[i]; + if (value != null) { + if (!first) { + sb.append(", "); + } + sb.append(keyToString(keys[i])) + .append('=') + .append(value == this ? "(this Map)" : toExternal(value)); + first = false; + } + } + return sb.append('}').toString(); + } + + /** + * Helper method called by {@link #toString()} in order to convert a single map key into a string. + * This is protected to allow subclasses to override the appearance of a given key. + */ + protected String keyToString(int key) { + return Integer.toString(key); + } + + /** Set implementation for iterating over the entries of the map. */ + private final class EntrySet extends AbstractSet> { + @Override + public Iterator> iterator() { + return new MapIterator(); + } + + @Override + public int size() { + return Int2ObjectHashMap.this.size(); + } + } + + /** Set implementation for iterating over the keys. */ + private final class KeySet extends AbstractSet { + @Override + public int size() { + return Int2ObjectHashMap.this.size(); + } + + @Override + public boolean contains(Object o) { + return Int2ObjectHashMap.this.containsKey(o); + } + + @Override + public boolean remove(Object o) { + return Int2ObjectHashMap.this.remove(o) != null; + } + + @Override + public boolean retainAll(Collection retainedKeys) { + boolean changed = false; + for (Iterator> iter = entries().iterator(); iter.hasNext(); ) { + PrimitiveEntry entry = iter.next(); + if (!retainedKeys.contains(entry.key())) { + changed = true; + iter.remove(); + } + } + return changed; + } + + @Override + public void clear() { + Int2ObjectHashMap.this.clear(); + } + + @Override + public Iterator iterator() { + return new Iterator() { + private final Iterator> iter = entrySet.iterator(); + + @Override + public boolean hasNext() { + return iter.hasNext(); + } + + @Override + public Integer next() { + return iter.next().getKey(); + } + + @Override + public void remove() { + iter.remove(); + } + }; + } + } + + /** + * Iterator over primitive entries. Entry key/values are overwritten by each call to {@link + * #next()}. + */ + private final class PrimitiveIterator implements Iterator>, PrimitiveEntry { + private int prevIndex = -1; + private int nextIndex = -1; + private int entryIndex = -1; + + private void scanNext() { + for (; ; ) { + if (++nextIndex == values.length || values[nextIndex] != null) { + break; + } + } + } + + @Override + public boolean hasNext() { + if (nextIndex == -1) { + scanNext(); + } + return nextIndex < keys.length; + } + + @Override + public PrimitiveEntry next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + + prevIndex = nextIndex; + scanNext(); + + // Always return the same Entry object, just change its index each time. + entryIndex = prevIndex; + return this; + } + + @Override + public void remove() { + if (prevIndex < 0) { + throw new IllegalStateException("next must be called before each remove."); + } + if (removeAt(prevIndex)) { + // removeAt may move elements "back" in the array if they have been displaced because + // their spot in the array was occupied when they were inserted. If this occurs then the + // nextIndex is now invalid and should instead point to the prevIndex which now holds an + // element which was "moved back". + nextIndex = prevIndex; + } + prevIndex = -1; + } + + // Entry implementation. Since this implementation uses a single Entry, we coalesce that + // into the Iterator object (potentially making loop optimization much easier). + + @Override + public int key() { + return keys[entryIndex]; + } + + @Override + public V value() { + return toExternal(values[entryIndex]); + } + + @Override + public void setValue(V value) { + values[entryIndex] = toInternal(value); + } + } + + /** Iterator used by the {@link Map} interface. */ + private final class MapIterator implements Iterator> { + private final PrimitiveIterator iter = new PrimitiveIterator(); + + @Override + public boolean hasNext() { + return iter.hasNext(); + } + + @Override + public Entry next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + + iter.next(); + + return new MapEntry(iter.entryIndex); + } + + @Override + public void remove() { + iter.remove(); + } + } + + /** A single entry in the map. */ + final class MapEntry implements Entry { + private final int entryIndex; + + MapEntry(int entryIndex) { + this.entryIndex = entryIndex; + } + + @Override + public Integer getKey() { + verifyExists(); + return keys[entryIndex]; + } + + @Override + public V getValue() { + verifyExists(); + return toExternal(values[entryIndex]); + } + + @Override + public V setValue(V value) { + verifyExists(); + V prevValue = toExternal(values[entryIndex]); + values[entryIndex] = toInternal(value); + return prevValue; + } + + private void verifyExists() { + if (values[entryIndex] == null) { + throw new IllegalStateException("The map entry has been removed"); + } + } + } + + /** + * Fast method of finding the next power of 2 greater than or equal to the supplied value. + * + *

If the value is {@code <= 0} then 1 will be returned. This method is not suitable for {@link + * Integer#MIN_VALUE} or numbers greater than 2^30. + * + * @param value from which to search for next power of 2 + * @return The next power of 2 or the value itself if it is a power of 2 + */ + private static int findNextPositivePowerOfTwo(final int value) { + assert value > Integer.MIN_VALUE && value < 0x40000000; + return 1 << (32 - Integer.numberOfLeadingZeros(value - 1)); + } +} diff --git a/java/core/src/main/java/com/google/protobuf/JavaType.java b/java/core/src/main/java/com/google/protobuf/JavaType.java new file mode 100644 index 00000000..0e4c5c41 --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/JavaType.java @@ -0,0 +1,87 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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; + +/** + * Enum that identifies the Java types required to store protobuf fields. + */ +@ExperimentalApi +public enum JavaType { + VOID(Void.class, Void.class, null), + INT(int.class, Integer.class, 0), + LONG(long.class, Long.class, 0L), + FLOAT(float.class, Float.class, 0F), + DOUBLE(double.class, Double.class, 0D), + BOOLEAN(boolean.class, Boolean.class, false), + STRING(String.class, String.class, ""), + BYTE_STRING(ByteString.class, ByteString.class, ByteString.EMPTY), + ENUM(int.class, Integer.class, null), + MESSAGE(Object.class, Object.class, null); + + private final Class type; + private final Class boxedType; + private final Object defaultDefault; + + JavaType(Class type, Class boxedType, Object defaultDefault) { + this.type = type; + this.boxedType = boxedType; + this.defaultDefault = defaultDefault; + } + + /** + * The default default value for fields of this type, if it's a primitive + * type. + */ + public Object getDefaultDefault() { + return defaultDefault; + } + + /** + * Gets the required type for a field that would hold a value of this type. + */ + public Class getType() { + return type; + } + + /** + * @return the boxedType + */ + public Class getBoxedType() { + return boxedType; + } + + /** + * Indicates whether or not this {@link JavaType} can be applied to a field of the given type. + */ + public boolean isValidType(Class t) { + return type.isAssignableFrom(t); + } +} diff --git a/java/core/src/main/java/com/google/protobuf/MessageInfo.java b/java/core/src/main/java/com/google/protobuf/MessageInfo.java new file mode 100644 index 00000000..fdcfc2d8 --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/MessageInfo.java @@ -0,0 +1,158 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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 static com.google.protobuf.Internal.checkNotNull; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +/** + * Information for the layout of a protobuf message class. This describes all of the fields + * contained within a message. + */ +@ExperimentalApi +public final class MessageInfo { + private final ProtoSyntax syntax; + private final boolean messageSetWireFormat; + private final List fields; + + /** + * Constructor. + * + * @param fields the set of fields for the message. + */ + private MessageInfo(ProtoSyntax syntax, boolean messageSetWireFormat, List fields) { + this.syntax = syntax; + this.messageSetWireFormat = messageSetWireFormat; + this.fields = fields; + } + + /** Gets the syntax for the message (e.g. PROTO2, PROTO3). */ + public ProtoSyntax getSyntax() { + return syntax; + } + + /** Indicates whether or not the message should be represented with message set wire format. */ + public boolean isMessageSetWireFormat() { + return messageSetWireFormat; + } + + /** + * Gets the information for all fields within this message, sorted in ascending order by their + * field number. + */ + public List getFields() { + return fields; + } + + /** Creates a new map of field number to message class for message fields. */ + public Int2ObjectHashMap> messageFieldClassMap() { + Int2ObjectHashMap> classMap = new Int2ObjectHashMap>(); + for (int i = 0; i < fields.size(); ++i) { + FieldInfo fd = fields.get(i); + int fieldNumber = fd.getFieldNumber(); + + // Configure messages + switch (fd.getType()) { + case MESSAGE: + classMap.put(fieldNumber, fd.getField().getType()); + break; + case MESSAGE_LIST: + classMap.put(fieldNumber, fd.getListElementType()); + break; + case GROUP: + classMap.put(fieldNumber, fd.getField().getType()); + break; + case GROUP_LIST: + classMap.put(fieldNumber, fd.getListElementType()); + break; + default: + break; + } + } + return classMap; + } + + /** Helper method for creating a new builder for {@link MessageInfo}. */ + public static Builder newBuilder() { + return new Builder(); + } + + /** Helper method for creating a new builder for {@link MessageInfo}. */ + public static Builder newBuilder(int numFields) { + return new Builder(numFields); + } + + /** A builder of {@link MessageInfo} instances. */ + public static final class Builder { + private final ArrayList fields; + private ProtoSyntax syntax; + private boolean wasBuilt; + private boolean messageSetWireFormat; + + public Builder() { + fields = new ArrayList(); + } + + public Builder(int numFields) { + fields = new ArrayList(numFields); + } + + public void withSyntax(ProtoSyntax syntax) { + this.syntax = checkNotNull(syntax, "syntax"); + } + + public void withMessageSetWireFormat(boolean messageSetWireFormat) { + this.messageSetWireFormat = messageSetWireFormat; + } + + public void add(FieldInfo field) { + if (wasBuilt) { + throw new IllegalStateException("Builder can only build once"); + } + fields.add(field); + } + + public MessageInfo build() { + if (wasBuilt) { + throw new IllegalStateException("Builder can only build once"); + } + if (syntax == null) { + throw new IllegalStateException("Must specify a proto syntax"); + } + wasBuilt = true; + Collections.sort(fields); + return new MessageInfo(syntax, messageSetWireFormat, Collections.unmodifiableList(fields)); + } + } +} diff --git a/java/core/src/main/java/com/google/protobuf/MessageInfoFactory.java b/java/core/src/main/java/com/google/protobuf/MessageInfoFactory.java new file mode 100644 index 00000000..c17f8ec4 --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/MessageInfoFactory.java @@ -0,0 +1,38 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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; + +/** A factory that creates {@link MessageInfo} instances for message types. */ +@ExperimentalApi +public interface MessageInfoFactory { + /** Returns a information of the message class. */ + MessageInfo messageInfoFor(Class clazz); +} diff --git a/java/core/src/main/java/com/google/protobuf/Proto2LiteLookupSchema.java b/java/core/src/main/java/com/google/protobuf/Proto2LiteLookupSchema.java new file mode 100644 index 00000000..959abc5f --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/Proto2LiteLookupSchema.java @@ -0,0 +1,281 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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 static com.google.protobuf.Proto2Manifest.offset; +import static com.google.protobuf.Proto2Manifest.type; + +import java.io.IOException; + +/** + * A generic, lookup-based schema that can be used with any proto3-lite message class. The message + * class must extend {@link GeneratedMessage}. + */ +final class Proto2LiteLookupSchema extends AbstractProto2LiteSchema { + private final Int2ObjectHashMap> messageFieldClassMap; + + Proto2LiteLookupSchema(Class messageClass, MessageInfo msgInfo) { + super(messageClass, Proto2Manifest.newLookupManifest(msgInfo)); + this.messageFieldClassMap = msgInfo.messageFieldClassMap(); + } + + @Override + public void mergeFrom(T message, Reader reader) throws IOException { + while (true) { + final int fieldNumber = reader.getFieldNumber(); + final long pos = manifest.lookupPositionForFieldNumber(fieldNumber); + if (pos >= 0L) { + final int typeAndOffset = manifest.typeAndOffsetAt(pos); + try { + switch (type(typeAndOffset)) { + case 0: //DOUBLE: + UnsafeUtil.putDouble(message, offset(typeAndOffset), reader.readDouble()); + manifest.setFieldPresent(message, pos); + continue; + case 1: //FLOAT: + UnsafeUtil.putFloat(message, offset(typeAndOffset), reader.readFloat()); + manifest.setFieldPresent(message, pos); + continue; + case 2: //INT64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readInt64()); + manifest.setFieldPresent(message, pos); + continue; + case 3: //UINT64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readUInt64()); + manifest.setFieldPresent(message, pos); + continue; + case 4: //INT32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readInt32()); + manifest.setFieldPresent(message, pos); + continue; + case 5: //FIXED64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readFixed64()); + manifest.setFieldPresent(message, pos); + continue; + case 6: //FIXED32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readFixed32()); + manifest.setFieldPresent(message, pos); + continue; + case 7: //BOOL: + UnsafeUtil.putBoolean(message, offset(typeAndOffset), reader.readBool()); + manifest.setFieldPresent(message, pos); + continue; + case 8: //STRING: + UnsafeUtil.putObject(message, offset(typeAndOffset), reader.readString()); + manifest.setFieldPresent(message, pos); + continue; + case 9: //MESSAGE: + UnsafeUtil.putObject( + message, + offset(typeAndOffset), + reader.readMessage(messageFieldClassMap.get(fieldNumber))); + manifest.setFieldPresent(message, pos); + continue; + case 10: //BYTES: + UnsafeUtil.putObject(message, offset(typeAndOffset), reader.readBytes()); + manifest.setFieldPresent(message, pos); + continue; + case 11: //UINT32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readUInt32()); + manifest.setFieldPresent(message, pos); + continue; + case 12: //ENUM: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readEnum()); + manifest.setFieldPresent(message, pos); + continue; + case 13: //SFIXED32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readSFixed32()); + manifest.setFieldPresent(message, pos); + continue; + case 14: //SFIXED64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readSFixed64()); + manifest.setFieldPresent(message, pos); + continue; + case 15: //SINT32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readSInt32()); + manifest.setFieldPresent(message, pos); + continue; + case 16: //SINT64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readSInt64()); + manifest.setFieldPresent(message, pos); + continue; + case 17: //DOUBLE_LIST: + reader.readDoubleList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 18: //FLOAT_LIST: + reader.readFloatList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 19: //INT64_LIST: + reader.readInt64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 20: //UINT64_LIST: + reader.readUInt64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 21: //INT32_LIST: + reader.readInt32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 22: //FIXED64_LIST: + reader.readFixed64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 23: //FIXED32_LIST: + reader.readFixed32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 24: //BOOL_LIST: + reader.readBoolList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 25: //STRING_LIST: + reader.readStringList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 26: //MESSAGE_LIST: + SchemaUtil.readProtobufMessageList( + message, offset(typeAndOffset), reader, messageFieldClassMap.get(fieldNumber)); + continue; + case 27: //BYTES_LIST: + reader.readBytesList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 28: //UINT32_LIST: + reader.readUInt32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 29: //ENUM_LIST: + reader.readEnumList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 30: //SFIXED32_LIST: + reader.readSFixed32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 31: //SFIXED64_LIST: + reader.readSFixed64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 32: //SINT32_LIST: + reader.readSInt32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 33: //SINT64_LIST: + reader.readSInt64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 34: //DOUBLE_LIST_PACKED: + reader.readDoubleList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 35: //FLOAT_LIST_PACKED: + reader.readFloatList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 36: //INT64_LIST_PACKED: + reader.readInt64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 37: //UINT64_LIST_PACKED: + reader.readUInt64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 38: //INT32_LIST_PACKED: + reader.readInt32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 39: //FIXED64_LIST_PACKED: + reader.readFixed64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 40: //FIXED32_LIST_PACKED: + reader.readFixed32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 41: //BOOL_LIST_PACKED: + reader.readBoolList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 42: //UINT32_LIST_PACKED: + reader.readUInt32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 43: //ENUM_LIST_PACKED: + reader.readEnumList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 44: //SFIXED32_LIST_PACKED: + reader.readSFixed32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 45: //SFIXED64_LIST_PACKED: + reader.readSFixed64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 46: //SINT32_LIST_PACKED: + reader.readSInt32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 47: //SINT64_LIST_PACKED: + reader.readSInt64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case -4: //GROUP (actually should be 252, but byte is [-128, 127]) + UnsafeUtil.putObject( + message, + offset(typeAndOffset), + reader.readGroup(messageFieldClassMap.get(fieldNumber))); + manifest.setFieldPresent(message, pos); + break; + case -3: //GROUP_LIST (actually should be 253, but byte is [-128, 127]) + SchemaUtil.readGroupList( + message, offset(typeAndOffset), reader, messageFieldClassMap.get(fieldNumber)); + break; + default: + // Unknown field type - break out of loop and skip the field. + break; + } + } catch (InvalidProtocolBufferException.InvalidWireTypeException e) { + // Treat it as an unknown field - same as the default case. + } + } + + // Unknown field. + if (!reader.skipField()) { + // Done reading. + return; + } + } + } +} diff --git a/java/core/src/main/java/com/google/protobuf/Proto2LiteTableSchema.java b/java/core/src/main/java/com/google/protobuf/Proto2LiteTableSchema.java new file mode 100644 index 00000000..5d60986a --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/Proto2LiteTableSchema.java @@ -0,0 +1,291 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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 static com.google.protobuf.Proto2Manifest.offset; +import static com.google.protobuf.Proto2Manifest.type; + +import java.io.IOException; + +/** + * A generic, table-based schema that can be used with any proto3 lite message class. The message + * class must extend {@link GeneratedMessage}. + */ +final class Proto2LiteTableSchema extends AbstractProto2LiteSchema { + private final Int2ObjectHashMap> messageFieldClassMap; + + Proto2LiteTableSchema(Class messageClass, MessageInfo descriptor) { + super(messageClass, Proto2Manifest.newTableManfiest(descriptor)); + this.messageFieldClassMap = descriptor.messageFieldClassMap(); + } + + @Override + public void mergeFrom(T message, Reader reader) throws IOException { + while (true) { + final int fieldNumber = reader.getFieldNumber(); + final long pos = manifest.tablePositionForFieldNumber(fieldNumber); + if (pos < 0) { + // Unknown field. + if (reader.skipField()) { + continue; + } + // Done reading. + return; + } + final int typeAndOffset = manifest.typeAndOffsetAt(pos); + + // Benchmarks have shown that switching on a byte is faster than an enum. + try { + switch (type(typeAndOffset)) { + case 0: //DOUBLE: + UnsafeUtil.putDouble(message, offset(typeAndOffset), reader.readDouble()); + manifest.setFieldPresent(message, pos); + break; + case 1: //FLOAT: + UnsafeUtil.putFloat(message, offset(typeAndOffset), reader.readFloat()); + manifest.setFieldPresent(message, pos); + break; + case 2: //INT64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readInt64()); + manifest.setFieldPresent(message, pos); + break; + case 3: //UINT64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readUInt64()); + manifest.setFieldPresent(message, pos); + break; + case 4: //INT32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readInt32()); + manifest.setFieldPresent(message, pos); + break; + case 5: //FIXED64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readFixed64()); + manifest.setFieldPresent(message, pos); + break; + case 6: //FIXED32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readFixed32()); + manifest.setFieldPresent(message, pos); + break; + case 7: //BOOL: + UnsafeUtil.putBoolean(message, offset(typeAndOffset), reader.readBool()); + manifest.setFieldPresent(message, pos); + break; + case 8: //STRING: + UnsafeUtil.putObject(message, offset(typeAndOffset), reader.readString()); + manifest.setFieldPresent(message, pos); + break; + case 9: //MESSAGE: + UnsafeUtil.putObject( + message, + offset(typeAndOffset), + reader.readMessage(messageFieldClassMap.get(fieldNumber))); + manifest.setFieldPresent(message, pos); + break; + case 10: //BYTES: + UnsafeUtil.putObject(message, offset(typeAndOffset), reader.readBytes()); + manifest.setFieldPresent(message, pos); + break; + case 11: //UINT32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readUInt32()); + manifest.setFieldPresent(message, pos); + break; + case 12: //ENUM: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readEnum()); + manifest.setFieldPresent(message, pos); + break; + case 13: //SFIXED32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readSFixed32()); + manifest.setFieldPresent(message, pos); + break; + case 14: //SFIXED64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readSFixed64()); + manifest.setFieldPresent(message, pos); + break; + case 15: //SINT32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readSInt32()); + manifest.setFieldPresent(message, pos); + break; + case 16: //SINT64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readSInt64()); + manifest.setFieldPresent(message, pos); + break; + case 17: //DOUBLE_LIST: + reader.readDoubleList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 18: //FLOAT_LIST: + reader.readFloatList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 19: //INT64_LIST: + reader.readInt64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 20: //UINT64_LIST: + reader.readUInt64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 21: //INT32_LIST: + reader.readInt32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 22: //FIXED64_LIST: + reader.readFixed64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 23: //FIXED32_LIST: + reader.readFixed32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 24: //BOOL_LIST: + reader.readBoolList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 25: //STRING_LIST: + reader.readStringList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 26: //MESSAGE_LIST: + SchemaUtil.readProtobufMessageList( + message, offset(typeAndOffset), reader, messageFieldClassMap.get(fieldNumber)); + break; + case 27: //BYTES_LIST: + reader.readBytesList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 28: //UINT32_LIST: + reader.readUInt32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 29: //ENUM_LIST: + reader.readEnumList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 30: //SFIXED32_LIST: + reader.readSFixed32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 31: //SFIXED64_LIST: + reader.readSFixed64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 32: //SINT32_LIST: + reader.readSInt32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 33: //SINT64_LIST: + reader.readSInt64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 34: //DOUBLE_LIST_PACKED: + reader.readDoubleList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 35: //FLOAT_LIST_PACKED: + reader.readFloatList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 36: //INT64_LIST_PACKED: + reader.readInt64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 37: //UINT64_LIST_PACKED: + reader.readUInt64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 38: //INT32_LIST_PACKED: + reader.readInt32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 39: //FIXED64_LIST_PACKED: + reader.readFixed64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 40: //FIXED32_LIST_PACKED: + reader.readFixed32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 41: //BOOL_LIST_PACKED: + reader.readBoolList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 42: //UINT32_LIST_PACKED: + reader.readUInt32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 43: //ENUM_LIST_PACKED: + reader.readEnumList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 44: //SFIXED32_LIST_PACKED: + reader.readSFixed32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 45: //SFIXED64_LIST_PACKED: + reader.readSFixed64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 46: //SINT32_LIST_PACKED: + reader.readSInt32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 47: //SINT64_LIST_PACKED: + reader.readSInt64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case -4: //GROUP (actually should be 252, but byte is [-128, 127]) + UnsafeUtil.putObject( + message, + offset(typeAndOffset), + reader.readGroup(messageFieldClassMap.get(fieldNumber))); + manifest.setFieldPresent(message, pos); + break; + case -3: //GROUP_LIST (actually should be 253, but byte is [-128, 127]) + SchemaUtil.readGroupList( + message, offset(typeAndOffset), reader, messageFieldClassMap.get(fieldNumber)); + break; + default: + // Assume we've landed on an empty entry. Treat it as an unknown field - just skip it. + if (!reader.skipField()) { + // Done reading. + return; + } + break; + } + // TODO(nathanmittler): Do we need to make lists immutable? + } catch (InvalidProtocolBufferException.InvalidWireTypeException e) { + // Treat fields with an invalid wire type as unknown fields (i.e. same as the default case). + if (!reader.skipField()) { + return; + } + } + } + } +} diff --git a/java/core/src/main/java/com/google/protobuf/Proto2LookupSchema.java b/java/core/src/main/java/com/google/protobuf/Proto2LookupSchema.java new file mode 100644 index 00000000..adab1c2c --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/Proto2LookupSchema.java @@ -0,0 +1,273 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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 static com.google.protobuf.Proto2Manifest.offset; +import static com.google.protobuf.Proto2Manifest.type; + +import java.io.IOException; + +/** + * A generic, lookup-based schema that can be used with any standard (i.e. non-lite) proto3 message + * class. The message class must extend {@link GeneratedMessage}. + */ +final class Proto2LookupSchema extends AbstractProto2StandardSchema { + private final Int2ObjectHashMap> messageFieldClassMap; + + Proto2LookupSchema(Class messageClass, MessageInfo descriptor) { + super(messageClass, Proto2Manifest.newLookupManifest(descriptor)); + this.messageFieldClassMap = descriptor.messageFieldClassMap(); + } + + @Override + public void mergeFrom(T message, Reader reader) throws IOException { + while (true) { + final int fieldNumber = reader.getFieldNumber(); + final long pos = manifest.lookupPositionForFieldNumber(fieldNumber); + if (pos >= 0L) { + final int typeAndOffset = manifest.typeAndOffsetAt(pos); + try { + switch (type(typeAndOffset)) { + case 0: //DOUBLE: + UnsafeUtil.putDouble(message, offset(typeAndOffset), reader.readDouble()); + manifest.setFieldPresent(message, pos); + continue; + case 1: //FLOAT: + UnsafeUtil.putFloat(message, offset(typeAndOffset), reader.readFloat()); + manifest.setFieldPresent(message, pos); + continue; + case 2: //INT64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readInt64()); + manifest.setFieldPresent(message, pos); + continue; + case 3: //UINT64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readUInt64()); + manifest.setFieldPresent(message, pos); + continue; + case 4: //INT32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readInt32()); + manifest.setFieldPresent(message, pos); + continue; + case 5: //FIXED64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readFixed64()); + manifest.setFieldPresent(message, pos); + continue; + case 6: //FIXED32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readFixed32()); + manifest.setFieldPresent(message, pos); + continue; + case 7: //BOOL: + UnsafeUtil.putBoolean(message, offset(typeAndOffset), reader.readBool()); + manifest.setFieldPresent(message, pos); + continue; + case 8: //STRING: + UnsafeUtil.putObject(message, offset(typeAndOffset), reader.readString()); + manifest.setFieldPresent(message, pos); + continue; + case 9: //MESSAGE: + UnsafeUtil.putObject( + message, + offset(typeAndOffset), + reader.readMessage(messageFieldClassMap.get(fieldNumber))); + manifest.setFieldPresent(message, pos); + continue; + case 10: //BYTES: + UnsafeUtil.putObject(message, offset(typeAndOffset), reader.readBytes()); + manifest.setFieldPresent(message, pos); + continue; + case 11: //UINT32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readUInt32()); + manifest.setFieldPresent(message, pos); + continue; + case 12: //ENUM: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readEnum()); + manifest.setFieldPresent(message, pos); + continue; + case 13: //SFIXED32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readSFixed32()); + manifest.setFieldPresent(message, pos); + continue; + case 14: //SFIXED64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readSFixed64()); + manifest.setFieldPresent(message, pos); + continue; + case 15: //SINT32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readSInt32()); + manifest.setFieldPresent(message, pos); + continue; + case 16: //SINT64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readSInt64()); + manifest.setFieldPresent(message, pos); + continue; + case 17: //DOUBLE_LIST: + reader.readDoubleList( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 18: //FLOAT_LIST: + reader.readFloatList(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 19: //INT64_LIST: + reader.readInt64List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 20: //UINT64_LIST: + reader.readUInt64List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 21: //INT32_LIST: + reader.readInt32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 22: //FIXED64_LIST: + reader.readFixed64List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 23: //FIXED32_LIST: + reader.readFixed32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 24: //BOOL_LIST: + reader.readBoolList( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 25: //STRING_LIST: + reader.readStringList( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 26: //MESSAGE_LIST: + SchemaUtil.readMessageList( + message, offset(typeAndOffset), reader, messageFieldClassMap.get(fieldNumber)); + continue; + case 27: //BYTES_LIST: + reader.readBytesList( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 28: //UINT32_LIST: + reader.readUInt32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 29: //ENUM_LIST: + reader.readEnumList( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 30: //SFIXED32_LIST: + reader.readSFixed32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 31: //SFIXED64_LIST: + reader.readSFixed64List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 32: //SINT32_LIST: + reader.readSInt32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 33: //SINT64_LIST: + reader.readSInt64List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 34: //DOUBLE_LIST_PACKED: + reader.readDoubleList( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 35: //FLOAT_LIST_PACKED: + reader.readFloatList(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 36: //INT64_LIST_PACKED: + reader.readInt64List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 37: //UINT64_LIST_PACKED: + reader.readUInt64List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 38: //INT32_LIST_PACKED: + reader.readInt32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 39: //FIXED64_LIST_PACKED: + reader.readFixed64List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 40: //FIXED32_LIST_PACKED: + reader.readFixed32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 41: //BOOL_LIST_PACKED: + reader.readBoolList( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 42: //UINT32_LIST_PACKED: + reader.readUInt32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 43: //ENUM_LIST_PACKED: + reader.readEnumList( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 44: //SFIXED32_LIST_PACKED: + reader.readSFixed32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 45: //SFIXED64_LIST_PACKED: + reader.readSFixed64List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 46: //SINT32_LIST_PACKED: + reader.readSInt32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 47: //SINT64_LIST_PACKED: + reader.readSInt64List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case -4: //GROUP (actually should be 252, but byte is [-128, 127]) + UnsafeUtil.putObject( + message, + offset(typeAndOffset), + reader.readGroup(messageFieldClassMap.get(fieldNumber))); + manifest.setFieldPresent(message, pos); + continue; + case -3: //GROUP_LIST (actually should be 253, but byte is [-128, 127]) + SchemaUtil.readGroupList( + message, offset(typeAndOffset), reader, messageFieldClassMap.get(fieldNumber)); + continue; + default: + // Unknown field type - break out of loop and skip the field. + break; + } + } catch (InvalidProtocolBufferException.InvalidWireTypeException e) { + // Treat it as an unknown field - same as the default case. + } + } + + // Unknown field. + if (!reader.skipField()) { + // Done reading. + return; + } + } + } +} diff --git a/java/core/src/main/java/com/google/protobuf/Proto2Manifest.java b/java/core/src/main/java/com/google/protobuf/Proto2Manifest.java new file mode 100644 index 00000000..b6eed904 --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/Proto2Manifest.java @@ -0,0 +1,261 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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.nio.ByteBuffer; +import java.util.List; + +/** Container for the field metadata of a single proto2 schema. */ +final class Proto2Manifest { + static final int INT_LENGTH = 4; + static final int LONG_LENGTH = INT_LENGTH * 2; + static final int LONGS_PER_FIELD = 2; + /** + * Note that field length is always a power of two so that we can use bit shifting (rather than + * division) to find the location of a field when parsing. + */ + static final int FIELD_LENGTH = LONGS_PER_FIELD * LONG_LENGTH; + + static final int FIELD_SHIFT = 4 /* 2^4 = 16 */; + static final int OFFSET_BITS = 20; + static final int OFFSET_MASK = 0XFFFFF; + static final long EMPTY_LONG = 0xFFFFFFFFFFFFFFFFL; + + /** + * Holds all information for accessing the message fields. The layout is as follows (field + * positions are relative to the offset of the start of the field in the buffer): + * + *

+ * + * 

+   * [ 0 -   3] unused
+   * [ 4 -  31] field number
+   * [32 -  37] unused
+   * [38 -  43] field type
+   * [44 -  63] field offset
+   * [64 -  69] unused
+   * [70 -  75] field presence mask shift
+   * [76 -  95] presence field offset
+   * [96 - 127] unused
+   *
+ */ + final ByteBuffer buffer; + + final long address; + final long limit; + final int numFields; + + final int minFieldNumber; + final int maxFieldNumber; + + private Proto2Manifest( + ByteBuffer buffer, + long address, + long limit, + int numFields, + int minFieldNumber, + int maxFieldNumber) { + this.buffer = buffer; + this.address = address; + this.limit = limit; + this.numFields = numFields; + this.minFieldNumber = minFieldNumber; + this.maxFieldNumber = maxFieldNumber; + } + + boolean isFieldInRange(int fieldNumber) { + return fieldNumber >= minFieldNumber && fieldNumber <= maxFieldNumber; + } + + long tablePositionForFieldNumber(int fieldNumber) { + if (fieldNumber < minFieldNumber || fieldNumber > maxFieldNumber) { + return -1; + } + + return indexToAddress(fieldNumber - minFieldNumber); + } + + boolean isFieldPresent(T message, long pos) { + int maskShiftAndOffset = UnsafeUtil.getInt(pos + LONG_LENGTH); + long offset = maskShiftAndOffset & OFFSET_MASK; + int mask = 1 << (maskShiftAndOffset >>> OFFSET_BITS); + return (UnsafeUtil.getInt(message, offset) & mask) != 0; + } + + void setFieldPresent(T message, long pos) { + int maskShiftAndOffset = UnsafeUtil.getInt(pos + LONG_LENGTH); + long offset = maskShiftAndOffset & OFFSET_MASK; + int mask = 1 << (maskShiftAndOffset >>> OFFSET_BITS); + UnsafeUtil.putInt(message, offset, UnsafeUtil.getInt(message, offset) | mask); + } + + long lookupPositionForFieldNumber(int fieldNumber) { + int min = 0; + int max = numFields - 1; + while (min <= max) { + // Find the midpoint address. + int mid = (max + min) >>> 1; + long midAddress = indexToAddress(mid); + int midFieldNumber = numberAt(midAddress); + if (fieldNumber == midFieldNumber) { + // Found the field. + return midAddress; + } + if (fieldNumber < midFieldNumber) { + // Search the lower half. + max = mid - 1; + } else { + // Search the upper half. + min = mid + 1; + } + } + return -1; + } + + int numberAt(long pos) { + return UnsafeUtil.getInt(pos); + } + + int typeAndOffsetAt(long pos) { + return UnsafeUtil.getInt(pos + INT_LENGTH); + } + + private long indexToAddress(int index) { + return address + (index << FIELD_SHIFT); + } + + static byte type(int value) { + return (byte) (value >>> OFFSET_BITS); + } + + static long offset(int value) { + return value & OFFSET_MASK; + } + + static Proto2Manifest newTableManfiest(MessageInfo descriptor) { + List fds = descriptor.getFields(); + if (fds.isEmpty()) { + throw new IllegalArgumentException("Table-based schema requires at least one field"); + } + + // Set up the buffer for direct indexing by field number. + final int minFieldNumber = fds.get(0).getFieldNumber(); + final int maxFieldNumber = fds.get(fds.size() - 1).getFieldNumber(); + final int numEntries = (maxFieldNumber - minFieldNumber) + 1; + + int bufferLength = numEntries * FIELD_LENGTH; + ByteBuffer buffer = ByteBuffer.allocateDirect(bufferLength + LONG_LENGTH); + long tempAddress = UnsafeUtil.addressOffset(buffer); + if ((tempAddress & 7L) != 0) { + // Make sure that the memory address is 8-byte aligned. + tempAddress = (tempAddress & ~7L) + LONG_LENGTH; + } + final long address = tempAddress; + final long limit = address + bufferLength; + + // Fill in the manifest data from the descriptors. + int fieldIndex = 0; + FieldInfo fd = fds.get(fieldIndex++); + for (int bufferIndex = 0; bufferIndex < bufferLength; bufferIndex += FIELD_LENGTH) { + final int fieldNumber = fd.getFieldNumber(); + if (bufferIndex < ((fieldNumber - minFieldNumber) << FIELD_SHIFT)) { + // Mark this entry as "empty". + long skipLimit = address + bufferIndex + FIELD_LENGTH; + for (long skipPos = address + bufferIndex; skipPos < skipLimit; skipPos += LONG_LENGTH) { + UnsafeUtil.putLong(skipPos, EMPTY_LONG); + } + continue; + } + + // We found the entry for the next field. Store the entry in the manifest for + // this field and increment the field index. + FieldType type = fd.getType(); + long pos = address + bufferIndex; + UnsafeUtil.putInt(pos, fieldNumber); + UnsafeUtil.putInt( + pos + INT_LENGTH, + (type.id() << OFFSET_BITS) | (int) UnsafeUtil.objectFieldOffset(fd.getField())); + if (!type.isList()) { + int presenceOffset = (int) UnsafeUtil.objectFieldOffset(fd.getPresenceField()); + int maskShift = Integer.numberOfTrailingZeros(fd.getPresenceMask()); + UnsafeUtil.putInt(pos + LONG_LENGTH, maskShift << OFFSET_BITS | presenceOffset); + } + + // Advance to the next field, unless we're at the end. + if (fieldIndex < fds.size()) { + fd = fds.get(fieldIndex++); + } + } + + return new Proto2Manifest(buffer, address, limit, fds.size(), minFieldNumber, maxFieldNumber); + } + + static Proto2Manifest newLookupManifest(MessageInfo descriptor) { + List fds = descriptor.getFields(); + + final int numFields = fds.size(); + int bufferLength = numFields * FIELD_LENGTH; + final ByteBuffer buffer = ByteBuffer.allocateDirect(bufferLength + LONG_LENGTH); + long tempAddress = UnsafeUtil.addressOffset(buffer); + if ((tempAddress & 7L) != 0) { + // Make sure that the memory address is 8-byte aligned. + tempAddress = (tempAddress & ~7L) + LONG_LENGTH; + } + final long address = tempAddress; + final long limit = address + bufferLength; + + // Allocate and populate the data buffer. + long pos = address; + for (int i = 0; i < fds.size(); ++i, pos += FIELD_LENGTH) { + FieldInfo fd = fds.get(i); + UnsafeUtil.putInt(pos, fd.getFieldNumber()); + UnsafeUtil.putInt( + pos + INT_LENGTH, + (fd.getType().id() << OFFSET_BITS) | (int) UnsafeUtil.objectFieldOffset(fd.getField())); + if (!fd.getType().isList()) { + int presenceOffset = (int) UnsafeUtil.objectFieldOffset(fd.getPresenceField()); + int maskShift = Integer.numberOfTrailingZeros(fd.getPresenceMask()); + UnsafeUtil.putInt(pos + LONG_LENGTH, maskShift << OFFSET_BITS | presenceOffset); + } + } + + if (numFields > 0) { + return new Proto2Manifest( + buffer, + address, + limit, + numFields, + fds.get(0).getFieldNumber(), + fds.get(numFields - 1).getFieldNumber()); + } + return new Proto2Manifest(buffer, address, limit, numFields, -1, -1); + } +} diff --git a/java/core/src/main/java/com/google/protobuf/Proto2SchemaFactory.java b/java/core/src/main/java/com/google/protobuf/Proto2SchemaFactory.java new file mode 100644 index 00000000..e686cbd7 --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/Proto2SchemaFactory.java @@ -0,0 +1,112 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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 static com.google.protobuf.Internal.checkNotNull; + +/** Manufactures instances of {@link Proto3TableSchema}. */ +@ExperimentalApi +public final class Proto2SchemaFactory implements SchemaFactory { + /** + * The mode with which to generate schemas. + * + *

For testing purposes only. + */ + public enum Mode { + /** Always use a table-based indexing of fields. */ + TABLE, + + /** Always used lookup-based (i.e. binary search) indexing of fields. */ + LOOKUP, + + /** + * Default. Determine the appropriate field indexing mode based on how sparse the field numbers + * are for the message. + */ + DYNAMIC + } + + private final MessageInfoFactory messageDescriptorFactory; + private final Mode mode; + + public Proto2SchemaFactory() { + this(DescriptorMessageInfoFactory.getInstance()); + } + + public Proto2SchemaFactory(MessageInfoFactory messageDescriptorFactory) { + this(messageDescriptorFactory, Mode.DYNAMIC); + } + + /** For testing purposes only. Allows specification of {@link Mode}. */ + public Proto2SchemaFactory(MessageInfoFactory messageDescriptorFactory, Mode mode) { + if (!isSupported()) { + throw new IllegalStateException("Schema factory is unsupported on this platform"); + } + this.messageDescriptorFactory = + checkNotNull(messageDescriptorFactory, "messageDescriptorFactory"); + this.mode = checkNotNull(mode, "mode"); + } + + public static boolean isSupported() { + return UnsafeUtil.hasUnsafeArrayOperations() && UnsafeUtil.hasUnsafeByteBufferOperations(); + } + + @Override + public Schema createSchema(Class messageType) { + SchemaUtil.requireGeneratedMessage(messageType); + + MessageInfo descriptor = messageDescriptorFactory.messageInfoFor(messageType); + switch (mode) { + case TABLE: + return newTableSchema(messageType, descriptor); + case LOOKUP: + return newLookupSchema(messageType, descriptor); + default: + return SchemaUtil.shouldUseTableSwitch(descriptor.getFields()) + ? newTableSchema(messageType, descriptor) + : newLookupSchema(messageType, descriptor); + } + } + + private Schema newTableSchema(Class messageType, MessageInfo descriptor) { + if (GeneratedMessageLite.class.isAssignableFrom(messageType)) { + return new Proto2LiteTableSchema(messageType, descriptor); + } + return new Proto2TableSchema(messageType, descriptor); + } + + private Schema newLookupSchema(Class messageType, MessageInfo descriptor) { + if (GeneratedMessageLite.class.isAssignableFrom(messageType)) { + return new Proto2LiteLookupSchema(messageType, descriptor); + } + return new Proto2LookupSchema(messageType, descriptor); + } +} diff --git a/java/core/src/main/java/com/google/protobuf/Proto2TableSchema.java b/java/core/src/main/java/com/google/protobuf/Proto2TableSchema.java new file mode 100644 index 00000000..24571462 --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/Proto2TableSchema.java @@ -0,0 +1,270 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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 static com.google.protobuf.Proto2Manifest.offset; +import static com.google.protobuf.Proto2Manifest.type; + +import java.io.IOException; + +/** + * A generic, table-based schema that can be used with any proto2 message class. The message class + * must extend {@link GeneratedMessage}. + */ +final class Proto2TableSchema extends AbstractProto2StandardSchema { + private final Int2ObjectHashMap> messageFieldClassMap; + + Proto2TableSchema(Class messageClass, MessageInfo descriptor) { + super(messageClass, Proto2Manifest.newTableManfiest(descriptor)); + this.messageFieldClassMap = descriptor.messageFieldClassMap(); + } + + @Override + public void mergeFrom(T message, Reader reader) throws IOException { + while (true) { + final int fieldNumber = reader.getFieldNumber(); + final long pos = manifest.tablePositionForFieldNumber(fieldNumber); + if (pos < 0) { + // Unknown field. + if (reader.skipField()) { + continue; + } + // Done reading. + return; + } + final int typeAndOffset = manifest.typeAndOffsetAt(pos); + + // Benchmarks have shown that switching on a byte is faster than an enum. + try { + switch (type(typeAndOffset)) { + case 0: //DOUBLE: + UnsafeUtil.putDouble(message, offset(typeAndOffset), reader.readDouble()); + manifest.setFieldPresent(message, pos); + break; + case 1: //FLOAT: + UnsafeUtil.putFloat(message, offset(typeAndOffset), reader.readFloat()); + manifest.setFieldPresent(message, pos); + break; + case 2: //INT64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readInt64()); + manifest.setFieldPresent(message, pos); + break; + case 3: //UINT64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readUInt64()); + manifest.setFieldPresent(message, pos); + break; + case 4: //INT32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readInt32()); + manifest.setFieldPresent(message, pos); + break; + case 5: //FIXED64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readFixed64()); + manifest.setFieldPresent(message, pos); + break; + case 6: //FIXED32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readFixed32()); + manifest.setFieldPresent(message, pos); + break; + case 7: //BOOL: + UnsafeUtil.putBoolean(message, offset(typeAndOffset), reader.readBool()); + manifest.setFieldPresent(message, pos); + break; + case 8: //STRING: + UnsafeUtil.putObject(message, offset(typeAndOffset), reader.readString()); + manifest.setFieldPresent(message, pos); + break; + case 9: //MESSAGE: + UnsafeUtil.putObject( + message, + offset(typeAndOffset), + reader.readMessage(messageFieldClassMap.get(fieldNumber))); + manifest.setFieldPresent(message, pos); + break; + case 10: //BYTES: + UnsafeUtil.putObject(message, offset(typeAndOffset), reader.readBytes()); + manifest.setFieldPresent(message, pos); + break; + case 11: //UINT32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readUInt32()); + manifest.setFieldPresent(message, pos); + break; + case 12: //ENUM: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readEnum()); + manifest.setFieldPresent(message, pos); + break; + case 13: //SFIXED32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readSFixed32()); + manifest.setFieldPresent(message, pos); + break; + case 14: //SFIXED64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readSFixed64()); + manifest.setFieldPresent(message, pos); + break; + case 15: //SINT32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readSInt32()); + manifest.setFieldPresent(message, pos); + break; + case 16: //SINT64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readSInt64()); + manifest.setFieldPresent(message, pos); + break; + case 17: //DOUBLE_LIST: + reader.readDoubleList(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 18: //FLOAT_LIST: + reader.readFloatList(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 19: //INT64_LIST: + reader.readInt64List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 20: //UINT64_LIST: + reader.readUInt64List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 21: //INT32_LIST: + reader.readInt32List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 22: //FIXED64_LIST: + reader.readFixed64List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 23: //FIXED32_LIST: + reader.readFixed32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 24: //BOOL_LIST: + reader.readBoolList(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 25: //STRING_LIST: + reader.readStringList(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 26: //MESSAGE_LIST: + SchemaUtil.readMessageList( + message, offset(typeAndOffset), reader, messageFieldClassMap.get(fieldNumber)); + break; + case 27: //BYTES_LIST: + reader.readBytesList( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 28: //UINT32_LIST: + reader.readUInt32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 29: //ENUM_LIST: + reader.readEnumList(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 30: //SFIXED32_LIST: + reader.readSFixed32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 31: //SFIXED64_LIST: + reader.readSFixed64List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 32: //SINT32_LIST: + reader.readSInt32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 33: //SINT64_LIST: + reader.readSInt64List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 34: //DOUBLE_LIST_PACKED: + reader.readDoubleList(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 35: //FLOAT_LIST_PACKED: + reader.readFloatList(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 36: //INT64_LIST_PACKED: + reader.readInt64List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 37: //UINT64_LIST_PACKED: + reader.readUInt64List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 38: //INT32_LIST_PACKED: + reader.readInt32List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 39: //FIXED64_LIST_PACKED: + reader.readFixed64List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 40: //FIXED32_LIST_PACKED: + reader.readFixed32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 41: //BOOL_LIST_PACKED: + reader.readBoolList(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 42: //UINT32_LIST_PACKED: + reader.readUInt32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 43: //ENUM_LIST_PACKED: + reader.readEnumList(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 44: //SFIXED32_LIST_PACKED: + reader.readSFixed32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 45: //SFIXED64_LIST_PACKED: + reader.readSFixed64List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 46: //SINT32_LIST_PACKED: + reader.readSInt32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 47: //SINT64_LIST_PACKED: + reader.readSInt64List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case -4: //GROUP (actually should be 252, but byte is [-128, 127]) + UnsafeUtil.putObject( + message, + offset(typeAndOffset), + reader.readGroup(messageFieldClassMap.get(fieldNumber))); + manifest.setFieldPresent(message, pos); + break; + case -3: //GROUP_LIST (actually should be 253, but byte is [-128, 127]) + SchemaUtil.readGroupList( + message, offset(typeAndOffset), reader, messageFieldClassMap.get(fieldNumber)); + break; + default: + // Assume we've landed on an empty entry. Treat it as an unknown field - just skip it. + if (!reader.skipField()) { + // Done reading. + return; + } + break; + } + // TODO(nathanmittler): Do we need to make lists immutable? + } catch (InvalidProtocolBufferException.InvalidWireTypeException e) { + // Treat fields with an invalid wire type as unknown fields (i.e. same as the default case). + if (!reader.skipField()) { + return; + } + } + } + } +} diff --git a/java/core/src/main/java/com/google/protobuf/Proto3LiteLookupSchema.java b/java/core/src/main/java/com/google/protobuf/Proto3LiteLookupSchema.java new file mode 100644 index 00000000..b25c3f0d --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/Proto3LiteLookupSchema.java @@ -0,0 +1,253 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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 static com.google.protobuf.Proto3Manifest.offset; +import static com.google.protobuf.Proto3Manifest.type; + +import java.io.IOException; + +/** + * A generic, lookup-based schema that can be used with any proto3-lite message class. The message + * class must extend {@link GeneratedMessage}. + */ +final class Proto3LiteLookupSchema extends AbstractProto3LiteSchema { + private final Int2ObjectHashMap> messageFieldClassMap; + + Proto3LiteLookupSchema(Class messageClass, MessageInfo descriptor) { + super(messageClass, Proto3Manifest.newLookupManifest(descriptor)); + this.messageFieldClassMap = descriptor.messageFieldClassMap(); + } + + @Override + public void mergeFrom(T message, Reader reader) throws IOException { + while (true) { + final int fieldNumber = reader.getFieldNumber(); + final long pos = manifest.lookupPositionForFieldNumber(fieldNumber); + if (pos >= 0L) { + final int typeAndOffset = manifest.typeAndOffsetAt(pos); + try { + switch (type(typeAndOffset)) { + case 0: //DOUBLE: + UnsafeUtil.putDouble(message, offset(typeAndOffset), reader.readDouble()); + continue; + case 1: //FLOAT: + UnsafeUtil.putFloat(message, offset(typeAndOffset), reader.readFloat()); + continue; + case 2: //INT64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readInt64()); + continue; + case 3: //UINT64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readUInt64()); + continue; + case 4: //INT32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readInt32()); + continue; + case 5: //FIXED64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readFixed64()); + continue; + case 6: //FIXED32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readFixed32()); + continue; + case 7: //BOOL: + UnsafeUtil.putBoolean(message, offset(typeAndOffset), reader.readBool()); + continue; + case 8: //STRING: + UnsafeUtil.putObject(message, offset(typeAndOffset), reader.readString()); + continue; + case 9: //MESSAGE: + UnsafeUtil.putObject( + message, + offset(typeAndOffset), + reader.readMessage(messageFieldClassMap.get(fieldNumber))); + continue; + case 10: //BYTES: + UnsafeUtil.putObject(message, offset(typeAndOffset), reader.readBytes()); + continue; + case 11: //UINT32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readUInt32()); + continue; + case 12: //ENUM: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readEnum()); + continue; + case 13: //SFIXED32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readSFixed32()); + continue; + case 14: //SFIXED64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readSFixed64()); + continue; + case 15: //SINT32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readSInt32()); + continue; + case 16: //SINT64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readSInt64()); + continue; + case 17: //DOUBLE_LIST: + reader.readDoubleList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 18: //FLOAT_LIST: + reader.readFloatList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 19: //INT64_LIST: + reader.readInt64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 20: //UINT64_LIST: + reader.readUInt64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 21: //INT32_LIST: + reader.readInt32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 22: //FIXED64_LIST: + reader.readFixed64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 23: //FIXED32_LIST: + reader.readFixed32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 24: //BOOL_LIST: + reader.readBoolList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 25: //STRING_LIST: + reader.readStringList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 26: //MESSAGE_LIST: + SchemaUtil.readProtobufMessageList( + message, offset(typeAndOffset), reader, messageFieldClassMap.get(fieldNumber)); + continue; + case 27: //BYTES_LIST: + reader.readBytesList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 28: //UINT32_LIST: + reader.readUInt32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 29: //ENUM_LIST: + reader.readEnumList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 30: //SFIXED32_LIST: + reader.readSFixed32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 31: //SFIXED64_LIST: + reader.readSFixed64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 32: //SINT32_LIST: + reader.readSInt32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 33: //SINT64_LIST: + reader.readSInt64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 34: //DOUBLE_LIST_PACKED: + reader.readDoubleList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 35: //FLOAT_LIST_PACKED: + reader.readFloatList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 36: //INT64_LIST_PACKED: + reader.readInt64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 37: //UINT64_LIST_PACKED: + reader.readUInt64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 38: //INT32_LIST_PACKED: + reader.readInt32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 39: //FIXED64_LIST_PACKED: + reader.readFixed64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 40: //FIXED32_LIST_PACKED: + reader.readFixed32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 41: //BOOL_LIST_PACKED: + reader.readBoolList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 42: //UINT32_LIST_PACKED: + reader.readUInt32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 43: //ENUM_LIST_PACKED: + reader.readEnumList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 44: //SFIXED32_LIST_PACKED: + reader.readSFixed32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 45: //SFIXED64_LIST_PACKED: + reader.readSFixed64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 46: //SINT32_LIST_PACKED: + reader.readSInt32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + case 47: //SINT64_LIST_PACKED: + reader.readSInt64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + continue; + default: + // Unknown field type - break out of loop and skip the field. + break; + } + } catch (InvalidProtocolBufferException.InvalidWireTypeException e) { + // Treat it as an unknown field - same as the default case. + } + } + + // Unknown field. + if (!reader.skipField()) { + // Done reading. + return; + } + } + } +} diff --git a/java/core/src/main/java/com/google/protobuf/Proto3LiteTableSchema.java b/java/core/src/main/java/com/google/protobuf/Proto3LiteTableSchema.java new file mode 100644 index 00000000..46abeb71 --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/Proto3LiteTableSchema.java @@ -0,0 +1,263 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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 static com.google.protobuf.Proto3Manifest.offset; +import static com.google.protobuf.Proto3Manifest.type; + +import java.io.IOException; + +/** + * A generic, table-based schema that can be used with any proto3 lite message class. The message + * class must extend {@link GeneratedMessage}. + */ +final class Proto3LiteTableSchema extends AbstractProto3LiteSchema { + private final Int2ObjectHashMap> messageFieldClassMap; + + Proto3LiteTableSchema(Class messageClass, MessageInfo descriptor) { + super(messageClass, Proto3Manifest.newTableManfiest(descriptor)); + this.messageFieldClassMap = descriptor.messageFieldClassMap(); + } + + @Override + public void mergeFrom(T message, Reader reader) throws IOException { + while (true) { + final int fieldNumber = reader.getFieldNumber(); + final long pos = manifest.tablePositionForFieldNumber(fieldNumber); + if (pos < 0) { + // Unknown field. + if (reader.skipField()) { + continue; + } + // Done reading. + return; + } + final int typeAndOffset = manifest.typeAndOffsetAt(pos); + + // Benchmarks have shown that switching on a byte is faster than an enum. + try { + switch (type(typeAndOffset)) { + case 0: //DOUBLE: + UnsafeUtil.putDouble(message, offset(typeAndOffset), reader.readDouble()); + break; + case 1: //FLOAT: + UnsafeUtil.putFloat(message, offset(typeAndOffset), reader.readFloat()); + break; + case 2: //INT64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readInt64()); + break; + case 3: //UINT64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readUInt64()); + break; + case 4: //INT32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readInt32()); + break; + case 5: //FIXED64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readFixed64()); + break; + case 6: //FIXED32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readFixed32()); + break; + case 7: //BOOL: + UnsafeUtil.putBoolean(message, offset(typeAndOffset), reader.readBool()); + break; + case 8: //STRING: + UnsafeUtil.putObject(message, offset(typeAndOffset), reader.readString()); + break; + case 9: //MESSAGE: + UnsafeUtil.putObject( + message, + offset(typeAndOffset), + reader.readMessage(messageFieldClassMap.get(fieldNumber))); + break; + case 10: //BYTES: + UnsafeUtil.putObject(message, offset(typeAndOffset), reader.readBytes()); + break; + case 11: //UINT32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readUInt32()); + break; + case 12: //ENUM: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readEnum()); + break; + case 13: //SFIXED32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readSFixed32()); + break; + case 14: //SFIXED64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readSFixed64()); + break; + case 15: //SINT32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readSInt32()); + break; + case 16: //SINT64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readSInt64()); + break; + case 17: //DOUBLE_LIST: + reader.readDoubleList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 18: //FLOAT_LIST: + reader.readFloatList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 19: //INT64_LIST: + reader.readInt64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 20: //UINT64_LIST: + reader.readUInt64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 21: //INT32_LIST: + reader.readInt32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 22: //FIXED64_LIST: + reader.readFixed64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 23: //FIXED32_LIST: + reader.readFixed32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 24: //BOOL_LIST: + reader.readBoolList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 25: //STRING_LIST: + reader.readStringList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 26: //MESSAGE_LIST: + SchemaUtil.readProtobufMessageList( + message, offset(typeAndOffset), reader, messageFieldClassMap.get(fieldNumber)); + break; + case 27: //BYTES_LIST: + reader.readBytesList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 28: //UINT32_LIST: + reader.readUInt32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 29: //ENUM_LIST: + reader.readEnumList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 30: //SFIXED32_LIST: + reader.readSFixed32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 31: //SFIXED64_LIST: + reader.readSFixed64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 32: //SINT32_LIST: + reader.readSInt32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 33: //SINT64_LIST: + reader.readSInt64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 34: //DOUBLE_LIST_PACKED: + reader.readDoubleList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 35: //FLOAT_LIST_PACKED: + reader.readFloatList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 36: //INT64_LIST_PACKED: + reader.readInt64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 37: //UINT64_LIST_PACKED: + reader.readUInt64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 38: //INT32_LIST_PACKED: + reader.readInt32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 39: //FIXED64_LIST_PACKED: + reader.readFixed64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 40: //FIXED32_LIST_PACKED: + reader.readFixed32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 41: //BOOL_LIST_PACKED: + reader.readBoolList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 42: //UINT32_LIST_PACKED: + reader.readUInt32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 43: //ENUM_LIST_PACKED: + reader.readEnumList( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 44: //SFIXED32_LIST_PACKED: + reader.readSFixed32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 45: //SFIXED64_LIST_PACKED: + reader.readSFixed64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 46: //SINT32_LIST_PACKED: + reader.readSInt32List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + case 47: //SINT64_LIST_PACKED: + reader.readSInt64List( + SchemaUtil.mutableProtobufListAt(message, offset(typeAndOffset))); + break; + default: + // Assume we've landed on an empty entry. Treat it as an unknown field - just skip it. + if (!reader.skipField()) { + // Done reading. + return; + } + break; + } + // TODO(nathanmittler): Do we need to make lists immutable? + } catch (InvalidProtocolBufferException.InvalidWireTypeException e) { + // Treat fields with an invalid wire type as unknown fields (i.e. same as the default case). + if (!reader.skipField()) { + return; + } + } + } + } +} diff --git a/java/core/src/main/java/com/google/protobuf/Proto3LookupSchema.java b/java/core/src/main/java/com/google/protobuf/Proto3LookupSchema.java new file mode 100644 index 00000000..5e0f9c51 --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/Proto3LookupSchema.java @@ -0,0 +1,245 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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 static com.google.protobuf.Proto3Manifest.offset; +import static com.google.protobuf.Proto3Manifest.type; + +import java.io.IOException; + +/** + * A generic, lookup-based schema that can be used with any standard (i.e. non-lite) proto3 message + * class. The message class must extend {@link GeneratedMessage}. + */ +final class Proto3LookupSchema extends AbstractProto3StandardSchema { + private final Int2ObjectHashMap> messageFieldClassMap; + + Proto3LookupSchema(Class messageClass, MessageInfo descriptor) { + super(messageClass, Proto3Manifest.newTableManfiest(descriptor)); + this.messageFieldClassMap = descriptor.messageFieldClassMap(); + } + + @Override + public void mergeFrom(T message, Reader reader) throws IOException { + while (true) { + final int fieldNumber = reader.getFieldNumber(); + final long pos = manifest.lookupPositionForFieldNumber(fieldNumber); + if (pos >= 0L) { + final int typeAndOffset = manifest.typeAndOffsetAt(pos); + try { + switch (type(typeAndOffset)) { + case 0: //DOUBLE: + UnsafeUtil.putDouble(message, offset(typeAndOffset), reader.readDouble()); + continue; + case 1: //FLOAT: + UnsafeUtil.putFloat(message, offset(typeAndOffset), reader.readFloat()); + continue; + case 2: //INT64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readInt64()); + continue; + case 3: //UINT64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readUInt64()); + continue; + case 4: //INT32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readInt32()); + continue; + case 5: //FIXED64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readFixed64()); + continue; + case 6: //FIXED32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readFixed32()); + continue; + case 7: //BOOL: + UnsafeUtil.putBoolean(message, offset(typeAndOffset), reader.readBool()); + continue; + case 8: //STRING: + UnsafeUtil.putObject(message, offset(typeAndOffset), reader.readString()); + continue; + case 9: //MESSAGE: + UnsafeUtil.putObject( + message, + offset(typeAndOffset), + reader.readMessage(messageFieldClassMap.get(fieldNumber))); + continue; + case 10: //BYTES: + UnsafeUtil.putObject(message, offset(typeAndOffset), reader.readBytes()); + continue; + case 11: //UINT32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readUInt32()); + continue; + case 12: //ENUM: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readEnum()); + continue; + case 13: //SFIXED32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readSFixed32()); + continue; + case 14: //SFIXED64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readSFixed64()); + continue; + case 15: //SINT32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readSInt32()); + continue; + case 16: //SINT64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readSInt64()); + continue; + case 17: //DOUBLE_LIST: + reader.readDoubleList( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 18: //FLOAT_LIST: + reader.readFloatList(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 19: //INT64_LIST: + reader.readInt64List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 20: //UINT64_LIST: + reader.readUInt64List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 21: //INT32_LIST: + reader.readInt32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 22: //FIXED64_LIST: + reader.readFixed64List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 23: //FIXED32_LIST: + reader.readFixed32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 24: //BOOL_LIST: + reader.readBoolList( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 25: //STRING_LIST: + reader.readStringList( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 26: //MESSAGE_LIST: + SchemaUtil.readMessageList( + message, offset(typeAndOffset), reader, messageFieldClassMap.get(fieldNumber)); + continue; + case 27: //BYTES_LIST: + reader.readBytesList( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 28: //UINT32_LIST: + reader.readUInt32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 29: //ENUM_LIST: + reader.readEnumList( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 30: //SFIXED32_LIST: + reader.readSFixed32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 31: //SFIXED64_LIST: + reader.readSFixed64List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 32: //SINT32_LIST: + reader.readSInt32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 33: //SINT64_LIST: + reader.readSInt64List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 34: //DOUBLE_LIST_PACKED: + reader.readDoubleList( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 35: //FLOAT_LIST_PACKED: + reader.readFloatList(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 36: //INT64_LIST_PACKED: + reader.readInt64List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 37: //UINT64_LIST_PACKED: + reader.readUInt64List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 38: //INT32_LIST_PACKED: + reader.readInt32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 39: //FIXED64_LIST_PACKED: + reader.readFixed64List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 40: //FIXED32_LIST_PACKED: + reader.readFixed32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 41: //BOOL_LIST_PACKED: + reader.readBoolList( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 42: //UINT32_LIST_PACKED: + reader.readUInt32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 43: //ENUM_LIST_PACKED: + reader.readEnumList( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 44: //SFIXED32_LIST_PACKED: + reader.readSFixed32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 45: //SFIXED64_LIST_PACKED: + reader.readSFixed64List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 46: //SINT32_LIST_PACKED: + reader.readSInt32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + case 47: //SINT64_LIST_PACKED: + reader.readSInt64List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + continue; + default: + // Unknown field type - break out of loop and skip the field. + break; + } + } catch (InvalidProtocolBufferException.InvalidWireTypeException e) { + // Treat it as an unknown field - same as the default case. + } + } + + // Unknown field. + if (!reader.skipField()) { + // Done reading. + return; + } + } + } +} diff --git a/java/core/src/main/java/com/google/protobuf/Proto3Manifest.java b/java/core/src/main/java/com/google/protobuf/Proto3Manifest.java new file mode 100644 index 00000000..6700a0b4 --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/Proto3Manifest.java @@ -0,0 +1,233 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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.nio.ByteBuffer; +import java.util.List; + +/** Container for the field metadata of a single proto3 schema. */ +final class Proto3Manifest { + static final int INT_LENGTH = 4; + static final int LONG_LENGTH = INT_LENGTH * 2; + static final int LONGS_PER_FIELD = 2; + /** + * Note that field length is always a power of two so that we can use bit shifting (rather than + * division) to find the location of a field when parsing. + */ + static final int FIELD_LENGTH = LONGS_PER_FIELD * LONG_LENGTH; + + static final int FIELD_SHIFT = 4 /* 2^4 = 16 */; + static final int OFFSET_BITS = 20; + static final int OFFSET_MASK = 0XFFFFF; + static final long EMPTY_LONG = 0xFFFFFFFFFFFFFFFFL; + + /** + * Holds all information for accessing the message fields. The layout is as follows (field + * positions are relative to the offset of the start of the field in the buffer): + * + *

+ * + * 

+   * [ 0 -   3] unused
+   * [ 4 -  31] field number
+   * [32 -  37] unused
+   * [38 -  43] field type
+   * [44 -  63] field offset
+   * [64 - 127] unused
+   *
+ */ + final ByteBuffer buffer; + + final long address; + final long limit; + final int numFields; + + final int minFieldNumber; + final int maxFieldNumber; + + private Proto3Manifest( + ByteBuffer buffer, + long address, + long limit, + int numFields, + int minFieldNumber, + int maxFieldNumber) { + this.buffer = buffer; + this.address = address; + this.limit = limit; + this.numFields = numFields; + this.minFieldNumber = minFieldNumber; + this.maxFieldNumber = maxFieldNumber; + } + + boolean isFieldInRange(int fieldNumber) { + return fieldNumber >= minFieldNumber && fieldNumber <= maxFieldNumber; + } + + long tablePositionForFieldNumber(int fieldNumber) { + if (fieldNumber < minFieldNumber || fieldNumber > maxFieldNumber) { + return -1; + } + + return indexToAddress(fieldNumber - minFieldNumber); + } + + long lookupPositionForFieldNumber(int fieldNumber) { + int min = 0; + int max = numFields - 1; + while (min <= max) { + // Find the midpoint address. + int mid = (max + min) >>> 1; + long midAddress = indexToAddress(mid); + int midFieldNumber = numberAt(midAddress); + if (fieldNumber == midFieldNumber) { + // Found the field. + return midAddress; + } + if (fieldNumber < midFieldNumber) { + // Search the lower half. + max = mid - 1; + } else { + // Search the upper half. + min = mid + 1; + } + } + return -1; + } + + int numberAt(long pos) { + return UnsafeUtil.getInt(pos); + } + + int typeAndOffsetAt(long pos) { + return UnsafeUtil.getInt(pos + INT_LENGTH); + } + + private long indexToAddress(int index) { + return address + (index << FIELD_SHIFT); + } + + static byte type(int value) { + return (byte) (value >>> OFFSET_BITS); + } + + static long offset(int value) { + return value & OFFSET_MASK; + } + + static Proto3Manifest newTableManfiest(MessageInfo descriptor) { + List fds = descriptor.getFields(); + if (fds.isEmpty()) { + throw new IllegalArgumentException("Table-based schema requires at least one field"); + } + + // Set up the buffer for direct indexing by field number. + final int minFieldNumber = fds.get(0).getFieldNumber(); + final int maxFieldNumber = fds.get(fds.size() - 1).getFieldNumber(); + final int numEntries = (maxFieldNumber - minFieldNumber) + 1; + + int bufferLength = numEntries * FIELD_LENGTH; + ByteBuffer buffer = ByteBuffer.allocateDirect(bufferLength + LONG_LENGTH); + long tempAddress = UnsafeUtil.addressOffset(buffer); + if ((tempAddress & 7L) != 0) { + // Make sure that the memory address is 8-byte aligned. + tempAddress = (tempAddress & ~7L) + LONG_LENGTH; + } + final long address = tempAddress; + final long limit = address + bufferLength; + + // Fill in the manifest data from the descriptors. + int fieldIndex = 0; + FieldInfo fd = fds.get(fieldIndex++); + for (int bufferIndex = 0; bufferIndex < bufferLength; bufferIndex += FIELD_LENGTH) { + final int fieldNumber = fd.getFieldNumber(); + if (bufferIndex < ((fieldNumber - minFieldNumber) << FIELD_SHIFT)) { + // Mark this entry as "empty". + long skipLimit = address + bufferIndex + FIELD_LENGTH; + for (long skipPos = address + bufferIndex; skipPos < skipLimit; skipPos += LONG_LENGTH) { + UnsafeUtil.putLong(skipPos, EMPTY_LONG); + } + continue; + } + + // We found the entry for the next field. Store the entry in the manifest for + // this field and increment the field index. + FieldType type = fd.getType(); + UnsafeUtil.putInt(address + bufferIndex, fieldNumber); + UnsafeUtil.putInt( + address + bufferIndex + INT_LENGTH, + (type.id() << OFFSET_BITS) | (int) UnsafeUtil.objectFieldOffset(fd.getField())); + + // Advance to the next field, unless we're at the end. + if (fieldIndex < fds.size()) { + fd = fds.get(fieldIndex++); + } + } + + return new Proto3Manifest(buffer, address, limit, fds.size(), minFieldNumber, maxFieldNumber); + } + + static Proto3Manifest newLookupManifest(MessageInfo descriptor) { + List fds = descriptor.getFields(); + + final int numFields = fds.size(); + int bufferLength = numFields * FIELD_LENGTH; + final ByteBuffer buffer = ByteBuffer.allocateDirect(bufferLength + LONG_LENGTH); + long tempAddress = UnsafeUtil.addressOffset(buffer); + if ((tempAddress & 7L) != 0) { + // Make sure that the memory address is 8-byte aligned. + tempAddress = (tempAddress & ~7L) + LONG_LENGTH; + } + final long address = tempAddress; + final long limit = address + bufferLength; + + // Allocate and populate the data buffer. + long pos = address; + for (int i = 0; i < fds.size(); ++i, pos += FIELD_LENGTH) { + FieldInfo fd = fds.get(i); + UnsafeUtil.putInt(pos, fd.getFieldNumber()); + UnsafeUtil.putInt( + pos + INT_LENGTH, + (fd.getType().id() << OFFSET_BITS) | (int) UnsafeUtil.objectFieldOffset(fd.getField())); + } + + if (numFields > 0) { + return new Proto3Manifest( + buffer, + address, + limit, + numFields, + fds.get(0).getFieldNumber(), + fds.get(numFields - 1).getFieldNumber()); + } + return new Proto3Manifest(buffer, address, limit, numFields, -1, -1); + } +} diff --git a/java/core/src/main/java/com/google/protobuf/Proto3SchemaFactory.java b/java/core/src/main/java/com/google/protobuf/Proto3SchemaFactory.java new file mode 100644 index 00000000..c991dd12 --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/Proto3SchemaFactory.java @@ -0,0 +1,115 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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 static com.google.protobuf.Internal.checkNotNull; + +/** + * Manufactures schemas for proto3 messages. Message classes must extend {@link + * com.google.protobuf.GeneratedMessage} or {@link com.google.protobuf.GeneratedMessageLite}. + */ +@ExperimentalApi +public final class Proto3SchemaFactory implements SchemaFactory { + /** + * The mode with which to generate schemas. + * + *

For testing purposes only. + */ + public enum Mode { + /** Always use a table-based indexing of fields. */ + TABLE, + + /** Always used lookup-based (i.e. binary search) indexing of fields. */ + LOOKUP, + + /** + * Default. Determine the appropriate field indexing mode based on how sparse the field numbers + * are for the message. + */ + DYNAMIC + } + + private final MessageInfoFactory messageDescriptorFactory; + private final Mode mode; + + public Proto3SchemaFactory() { + this(DescriptorMessageInfoFactory.getInstance()); + } + + public Proto3SchemaFactory(MessageInfoFactory messageDescriptorFactory) { + this(messageDescriptorFactory, Mode.DYNAMIC); + } + + /** For testing purposes only. Allows specification of {@link Mode}. */ + public Proto3SchemaFactory(MessageInfoFactory messageDescriptorFactory, Mode mode) { + if (!isSupported()) { + throw new IllegalStateException("Schema factory is unsupported on this platform"); + } + this.messageDescriptorFactory = + checkNotNull(messageDescriptorFactory, "messageDescriptorFactory"); + this.mode = checkNotNull(mode, "mode"); + } + + public static boolean isSupported() { + return UnsafeUtil.hasUnsafeArrayOperations() && UnsafeUtil.hasUnsafeByteBufferOperations(); + } + + @Override + public Schema createSchema(Class messageType) { + SchemaUtil.requireGeneratedMessage(messageType); + + MessageInfo descriptor = messageDescriptorFactory.messageInfoFor(messageType); + switch (mode) { + case TABLE: + return newTableSchema(messageType, descriptor); + case LOOKUP: + return newLookupSchema(messageType, descriptor); + default: + return SchemaUtil.shouldUseTableSwitch(descriptor.getFields()) + ? newTableSchema(messageType, descriptor) + : newLookupSchema(messageType, descriptor); + } + } + + private Schema newTableSchema(Class messageType, MessageInfo descriptor) { + if (GeneratedMessageLite.class.isAssignableFrom(messageType)) { + return new Proto3LiteTableSchema(messageType, descriptor); + } + return new Proto3TableSchema(messageType, descriptor); + } + + private Schema newLookupSchema(Class messageType, MessageInfo descriptor) { + if (GeneratedMessageLite.class.isAssignableFrom(messageType)) { + return new Proto3LiteLookupSchema(messageType, descriptor); + } + return new Proto3LookupSchema(messageType, descriptor); + } +} diff --git a/java/core/src/main/java/com/google/protobuf/Proto3TableSchema.java b/java/core/src/main/java/com/google/protobuf/Proto3TableSchema.java new file mode 100644 index 00000000..3a4f1018 --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/Proto3TableSchema.java @@ -0,0 +1,242 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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 static com.google.protobuf.Proto3Manifest.offset; +import static com.google.protobuf.Proto3Manifest.type; + +import java.io.IOException; + +/** + * A generic, table-based schema that can be used with any proto3 message class. The message class + * must extend {@link GeneratedMessage}. + */ +final class Proto3TableSchema extends AbstractProto3StandardSchema { + private final Int2ObjectHashMap> messageFieldClassMap; + + Proto3TableSchema(Class messageClass, MessageInfo descriptor) { + super(messageClass, Proto3Manifest.newTableManfiest(descriptor)); + this.messageFieldClassMap = descriptor.messageFieldClassMap(); + } + + @Override + public void mergeFrom(T message, Reader reader) throws IOException { + while (true) { + final int fieldNumber = reader.getFieldNumber(); + final long pos = manifest.tablePositionForFieldNumber(fieldNumber); + if (pos < 0) { + // Unknown field. + if (reader.skipField()) { + continue; + } + // Done reading. + return; + } + final int typeAndOffset = manifest.typeAndOffsetAt(pos); + + // Benchmarks have shown that switching on a byte is faster than an enum. + try { + switch (type(typeAndOffset)) { + case 0: //DOUBLE: + UnsafeUtil.putDouble(message, offset(typeAndOffset), reader.readDouble()); + break; + case 1: //FLOAT: + UnsafeUtil.putFloat(message, offset(typeAndOffset), reader.readFloat()); + break; + case 2: //INT64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readInt64()); + break; + case 3: //UINT64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readUInt64()); + break; + case 4: //INT32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readInt32()); + break; + case 5: //FIXED64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readFixed64()); + break; + case 6: //FIXED32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readFixed32()); + break; + case 7: //BOOL: + UnsafeUtil.putBoolean(message, offset(typeAndOffset), reader.readBool()); + break; + case 8: //STRING: + UnsafeUtil.putObject(message, offset(typeAndOffset), reader.readString()); + break; + case 9: //MESSAGE: + UnsafeUtil.putObject( + message, + offset(typeAndOffset), + reader.readMessage(messageFieldClassMap.get(fieldNumber))); + break; + case 10: //BYTES: + UnsafeUtil.putObject(message, offset(typeAndOffset), reader.readBytes()); + break; + case 11: //UINT32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readUInt32()); + break; + case 12: //ENUM: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readEnum()); + break; + case 13: //SFIXED32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readSFixed32()); + break; + case 14: //SFIXED64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readSFixed64()); + break; + case 15: //SINT32: + UnsafeUtil.putInt(message, offset(typeAndOffset), reader.readSInt32()); + break; + case 16: //SINT64: + UnsafeUtil.putLong(message, offset(typeAndOffset), reader.readSInt64()); + break; + case 17: //DOUBLE_LIST: + reader.readDoubleList(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 18: //FLOAT_LIST: + reader.readFloatList(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 19: //INT64_LIST: + reader.readInt64List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 20: //UINT64_LIST: + reader.readUInt64List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 21: //INT32_LIST: + reader.readInt32List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 22: //FIXED64_LIST: + reader.readFixed64List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 23: //FIXED32_LIST: + reader.readFixed32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 24: //BOOL_LIST: + reader.readBoolList(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 25: //STRING_LIST: + reader.readStringList(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 26: //MESSAGE_LIST: + SchemaUtil.readMessageList( + message, offset(typeAndOffset), reader, messageFieldClassMap.get(fieldNumber)); + break; + case 27: //BYTES_LIST: + reader.readBytesList( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 28: //UINT32_LIST: + reader.readUInt32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 29: //ENUM_LIST: + reader.readEnumList(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 30: //SFIXED32_LIST: + reader.readSFixed32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 31: //SFIXED64_LIST: + reader.readSFixed64List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 32: //SINT32_LIST: + reader.readSInt32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 33: //SINT64_LIST: + reader.readSInt64List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 34: //DOUBLE_LIST_PACKED: + reader.readDoubleList(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 35: //FLOAT_LIST_PACKED: + reader.readFloatList(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 36: //INT64_LIST_PACKED: + reader.readInt64List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 37: //UINT64_LIST_PACKED: + reader.readUInt64List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 38: //INT32_LIST_PACKED: + reader.readInt32List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 39: //FIXED64_LIST_PACKED: + reader.readFixed64List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 40: //FIXED32_LIST_PACKED: + reader.readFixed32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 41: //BOOL_LIST_PACKED: + reader.readBoolList(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 42: //UINT32_LIST_PACKED: + reader.readUInt32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 43: //ENUM_LIST_PACKED: + reader.readEnumList(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 44: //SFIXED32_LIST_PACKED: + reader.readSFixed32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 45: //SFIXED64_LIST_PACKED: + reader.readSFixed64List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 46: //SINT32_LIST_PACKED: + reader.readSInt32List( + SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + case 47: //SINT64_LIST_PACKED: + reader.readSInt64List(SchemaUtil.mutableListAt(message, offset(typeAndOffset))); + break; + default: + // Assume we've landed on an empty entry. Treat it as an unknown field - just skip it. + if (!reader.skipField()) { + // Done reading. + return; + } + break; + } + // TODO(nathanmittler): Do we need to make lists immutable? + } catch (InvalidProtocolBufferException.InvalidWireTypeException e) { + // Treat fields with an invalid wire type as unknown fields (i.e. same as the default case). + if (!reader.skipField()) { + return; + } + } + } + } +} diff --git a/java/core/src/main/java/com/google/protobuf/ProtoSyntax.java b/java/core/src/main/java/com/google/protobuf/ProtoSyntax.java new file mode 100644 index 00000000..851b839f --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/ProtoSyntax.java @@ -0,0 +1,38 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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; + +/** Represents the syntax version of the message. */ +@ExperimentalApi +public enum ProtoSyntax { + PROTO2, + PROTO3; +} diff --git a/java/core/src/main/java/com/google/protobuf/Protobuf.java b/java/core/src/main/java/com/google/protobuf/Protobuf.java new file mode 100644 index 00000000..6c6aad24 --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/Protobuf.java @@ -0,0 +1,148 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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 static com.google.protobuf.Internal.checkNotNull; + +import java.io.IOException; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentMap; + +/** + * Main runtime interface for protobuf. Applications should interact with this interface (rather + * than directly accessing internal APIs) in order to perform operations on protobuf messages. + */ +@ExperimentalApi +public final class Protobuf { + private static final Protobuf INSTANCE = new Protobuf(); + + private final SchemaFactory schemaFactory; + + // TODO(nathanmittler): Consider using ClassValue instead. + private final ConcurrentMap, Schema> schemaCache = + new ConcurrentHashMap, Schema>(); + + /** Gets the singleton instance of the Protobuf runtime. */ + public static Protobuf getInstance() { + return INSTANCE; + } + + /** Writes the given message to the target {@link Writer}. */ + public void writeTo(T message, Writer writer) { + schemaFor(message).writeTo(message, writer); + } + + /** Reads fields from the given {@link Reader} and merges them into the message. */ + public void mergeFrom(T message, Reader reader) throws IOException { + schemaFor(message).mergeFrom(message, reader); + } + + /** Gets the schema for the given message type. */ + public Schema schemaFor(Class messageType) { + checkNotNull(messageType, "messageType"); + @SuppressWarnings("unchecked") + Schema schema = (Schema) schemaCache.get(messageType); + if (schema == null) { + schema = schemaFactory.createSchema(messageType); + @SuppressWarnings("unchecked") + Schema previous = (Schema) registerSchema(messageType, schema); + if (previous != null) { + // A new schema was registered by another thread. + schema = previous; + } + } + return schema; + } + + /** Gets the schema for the given message. */ + @SuppressWarnings("unchecked") + public Schema schemaFor(T message) { + return schemaFor((Class) message.getClass()); + } + + /** + * Registers the given schema for the message type only if a schema was not already registered. + * + * @param messageType the type of message on which the schema operates. + * @param schema the schema for the message type. + * @return the previously registered schema, or {@code null} if the given schema was successfully + * registered. + */ + public Schema registerSchema(Class messageType, Schema schema) { + checkNotNull(messageType, "messageType"); + checkNotNull(schema, "schema"); + return schemaCache.putIfAbsent(messageType, schema); + } + + /** + * Visible for testing only. Registers the given schema for the message type. If a schema was + * previously registered, it will be replaced by the provided schema. + * + * @param messageType the type of message on which the schema operates. + * @param schema the schema for the message type. + * @return the previously registered schema, or {@code null} if no schema was registered + * previously. + */ + public Schema registerSchemaOverride(Class messageType, Schema schema) { + checkNotNull(messageType, "messageType"); + checkNotNull(schema, "schema"); + return schemaCache.put(messageType, schema); + } + + private Protobuf() { + // TODO(nathanmittler): Detect the proper factory for the platform. + SchemaFactory factory = null; + for (String className : + new String[] { + "com.google.frameworks.protobuf.experimental.android.schema.AndroidProto3SchemaFactory", + // TODO(nathanmittler): Remove this once the code has been completely ported over. + "com.google.frameworks.protobuf.experimental.schema.generic.Proto3SchemaFactory", + "com.google.protobuf.Proto3SchemaFactory" + }) { + factory = newSchemaFactory(className); + if (factory != null) { + break; + } + } + if (factory == null) { + throw new IllegalStateException("Unable to locate a default SchemaFactory. Check classpath."); + } + schemaFactory = factory; + } + + private static SchemaFactory newSchemaFactory(String className) { + try { + return (SchemaFactory) Class.forName(className).getConstructor().newInstance(); + } catch (Throwable e) { + return null; + } + } +} diff --git a/java/core/src/main/java/com/google/protobuf/ProtobufLists.java b/java/core/src/main/java/com/google/protobuf/ProtobufLists.java new file mode 100644 index 00000000..e01f21ec --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/ProtobufLists.java @@ -0,0 +1,96 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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 com.google.protobuf.Internal.BooleanList; +import com.google.protobuf.Internal.DoubleList; +import com.google.protobuf.Internal.FloatList; +import com.google.protobuf.Internal.IntList; +import com.google.protobuf.Internal.LongList; +import com.google.protobuf.Internal.ProtobufList; + +/** + * Utility class for construction of lists that extend {@link ProtobufList}. + */ +@ExperimentalApi +public final class ProtobufLists { + private ProtobufLists() {} + + public static ProtobufList emptyProtobufList() { + return ProtobufArrayList.emptyList(); + } + + public static ProtobufList mutableCopy(ProtobufList list) { + int size = list.size(); + return list.mutableCopyWithCapacity( + size == 0 ? AbstractProtobufList.DEFAULT_CAPACITY : size * 2); + } + + public static BooleanList emptyBooleanList() { + return BooleanArrayList.emptyList(); + } + + public static BooleanList newBooleanList() { + return new BooleanArrayList(); + } + + public static IntList emptyIntList() { + return IntArrayList.emptyList(); + } + + public static IntList newIntList() { + return new IntArrayList(); + } + + public static LongList emptyLongList() { + return LongArrayList.emptyList(); + } + + public static LongList newLongList() { + return new LongArrayList(); + } + + public static FloatList emptyFloatList() { + return FloatArrayList.emptyList(); + } + + public static FloatList newFloatList() { + return new FloatArrayList(); + } + + public static DoubleList emptyDoubleList() { + return DoubleArrayList.emptyList(); + } + + public static DoubleList newDoubleList() { + return new DoubleArrayList(); + } +} diff --git a/java/core/src/main/java/com/google/protobuf/Reader.java b/java/core/src/main/java/com/google/protobuf/Reader.java new file mode 100644 index 00000000..aa5b330f --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/Reader.java @@ -0,0 +1,312 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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.util.List; + +/** A reader of fields from a serialized protobuf message. */ +// TODO(nathanmittler): Refactor to allow the reader to allocate properly sized lists. +@ExperimentalApi +public interface Reader { + /** Value used to indicate that the end of input has been reached. */ + int READ_DONE = Integer.MAX_VALUE; + + /** + * Gets the field number for the current field being read. + * + * @return the current field number or {@link #READ_DONE} if the end of input has been reached. + */ + int getFieldNumber() throws IOException; + + /** + * Skips the current field and advances the reader to the next field. + * + * @return {@code true} if there are more fields or {@link #READ_DONE} if the end of input has + * been reached. + */ + boolean skipField() throws IOException; + + /** + * Reads and returns the next field of type {@code DOUBLE} and advances the reader to the next + * field. + */ + double readDouble() throws IOException; + + /** + * Reads and returns the next field of type {@code FLOAT} and advances the reader to the next + * field. + */ + float readFloat() throws IOException; + + /** + * Reads and returns the next field of type {@code UINT64} and advances the reader to the next + * field. + */ + long readUInt64() throws IOException; + + /** + * Reads and returns the next field of type {@code INT64} and advances the reader to the next + * field. + */ + long readInt64() throws IOException; + + /** + * Reads and returns the next field of type {@code INT32} and advances the reader to the next + * field. + */ + int readInt32() throws IOException; + + /** + * Reads and returns the next field of type {@code FIXED64} and advances the reader to the next + * field. + */ + long readFixed64() throws IOException; + + /** + * Reads and returns the next field of type {@code FIXED32} and advances the reader to the next + * field. + */ + int readFixed32() throws IOException; + + /** + * Reads and returns the next field of type {@code BOOL} and advances the reader to the next + * field. + */ + boolean readBool() throws IOException; + + /** + * Reads and returns the next field of type {@code STRING} and advances the reader to the next + * field. + */ + String readString() throws IOException; + + /** + * Reads and returns the next field of type {@code MESSAGE} and advances the reader to the next + * field. + */ + T readMessage(Class clazz) throws IOException; + + /** + * Reads and returns the next field of type {@code GROUP} and advances the reader to the next + * field. + * + * @deprecated groups fields are deprecated. + */ + @Deprecated + T readGroup(Class clazz) throws IOException; + + /** + * Reads and returns the next field of type {@code BYTES} and advances the reader to the next + * field. + */ + ByteString readBytes() throws IOException; + + /** + * Reads and returns the next field of type {@code UINT32} and advances the reader to the next + * field. + */ + int readUInt32() throws IOException; + + /** + * Reads and returns the next field of type {@code ENUM} and advances the reader to the next + * field. + */ + int readEnum() throws IOException; + + /** + * Reads and returns the next field of type {@code SFIXED32} and advances the reader to the next + * field. + */ + int readSFixed32() throws IOException; + + /** + * Reads and returns the next field of type {@code SFIXED64} and advances the reader to the next + * field. + */ + long readSFixed64() throws IOException; + + /** + * Reads and returns the next field of type {@code SINT32} and advances the reader to the next + * field. + */ + int readSInt32() throws IOException; + + /** + * Reads and returns the next field of type {@code SINT64} and advances the reader to the next + * field. + */ + long readSInt64() throws IOException; + + /** + * Reads the next field of type {@code DOUBLE_LIST} or {@code DOUBLE_LIST_PACKED} and advances the + * reader to the next field. + * + * @param target the list that will receive the read values. + */ + void readDoubleList(List target) throws IOException; + + /** + * Reads the next field of type {@code FLOAT_LIST} or {@code FLOAT_LIST_PACKED} and advances the + * reader to the next field. + * + * @param target the list that will receive the read values. + */ + void readFloatList(List target) throws IOException; + + /** + * Reads the next field of type {@code UINT64_LIST} or {@code UINT64_LIST_PACKED} and advances the + * reader to the next field. + * + * @param target the list that will receive the read values. + */ + void readUInt64List(List target) throws IOException; + + /** + * Reads the next field of type {@code INT64_LIST} or {@code INT64_LIST_PACKED} and advances the + * reader to the next field. + * + * @param target the list that will receive the read values. + */ + void readInt64List(List target) throws IOException; + + /** + * Reads the next field of type {@code INT32_LIST} or {@code INT32_LIST_PACKED} and advances the + * reader to the next field. + * + * @param target the list that will receive the read values. + */ + void readInt32List(List target) throws IOException; + + /** + * Reads the next field of type {@code FIXED64_LIST} or {@code FIXED64_LIST_PACKED} and advances + * the reader to the next field. + * + * @param target the list that will receive the read values. + */ + void readFixed64List(List target) throws IOException; + + /** + * Reads the next field of type {@code FIXED32_LIST} or {@code FIXED32_LIST_PACKED} and advances + * the reader to the next field. + * + * @param target the list that will receive the read values. + */ + void readFixed32List(List target) throws IOException; + + /** + * Reads the next field of type {@code BOOL_LIST} or {@code BOOL_LIST_PACKED} and advances the + * reader to the next field. + * + * @param target the list that will receive the read values. + */ + void readBoolList(List target) throws IOException; + + /** + * Reads the next field of type {@code STRING_LIST} and advances the reader to the next field. + * + * @param target the list that will receive the read values. + */ + void readStringList(List target) throws IOException; + + /** + * Reads the next field of type {@code MESSAGE_LIST} and advances the reader to the next field. + * + * @param target the list that will receive the read values. + * @param targetType the type of the elements stored in the {@code target} list. + */ + void readMessageList(List target, Class targetType) throws IOException; + + /** + * Reads the next field of type {@code GROUP_LIST} and advances the reader to the next field. + * + * @param target the list that will receive the read values. + * @param targetType the type of the elements stored in the {@code target} list. + * @deprecated groups fields are deprecated. + */ + @Deprecated + void readGroupList(List target, Class targetType) throws IOException; + + /** + * Reads the next field of type {@code BYTES_LIST} and advances the reader to the next field. + * + * @param target the list that will receive the read values. + */ + void readBytesList(List target) throws IOException; + + /** + * Reads the next field of type {@code UINT32_LIST} or {@code UINT32_LIST_PACKED} and advances the + * reader to the next field. + * + * @param target the list that will receive the read values. + */ + void readUInt32List(List target) throws IOException; + + /** + * Reads the next field of type {@code ENUM_LIST} or {@code ENUM_LIST_PACKED} and advances the + * reader to the next field. + * + * @param target the list that will receive the read values. + */ + void readEnumList(List target) throws IOException; + + /** + * Reads the next field of type {@code SFIXED32_LIST} or {@code SFIXED32_LIST_PACKED} and advances + * the reader to the next field. + * + * @param target the list that will receive the read values. + */ + void readSFixed32List(List target) throws IOException; + + /** + * Reads the next field of type {@code SFIXED64_LIST} or {@code SFIXED64_LIST_PACKED} and advances + * the reader to the next field. + * + * @param target the list that will receive the read values. + */ + void readSFixed64List(List target) throws IOException; + + /** + * Reads the next field of type {@code SINT32_LIST} or {@code SINT32_LIST_PACKED} and advances the + * reader to the next field. + * + * @param target the list that will receive the read values. + */ + void readSInt32List(List target) throws IOException; + + /** + * Reads the next field of type {@code SINT64_LIST} or {@code SINT64_LIST_PACKED} and advances the + * reader to the next field. + * + * @param target the list that will receive the read values. + */ + void readSInt64List(List target) throws IOException; +} diff --git a/java/core/src/main/java/com/google/protobuf/RopeByteString.java b/java/core/src/main/java/com/google/protobuf/RopeByteString.java index 6fa555df..4c98b492 100644 --- a/java/core/src/main/java/com/google/protobuf/RopeByteString.java +++ b/java/core/src/main/java/com/google/protobuf/RopeByteString.java @@ -406,6 +406,11 @@ final class RopeByteString extends ByteString { right.writeTo(output); } + @Override + void writeToReverse(ByteOutput output) throws IOException { + right.writeToReverse(output); + left.writeToReverse(output); + } @Override protected String toStringInternal(Charset charset) { diff --git a/java/core/src/main/java/com/google/protobuf/Schema.java b/java/core/src/main/java/com/google/protobuf/Schema.java new file mode 100644 index 00000000..be9f3347 --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/Schema.java @@ -0,0 +1,55 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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; + +/** + * A runtime schema for a single protobuf message. A schema provides operations on message + * instances such as serialization/deserialization. + */ +@ExperimentalApi +public interface Schema { + /** + * Writes the given message to the target {@link Writer}. + */ + void writeTo(T message, Writer writer); + + /** + * Reads fields from the given {@link Reader} and merges them into the message. + */ + void mergeFrom(T message, Reader reader) throws IOException; + + /** + * Creates a new instance of the message class. + */ + T newInstance(); +} diff --git a/java/core/src/main/java/com/google/protobuf/SchemaFactory.java b/java/core/src/main/java/com/google/protobuf/SchemaFactory.java new file mode 100644 index 00000000..49682598 --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/SchemaFactory.java @@ -0,0 +1,42 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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; + +/** + * A factory that manufactures {@link Schema} instances for protobuf messages. + */ +@ExperimentalApi +public interface SchemaFactory { + /** + * Creates a schema instance for the given protobuf message type. + */ + Schema createSchema(Class messageType); +} diff --git a/java/core/src/main/java/com/google/protobuf/SchemaUtil.java b/java/core/src/main/java/com/google/protobuf/SchemaUtil.java new file mode 100644 index 00000000..db2dc949 --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/SchemaUtil.java @@ -0,0 +1,516 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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 com.google.protobuf.Internal.ProtobufList; +import java.io.IOException; +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +/** Helper methods used by schemas. */ +@ExperimentalApi +public final class SchemaUtil { + private static final Class UNMODIFIABLE_LIST_CLASS = + Collections.unmodifiableList(new ArrayList()).getClass(); + private static final Class ABSTRACT_MESSAGE_CLASS = getAbstractMessageClass(); + private static final Class GENERATED_MESSAGE_CLASS = getGeneratedMessageClass(); + private static final Class UNKNOWN_FIELD_SET_CLASS = getUnknownFieldSetClass(); + private static final long UNKNOWN_FIELD_OFFSET = unknownFieldOffset(); + private static final long LITE_UNKNOWN_FIELD_OFFSET = unknownFieldLiteOffset(); + private static final Object DEFAULT_UNKNOWN_FIELD_SET = defaultUnknownFieldSet(); + private static final long MEMOIZED_SIZE_FIELD_OFFSET = getMemoizedSizeFieldOffset(); + private static final long LITE_MEMOIZED_SIZE_FIELD_OFFSET = getLiteMemoizedSizeFieldOffset(); + + private SchemaUtil() {} + + /** + * Initializes all of the base class fields for the given {@link GeneratedMessageLite} to their + * default values. + */ + public static void initLiteBaseClassFields(Object msg) { + UnsafeUtil.putObject(msg, LITE_UNKNOWN_FIELD_OFFSET, UnknownFieldSetLite.getDefaultInstance()); + UnsafeUtil.putInt(msg, LITE_MEMOIZED_SIZE_FIELD_OFFSET, -1); + } + + /** + * Initializes all of the base class fields for the given {@link + * com.google.protobuf.GeneratedMessage} to their default values. + */ + public static void initBaseClassFields(Object msg) { + UnsafeUtil.putObject(msg, UNKNOWN_FIELD_OFFSET, DEFAULT_UNKNOWN_FIELD_SET); + UnsafeUtil.putInt(msg, MEMOIZED_SIZE_FIELD_OFFSET, -1); + } + + /** + * Requires that the given message extend {@link com.google.protobuf.GeneratedMessage} or {@link + * GeneratedMessageLite}. + */ + public static void requireGeneratedMessage(Class messageType) { + if (!GeneratedMessageLite.class.isAssignableFrom(messageType) + && !GENERATED_MESSAGE_CLASS.isAssignableFrom(messageType)) { + throw new IllegalArgumentException( + "Message classes must extend GeneratedMessage or GeneratedMessageLite"); + } + } + + /** Initializes the message's memoized size to the default value. */ + public static void initMemoizedSize(Object msg) { + final long fieldOffset = + (msg instanceof GeneratedMessageLite) + ? LITE_MEMOIZED_SIZE_FIELD_OFFSET + : MEMOIZED_SIZE_FIELD_OFFSET; + + if (fieldOffset < 0) { + throw new IllegalArgumentException( + "Unable to identify memoizedSize field offset for message of type: " + + msg.getClass().getName()); + } + + UnsafeUtil.putInt(msg, fieldOffset, -1); + } + + public static void writeDouble(int fieldNumber, double value, Writer writer) { + if (Double.compare(value, 0.0) != 0) { + writer.writeDouble(fieldNumber, value); + } + } + + public static void writeFloat(int fieldNumber, float value, Writer writer) { + if (Float.compare(value, 0.0f) != 0) { + writer.writeFloat(fieldNumber, value); + } + } + + public static void writeInt64(int fieldNumber, long value, Writer writer) { + if (value != 0) { + writer.writeInt64(fieldNumber, value); + } + } + + public static void writeUInt64(int fieldNumber, long value, Writer writer) { + if (value != 0) { + writer.writeUInt64(fieldNumber, value); + } + } + + public static void writeSInt64(int fieldNumber, long value, Writer writer) { + if (value != 0) { + writer.writeSInt64(fieldNumber, value); + } + } + + public static void writeFixed64(int fieldNumber, long value, Writer writer) { + if (value != 0) { + writer.writeFixed64(fieldNumber, value); + } + } + + public static void writeSFixed64(int fieldNumber, long value, Writer writer) { + if (value != 0) { + writer.writeSFixed64(fieldNumber, value); + } + } + + public static void writeInt32(int fieldNumber, int value, Writer writer) { + if (value != 0) { + writer.writeInt32(fieldNumber, value); + } + } + + public static void writeUInt32(int fieldNumber, int value, Writer writer) { + if (value != 0) { + writer.writeUInt32(fieldNumber, value); + } + } + + public static void writeSInt32(int fieldNumber, int value, Writer writer) { + if (value != 0) { + writer.writeSInt32(fieldNumber, value); + } + } + + public static void writeFixed32(int fieldNumber, int value, Writer writer) { + if (value != 0) { + writer.writeFixed32(fieldNumber, value); + } + } + + public static void writeSFixed32(int fieldNumber, int value, Writer writer) { + if (value != 0) { + writer.writeSFixed32(fieldNumber, value); + } + } + + public static void writeEnum(int fieldNumber, int value, Writer writer) { + if (value != 0) { + writer.writeEnum(fieldNumber, value); + } + } + + public static void writeBool(int fieldNumber, boolean value, Writer writer) { + if (value) { + writer.writeBool(fieldNumber, true); + } + } + + public static void writeString(int fieldNumber, Object value, Writer writer) { + if (value instanceof String) { + writeStringInternal(fieldNumber, (String) value, writer); + } else { + writeBytes(fieldNumber, (ByteString) value, writer); + } + } + + private static void writeStringInternal(int fieldNumber, String value, Writer writer) { + if (value != null && !value.isEmpty()) { + writer.writeString(fieldNumber, value); + } + } + + public static void writeBytes(int fieldNumber, ByteString value, Writer writer) { + if (value != null && !value.isEmpty()) { + writer.writeBytes(fieldNumber, value); + } + } + + public static void writeMessage(int fieldNumber, Object value, Writer writer) { + if (value != null) { + writer.writeMessage(fieldNumber, value); + } + } + + public static void writeDoubleList( + int fieldNumber, List value, Writer writer, boolean packed) { + if (value != null && !value.isEmpty()) { + writer.writeDoubleList(fieldNumber, value, packed); + } + } + + public static void writeFloatList( + int fieldNumber, List value, Writer writer, boolean packed) { + if (value != null && !value.isEmpty()) { + writer.writeFloatList(fieldNumber, value, packed); + } + } + + public static void writeInt64List( + int fieldNumber, List value, Writer writer, boolean packed) { + if (value != null && !value.isEmpty()) { + writer.writeInt64List(fieldNumber, value, packed); + } + } + + public static void writeUInt64List( + int fieldNumber, List value, Writer writer, boolean packed) { + if (value != null && !value.isEmpty()) { + writer.writeUInt64List(fieldNumber, value, packed); + } + } + + public static void writeSInt64List( + int fieldNumber, List value, Writer writer, boolean packed) { + if (value != null && !value.isEmpty()) { + writer.writeSInt64List(fieldNumber, value, packed); + } + } + + public static void writeFixed64List( + int fieldNumber, List value, Writer writer, boolean packed) { + if (value != null && !value.isEmpty()) { + writer.writeFixed64List(fieldNumber, value, packed); + } + } + + public static void writeSFixed64List( + int fieldNumber, List value, Writer writer, boolean packed) { + if (value != null && !value.isEmpty()) { + writer.writeSFixed64List(fieldNumber, value, packed); + } + } + + public static void writeInt32List( + int fieldNumber, List value, Writer writer, boolean packed) { + if (value != null && !value.isEmpty()) { + writer.writeInt32List(fieldNumber, value, packed); + } + } + + public static void writeUInt32List( + int fieldNumber, List value, Writer writer, boolean packed) { + if (value != null && !value.isEmpty()) { + writer.writeUInt32List(fieldNumber, value, packed); + } + } + + public static void writeSInt32List( + int fieldNumber, List value, Writer writer, boolean packed) { + if (value != null && !value.isEmpty()) { + writer.writeSInt32List(fieldNumber, value, packed); + } + } + + public static void writeFixed32List( + int fieldNumber, List value, Writer writer, boolean packed) { + if (value != null && !value.isEmpty()) { + writer.writeFixed32List(fieldNumber, value, packed); + } + } + + public static void writeSFixed32List( + int fieldNumber, List value, Writer writer, boolean packed) { + if (value != null && !value.isEmpty()) { + writer.writeSFixed32List(fieldNumber, value, packed); + } + } + + public static void writeEnumList( + int fieldNumber, List value, Writer writer, boolean packed) { + if (value != null && !value.isEmpty()) { + writer.writeEnumList(fieldNumber, value, packed); + } + } + + public static void writeBoolList( + int fieldNumber, List value, Writer writer, boolean packed) { + if (value != null && !value.isEmpty()) { + writer.writeBoolList(fieldNumber, value, packed); + } + } + + public static void writeStringList(int fieldNumber, List value, Writer writer) { + if (value != null && !value.isEmpty()) { + writer.writeStringList(fieldNumber, value); + } + } + + public static void writeBytesList(int fieldNumber, List value, Writer writer) { + if (value != null && !value.isEmpty()) { + writer.writeBytesList(fieldNumber, value); + } + } + + public static void writeMessageList(int fieldNumber, List value, Writer writer) { + if (value != null && !value.isEmpty()) { + writer.writeMessageList(fieldNumber, value); + } + } + + public static void writeGroupList(int fieldNumber, List value, Writer writer) { + if (value != null && !value.isEmpty()) { + writer.writeGroupList(fieldNumber, value); + } + } + + /** + * Used for protobuf-lite (i.e. messages that extend {@link GeneratedMessageLite}). Reads in a + * list of messages into a target {@link ProtobufList} field in the message. + */ + public static final void readProtobufMessageList( + Object message, long offset, Reader reader, Class targetType) throws IOException { + reader.readMessageList(SchemaUtil.mutableProtobufListAt(message, offset), targetType); + } + + /** + * Used for standard protobuf messages (i.e. messages that extend {@link + * com.google.protobuf.GeneratedMessage}). Reads in a list of messages into a target list field in + * the message. + */ + public static void readMessageList( + Object message, long offset, Reader reader, Class targetType) throws IOException { + reader.readMessageList(SchemaUtil.mutableListAt(message, offset), targetType); + } + + /** + * Used for group types. Reads in a list of group messages into a target list field in the + * message. + */ + public static void readGroupList( + Object message, long offset, Reader reader, Class targetType) throws IOException { + reader.readGroupList(SchemaUtil.mutableListAt(message, offset), targetType); + } + + /** + * Used for protobuf-lite (i.e. messages that extend GeneratedMessageLite). Converts the {@link + * ProtobufList} at the given field position in the message into a mutable list (if it isn't + * already). + */ + @SuppressWarnings("unchecked") + public static ProtobufList mutableProtobufListAt(Object message, long pos) { + ProtobufList list = (ProtobufList) UnsafeUtil.getObject(message, pos); + if (!list.isModifiable()) { + int size = list.size(); + list = list.mutableCopyWithCapacity( + size == 0 ? AbstractProtobufList.DEFAULT_CAPACITY : size * 2); + UnsafeUtil.putObject(message, pos, list); + } + return list; + } + + /** Converts the list at the given field location in the message into a mutable list. */ + @SuppressWarnings("unchecked") + public static List mutableListAt(Object message, long pos) { + List list = (List) UnsafeUtil.getObject(message, pos); + if (list.isEmpty()) { + list = + (list instanceof LazyStringList) + ? (List) new LazyStringArrayList() + : new ArrayList(); + UnsafeUtil.putObject(message, pos, list); + } else if (UNMODIFIABLE_LIST_CLASS.isAssignableFrom(list.getClass())) { + list = new ArrayList(list); + UnsafeUtil.putObject(message, pos, list); + } else if (list instanceof UnmodifiableLazyStringList) { + // Convert the list to a mutable list. + list = (List) new LazyStringArrayList((List) list); + UnsafeUtil.putObject(message, pos, list); + } + return list; + } + + /** + * Determines whether to issue tableswitch or lookupswitch for the mergeFrom method. + * + * @see #shouldUseTableSwitch(int, int, int) + */ + public static boolean shouldUseTableSwitch(List fields) { + // Determine whether to issue a tableswitch or a lookupswitch + // instruction. + if (fields.isEmpty()) { + return false; + } + + int lo = fields.get(0).getFieldNumber(); + int hi = fields.get(fields.size() - 1).getFieldNumber(); + return shouldUseTableSwitch(lo, hi, fields.size()); + } + + /** + * Determines whether to issue tableswitch or lookupswitch for the mergeFrom method. This is based + * on the + * logic in the JDK. + * + * @param lo the lowest fieldNumber contained within the message. + * @param hi the higest fieldNumber contained within the message. + * @param numFields the total number of fields in the message. + * @return {@code true} if tableswitch should be used, rather than lookupswitch. + */ + public static boolean shouldUseTableSwitch(int lo, int hi, int numFields) { + long tableSpaceCost = 4 + ((long) hi - lo + 1); // words + long tableTimeCost = 3; // comparisons + long lookupSpaceCost = 3 + 2 * (long) numFields; + long lookupTimeCost = numFields; + return tableSpaceCost + 3 * tableTimeCost <= lookupSpaceCost + 3 * lookupTimeCost; + } + + private static Class getAbstractMessageClass() { + try { + return Class.forName("com.google.protobuf.AbstractMessage"); + } catch (Throwable e) { + return null; + } + } + + private static Class getGeneratedMessageClass() { + try { + return Class.forName("com.google.protobuf.GeneratedMessage"); + } catch (Throwable e) { + return null; + } + } + + private static Class getUnknownFieldSetClass() { + try { + return Class.forName("com.google.protobuf.UnknownFieldSet"); + } catch (Throwable e) { + return null; + } + } + + private static long unknownFieldOffset() { + try { + if (GENERATED_MESSAGE_CLASS != null) { + Field field = GENERATED_MESSAGE_CLASS.getDeclaredField("unknownFields"); + return UnsafeUtil.objectFieldOffset(field); + } + } catch (Throwable e) { + // Do nothing. + } + return -1; + } + + private static long unknownFieldLiteOffset() { + try { + Field field = GeneratedMessageLite.class.getDeclaredField("unknownFields"); + return UnsafeUtil.objectFieldOffset(field); + } catch (Throwable e) { + // Do nothing. + } + return -1; + } + + private static Object defaultUnknownFieldSet() { + try { + if (UNKNOWN_FIELD_SET_CLASS != null) { + Method method = UNKNOWN_FIELD_SET_CLASS.getDeclaredMethod("getDefaultInstance"); + return method.invoke(null); + } + } catch (Throwable e) { + // Do nothing. + } + return null; + } + + private static long getMemoizedSizeFieldOffset() { + try { + if (ABSTRACT_MESSAGE_CLASS != null) { + Field field = ABSTRACT_MESSAGE_CLASS.getDeclaredField("memoizedSize"); + return UnsafeUtil.objectFieldOffset(field); + } + } catch (Throwable e) { + // Do nothing. + } + return -1; + } + + private static long getLiteMemoizedSizeFieldOffset() { + try { + Field field = GeneratedMessageLite.class.getDeclaredField("memoizedSerializedSize"); + return UnsafeUtil.objectFieldOffset(field); + } catch (Throwable e) { + // Do nothing. + } + return -1; + } +} diff --git a/java/core/src/main/java/com/google/protobuf/Writer.java b/java/core/src/main/java/com/google/protobuf/Writer.java new file mode 100644 index 00000000..829f270f --- /dev/null +++ b/java/core/src/main/java/com/google/protobuf/Writer.java @@ -0,0 +1,155 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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.util.List; + +/** A writer that performs serialization of protobuf message fields. */ +@ExperimentalApi +public interface Writer { + /** Writes a field of type {@link FieldType#SFIXED32}. */ + void writeSFixed32(int fieldNumber, int value); + + /** Writes a field of type {@link FieldType#INT64}. */ + void writeInt64(int fieldNumber, long value); + + /** Writes a field of type {@link FieldType#SFIXED64}. */ + void writeSFixed64(int fieldNumber, long value); + + /** Writes a field of type {@link FieldType#FLOAT}. */ + void writeFloat(int fieldNumber, float value); + + /** Writes a field of type {@link FieldType#DOUBLE}. */ + void writeDouble(int fieldNumber, double value); + + /** Writes a field of type {@link FieldType#ENUM}. */ + void writeEnum(int fieldNumber, int value); + + /** Writes a field of type {@link FieldType#UINT64}. */ + void writeUInt64(int fieldNumber, long value); + + /** Writes a field of type {@link FieldType#INT32}. */ + void writeInt32(int fieldNumber, int value); + + /** Writes a field of type {@link FieldType#FIXED64}. */ + void writeFixed64(int fieldNumber, long value); + + /** Writes a field of type {@link FieldType#FIXED32}. */ + void writeFixed32(int fieldNumber, int value); + + /** Writes a field of type {@link FieldType#BOOL}. */ + void writeBool(int fieldNumber, boolean value); + + /** Writes a field of type {@link FieldType#STRING}. */ + void writeString(int fieldNumber, String value); + + /** Writes a field of type {@link FieldType#BYTES}. */ + void writeBytes(int fieldNumber, ByteString value); + + /** Writes a field of type {@link FieldType#UINT32}. */ + void writeUInt32(int fieldNumber, int value); + + /** Writes a field of type {@link FieldType#SINT32}. */ + void writeSInt32(int fieldNumber, int value); + + /** Writes a field of type {@link FieldType#SINT64}. */ + void writeSInt64(int fieldNumber, long value); + + /** Writes a field of type {@link FieldType#MESSAGE}. */ + void writeMessage(int fieldNumber, Object value); + + /** + * Writes a field of type {@link FieldType#GROUP}. + * + * @deprecated groups fields are deprecated. + */ + @Deprecated + void writeGroup(int fieldNumber, Object value); + + /** Writes a list field of type {@link FieldType#INT32}. */ + void writeInt32List(int fieldNumber, List value, boolean packed); + + /** Writes a list field of type {@link FieldType#FIXED32}. */ + void writeFixed32List(int fieldNumber, List value, boolean packed); + + /** Writes a list field of type {@link FieldType#INT64}. */ + void writeInt64List(int fieldNumber, List value, boolean packed); + + /** Writes a list field of type {@link FieldType#UINT64}. */ + void writeUInt64List(int fieldNumber, List value, boolean packed); + + /** Writes a list field of type {@link FieldType#FIXED64}. */ + void writeFixed64List(int fieldNumber, List value, boolean packed); + + /** Writes a list field of type {@link FieldType#FLOAT}. */ + void writeFloatList(int fieldNumber, List value, boolean packed); + + /** Writes a list field of type {@link FieldType#DOUBLE}. */ + void writeDoubleList(int fieldNumber, List value, boolean packed); + + /** Writes a list field of type {@link FieldType#ENUM}. */ + void writeEnumList(int fieldNumber, List value, boolean packed); + + /** Writes a list field of type {@link FieldType#BOOL}. */ + void writeBoolList(int fieldNumber, List value, boolean packed); + + /** Writes a list field of type {@link FieldType#STRING}. */ + void writeStringList(int fieldNumber, List value); + + /** Writes a list field of type {@link FieldType#BYTES}. */ + void writeBytesList(int fieldNumber, List value); + + /** Writes a list field of type {@link FieldType#UINT32}. */ + void writeUInt32List(int fieldNumber, List value, boolean packed); + + /** Writes a list field of type {@link FieldType#SFIXED32}. */ + void writeSFixed32List(int fieldNumber, List value, boolean packed); + + /** Writes a list field of type {@link FieldType#SFIXED64}. */ + void writeSFixed64List(int fieldNumber, List value, boolean packed); + + /** Writes a list field of type {@link FieldType#SINT32}. */ + void writeSInt32List(int fieldNumber, List value, boolean packed); + + /** Writes a list field of type {@link FieldType#SINT64}. */ + void writeSInt64List(int fieldNumber, List value, boolean packed); + + /** Writes a list field of type {@link FieldType#MESSAGE}. */ + void writeMessageList(int fieldNumber, List value); + + /** + * Writes a list field of type {@link FieldType#GROUP}. + * + * @deprecated groups fields are deprecated. + */ + @Deprecated + void writeGroupList(int fieldNumber, List value); +}